diff --git a/lib/python3.12/site-packages/IPython/core/magics/__init__.py b/lib/python3.12/site-packages/IPython/core/magics/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6c5f474c15d29032a23a50d9c884e00235e56ac
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/__init__.py
@@ -0,0 +1,42 @@
+"""Implementation of all the magic functions built into IPython.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+from ..magic import Magics, magics_class
+from .auto import AutoMagics
+from .basic import BasicMagics, AsyncMagics
+from .code import CodeMagics, MacroToEdit
+from .config import ConfigMagics
+from .display import DisplayMagics
+from .execution import ExecutionMagics
+from .extension import ExtensionMagics
+from .history import HistoryMagics
+from .logging import LoggingMagics
+from .namespace import NamespaceMagics
+from .osm import OSMagics
+from .packaging import PackagingMagics
+from .pylab import PylabMagics
+from .script import ScriptMagics
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+@magics_class
+class UserMagics(Magics):
+    """Placeholder for user-defined magics to be added at runtime.
+
+    All magics are eventually merged into a single namespace at runtime, but we
+    use this class to isolate the magics defined dynamically by the user into
+    their own class.
+    """
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..65d293016f51531d3ff5661c881edec6ec2160c4
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/__init__.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/ast_mod.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/ast_mod.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55761c6c145d7331a9dd938bc51c8d9ad00c4c76
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/ast_mod.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/auto.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/auto.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a03b7a0bbd58120f901acc188ae6d5082afcc0a9
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/auto.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/basic.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/basic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0800eeca382a7305512433c7d4a9e36ba5340ec1
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/basic.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/code.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/code.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05c8c3ebd23c438a7ba821ece0fda3a2286d8cf9
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/code.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/config.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/config.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..375f8525b30c7a1974990d7f25be719f21d16851
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/config.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/display.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/display.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca6ab849d9d049ce06af793d3d60c258e2eda26d
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/display.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/execution.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/execution.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..52b4532dbb161e3997a2aefea0d5b4ef6acd5f64
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/execution.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/extension.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/extension.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..266faffbbed71dc454fcf6dddb5bcd82acaca177
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/extension.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/history.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/history.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fd242fb3c91908000ef34d17417e9be1cd0d1c2b
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/history.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/logging.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/logging.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6a67cb7cb27e7de85eab8b4f7dd7184cad84fb36
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/logging.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/namespace.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/namespace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f1e44214abcb12cf7206d307273cc7f0fb1c459e
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/namespace.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/osm.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/osm.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f1320668e8e6c2316ebb0ce540f706f3d8225c8d
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/osm.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/packaging.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/packaging.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..995935770c8eaaf2c939654268b0d04592fa1ac9
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/packaging.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/pylab.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/pylab.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..53914e5daa5846e18bef38ff5861fc4161d77c27
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/pylab.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/__pycache__/script.cpython-312.pyc b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/script.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dbcf5ae239524d2bc762d8ca9c8100a4930b3ede
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/core/magics/__pycache__/script.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/core/magics/ast_mod.py b/lib/python3.12/site-packages/IPython/core/magics/ast_mod.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc3c5bc76838008d970f50416a4565ebb7ad78b9
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/ast_mod.py
@@ -0,0 +1,330 @@
+"""
+This module contains utility function and classes to inject simple ast
+transformations based on code strings into IPython. While it is already possible
+with ast-transformers it is not easy to directly manipulate ast.
+
+
+IPython has pre-code and post-code hooks, but are ran from within the IPython
+machinery so may be inappropriate, for example for performance measurement.
+
+This module give you tools to simplify this, and expose 2 classes:
+
+- `ReplaceCodeTransformer` which is a simple ast transformer based on code
+  template,
+
+and for advance case:
+
+- `Mangler` which is a simple ast transformer that mangle names in the ast.
+
+
+Example, let's try to make a simple version of the ``timeit`` magic, that run a
+code snippet 10 times and print the average time taken.
+
+Basically we want to run :
+
+.. code-block:: python
+
+    from time import perf_counter
+    now = perf_counter()
+    for i in range(10):
+        __code__ # our code
+    print(f"Time taken: {(perf_counter() - now)/10}")
+    __ret__ # the result of the last statement
+
+Where ``__code__`` is the code snippet we want to run, and ``__ret__`` is the
+result, so that if we for example run `dataframe.head()` IPython still display
+the head of dataframe instead of nothing.
+
+Here is a complete example of a file `timit2.py` that define such a magic:
+
+.. code-block:: python
+
+    from IPython.core.magic import (
+        Magics,
+        magics_class,
+        line_cell_magic,
+    )
+    from IPython.core.magics.ast_mod import ReplaceCodeTransformer
+    from textwrap import dedent
+    import ast
+
+    template = template = dedent('''
+        from time import perf_counter
+        now = perf_counter()
+        for i in range(10):
+            __code__
+        print(f"Time taken: {(perf_counter() - now)/10}")
+        __ret__
+    '''
+    )
+
+
+    @magics_class
+    class AstM(Magics):
+        @line_cell_magic
+        def t2(self, line, cell):
+            transformer = ReplaceCodeTransformer.from_string(template)
+            transformer.debug = True
+            transformer.mangler.debug = True
+            new_code = transformer.visit(ast.parse(cell))
+            return exec(compile(new_code, "<ast>", "exec"))
+
+
+    def load_ipython_extension(ip):
+        ip.register_magics(AstM)
+
+
+
+.. code-block:: python
+
+    In [1]: %load_ext timit2
+
+    In [2]: %%t2
+       ...: import time
+       ...: time.sleep(0.05)
+       ...:
+       ...:
+    Time taken: 0.05435649999999441
+
+
+If you wish to ran all the code enter in IPython in an ast transformer, you can
+do so as well:
+
+.. code-block:: python
+
+    In [1]: from IPython.core.magics.ast_mod import ReplaceCodeTransformer
+       ...:
+       ...: template = '''
+       ...: from time import perf_counter
+       ...: now = perf_counter()
+       ...: __code__
+       ...: print(f"Code ran in {perf_counter()-now}")
+       ...: __ret__'''
+       ...:
+       ...: get_ipython().ast_transformers.append(ReplaceCodeTransformer.from_string(template))
+
+    In [2]: 1+1
+    Code ran in 3.40410006174352e-05
+    Out[2]: 2
+
+
+
+Hygiene and Mangling
+--------------------
+
+The ast transformer above is not hygienic, it may not work if the user code use
+the same variable names as the ones used in the template. For example.
+
+To help with this by default the `ReplaceCodeTransformer` will mangle all names
+staring with 3 underscores. This is a simple heuristic that should work in most
+case, but can be cumbersome in some case. We provide a `Mangler` class that can
+be overridden to change the mangling heuristic, or simply use the `mangle_all`
+utility function. It will _try_ to mangle all names (except `__ret__` and
+`__code__`), but this include builtins (``print``, ``range``, ``type``) and
+replace those by invalid identifiers py prepending ``mangle-``:
+``mangle-print``, ``mangle-range``, ``mangle-type`` etc. This is not a problem
+as currently Python AST support invalid identifiers, but it may not be the case
+in the future.
+
+You can set `ReplaceCodeTransformer.debug=True` and
+`ReplaceCodeTransformer.mangler.debug=True` to see the code after mangling and
+transforming:
+
+.. code-block:: python
+
+
+    In [1]: from IPython.core.magics.ast_mod import ReplaceCodeTransformer, mangle_all
+       ...:
+       ...: template = '''
+       ...: from builtins import type, print
+       ...: from time import perf_counter
+       ...: now = perf_counter()
+       ...: __code__
+       ...: print(f"Code ran in {perf_counter()-now}")
+       ...: __ret__'''
+       ...:
+       ...: transformer = ReplaceCodeTransformer.from_string(template, mangling_predicate=mangle_all)
+
+
+    In [2]: transformer.debug = True
+       ...: transformer.mangler.debug = True
+       ...: get_ipython().ast_transformers.append(transformer)
+
+    In [3]: 1+1
+    Mangling Alias mangle-type
+    Mangling Alias mangle-print
+    Mangling Alias mangle-perf_counter
+    Mangling now
+    Mangling perf_counter
+    Not mangling __code__
+    Mangling print
+    Mangling perf_counter
+    Mangling now
+    Not mangling __ret__
+    ---- Transformed code ----
+    from builtins import type as mangle-type, print as mangle-print
+    from time import perf_counter as mangle-perf_counter
+    mangle-now = mangle-perf_counter()
+    ret-tmp = 1 + 1
+    mangle-print(f'Code ran in {mangle-perf_counter() - mangle-now}')
+    ret-tmp
+    ---- ---------------- ----
+    Code ran in 0.00013654199938173406
+    Out[3]: 2
+
+
+"""
+
+__skip_doctest__ = True
+
+
+from ast import (
+    NodeTransformer,
+    Store,
+    Load,
+    Name,
+    Expr,
+    Assign,
+    Module,
+    Import,
+    ImportFrom,
+)
+import ast
+import copy
+
+from typing import Dict, Optional, Union
+
+
+mangle_all = lambda name: False if name in ("__ret__", "__code__") else True
+
+
+class Mangler(NodeTransformer):
+    """
+    Mangle given names in and ast tree to make sure they do not conflict with
+    user code.
+    """
+
+    enabled: bool = True
+    debug: bool = False
+
+    def log(self, *args, **kwargs):
+        if self.debug:
+            print(*args, **kwargs)
+
+    def __init__(self, predicate=None):
+        if predicate is None:
+            predicate = lambda name: name.startswith("___")
+        self.predicate = predicate
+
+    def visit_Name(self, node):
+        if self.predicate(node.id):
+            self.log("Mangling", node.id)
+            # Once in the ast we do not need
+            # names to be valid identifiers.
+            node.id = "mangle-" + node.id
+        else:
+            self.log("Not mangling", node.id)
+        return node
+
+    def visit_FunctionDef(self, node):
+        if self.predicate(node.name):
+            self.log("Mangling", node.name)
+            node.name = "mangle-" + node.name
+        else:
+            self.log("Not mangling", node.name)
+
+        for arg in node.args.args:
+            if self.predicate(arg.arg):
+                self.log("Mangling function arg", arg.arg)
+                arg.arg = "mangle-" + arg.arg
+            else:
+                self.log("Not mangling function arg", arg.arg)
+        return self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ImportFrom):
+        return self._visit_Import_and_ImportFrom(node)
+
+    def visit_Import(self, node: Import):
+        return self._visit_Import_and_ImportFrom(node)
+
+    def _visit_Import_and_ImportFrom(self, node: Union[Import, ImportFrom]):
+        for alias in node.names:
+            asname = alias.name if alias.asname is None else alias.asname
+            if self.predicate(asname):
+                new_name: str = "mangle-" + asname
+                self.log("Mangling Alias", new_name)
+                alias.asname = new_name
+            else:
+                self.log("Not mangling Alias", alias.asname)
+        return node
+
+
+class ReplaceCodeTransformer(NodeTransformer):
+    enabled: bool = True
+    debug: bool = False
+    mangler: Mangler
+
+    def __init__(
+        self, template: Module, mapping: Optional[Dict] = None, mangling_predicate=None
+    ):
+        assert isinstance(mapping, (dict, type(None)))
+        assert isinstance(mangling_predicate, (type(None), type(lambda: None)))
+        assert isinstance(template, ast.Module)
+        self.template = template
+        self.mangler = Mangler(predicate=mangling_predicate)
+        if mapping is None:
+            mapping = {}
+        self.mapping = mapping
+
+    @classmethod
+    def from_string(
+        cls, template: str, mapping: Optional[Dict] = None, mangling_predicate=None
+    ):
+        return cls(
+            ast.parse(template), mapping=mapping, mangling_predicate=mangling_predicate
+        )
+
+    def visit_Module(self, code):
+        if not self.enabled:
+            return code
+        # if not isinstance(code, ast.Module):
+        # recursively called...
+        #    return generic_visit(self, code)
+        last = code.body[-1]
+        if isinstance(last, Expr):
+            code.body.pop()
+            code.body.append(Assign([Name("ret-tmp", ctx=Store())], value=last.value))
+            ast.fix_missing_locations(code)
+            ret = Expr(value=Name("ret-tmp", ctx=Load()))
+            ret = ast.fix_missing_locations(ret)
+            self.mapping["__ret__"] = ret
+        else:
+            self.mapping["__ret__"] = ast.parse("None").body[0]
+        self.mapping["__code__"] = code.body
+        tpl = ast.fix_missing_locations(self.template)
+
+        tx = copy.deepcopy(tpl)
+        tx = self.mangler.visit(tx)
+        node = self.generic_visit(tx)
+        node_2 = ast.fix_missing_locations(node)
+        if self.debug:
+            print("---- Transformed code ----")
+            print(ast.unparse(node_2))
+            print("---- ---------------- ----")
+        return node_2
+
+    # this does not work as the name might be in a list and one might want to extend the list.
+    # def visit_Name(self, name):
+    #     if name.id in self.mapping and name.id == "__ret__":
+    #         print(name, "in mapping")
+    #         if isinstance(name.ctx, ast.Store):
+    #             return Name("tmp", ctx=Store())
+    #         else:
+    #             return copy.deepcopy(self.mapping[name.id])
+    #     return name
+
+    def visit_Expr(self, expr):
+        if isinstance(expr.value, Name) and expr.value.id in self.mapping:
+            if self.mapping[expr.value.id] is not None:
+                return copy.deepcopy(self.mapping[expr.value.id])
+        return self.generic_visit(expr)
diff --git a/lib/python3.12/site-packages/IPython/core/magics/auto.py b/lib/python3.12/site-packages/IPython/core/magics/auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..329e7acdbe518725443352523112f4805322e8fe
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/auto.py
@@ -0,0 +1,144 @@
+"""Implementation of magic functions that control various automatic behaviors.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Our own packages
+from IPython.core.magic import Bunch, Magics, magics_class, line_magic
+from IPython.testing.skipdoctest import skip_doctest
+from logging import error
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+@magics_class
+class AutoMagics(Magics):
+    """Magics that control various autoX behaviors."""
+
+    def __init__(self, shell):
+        super(AutoMagics, self).__init__(shell)
+        # namespace for holding state we may need
+        self._magic_state = Bunch()
+
+    @line_magic
+    def automagic(self, parameter_s=''):
+        """Make magic functions callable without having to type the initial %.
+
+        Without arguments toggles on/off (when off, you must call it as
+        %automagic, of course).  With arguments it sets the value, and you can
+        use any of (case insensitive):
+
+         - on, 1, True: to activate
+
+         - off, 0, False: to deactivate.
+
+        Note that magic functions have lowest priority, so if there's a
+        variable whose name collides with that of a magic fn, automagic won't
+        work for that function (you get the variable instead). However, if you
+        delete the variable (del var), the previously shadowed magic function
+        becomes visible to automagic again."""
+
+        arg = parameter_s.lower()
+        mman = self.shell.magics_manager
+        if arg in ('on', '1', 'true'):
+            val = True
+        elif arg in ('off', '0', 'false'):
+            val = False
+        else:
+            val = not mman.auto_magic
+        mman.auto_magic = val
+        print('\n' + self.shell.magics_manager.auto_status())
+
+    @skip_doctest
+    @line_magic
+    def autocall(self, parameter_s=''):
+        """Make functions callable without having to type parentheses.
+
+        Usage:
+
+           %autocall [mode]
+
+        The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the
+        value is toggled on and off (remembering the previous state).
+
+        In more detail, these values mean:
+
+        0 -> fully disabled
+
+        1 -> active, but do not apply if there are no arguments on the line.
+
+        In this mode, you get::
+
+          In [1]: callable
+          Out[1]: <built-in function callable>
+
+          In [2]: callable 'hello'
+          ------> callable('hello')
+          Out[2]: False
+
+        2 -> Active always.  Even if no arguments are present, the callable
+        object is called::
+
+          In [2]: float
+          ------> float()
+          Out[2]: 0.0
+
+        Note that even with autocall off, you can still use '/' at the start of
+        a line to treat the first argument on the command line as a function
+        and add parentheses to it::
+
+          In [8]: /str 43
+          ------> str(43)
+          Out[8]: '43'
+
+        # all-random (note for auto-testing)
+        """
+
+        valid_modes = {
+            0: "Off",
+            1: "Smart",
+            2: "Full",
+        }
+
+        def errorMessage() -> str:
+            error = "Valid modes: "
+            for k, v in valid_modes.items():
+                error += str(k) + "->" + v + ", "
+            error = error[:-2]  # remove tailing `, ` after last element
+            return error
+
+        if parameter_s:
+            if parameter_s not in map(str, valid_modes.keys()):
+                error(errorMessage())
+                return
+            arg = int(parameter_s)
+        else:
+            arg = 'toggle'
+
+        if arg not in (*list(valid_modes.keys()), "toggle"):
+            error(errorMessage())
+            return
+
+        if arg in (valid_modes.keys()):
+            self.shell.autocall = arg
+        else: # toggle
+            if self.shell.autocall:
+                self._magic_state.autocall_save = self.shell.autocall
+                self.shell.autocall = 0
+            else:
+                try:
+                    self.shell.autocall = self._magic_state.autocall_save
+                except AttributeError:
+                    self.shell.autocall = self._magic_state.autocall_save = 1
+
+        print("Automatic calling is:", list(valid_modes.values())[self.shell.autocall])
diff --git a/lib/python3.12/site-packages/IPython/core/magics/config.py b/lib/python3.12/site-packages/IPython/core/magics/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e1cb38c254f412cae88890bdd2da92da5232908
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/config.py
@@ -0,0 +1,140 @@
+"""Implementation of configuration-related magic functions.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib
+import re
+
+# Our own packages
+from IPython.core.error import UsageError
+from IPython.core.magic import Magics, magics_class, line_magic
+from logging import error
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+reg = re.compile(r'^\w+\.\w+$')
+@magics_class
+class ConfigMagics(Magics):
+
+    def __init__(self, shell):
+        super(ConfigMagics, self).__init__(shell)
+        self.configurables = []
+
+    @line_magic
+    def config(self, s):
+        """configure IPython
+
+            %config Class[.trait=value]
+
+        This magic exposes most of the IPython config system. Any
+        Configurable class should be able to be configured with the simple
+        line::
+
+            %config Class.trait=value
+
+        Where `value` will be resolved in the user's namespace, if it is an
+        expression or variable name.
+
+        Examples
+        --------
+
+        To see what classes are available for config, pass no arguments::
+
+            In [1]: %config
+            Available objects for config:
+                AliasManager
+                DisplayFormatter
+                HistoryManager
+                IPCompleter
+                LoggingMagics
+                MagicsManager
+                OSMagics
+                PrefilterManager
+                ScriptMagics
+                TerminalInteractiveShell
+
+        To view what is configurable on a given class, just pass the class
+        name::
+
+            In [2]: %config LoggingMagics
+            LoggingMagics(Magics) options
+            ---------------------------
+            LoggingMagics.quiet=<Bool>
+                Suppress output of log state when logging is enabled
+                Current: False
+
+        but the real use is in setting values::
+
+            In [3]: %config LoggingMagics.quiet = True
+
+        and these values are read from the user_ns if they are variables::
+
+            In [4]: feeling_quiet=False
+
+            In [5]: %config LoggingMagics.quiet = feeling_quiet
+
+        """
+        from traitlets.config.loader import Config
+        # some IPython objects are Configurable, but do not yet have
+        # any configurable traits.  Exclude them from the effects of
+        # this magic, as their presence is just noise:
+        configurables = sorted(set([ c for c in self.shell.configurables
+                                     if c.__class__.class_traits(config=True)
+                                     ]), key=lambda x: x.__class__.__name__)
+        classnames = [ c.__class__.__name__ for c in configurables ]
+
+        line = s.strip()
+        if not line:
+            # print available configurable names
+            print("Available objects for config:")
+            for name in classnames:
+                print("   ", name)
+            return
+        elif line in classnames:
+            # `%config TerminalInteractiveShell` will print trait info for
+            # TerminalInteractiveShell
+            c = configurables[classnames.index(line)]
+            cls = c.__class__
+            help = cls.class_get_help(c)
+            # strip leading '--' from cl-args:
+            help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
+            print(help)
+            return
+        elif reg.match(line):
+            cls, attr = line.split('.')
+            return getattr(configurables[classnames.index(cls)],attr)
+        elif '=' not in line:
+            msg = "Invalid config statement: %r, "\
+                  "should be `Class.trait = value`."
+            
+            ll = line.lower()
+            for classname in classnames:
+                if ll == classname.lower():
+                    msg = msg + '\nDid you mean %s (note the case)?' % classname
+                    break
+
+            raise UsageError( msg % line)
+
+        # otherwise, assume we are setting configurables.
+        # leave quotes on args when splitting, because we want
+        # unquoted args to eval in user_ns
+        cfg = Config()
+        exec("cfg."+line, self.shell.user_ns, locals())
+
+        for configurable in configurables:
+            try:
+                configurable.update_config(cfg)
+            except Exception as e:
+                error(e)
diff --git a/lib/python3.12/site-packages/IPython/core/magics/display.py b/lib/python3.12/site-packages/IPython/core/magics/display.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c0eff6884f7666548f2c701c3a901b59f4c5abc
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/display.py
@@ -0,0 +1,93 @@
+"""Simple magics for display formats"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Our own packages
+from IPython.display import display, Javascript, Latex, SVG, HTML, Markdown
+from IPython.core.magic import  (
+    Magics, magics_class, cell_magic
+)
+from IPython.core import magic_arguments
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+
+@magics_class
+class DisplayMagics(Magics):
+    """Magics for displaying various output types with literals
+
+    Defines javascript/latex/svg/html cell magics for writing
+    blocks in those languages, to be rendered in the frontend.
+    """
+
+    @cell_magic
+    def js(self, line, cell):
+        """Run the cell block of Javascript code
+
+        Alias of `%%javascript`
+
+        Starting with IPython 8.0 %%javascript is pending deprecation to be replaced
+        by a more flexible system
+
+        Please See https://github.com/ipython/ipython/issues/13376
+        """
+        self.javascript(line, cell)
+
+    @cell_magic
+    def javascript(self, line, cell):
+        """Run the cell block of Javascript code
+
+        Starting with IPython 8.0 %%javascript is pending deprecation to be replaced
+        by a more flexible system
+
+        Please See https://github.com/ipython/ipython/issues/13376
+        """
+        display(Javascript(cell))
+
+
+    @cell_magic
+    def latex(self, line, cell):
+        """Render the cell as a block of LaTeX
+
+        The subset of LaTeX which is supported depends on the implementation in
+        the client.  In the Jupyter Notebook, this magic only renders the subset
+        of LaTeX defined by MathJax
+        [here](https://docs.mathjax.org/en/v2.5-latest/tex.html)."""
+        display(Latex(cell))
+
+    @cell_magic
+    def svg(self, line, cell):
+        """Render the cell as an SVG literal"""
+        display(SVG(cell))
+
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        '--isolated', action='store_true', default=False,
+        help="""Annotate the cell as 'isolated'.
+Isolated cells are rendered inside their own <iframe> tag"""
+    )
+    @cell_magic
+    def html(self, line, cell):
+        """Render the cell as a block of HTML"""
+        args = magic_arguments.parse_argstring(self.html, line)
+        html = HTML(cell)
+        if args.isolated:
+            display(html, metadata={'text/html':{'isolated':True}})
+        else:
+            display(html)
+
+    @cell_magic
+    def markdown(self, line, cell):
+        """Render the cell as Markdown text block"""
+        display(Markdown(cell))
diff --git a/lib/python3.12/site-packages/IPython/core/magics/execution.py b/lib/python3.12/site-packages/IPython/core/magics/execution.py
new file mode 100644
index 0000000000000000000000000000000000000000..313d0640b9683a88116b682a8f2917905c3e5562
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/execution.py
@@ -0,0 +1,1707 @@
+# -*- coding: utf-8 -*-
+"""Implementation of execution-related magic functions."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import ast
+import bdb
+import builtins as builtin_mod
+import copy
+import cProfile as profile
+import gc
+import itertools
+import math
+import os
+import pstats
+import re
+import shlex
+import sys
+import time
+import timeit
+import signal
+from typing import Dict, Any
+from ast import (
+    Assign,
+    Call,
+    Expr,
+    Load,
+    Module,
+    Name,
+    NodeTransformer,
+    Store,
+    parse,
+    unparse,
+)
+from io import StringIO
+from logging import error
+from pathlib import Path
+from pdb import Restart
+from textwrap import dedent, indent
+from warnings import warn
+
+from IPython.core import magic_arguments, oinspect, page
+from IPython.core.displayhook import DisplayHook
+from IPython.core.error import UsageError
+from IPython.core.macro import Macro
+from IPython.core.magic import (
+    Magics,
+    cell_magic,
+    line_cell_magic,
+    line_magic,
+    magics_class,
+    needs_local_scope,
+    no_var_expand,
+    on_off,
+    output_can_be_silenced,
+)
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.capture import capture_output
+from IPython.utils.contexts import preserve_keys
+from IPython.utils.ipstruct import Struct
+from IPython.utils.module_paths import find_mod
+from IPython.utils.path import get_py_filename, shellglob
+from IPython.utils.timing import clock, clock2
+from IPython.core.magics.ast_mod import ReplaceCodeTransformer
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+
+class TimeitResult:
+    """
+    Object returned by the timeit magic with info about the run.
+
+    Contains the following attributes:
+
+    loops: int
+      number of loops done per measurement
+
+    repeat: int
+      number of times the measurement was repeated
+
+    best: float
+      best execution time / number
+
+    all_runs : list[float]
+      execution time of each run (in s)
+
+    compile_time: float
+      time of statement compilation (s)
+
+    """
+    def __init__(self, loops, repeat, best, worst, all_runs, compile_time, precision):
+        self.loops = loops
+        self.repeat = repeat
+        self.best = best
+        self.worst = worst
+        self.all_runs = all_runs
+        self.compile_time = compile_time
+        self._precision = precision
+        self.timings = [dt / self.loops for dt in all_runs]
+
+    @property
+    def average(self):
+        return math.fsum(self.timings) / len(self.timings)
+
+    @property
+    def stdev(self):
+        mean = self.average
+        return (math.fsum([(x - mean) ** 2 for x in self.timings]) / len(self.timings)) ** 0.5
+
+    def __str__(self):
+        pm = '+-'
+        if hasattr(sys.stdout, 'encoding') and sys.stdout.encoding:
+            try:
+                "\xb1".encode(sys.stdout.encoding)
+                pm = "\xb1"
+            except:
+                pass
+        return "{mean} {pm} {std} per loop (mean {pm} std. dev. of {runs} run{run_plural}, {loops:,} loop{loop_plural} each)".format(
+            pm=pm,
+            runs=self.repeat,
+            loops=self.loops,
+            loop_plural="" if self.loops == 1 else "s",
+            run_plural="" if self.repeat == 1 else "s",
+            mean=_format_time(self.average, self._precision),
+            std=_format_time(self.stdev, self._precision),
+        )
+
+    def _repr_pretty_(self, p , cycle):
+        unic = self.__str__()
+        p.text("<TimeitResult : " + unic + ">")
+
+
+class TimeitTemplateFiller(ast.NodeTransformer):
+    """Fill in the AST template for timing execution.
+
+    This is quite closely tied to the template definition, which is in
+    :meth:`ExecutionMagics.timeit`.
+    """
+    def __init__(self, ast_setup, ast_stmt):
+        self.ast_setup = ast_setup
+        self.ast_stmt = ast_stmt
+
+    def visit_FunctionDef(self, node):
+        "Fill in the setup statement"
+        self.generic_visit(node)
+        if node.name == "inner":
+            node.body[:1] = self.ast_setup.body
+
+        return node
+
+    def visit_For(self, node):
+        "Fill in the statement to be timed"
+        if getattr(getattr(node.body[0], 'value', None), 'id', None) == 'stmt':
+            node.body = self.ast_stmt.body
+        return node
+
+
+class Timer(timeit.Timer):
+    """Timer class that explicitly uses self.inner
+
+    which is an undocumented implementation detail of CPython,
+    not shared by PyPy.
+    """
+
+    # Timer.timeit copied from CPython 3.4.2
+    def timeit(self, number=timeit.default_number):
+        """Time 'number' executions of the main statement.
+
+        To be precise, this executes the setup statement once, and
+        then returns the time it takes to execute the main statement
+        a number of times, as a float measured in seconds.  The
+        argument is the number of times through the loop, defaulting
+        to one million.  The main statement, the setup statement and
+        the timer function to be used are passed to the constructor.
+        """
+        it = itertools.repeat(None, number)
+        gcold = gc.isenabled()
+        gc.disable()
+        try:
+            timing = self.inner(it, self.timer)
+        finally:
+            if gcold:
+                gc.enable()
+        return timing
+
+
+@magics_class
+class ExecutionMagics(Magics):
+    """Magics related to code execution, debugging, profiling, etc."""
+
+    _transformers: Dict[str, Any] = {}
+
+    def __init__(self, shell):
+        super(ExecutionMagics, self).__init__(shell)
+        # Default execution function used to actually run user code.
+        self.default_runner = None
+
+    @skip_doctest
+    @no_var_expand
+    @line_cell_magic
+    def prun(self, parameter_s='', cell=None):
+        """Run a statement through the python code profiler.
+
+        **Usage, in line mode**::
+
+          %prun [options] statement
+
+        **Usage, in cell mode**::
+
+          %%prun [options] [statement]
+          code...
+          code...
+
+        In cell mode, the additional code lines are appended to the (possibly
+        empty) statement in the first line.  Cell mode allows you to easily
+        profile multiline blocks without having to put them in a separate
+        function.
+
+        The given statement (which doesn't require quote marks) is run via the
+        python profiler in a manner similar to the profile.run() function.
+        Namespaces are internally managed to work correctly; profile.run
+        cannot be used in IPython because it makes certain assumptions about
+        namespaces which do not hold under IPython.
+
+        Options:
+
+        -l <limit>
+          you can place restrictions on what or how much of the
+          profile gets printed. The limit value can be:
+
+             * A string: only information for function names containing this string
+               is printed.
+
+             * An integer: only these many lines are printed.
+
+             * A float (between 0 and 1): this fraction of the report is printed
+               (for example, use a limit of 0.4 to see the topmost 40% only).
+
+          You can combine several limits with repeated use of the option. For
+          example, ``-l __init__ -l 5`` will print only the topmost 5 lines of
+          information about class constructors.
+
+        -r
+          return the pstats.Stats object generated by the profiling. This
+          object has all the information about the profile in it, and you can
+          later use it for further analysis or in other functions.
+
+        -s <key>
+          sort profile by given key. You can provide more than one key
+          by using the option several times: '-s key1 -s key2 -s key3...'. The
+          default sorting key is 'time'.
+
+          The following is copied verbatim from the profile documentation
+          referenced below:
+
+          When more than one key is provided, additional keys are used as
+          secondary criteria when the there is equality in all keys selected
+          before them.
+
+          Abbreviations can be used for any key names, as long as the
+          abbreviation is unambiguous.  The following are the keys currently
+          defined:
+
+          ============  =====================
+          Valid Arg     Meaning
+          ============  =====================
+          "calls"       call count
+          "cumulative"  cumulative time
+          "file"        file name
+          "module"      file name
+          "pcalls"      primitive call count
+          "line"        line number
+          "name"        function name
+          "nfl"         name/file/line
+          "stdname"     standard name
+          "time"        internal time
+          ============  =====================
+
+          Note that all sorts on statistics are in descending order (placing
+          most time consuming items first), where as name, file, and line number
+          searches are in ascending order (i.e., alphabetical). The subtle
+          distinction between "nfl" and "stdname" is that the standard name is a
+          sort of the name as printed, which means that the embedded line
+          numbers get compared in an odd way.  For example, lines 3, 20, and 40
+          would (if the file names were the same) appear in the string order
+          "20" "3" and "40".  In contrast, "nfl" does a numeric compare of the
+          line numbers.  In fact, sort_stats("nfl") is the same as
+          sort_stats("name", "file", "line").
+
+        -T <filename>
+          save profile results as shown on screen to a text
+          file. The profile is still shown on screen.
+
+        -D <filename>
+          save (via dump_stats) profile statistics to given
+          filename. This data is in a format understood by the pstats module, and
+          is generated by a call to the dump_stats() method of profile
+          objects. The profile is still shown on screen.
+
+        -q
+          suppress output to the pager.  Best used with -T and/or -D above.
+
+        If you want to run complete programs under the profiler's control, use
+        ``%run -p [prof_opts] filename.py [args to program]`` where prof_opts
+        contains profiler specific options as described here.
+
+        You can read the complete documentation for the profile module with::
+
+          In [1]: import profile; profile.help()
+
+        .. versionchanged:: 7.3
+            User variables are no longer expanded,
+            the magic line is always left unmodified.
+
+        """
+        # TODO: port to magic_arguments as currently this is duplicated in IPCompleter._extract_code
+        opts, arg_str = self.parse_options(parameter_s, 'D:l:rs:T:q',
+                                           list_all=True, posix=False)
+        if cell is not None:
+            arg_str += '\n' + cell
+        arg_str = self.shell.transform_cell(arg_str)
+        return self._run_with_profiler(arg_str, opts, self.shell.user_ns)
+
+    def _run_with_profiler(self, code, opts, namespace):
+        """
+        Run `code` with profiler.  Used by ``%prun`` and ``%run -p``.
+
+        Parameters
+        ----------
+        code : str
+            Code to be executed.
+        opts : Struct
+            Options parsed by `self.parse_options`.
+        namespace : dict
+            A dictionary for Python namespace (e.g., `self.shell.user_ns`).
+
+        """
+
+        # Fill default values for unspecified options:
+        opts.merge(Struct(D=[''], l=[], s=['time'], T=['']))
+
+        prof = profile.Profile()
+        try:
+            prof = prof.runctx(code, namespace, namespace)
+            sys_exit = ''
+        except SystemExit:
+            sys_exit = """*** SystemExit exception caught in code being profiled."""
+
+        stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
+
+        lims = opts.l
+        if lims:
+            lims = []  # rebuild lims with ints/floats/strings
+            for lim in opts.l:
+                try:
+                    lims.append(int(lim))
+                except ValueError:
+                    try:
+                        lims.append(float(lim))
+                    except ValueError:
+                        lims.append(lim)
+
+        # Trap output.
+        stdout_trap = StringIO()
+        stats_stream = stats.stream
+        try:
+            stats.stream = stdout_trap
+            stats.print_stats(*lims)
+        finally:
+            stats.stream = stats_stream
+
+        output = stdout_trap.getvalue()
+        output = output.rstrip()
+
+        if 'q' not in opts:
+            page.page(output)
+        print(sys_exit, end=' ')
+
+        dump_file = opts.D[0]
+        text_file = opts.T[0]
+        if dump_file:
+            prof.dump_stats(dump_file)
+            print(
+                f"\n*** Profile stats marshalled to file {repr(dump_file)}.{sys_exit}"
+            )
+        if text_file:
+            pfile = Path(text_file)
+            pfile.touch(exist_ok=True)
+            pfile.write_text(output, encoding="utf-8")
+
+            print(
+                f"\n*** Profile printout saved to text file {repr(text_file)}.{sys_exit}"
+            )
+
+        if 'r' in opts:
+            return stats
+
+        return None
+
+    @line_magic
+    def pdb(self, parameter_s=''):
+        """Control the automatic calling of the pdb interactive debugger.
+
+        Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
+        argument it works as a toggle.
+
+        When an exception is triggered, IPython can optionally call the
+        interactive pdb debugger after the traceback printout. %pdb toggles
+        this feature on and off.
+
+        The initial state of this feature is set in your configuration
+        file (the option is ``InteractiveShell.pdb``).
+
+        If you want to just activate the debugger AFTER an exception has fired,
+        without having to type '%pdb on' and rerunning your code, you can use
+        the %debug magic."""
+
+        par = parameter_s.strip().lower()
+
+        if par:
+            try:
+                new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
+            except KeyError:
+                print ('Incorrect argument. Use on/1, off/0, '
+                       'or nothing for a toggle.')
+                return
+        else:
+            # toggle
+            new_pdb = not self.shell.call_pdb
+
+        # set on the shell
+        self.shell.call_pdb = new_pdb
+        print('Automatic pdb calling has been turned',on_off(new_pdb))
+
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument('--breakpoint', '-b', metavar='FILE:LINE',
+        help="""
+        Set break point at LINE in FILE.
+        """
+    )
+    @magic_arguments.kwds(
+        epilog="""
+      Any remaining arguments will be treated as code to run in the debugger.
+    """
+    )
+    @no_var_expand
+    @line_cell_magic
+    @needs_local_scope
+    def debug(self, line="", cell=None, local_ns=None):
+        """Activate the interactive debugger.
+
+        This magic command support two ways of activating debugger.
+        One is to activate debugger before executing code. This way, you
+        can set a break point, to step through the code from the point.
+        You can use this mode by giving statements to execute and optionally
+        a breakpoint.
+
+        The other one is to activate debugger in post-mortem mode. You can
+        activate this mode simply running %debug without any argument.
+        If an exception has just occurred, this lets you inspect its stack
+        frames interactively.  Note that this will always work only on the last
+        traceback that occurred, so you must call this quickly after an
+        exception that you wish to inspect has fired, because if another one
+        occurs, it clobbers the previous one.
+
+        If you want IPython to automatically do this on every exception, see
+        the %pdb magic for more details.
+
+        .. versionchanged:: 7.3
+            When running code, user variables are no longer expanded,
+            the magic line is always left unmodified.
+
+        """
+        args, extra = magic_arguments.parse_argstring(self.debug, line, partial=True)
+
+        if not (args.breakpoint or extra or cell):
+            self._debug_post_mortem()
+        elif not (args.breakpoint or cell):
+            # If there is no breakpoints, the line is just code to execute
+            self._debug_exec(line, None, local_ns)
+        else:
+            # Here we try to reconstruct the code from the output of
+            # parse_argstring. This might not work if the code has spaces
+            # For example this fails for `print("a b")`
+            code = " ".join(extra)
+            if cell:
+                code += "\n" + cell
+            self._debug_exec(code, args.breakpoint, local_ns)
+
+    def _debug_post_mortem(self):
+        self.shell.debugger(force=True)
+
+    def _debug_exec(self, code, breakpoint, local_ns=None):
+        if breakpoint:
+            (filename, bp_line) = breakpoint.rsplit(':', 1)
+            bp_line = int(bp_line)
+        else:
+            (filename, bp_line) = (None, None)
+        self._run_with_debugger(
+            code, self.shell.user_ns, filename, bp_line, local_ns=local_ns
+        )
+
+    @line_magic
+    def tb(self, s):
+        """Print the last traceback.
+
+        Optionally, specify an exception reporting mode, tuning the
+        verbosity of the traceback. By default the currently-active exception
+        mode is used. See %xmode for changing exception reporting modes.
+
+        Valid modes: Plain, Context, Verbose, and Minimal.
+        """
+        interactive_tb = self.shell.InteractiveTB
+        if s:
+            # Switch exception reporting mode for this one call.
+            # Ensure it is switched back.
+            def xmode_switch_err(name):
+                warn('Error changing %s exception modes.\n%s' %
+                    (name,sys.exc_info()[1]))
+
+            new_mode = s.strip().capitalize()
+            original_mode = interactive_tb.mode
+            try:
+                try:
+                    interactive_tb.set_mode(mode=new_mode)
+                except Exception:
+                    xmode_switch_err('user')
+                else:
+                    self.shell.showtraceback()
+            finally:
+                interactive_tb.set_mode(mode=original_mode)
+        else:
+            self.shell.showtraceback()
+
+    @skip_doctest
+    @line_magic
+    def run(self, parameter_s='', runner=None,
+                  file_finder=get_py_filename):
+        """Run the named file inside IPython as a program.
+
+        Usage::
+
+          %run [-n -i -e -G]
+               [( -t [-N<N>] | -d [-b<N>] | -p [profile options] )]
+               ( -m mod | filename ) [args]
+
+        The filename argument should be either a pure Python script (with
+        extension ``.py``), or a file with custom IPython syntax (such as
+        magics). If the latter, the file can be either a script with ``.ipy``
+        extension, or a Jupyter notebook with ``.ipynb`` extension. When running
+        a Jupyter notebook, the output from print statements and other
+        displayed objects will appear in the terminal (even matplotlib figures
+        will open, if a terminal-compliant backend is being used). Note that,
+        at the system command line, the ``jupyter run`` command offers similar
+        functionality for executing notebooks (albeit currently with some
+        differences in supported options).
+
+        Parameters after the filename are passed as command-line arguments to
+        the program (put in sys.argv). Then, control returns to IPython's
+        prompt.
+
+        This is similar to running at a system prompt ``python file args``,
+        but with the advantage of giving you IPython's tracebacks, and of
+        loading all variables into your interactive namespace for further use
+        (unless -p is used, see below).
+
+        The file is executed in a namespace initially consisting only of
+        ``__name__=='__main__'`` and sys.argv constructed as indicated. It thus
+        sees its environment as if it were being run as a stand-alone program
+        (except for sharing global objects such as previously imported
+        modules). But after execution, the IPython interactive namespace gets
+        updated with all variables defined in the program (except for ``__name__``
+        and ``sys.argv``). This allows for very convenient loading of code for
+        interactive work, while giving each program a 'clean sheet' to run in.
+
+        Arguments are expanded using shell-like glob match.  Patterns
+        '*', '?', '[seq]' and '[!seq]' can be used.  Additionally,
+        tilde '~' will be expanded into user's home directory.  Unlike
+        real shells, quotation does not suppress expansions.  Use
+        *two* back slashes (e.g. ``\\\\*``) to suppress expansions.
+        To completely disable these expansions, you can use -G flag.
+
+        On Windows systems, the use of single quotes `'` when specifying
+        a file is not supported. Use double quotes `"`.
+
+        Options:
+
+        -n
+          __name__ is NOT set to '__main__', but to the running file's name
+          without extension (as python does under import).  This allows running
+          scripts and reloading the definitions in them without calling code
+          protected by an ``if __name__ == "__main__"`` clause.
+
+        -i
+          run the file in IPython's namespace instead of an empty one. This
+          is useful if you are experimenting with code written in a text editor
+          which depends on variables defined interactively.
+
+        -e
+          ignore sys.exit() calls or SystemExit exceptions in the script
+          being run.  This is particularly useful if IPython is being used to
+          run unittests, which always exit with a sys.exit() call.  In such
+          cases you are interested in the output of the test results, not in
+          seeing a traceback of the unittest module.
+
+        -t
+          print timing information at the end of the run.  IPython will give
+          you an estimated CPU time consumption for your script, which under
+          Unix uses the resource module to avoid the wraparound problems of
+          time.clock().  Under Unix, an estimate of time spent on system tasks
+          is also given (for Windows platforms this is reported as 0.0).
+
+          If -t is given, an additional ``-N<N>`` option can be given, where <N>
+          must be an integer indicating how many times you want the script to
+          run.  The final timing report will include total and per run results.
+
+          For example (testing the script myscript.py)::
+
+              In [1]: run -t myscript
+
+              IPython CPU timings (estimated):
+                User  :    0.19597 s.
+                System:        0.0 s.
+
+              In [2]: run -t -N5 myscript
+
+              IPython CPU timings (estimated):
+              Total runs performed: 5
+                Times :      Total       Per run
+                User  :   0.910862 s,  0.1821724 s.
+                System:        0.0 s,        0.0 s.
+
+        -d
+          run your program under the control of pdb, the Python debugger.
+          This allows you to execute your program step by step, watch variables,
+          etc.  Internally, what IPython does is similar to calling::
+
+              pdb.run('execfile("YOURFILENAME")')
+
+          with a breakpoint set on line 1 of your file.  You can change the line
+          number for this automatic breakpoint to be <N> by using the -bN option
+          (where N must be an integer). For example::
+
+              %run -d -b40 myscript
+
+          will set the first breakpoint at line 40 in myscript.py.  Note that
+          the first breakpoint must be set on a line which actually does
+          something (not a comment or docstring) for it to stop execution.
+
+          Or you can specify a breakpoint in a different file::
+
+              %run -d -b myotherfile.py:20 myscript
+
+          When the pdb debugger starts, you will see a (Pdb) prompt.  You must
+          first enter 'c' (without quotes) to start execution up to the first
+          breakpoint.
+
+          Entering 'help' gives information about the use of the debugger.  You
+          can easily see pdb's full documentation with "import pdb;pdb.help()"
+          at a prompt.
+
+        -p
+          run program under the control of the Python profiler module (which
+          prints a detailed report of execution times, function calls, etc).
+
+          You can pass other options after -p which affect the behavior of the
+          profiler itself. See the docs for %prun for details.
+
+          In this mode, the program's variables do NOT propagate back to the
+          IPython interactive namespace (because they remain in the namespace
+          where the profiler executes them).
+
+          Internally this triggers a call to %prun, see its documentation for
+          details on the options available specifically for profiling.
+
+        There is one special usage for which the text above doesn't apply:
+        if the filename ends with .ipy[nb], the file is run as ipython script,
+        just as if the commands were written on IPython prompt.
+
+        -m
+          specify module name to load instead of script path. Similar to
+          the -m option for the python interpreter. Use this option last if you
+          want to combine with other %run options. Unlike the python interpreter
+          only source modules are allowed no .pyc or .pyo files.
+          For example::
+
+              %run -m example
+
+          will run the example module.
+
+        -G
+          disable shell-like glob expansion of arguments.
+
+        """
+
+        # Logic to handle issue #3664
+        # Add '--' after '-m <module_name>' to ignore additional args passed to a module.
+        if '-m' in parameter_s and '--' not in parameter_s:
+            argv = shlex.split(parameter_s, posix=(os.name == 'posix'))
+            for idx, arg in enumerate(argv):
+                if arg and arg.startswith('-') and arg != '-':
+                    if arg == '-m':
+                        argv.insert(idx + 2, '--')
+                        break
+                else:
+                    # Positional arg, break
+                    break
+            parameter_s = ' '.join(shlex.quote(arg) for arg in argv)
+
+        # get arguments and set sys.argv for program to be run.
+        opts, arg_lst = self.parse_options(parameter_s,
+                                           'nidtN:b:pD:l:rs:T:em:G',
+                                           mode='list', list_all=1)
+        if "m" in opts:
+            modulename = opts["m"][0]
+            modpath = find_mod(modulename)
+            if modpath is None:
+                msg = '%r is not a valid modulename on sys.path'%modulename
+                raise Exception(msg)
+            arg_lst = [modpath] + arg_lst
+        try:
+            fpath = None # initialize to make sure fpath is in scope later
+            fpath = arg_lst[0]
+            filename = file_finder(fpath)
+        except IndexError as e:
+            msg = 'you must provide at least a filename.'
+            raise Exception(msg) from e
+        except IOError as e:
+            try:
+                msg = str(e)
+            except UnicodeError:
+                msg = e.message
+            if os.name == 'nt' and re.match(r"^'.*'$",fpath):
+                warn('For Windows, use double quotes to wrap a filename: %run "mypath\\myfile.py"')
+            raise Exception(msg) from e
+        except TypeError:
+            if fpath in sys.meta_path:
+                filename = ""
+            else:
+                raise
+
+        if filename.lower().endswith(('.ipy', '.ipynb')):
+            with preserve_keys(self.shell.user_ns, '__file__'):
+                self.shell.user_ns['__file__'] = filename
+                self.shell.safe_execfile_ipy(filename, raise_exceptions=True)
+            return
+
+        # Control the response to exit() calls made by the script being run
+        exit_ignore = 'e' in opts
+
+        # Make sure that the running script gets a proper sys.argv as if it
+        # were run from a system shell.
+        save_argv = sys.argv # save it for later restoring
+
+        if 'G' in opts:
+            args = arg_lst[1:]
+        else:
+            # tilde and glob expansion
+            args = shellglob(map(os.path.expanduser,  arg_lst[1:]))
+
+        sys.argv = [filename] + args  # put in the proper filename
+
+        if 'n' in opts:
+            name = Path(filename).stem
+        else:
+            name = '__main__'
+
+        if 'i' in opts:
+            # Run in user's interactive namespace
+            prog_ns = self.shell.user_ns
+            __name__save = self.shell.user_ns['__name__']
+            prog_ns['__name__'] = name
+            main_mod = self.shell.user_module
+
+            # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
+            # set the __file__ global in the script's namespace
+            # TK: Is this necessary in interactive mode?
+            prog_ns['__file__'] = filename
+        else:
+            # Run in a fresh, empty namespace
+
+            # The shell MUST hold a reference to prog_ns so after %run
+            # exits, the python deletion mechanism doesn't zero it out
+            # (leaving dangling references). See interactiveshell for details
+            main_mod = self.shell.new_main_mod(filename, name)
+            prog_ns = main_mod.__dict__
+
+        # pickle fix.  See interactiveshell for an explanation.  But we need to
+        # make sure that, if we overwrite __main__, we replace it at the end
+        main_mod_name = prog_ns['__name__']
+
+        if main_mod_name == '__main__':
+            restore_main = sys.modules['__main__']
+        else:
+            restore_main = False
+
+        # This needs to be undone at the end to prevent holding references to
+        # every single object ever created.
+        sys.modules[main_mod_name] = main_mod
+
+        if 'p' in opts or 'd' in opts:
+            if 'm' in opts:
+                code = 'run_module(modulename, prog_ns)'
+                code_ns = {
+                    'run_module': self.shell.safe_run_module,
+                    'prog_ns': prog_ns,
+                    'modulename': modulename,
+                }
+            else:
+                if 'd' in opts:
+                    # allow exceptions to raise in debug mode
+                    code = 'execfile(filename, prog_ns, raise_exceptions=True)'
+                else:
+                    code = 'execfile(filename, prog_ns)'
+                code_ns = {
+                    'execfile': self.shell.safe_execfile,
+                    'prog_ns': prog_ns,
+                    'filename': get_py_filename(filename),
+                }
+
+        try:
+            stats = None
+            if 'p' in opts:
+                stats = self._run_with_profiler(code, opts, code_ns)
+            else:
+                if 'd' in opts:
+                    bp_file, bp_line = parse_breakpoint(
+                        opts.get('b', ['1'])[0], filename)
+                    self._run_with_debugger(
+                        code, code_ns, filename, bp_line, bp_file)
+                else:
+                    if 'm' in opts:
+                        def run():
+                            self.shell.safe_run_module(modulename, prog_ns)
+                    else:
+                        if runner is None:
+                            runner = self.default_runner
+                        if runner is None:
+                            runner = self.shell.safe_execfile
+
+                        def run():
+                            runner(filename, prog_ns, prog_ns,
+                                    exit_ignore=exit_ignore)
+
+                    if 't' in opts:
+                        # timed execution
+                        try:
+                            nruns = int(opts['N'][0])
+                            if nruns < 1:
+                                error('Number of runs must be >=1')
+                                return
+                        except (KeyError):
+                            nruns = 1
+                        self._run_with_timing(run, nruns)
+                    else:
+                        # regular execution
+                        run()
+
+            if 'i' in opts:
+                self.shell.user_ns['__name__'] = __name__save
+            else:
+                # update IPython interactive namespace
+
+                # Some forms of read errors on the file may mean the
+                # __name__ key was never set; using pop we don't have to
+                # worry about a possible KeyError.
+                prog_ns.pop('__name__', None)
+
+                with preserve_keys(self.shell.user_ns, '__file__'):
+                    self.shell.user_ns.update(prog_ns)
+        finally:
+            # It's a bit of a mystery why, but __builtins__ can change from
+            # being a module to becoming a dict missing some key data after
+            # %run.  As best I can see, this is NOT something IPython is doing
+            # at all, and similar problems have been reported before:
+            # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
+            # Since this seems to be done by the interpreter itself, the best
+            # we can do is to at least restore __builtins__ for the user on
+            # exit.
+            self.shell.user_ns['__builtins__'] = builtin_mod
+
+            # Ensure key global structures are restored
+            sys.argv = save_argv
+            if restore_main:
+                sys.modules['__main__'] = restore_main
+                if '__mp_main__' in sys.modules:
+                    sys.modules['__mp_main__'] = restore_main
+            else:
+                # Remove from sys.modules the reference to main_mod we'd
+                # added.  Otherwise it will trap references to objects
+                # contained therein.
+                del sys.modules[main_mod_name]
+
+        return stats
+
+    def _run_with_debugger(
+        self, code, code_ns, filename=None, bp_line=None, bp_file=None, local_ns=None
+    ):
+        """
+        Run `code` in debugger with a break point.
+
+        Parameters
+        ----------
+        code : str
+            Code to execute.
+        code_ns : dict
+            A namespace in which `code` is executed.
+        filename : str
+            `code` is ran as if it is in `filename`.
+        bp_line : int, optional
+            Line number of the break point.
+        bp_file : str, optional
+            Path to the file in which break point is specified.
+            `filename` is used if not given.
+        local_ns : dict, optional
+            A local namespace in which `code` is executed.
+
+        Raises
+        ------
+        UsageError
+            If the break point given by `bp_line` is not valid.
+
+        """
+        deb = self.shell.InteractiveTB.pdb
+        if not deb:
+            self.shell.InteractiveTB.pdb = self.shell.InteractiveTB.debugger_cls()
+            deb = self.shell.InteractiveTB.pdb
+
+        # reset Breakpoint state, which is moronically kept
+        # in a class
+        bdb.Breakpoint.next = 1
+        bdb.Breakpoint.bplist = {}
+        bdb.Breakpoint.bpbynumber = [None]
+        deb.clear_all_breaks()
+        if bp_line is not None:
+            # Set an initial breakpoint to stop execution
+            maxtries = 10
+            bp_file = bp_file or filename
+            checkline = deb.checkline(bp_file, bp_line)
+            if not checkline:
+                for bp in range(bp_line + 1, bp_line + maxtries + 1):
+                    if deb.checkline(bp_file, bp):
+                        break
+                else:
+                    msg = ("\nI failed to find a valid line to set "
+                           "a breakpoint\n"
+                           "after trying up to line: %s.\n"
+                           "Please set a valid breakpoint manually "
+                           "with the -b option." % bp)
+                    raise UsageError(msg)
+            # if we find a good linenumber, set the breakpoint
+            deb.do_break('%s:%s' % (bp_file, bp_line))
+
+        if filename:
+            # Mimic Pdb._runscript(...)
+            deb._wait_for_mainpyfile = True
+            deb.mainpyfile = deb.canonic(filename)
+
+        # Start file run
+        print("NOTE: Enter 'c' at the %s prompt to continue execution." % deb.prompt)
+        try:
+            if filename:
+                # save filename so it can be used by methods on the deb object
+                deb._exec_filename = filename
+            while True:
+                try:
+                    trace = sys.gettrace()
+                    deb.run(code, code_ns, local_ns)
+                except Restart:
+                    print("Restarting")
+                    if filename:
+                        deb._wait_for_mainpyfile = True
+                        deb.mainpyfile = deb.canonic(filename)
+                    continue
+                else:
+                    break
+                finally:
+                    sys.settrace(trace)
+
+            # Perform proper cleanup of the session in case if
+            # it exited with "continue" and not "quit" command
+            if hasattr(deb, "rcLines"):
+                # Run this code defensively in case if custom debugger
+                # class does not implement rcLines, which although public
+                # is an implementation detail of `pdb.Pdb` and not part of
+                # the more generic basic debugger framework (`bdb.Bdb`).
+                deb.set_quit()
+                deb.rcLines.extend(["q"])
+                try:
+                    deb.run("", code_ns, local_ns)
+                except StopIteration:
+                    # Stop iteration is raised on quit command
+                    pass
+
+        except Exception:
+            etype, value, tb = sys.exc_info()
+            # Skip three frames in the traceback: the %run one,
+            # one inside bdb.py, and the command-line typed by the
+            # user (run by exec in pdb itself).
+            self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
+
+    @staticmethod
+    def _run_with_timing(run, nruns):
+        """
+        Run function `run` and print timing information.
+
+        Parameters
+        ----------
+        run : callable
+            Any callable object which takes no argument.
+        nruns : int
+            Number of times to execute `run`.
+
+        """
+        twall0 = time.perf_counter()
+        if nruns == 1:
+            t0 = clock2()
+            run()
+            t1 = clock2()
+            t_usr = t1[0] - t0[0]
+            t_sys = t1[1] - t0[1]
+            print("\nIPython CPU timings (estimated):")
+            print("  User   : %10.2f s." % t_usr)
+            print("  System : %10.2f s." % t_sys)
+        else:
+            runs = range(nruns)
+            t0 = clock2()
+            for nr in runs:
+                run()
+            t1 = clock2()
+            t_usr = t1[0] - t0[0]
+            t_sys = t1[1] - t0[1]
+            print("\nIPython CPU timings (estimated):")
+            print("Total runs performed:", nruns)
+            print("  Times  : %10s   %10s" % ('Total', 'Per run'))
+            print("  User   : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns))
+            print("  System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns))
+        twall1 = time.perf_counter()
+        print("Wall time: %10.2f s." % (twall1 - twall0))
+
+    @skip_doctest
+    @no_var_expand
+    @line_cell_magic
+    @needs_local_scope
+    def timeit(self, line='', cell=None, local_ns=None):
+        """Time execution of a Python statement or expression
+
+        **Usage, in line mode**::
+
+          %timeit [-n<N> -r<R> [-t|-c] -q -p<P> [-o|-v <V>]] statement
+
+        **or in cell mode**::
+
+          %%timeit [-n<N> -r<R> [-t|-c] -q -p<P> [-o|-v <V>]] setup_code
+          code
+          code...
+
+        Time execution of a Python statement or expression using the timeit
+        module.  This function can be used both as a line and cell magic:
+
+        - In line mode you can time a single-line statement (though multiple
+          ones can be chained with using semicolons).
+
+        - In cell mode, the statement in the first line is used as setup code
+          (executed but not timed) and the body of the cell is timed.  The cell
+          body has access to any variables created in the setup code.
+
+        Options:
+
+        -n<N>
+          Execute the given statement N times in a loop. If N is not
+          provided, N is determined so as to get sufficient accuracy.
+
+        -r<R>
+          Number of repeats R, each consisting of N loops, and take the
+          average result.
+          Default: 7
+
+        -t
+          Use ``time.time`` to measure the time, which is the default on Unix.
+          This function measures wall time.
+
+        -c
+          Use ``time.clock`` to measure the time, which is the default on
+          Windows and measures wall time. On Unix, ``resource.getrusage`` is used
+          instead and returns the CPU user time.
+
+        -p<P>
+          Use a precision of P digits to display the timing result.
+          Default: 3
+
+        -q
+          Quiet, do not print result.
+
+        -o
+          Return a ``TimeitResult`` that can be stored in a variable to inspect
+          the result in more details.
+
+        -v <V>
+          Like ``-o``, but save the ``TimeitResult`` directly to variable <V>.
+
+        .. versionchanged:: 7.3
+            User variables are no longer expanded,
+            the magic line is always left unmodified.
+
+        Examples
+        --------
+        ::
+
+          In [1]: %timeit pass
+          8.26 ns ± 0.12 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
+
+          In [2]: u = None
+
+          In [3]: %timeit u is None
+          29.9 ns ± 0.643 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+
+          In [4]: %timeit -r 4 u == None
+
+          In [5]: import time
+
+          In [6]: %timeit -n1 time.sleep(2)
+
+        The times reported by ``%timeit`` will be slightly higher than those
+        reported by the timeit.py script when variables are accessed. This is
+        due to the fact that ``%timeit`` executes the statement in the namespace
+        of the shell, compared with timeit.py, which uses a single setup
+        statement to import function or create variables. Generally, the bias
+        does not matter as long as results from timeit.py are not mixed with
+        those from ``%timeit``."""
+
+        # TODO: port to magic_arguments as currently this is duplicated in IPCompleter._extract_code
+        opts, stmt = self.parse_options(
+            line, "n:r:tcp:qov:", posix=False, strict=False, preserve_non_opts=True
+        )
+        if stmt == "" and cell is None:
+            return
+
+        timefunc = timeit.default_timer
+        number = int(getattr(opts, "n", 0))
+        default_repeat = 7 if timeit.default_repeat < 7 else timeit.default_repeat
+        repeat = int(getattr(opts, "r", default_repeat))
+        precision = int(getattr(opts, "p", 3))
+        quiet = "q" in opts
+        return_result = "o" in opts
+        save_result = "v" in opts
+        if hasattr(opts, "t"):
+            timefunc = time.time
+        if hasattr(opts, "c"):
+            timefunc = clock
+
+        timer = Timer(timer=timefunc)
+        # this code has tight coupling to the inner workings of timeit.Timer,
+        # but is there a better way to achieve that the code stmt has access
+        # to the shell namespace?
+        transform  = self.shell.transform_cell
+
+        if cell is None:
+            # called as line magic
+            ast_setup = self.shell.compile.ast_parse("pass")
+            ast_stmt = self.shell.compile.ast_parse(transform(stmt))
+        else:
+            ast_setup = self.shell.compile.ast_parse(transform(stmt))
+            ast_stmt = self.shell.compile.ast_parse(transform(cell))
+
+        ast_setup = self.shell.transform_ast(ast_setup)
+        ast_stmt = self.shell.transform_ast(ast_stmt)
+
+        # Check that these compile to valid Python code *outside* the timer func
+        # Invalid code may become valid when put inside the function & loop,
+        # which messes up error messages.
+        # https://github.com/ipython/ipython/issues/10636
+        self.shell.compile(ast_setup, "<magic-timeit-setup>", "exec")
+        self.shell.compile(ast_stmt, "<magic-timeit-stmt>", "exec")
+
+        # This codestring is taken from timeit.template - we fill it in as an
+        # AST, so that we can apply our AST transformations to the user code
+        # without affecting the timing code.
+        timeit_ast_template = ast.parse('def inner(_it, _timer):\n'
+                                        '    setup\n'
+                                        '    _t0 = _timer()\n'
+                                        '    for _i in _it:\n'
+                                        '        stmt\n'
+                                        '    _t1 = _timer()\n'
+                                        '    return _t1 - _t0\n')
+
+        timeit_ast = TimeitTemplateFiller(ast_setup, ast_stmt).visit(timeit_ast_template)
+        timeit_ast = ast.fix_missing_locations(timeit_ast)
+
+        # Track compilation time so it can be reported if too long
+        # Minimum time above which compilation time will be reported
+        tc_min = 0.1
+
+        t0 = clock()
+        code = self.shell.compile(timeit_ast, "<magic-timeit>", "exec")
+        tc = clock()-t0
+
+        ns = {}
+        glob = self.shell.user_ns
+        # handles global vars with same name as local vars. We store them in conflict_globs.
+        conflict_globs = {}
+        if local_ns and cell is None:
+            for var_name, var_val in glob.items():
+                if var_name in local_ns:
+                    conflict_globs[var_name] = var_val
+            glob.update(local_ns)
+
+        exec(code, glob, ns)
+        timer.inner = ns["inner"]
+
+        # This is used to check if there is a huge difference between the
+        # best and worst timings.
+        # Issue: https://github.com/ipython/ipython/issues/6471
+        if number == 0:
+            # determine number so that 0.2 <= total time < 2.0
+            for index in range(0, 10):
+                number = 10 ** index
+                time_number = timer.timeit(number)
+                if time_number >= 0.2:
+                    break
+
+        all_runs = timer.repeat(repeat, number)
+        best = min(all_runs) / number
+        worst = max(all_runs) / number
+        timeit_result = TimeitResult(number, repeat, best, worst, all_runs, tc, precision)
+
+        # Restore global vars from conflict_globs
+        if conflict_globs:
+            glob.update(conflict_globs)
+
+        if not quiet:
+            # Check best timing is greater than zero to avoid a
+            # ZeroDivisionError.
+            # In cases where the slowest timing is lesser than a microsecond
+            # we assume that it does not really matter if the fastest
+            # timing is 4 times faster than the slowest timing or not.
+            if worst > 4 * best and best > 0 and worst > 1e-6:
+                print("The slowest run took %0.2f times longer than the "
+                      "fastest. This could mean that an intermediate result "
+                      "is being cached." % (worst / best))
+
+            print( timeit_result )
+
+            if tc > tc_min:
+                print("Compiler time: %.2f s" % tc)
+
+        if save_result:
+            self.shell.user_ns[opts.v] = timeit_result
+
+        if return_result:
+            return timeit_result
+
+    @no_var_expand
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        "--no-raise-error",
+        action="store_true",
+        dest="no_raise_error",
+        help="If given, don't re-raise exceptions",
+    )
+    @magic_arguments.kwds(
+        epilog="""
+      Any remaining arguments will be treated as code to run.
+    """
+    )
+    @skip_doctest
+    @needs_local_scope
+    @line_cell_magic
+    @output_can_be_silenced
+    def time(self, line="", cell=None, local_ns=None):
+        """Time execution of a Python statement or expression.
+
+        The CPU and wall clock times are printed, and the value of the
+        expression (if any) is returned.  Note that under Win32, system time
+        is always reported as 0, since it can not be measured.
+
+        This function can be used both as a line and cell magic:
+
+        - In line mode you can time a single-line statement (though multiple
+          ones can be chained with using semicolons).
+
+        - In cell mode, you can time the cell body (a directly
+          following statement raises an error).
+
+        This function provides very basic timing functionality. Use the timeit
+        magic for more control over the measurement.
+
+        .. versionchanged:: 7.3
+            User variables are no longer expanded,
+            the magic line is always left unmodified.
+
+        .. versionchanged:: 8.3
+            The time magic now correctly propagates system-exiting exceptions
+            (such as ``KeyboardInterrupt`` invoked when interrupting execution)
+            rather than just printing out the exception traceback.
+            The non-system-exception will still be caught as before.
+
+        Examples
+        --------
+        ::
+
+          In [1]: %time 2**128
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00
+          Out[1]: 340282366920938463463374607431768211456L
+
+          In [2]: n = 1000000
+
+          In [3]: %time sum(range(n))
+          CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
+          Wall time: 1.37
+          Out[3]: 499999500000L
+
+          In [4]: %time print('hello world')
+          hello world
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00
+
+        .. note::
+            The time needed by Python to compile the given expression will be
+            reported if it is more than 0.1s.
+
+            In the example below, the actual exponentiation is done by Python
+            at compilation time, so while the expression can take a noticeable
+            amount of time to compute, that time is purely due to the
+            compilation::
+
+                In [5]: %time 3**9999;
+                CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+                Wall time: 0.00 s
+
+                In [6]: %time 3**999999;
+                CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+                Wall time: 0.00 s
+                Compiler : 0.78 s
+        """
+        args, extra = magic_arguments.parse_argstring(self.time, line, partial=True)
+        line = " ".join(extra)
+
+        if line and cell:
+            raise UsageError("Can't use statement directly after '%%time'!")
+
+        if cell:
+            expr = self.shell.transform_cell(cell)
+        else:
+            expr = self.shell.transform_cell(line)
+
+        # Minimum time above which parse time will be reported
+        tp_min = 0.1
+
+        t0 = clock()
+        expr_ast = self.shell.compile.ast_parse(expr)
+        tp = clock() - t0
+
+        # Apply AST transformations
+        expr_ast = self.shell.transform_ast(expr_ast)
+
+        # Minimum time above which compilation time will be reported
+        tc_min = 0.1
+
+        expr_val = None
+        if len(expr_ast.body) == 1 and isinstance(expr_ast.body[0], ast.Expr):
+            mode = 'eval'
+            source = '<timed eval>'
+            expr_ast = ast.Expression(expr_ast.body[0].value)
+        else:
+            mode = 'exec'
+            source = '<timed exec>'
+            # multi-line %%time case
+            if len(expr_ast.body) > 1 and isinstance(expr_ast.body[-1], ast.Expr):
+                expr_val = expr_ast.body[-1]
+                expr_ast = expr_ast.body[:-1]
+                expr_ast = Module(expr_ast, [])
+                expr_val = ast.Expression(expr_val.value)
+
+        t0 = clock()
+        code = self.shell.compile(expr_ast, source, mode)
+        tc = clock() - t0
+
+        # skew measurement as little as possible
+        glob = self.shell.user_ns
+        wtime = time.time
+        # time execution
+        wall_st = wtime()
+        # Track whether to propagate exceptions or exit
+        exit_on_interrupt = False
+        interrupt_occured = False
+        captured_exception = None
+
+        if mode == "eval":
+            st = clock2()
+            try:
+                out = eval(code, glob, local_ns)
+            except KeyboardInterrupt as e:
+                captured_exception = e
+                interrupt_occured = True
+                exit_on_interrupt = True
+            except Exception as e:
+                captured_exception = e
+                interrupt_occured = True
+                if not args.no_raise_error:
+                    exit_on_interrupt = True
+            end = clock2()
+        else:
+            st = clock2()
+            try:
+                exec(code, glob, local_ns)
+                out = None
+                # multi-line %%time case
+                if expr_val is not None:
+                    code_2 = self.shell.compile(expr_val, source, 'eval')
+                    out = eval(code_2, glob, local_ns)
+            except KeyboardInterrupt as e:
+                captured_exception = e
+                interrupt_occured = True
+                exit_on_interrupt = True
+            except Exception as e:
+                captured_exception = e
+                interrupt_occured = True
+                if not args.no_raise_error:
+                    exit_on_interrupt = True
+            end = clock2()
+        wall_end = wtime()
+        # Compute actual times and report
+        wall_time = wall_end - wall_st
+        cpu_user = end[0] - st[0]
+        cpu_sys = end[1] - st[1]
+        cpu_tot = cpu_user + cpu_sys
+        # On windows cpu_sys is always zero, so only total is displayed
+        if sys.platform != "win32":
+            print(
+                f"CPU times: user {_format_time(cpu_user)}, sys: {_format_time(cpu_sys)}, total: {_format_time(cpu_tot)}"
+            )
+        else:
+            print(f"CPU times: total: {_format_time(cpu_tot)}")
+        print(f"Wall time: {_format_time(wall_time)}")
+        if tc > tc_min:
+            print(f"Compiler : {_format_time(tc)}")
+        if tp > tp_min:
+            print(f"Parser   : {_format_time(tp)}")
+        if interrupt_occured:
+            if exit_on_interrupt and captured_exception:
+                raise captured_exception
+            return
+        return out
+
+    @skip_doctest
+    @line_magic
+    def macro(self, parameter_s=''):
+        """Define a macro for future re-execution. It accepts ranges of history,
+        filenames or string objects.
+
+        Usage::
+
+          %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
+
+        Options:
+
+        -r
+          Use 'raw' input.  By default, the 'processed' history is used,
+          so that magics are loaded in their transformed version to valid
+          Python.  If this option is given, the raw input as typed at the
+          command line is used instead.
+
+        -q
+          Quiet macro definition.  By default, a tag line is printed
+          to indicate the macro has been created, and then the contents of
+          the macro are printed.  If this option is given, then no printout
+          is produced once the macro is created.
+
+        This will define a global variable called `name` which is a string
+        made of joining the slices and lines you specify (n1,n2,... numbers
+        above) from your input history into a single string. This variable
+        acts like an automatic function which re-executes those lines as if
+        you had typed them. You just type 'name' at the prompt and the code
+        executes.
+
+        The syntax for indicating input ranges is described in %history.
+
+        Note: as a 'hidden' feature, you can also use traditional python slice
+        notation, where N:M means numbers N through M-1.
+
+        For example, if your history contains (print using %hist -n )::
+
+          44: x=1
+          45: y=3
+          46: z=x+y
+          47: print(x)
+          48: a=5
+          49: print('x',x,'y',y)
+
+        you can create a macro with lines 44 through 47 (included) and line 49
+        called my_macro with::
+
+          In [55]: %macro my_macro 44-47 49
+
+        Now, typing `my_macro` (without quotes) will re-execute all this code
+        in one pass.
+
+        You don't need to give the line-numbers in order, and any given line
+        number can appear multiple times. You can assemble macros with any
+        lines from your input history in any order.
+
+        The macro is a simple object which holds its value in an attribute,
+        but IPython's display system checks for macros and executes them as
+        code instead of printing them when you type their name.
+
+        You can view a macro's contents by explicitly printing it with::
+
+          print(macro_name)
+
+        """
+        opts,args = self.parse_options(parameter_s,'rq',mode='list')
+        if not args:   # List existing macros
+            return sorted(k for k,v in self.shell.user_ns.items() if isinstance(v, Macro))
+        if len(args) == 1:
+            raise UsageError(
+                "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
+        name, codefrom = args[0], " ".join(args[1:])
+
+        # print('rng',ranges)  # dbg
+        try:
+            lines = self.shell.find_user_code(codefrom, 'r' in opts)
+        except (ValueError, TypeError) as e:
+            print(e.args[0])
+            return
+        macro = Macro(lines)
+        self.shell.define_macro(name, macro)
+        if "q" not in opts:
+            print(
+                "Macro `%s` created. To execute, type its name (without quotes)." % name
+            )
+            print("=== Macro contents: ===")
+            print(macro, end=" ")
+
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        "output",
+        type=str,
+        default="",
+        nargs="?",
+        help="""
+
+        The name of the variable in which to store output.
+        This is a ``utils.io.CapturedIO`` object with stdout/err attributes
+        for the text of the captured output.
+
+        CapturedOutput also has a ``show()`` method for displaying the output,
+        and ``__call__`` as well, so you can use that to quickly display the
+        output.
+
+        If unspecified, captured output is discarded.
+        """,
+    )
+    @magic_arguments.argument(
+        "--no-stderr", action="store_true", help="""Don't capture stderr."""
+    )
+    @magic_arguments.argument(
+        "--no-stdout", action="store_true", help="""Don't capture stdout."""
+    )
+    @magic_arguments.argument(
+        "--no-display",
+        action="store_true",
+        help="""Don't capture IPython's rich display."""
+    )
+    @cell_magic
+    def capture(self, line, cell):
+        """run the cell, capturing stdout, stderr, and IPython's rich display() calls."""
+        args = magic_arguments.parse_argstring(self.capture, line)
+        out = not args.no_stdout
+        err = not args.no_stderr
+        disp = not args.no_display
+        with capture_output(out, err, disp) as io:
+            self.shell.run_cell(cell)
+        if DisplayHook.semicolon_at_end_of_expression(cell):
+            if args.output in self.shell.user_ns:
+                del self.shell.user_ns[args.output]
+        elif args.output:
+            self.shell.user_ns[args.output] = io
+
+    @skip_doctest
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument("name", type=str, default="default", nargs="?")
+    @magic_arguments.argument(
+        "--remove", action="store_true", help="remove the current transformer"
+    )
+    @magic_arguments.argument(
+        "--list", action="store_true", help="list existing transformers name"
+    )
+    @magic_arguments.argument(
+        "--list-all",
+        action="store_true",
+        help="list existing transformers name and code template",
+    )
+    @line_cell_magic
+    def code_wrap(self, line, cell=None):
+        """
+        Simple magic to quickly define a code transformer for all IPython's future input.
+
+        ``__code__`` and ``__ret__`` are special variable that represent the code to run
+        and the value of the last expression of ``__code__`` respectively.
+
+        Examples
+        --------
+
+        .. ipython::
+
+            In [1]: %%code_wrap before_after
+               ...: print('before')
+               ...: __code__
+               ...: print('after')
+               ...: __ret__
+
+
+            In [2]: 1
+            before
+            after
+            Out[2]: 1
+
+            In [3]: %code_wrap --list
+            before_after
+
+            In [4]: %code_wrap --list-all
+            before_after :
+                print('before')
+                __code__
+                print('after')
+                __ret__
+
+            In [5]: %code_wrap --remove before_after
+
+        """
+        args = magic_arguments.parse_argstring(self.code_wrap, line)
+
+        if args.list:
+            for name in self._transformers.keys():
+                print(name)
+            return
+        if args.list_all:
+            for name, _t in self._transformers.items():
+                print(name, ":")
+                print(indent(ast.unparse(_t.template), "    "))
+            print()
+            return
+
+        to_remove = self._transformers.pop(args.name, None)
+        if to_remove in self.shell.ast_transformers:
+            self.shell.ast_transformers.remove(to_remove)
+        if cell is None or args.remove:
+            return
+
+        _trs = ReplaceCodeTransformer(ast.parse(cell))
+
+        self._transformers[args.name] = _trs
+        self.shell.ast_transformers.append(_trs)
+
+
+def parse_breakpoint(text, current_file):
+    '''Returns (file, line) for file:line and (current_file, line) for line'''
+    colon = text.find(':')
+    if colon == -1:
+        return current_file, int(text)
+    else:
+        return text[:colon], int(text[colon+1:])
+
+
+def _format_time(timespan, precision=3):
+    """Formats the timespan in a human readable form"""
+
+    if timespan >= 60.0:
+        # we have more than a minute, format that in a human readable form
+        # Idea from http://snipplr.com/view/5713/
+        parts = [("d", 60 * 60 * 24), ("h", 60 * 60), ("min", 60), ("s", 1)]
+        time = []
+        leftover = timespan
+        for suffix, length in parts:
+            value = int(leftover / length)
+            if value > 0:
+                leftover = leftover % length
+                time.append("%s%s" % (str(value), suffix))
+            if leftover < 1:
+                break
+        return " ".join(time)
+
+    # Unfortunately characters outside of range(128) can cause problems in
+    # certain terminals.
+    # See bug: https://bugs.launchpad.net/ipython/+bug/348466
+    # Try to prevent crashes by being more secure than it needs to
+    # E.g. eclipse is able to print a µ, but has no sys.stdout.encoding set.
+    units = ["s", "ms", "us", "ns"]  # the safe value
+    if hasattr(sys.stdout, "encoding") and sys.stdout.encoding:
+        try:
+            "μ".encode(sys.stdout.encoding)
+            units = ["s", "ms", "μs", "ns"]
+        except:
+            pass
+    scaling = [1, 1e3, 1e6, 1e9]
+
+    if timespan > 0.0:
+        order = min(-int(math.floor(math.log10(timespan)) // 3), 3)
+    else:
+        order = 3
+    return "%.*g %s" % (precision, timespan * scaling[order], units[order])
diff --git a/lib/python3.12/site-packages/IPython/core/magics/history.py b/lib/python3.12/site-packages/IPython/core/magics/history.py
new file mode 100644
index 0000000000000000000000000000000000000000..54b19ce36968c9d0b5f134a332324bc1b0032f29
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/history.py
@@ -0,0 +1,361 @@
+"""Implementation of magic functions related to History.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012, IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib
+import os
+import sys
+from io import open as io_open
+import fnmatch
+
+# Our own packages
+from IPython.core.error import StdinNotImplementedError
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.core.magic_arguments import (argument, magic_arguments,
+                                          parse_argstring)
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils import io
+
+#-----------------------------------------------------------------------------
+# Magics class implementation
+#-----------------------------------------------------------------------------
+
+
+_unspecified = object()
+
+
+@magics_class
+class HistoryMagics(Magics):
+
+    @magic_arguments()
+    @argument(
+        '-n', dest='print_nums', action='store_true', default=False,
+        help="""
+        print line numbers for each input.
+        This feature is only available if numbered prompts are in use.
+        """)
+    @argument(
+        '-o', dest='get_output', action='store_true', default=False,
+        help="also print outputs for each input.")
+    @argument(
+        '-p', dest='pyprompts', action='store_true', default=False,
+        help="""
+        print classic '>>>' python prompts before each input.
+        This is useful for making documentation, and in conjunction
+        with -o, for producing doctest-ready output.
+        """)
+    @argument(
+        '-t', dest='raw', action='store_false', default=True,
+        help="""
+        print the 'translated' history, as IPython understands it.
+        IPython filters your input and converts it all into valid Python
+        source before executing it (things like magics or aliases are turned
+        into function calls, for example). With this option, you'll see the
+        native history instead of the user-entered version: '%%cd /' will be
+        seen as 'get_ipython().run_line_magic("cd", "/")' instead of '%%cd /'.
+        """)
+    @argument(
+        '-f', dest='filename',
+        help="""
+        FILENAME: instead of printing the output to the screen, redirect
+        it to the given file.  The file is always overwritten, though *when
+        it can*, IPython asks for confirmation first. In particular, running
+        the command 'history -f FILENAME' from the IPython Notebook
+        interface will replace FILENAME even if it already exists *without*
+        confirmation.
+        """,
+    )
+    @argument(
+        "-y",
+        dest="overwrite",
+        help="yes, overwrite filename even if exists",
+        action="store_true",
+        default=None,
+    )
+    @argument(
+        "-g",
+        dest="pattern",
+        nargs="*",
+        default=None,
+        help="""
+        treat the arg as a glob pattern to search for in (full) history.
+        This includes the saved history (almost all commands ever written).
+        The pattern may contain '?' to match one unknown character and '*'
+        to match any number of unknown characters. Use '%%hist -g' to show
+        full saved history (may be very long).
+        """)
+    @argument(
+        '-l', dest='limit', type=int, nargs='?', default=_unspecified,
+        help="""
+        get the last n lines from all sessions. Specify n as a single
+        arg, or the default is the last 10 lines.
+        """)
+    @argument(
+        '-u', dest='unique', action='store_true',
+        help="""
+        when searching history using `-g`, show only unique history.
+        """)
+    @argument('range', nargs='*')
+    @skip_doctest
+    @line_magic
+    def history(self, parameter_s = ''):
+        """Print input history (_i<n> variables), with most recent last.
+
+        By default, input history is printed without line numbers so it can be
+        directly pasted into an editor. Use -n to show them.
+
+        By default, all input history from the current session is displayed.
+        Ranges of history can be indicated using the syntax:
+
+        ``4``
+            Line 4, current session
+        ``4-6``
+            Lines 4-6, current session
+        ``4-``
+            Lines 4 onward (to end), current session
+        ``243/1-5``
+            Lines 1-5, session 243
+        ``~2/``
+            All lines of session 2 before current
+        ``~4/4-``
+            Lines 4 onward (to end), session 4 before current
+        ``~2/7``
+            Line 7, session 2 before current
+        ``~8/1-~6/5``
+            From the first line of 8 sessions ago, to the fifth line of 6
+            sessions ago.
+
+        Multiple ranges can be entered, separated by spaces
+
+        The same syntax is used by %macro, %save, %edit, %rerun
+
+        Examples
+        --------
+        ::
+
+          In [6]: %history -n 4-6
+          4:a = 12
+          5:print(a**2)
+          6:%history -n 4-6
+
+        """
+
+        args = parse_argstring(self.history, parameter_s)
+
+        # For brevity
+        history_manager = self.shell.history_manager
+
+        def _format_lineno(session, line):
+            """Helper function to format line numbers properly."""
+            if session in (0, history_manager.session_number):
+                return str(line)
+            return "%s/%s" % (session, line)
+
+        # Check if output to specific file was requested.
+        outfname = args.filename
+        if not outfname:
+            outfile = sys.stdout  # default
+            # We don't want to close stdout at the end!
+            close_at_end = False
+        else:
+            outfname = os.path.expanduser(outfname)
+            if args.overwrite is True:
+                ans = True
+            elif os.path.exists(outfname):
+                ans = True
+                if sys.stdin.isatty():
+                    ans = io.ask_yes_no("File %r exists. Overwrite?" % outfname)
+                else:
+                    try:
+                        ans = io.ask_yes_no("File %r exists. Overwrite?" % outfname)
+                    except StdinNotImplementedError:
+                        ans = True
+                if not ans:
+                    print("Aborting.")
+                    return
+                print("Overwriting file.")
+            outfile = io_open(outfname, 'w', encoding='utf-8')
+            close_at_end = True
+
+        print_nums = args.print_nums
+        get_output = args.get_output
+        pyprompts = args.pyprompts
+        raw = args.raw
+
+        pattern = None
+        limit = None if args.limit is _unspecified else args.limit
+
+        range_pattern = False
+        if args.pattern is not None and not args.range:
+            if args.pattern:
+                pattern = "*" + " ".join(args.pattern) + "*"
+            else:
+                pattern = "*"
+            hist = history_manager.search(pattern, raw=raw, output=get_output,
+                                          n=limit, unique=args.unique)
+            print_nums = True
+        elif args.limit is not _unspecified:
+            n = 10 if limit is None else limit
+            hist = history_manager.get_tail(n, raw=raw, output=get_output)
+        else:
+            if args.pattern:
+                range_pattern = "*" + " ".join(args.pattern) + "*"
+                print_nums = True
+            hist = history_manager.get_range_by_str(
+                " ".join(args.range), raw, get_output
+            )
+
+        # We could be displaying the entire history, so let's not try to pull
+        # it into a list in memory. Anything that needs more space will just
+        # misalign.
+        width = 4
+
+        for session, lineno, inline in hist:
+            # Print user history with tabs expanded to 4 spaces.  The GUI
+            # clients use hard tabs for easier usability in auto-indented code,
+            # but we want to produce PEP-8 compliant history for safe pasting
+            # into an editor.
+            if get_output:
+                inline, output = inline
+            if range_pattern:
+                if not fnmatch.fnmatch(inline, range_pattern):
+                    continue
+            inline = inline.expandtabs(4).rstrip()
+
+            multiline = "\n" in inline
+            line_sep = '\n' if multiline else ' '
+            if print_nums:
+                print(u'%s:%s' % (_format_lineno(session, lineno).rjust(width),
+                        line_sep),  file=outfile, end=u'')
+            if pyprompts:
+                print(u">>> ", end=u"", file=outfile)
+                if multiline:
+                    inline = "\n... ".join(inline.splitlines()) + "\n..."
+            print(inline, file=outfile)
+            if get_output and output:
+                print(output, file=outfile)
+
+        if close_at_end:
+            outfile.close()
+
+    @line_magic
+    def recall(self, arg):
+        r"""Repeat a command, or get command to input line for editing.
+
+        %recall and %rep are equivalent.
+
+        - %recall (no arguments):
+
+        Place a string version of last computation result (stored in the
+        special '_' variable) to the next input prompt. Allows you to create
+        elaborate command lines without using copy-paste::
+
+             In[1]: l = ["hei", "vaan"]
+             In[2]: "".join(l)
+            Out[2]: heivaan
+             In[3]: %recall
+             In[4]: heivaan_ <== cursor blinking
+
+        %recall 45
+
+        Place history line 45 on the next input prompt. Use %hist to find
+        out the number.
+
+        %recall 1-4
+
+        Combine the specified lines into one cell, and place it on the next
+        input prompt. See %history for the slice syntax.
+
+        %recall foo+bar
+
+        If foo+bar can be evaluated in the user namespace, the result is
+        placed at the next input prompt. Otherwise, the history is searched
+        for lines which contain that substring, and the most recent one is
+        placed at the next input prompt.
+        """
+        if not arg:                 # Last output
+            self.shell.set_next_input(str(self.shell.user_ns["_"]))
+            return
+                                    # Get history range
+        histlines = self.shell.history_manager.get_range_by_str(arg)
+        cmd = "\n".join(x[2] for x in histlines)
+        if cmd:
+            self.shell.set_next_input(cmd.rstrip())
+            return
+
+        try:                        # Variable in user namespace
+            cmd = str(eval(arg, self.shell.user_ns))
+        except Exception:           # Search for term in history
+            histlines = self.shell.history_manager.search("*"+arg+"*")
+            for h in reversed([x[2] for x in histlines]):
+                if 'recall' in h or 'rep' in h:
+                    continue
+                self.shell.set_next_input(h.rstrip())
+                return
+        else:
+            self.shell.set_next_input(cmd.rstrip())
+            return
+        print("Couldn't evaluate or find in history:", arg)
+
+    @line_magic
+    def rerun(self, parameter_s=''):
+        """Re-run previous input
+
+        By default, you can specify ranges of input history to be repeated
+        (as with %history). With no arguments, it will repeat the last line.
+
+        Options:
+
+          -l <n> : Repeat the last n lines of input, not including the
+          current command.
+
+          -g foo : Repeat the most recent line which contains foo
+        """
+        opts, args = self.parse_options(parameter_s, 'l:g:', mode='string')
+        if "l" in opts:         # Last n lines
+            try:
+                n = int(opts["l"])
+            except ValueError:
+                print("Number of lines must be an integer")
+                return
+
+            if n == 0:
+                print("Requested 0 last lines - nothing to run")
+                return
+            elif n < 0:
+                print("Number of lines to rerun cannot be negative")
+                return
+
+            hist = self.shell.history_manager.get_tail(n)
+        elif "g" in opts:       # Search
+            p = "*"+opts['g']+"*"
+            hist = list(self.shell.history_manager.search(p))
+            for l in reversed(hist):
+                if "rerun" not in l[2]:
+                    hist = [l]     # The last match which isn't a %rerun
+                    break
+            else:
+                hist = []          # No matches except %rerun
+        elif args:              # Specify history ranges
+            hist = self.shell.history_manager.get_range_by_str(args)
+        else:                   # Last line
+            hist = self.shell.history_manager.get_tail(1)
+        hist = [x[2] for x in hist]
+        if not hist:
+            print("No lines in history match specification")
+            return
+        histlines = "\n".join(hist)
+        print("=== Executing: ===")
+        print(histlines)
+        print("=== Output: ===")
+        self.shell.run_cell("\n".join(hist), store_history=False)
diff --git a/lib/python3.12/site-packages/IPython/core/magics/namespace.py b/lib/python3.12/site-packages/IPython/core/magics/namespace.py
new file mode 100644
index 0000000000000000000000000000000000000000..82cc181fec0a89b6e0999a973a0413b33399e49f
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/namespace.py
@@ -0,0 +1,723 @@
+"""Implementation of namespace-related magic functions.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib
+import gc
+import re
+import sys
+
+# Our own packages
+from IPython.core import page
+from IPython.core.error import StdinNotImplementedError, UsageError
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.encoding import DEFAULT_ENCODING
+from IPython.utils.openpy import read_py_file
+from IPython.utils.path import get_py_filename
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+@magics_class
+class NamespaceMagics(Magics):
+    """Magics to manage various aspects of the user's namespace.
+
+    These include listing variables, introspecting into them, etc.
+    """
+
+    @line_magic
+    def pinfo(self, parameter_s='', namespaces=None):
+        """Provide detailed information about an object.
+
+        '%pinfo object' is just a synonym for object? or ?object."""
+
+        # print('pinfo par: <%s>' % parameter_s)  # dbg
+        # detail_level: 0 -> obj? , 1 -> obj??
+        detail_level = 0
+        # We need to detect if we got called as 'pinfo pinfo foo', which can
+        # happen if the user types 'pinfo foo?' at the cmd line.
+        pinfo,qmark1,oname,qmark2 = \
+               re.match(r'(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
+        if pinfo or qmark1 or qmark2:
+            detail_level = 1
+        if "*" in oname:
+            self.psearch(oname)
+        else:
+            self.shell._inspect('pinfo', oname, detail_level=detail_level,
+                                namespaces=namespaces)
+
+    @line_magic
+    def pinfo2(self, parameter_s='', namespaces=None):
+        """Provide extra detailed information about an object.
+
+        '%pinfo2 object' is just a synonym for object?? or ??object."""
+        self.shell._inspect('pinfo', parameter_s, detail_level=1,
+                            namespaces=namespaces)
+
+    @skip_doctest
+    @line_magic
+    def pdef(self, parameter_s='', namespaces=None):
+        """Print the call signature for any callable object.
+
+        If the object is a class, print the constructor information.
+
+        Examples
+        --------
+        ::
+
+          In [3]: %pdef urllib.urlopen
+          urllib.urlopen(url, data=None, proxies=None)
+        """
+        self.shell._inspect('pdef',parameter_s, namespaces)
+
+    @line_magic
+    def pdoc(self, parameter_s='', namespaces=None):
+        """Print the docstring for an object.
+
+        If the given object is a class, it will print both the class and the
+        constructor docstrings."""
+        self.shell._inspect('pdoc',parameter_s, namespaces)
+
+    @line_magic
+    def psource(self, parameter_s='', namespaces=None):
+        """Print (or run through pager) the source code for an object."""
+        if not parameter_s:
+            raise UsageError('Missing object name.')
+        self.shell._inspect('psource',parameter_s, namespaces)
+
+    @line_magic
+    def pfile(self, parameter_s='', namespaces=None):
+        """Print (or run through pager) the file where an object is defined.
+
+        The file opens at the line where the object definition begins. IPython
+        will honor the environment variable PAGER if set, and otherwise will
+        do its best to print the file in a convenient form.
+
+        If the given argument is not an object currently defined, IPython will
+        try to interpret it as a filename (automatically adding a .py extension
+        if needed). You can thus use %pfile as a syntax highlighting code
+        viewer."""
+
+        # first interpret argument as an object name
+        out = self.shell._inspect('pfile',parameter_s, namespaces)
+        # if not, try the input as a filename
+        if out == 'not found':
+            try:
+                filename = get_py_filename(parameter_s)
+            except IOError as msg:
+                print(msg)
+                return
+            page.page(self.shell.pycolorize(read_py_file(filename, skip_encoding_cookie=False)))
+
+    @line_magic
+    def psearch(self, parameter_s=''):
+        """Search for object in namespaces by wildcard.
+
+        %psearch [options] PATTERN [OBJECT TYPE]
+
+        Note: ? can be used as a synonym for %psearch, at the beginning or at
+        the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the
+        rest of the command line must be unchanged (options come first), so
+        for example the following forms are equivalent
+
+        %psearch -i a* function
+        -i a* function?
+        ?-i a* function
+
+        Arguments:
+
+          PATTERN
+
+          where PATTERN is a string containing * as a wildcard similar to its
+          use in a shell.  The pattern is matched in all namespaces on the
+          search path. By default objects starting with a single _ are not
+          matched, many IPython generated objects have a single
+          underscore. The default is case insensitive matching. Matching is
+          also done on the attributes of objects and not only on the objects
+          in a module.
+
+          [OBJECT TYPE]
+
+          Is the name of a python type from the types module. The name is
+          given in lowercase without the ending type, ex. StringType is
+          written string. By adding a type here only objects matching the
+          given type are matched. Using all here makes the pattern match all
+          types (this is the default).
+
+        Options:
+
+          -a: makes the pattern match even objects whose names start with a
+          single underscore.  These names are normally omitted from the
+          search.
+
+          -i/-c: make the pattern case insensitive/sensitive.  If neither of
+          these options are given, the default is read from your configuration
+          file, with the option ``InteractiveShell.wildcards_case_sensitive``.
+          If this option is not specified in your configuration file, IPython's
+          internal default is to do a case sensitive search.
+
+          -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you
+          specify can be searched in any of the following namespaces:
+          'builtin', 'user', 'user_global','internal', 'alias', where
+          'builtin' and 'user' are the search defaults.  Note that you should
+          not use quotes when specifying namespaces.
+
+          -l: List all available object types for object matching. This function
+          can be used without arguments.
+
+          'Builtin' contains the python module builtin, 'user' contains all
+          user data, 'alias' only contain the shell aliases and no python
+          objects, 'internal' contains objects used by IPython.  The
+          'user_global' namespace is only used by embedded IPython instances,
+          and it contains module-level globals.  You can add namespaces to the
+          search with -s or exclude them with -e (these options can be given
+          more than once).
+
+        Examples
+        --------
+        ::
+
+          %psearch a*            -> objects beginning with an a
+          %psearch -e builtin a* -> objects NOT in the builtin space starting in a
+          %psearch a* function   -> all functions beginning with an a
+          %psearch re.e*         -> objects beginning with an e in module re
+          %psearch r*.e*         -> objects that start with e in modules starting in r
+          %psearch r*.* string   -> all strings in modules beginning with r
+
+        Case sensitive search::
+
+          %psearch -c a*         list all object beginning with lower case a
+
+        Show objects beginning with a single _::
+
+          %psearch -a _*         list objects beginning with a single underscore
+
+        List available objects::
+
+          %psearch -l            list all available object types
+        """
+        # default namespaces to be searched
+        def_search = ['user_local', 'user_global', 'builtin']
+
+        # Process options/args
+        opts,args = self.parse_options(parameter_s,'cias:e:l',list_all=True)
+        opt = opts.get
+        shell = self.shell
+        psearch = shell.inspector.psearch
+        
+        # select list object types
+        list_types = False
+        if 'l' in opts:
+            list_types = True
+
+        # select case options
+        if 'i' in opts:
+            ignore_case = True
+        elif 'c' in opts:
+            ignore_case = False
+        else:
+            ignore_case = not shell.wildcards_case_sensitive
+
+        # Build list of namespaces to search from user options
+        def_search.extend(opt('s',[]))
+        ns_exclude = ns_exclude=opt('e',[])
+        ns_search = [nm for nm in def_search if nm not in ns_exclude]
+
+        # Call the actual search
+        try:
+            psearch(args,shell.ns_table,ns_search,
+                    show_all=opt('a'),ignore_case=ignore_case, list_types=list_types)
+        except:
+            shell.showtraceback()
+
+    @skip_doctest
+    @line_magic
+    def who_ls(self, parameter_s=''):
+        """Return a sorted list of all interactive variables.
+
+        If arguments are given, only variables of types matching these
+        arguments are returned.
+
+        Examples
+        --------
+        Define two variables and list them with who_ls::
+
+          In [1]: alpha = 123
+
+          In [2]: beta = 'test'
+
+          In [3]: %who_ls
+          Out[3]: ['alpha', 'beta']
+
+          In [4]: %who_ls int
+          Out[4]: ['alpha']
+
+          In [5]: %who_ls str
+          Out[5]: ['beta']
+        """
+
+        user_ns = self.shell.user_ns
+        user_ns_hidden = self.shell.user_ns_hidden
+        nonmatching = object()  # This can never be in user_ns
+        out = [ i for i in user_ns
+                if not i.startswith('_') \
+                and (user_ns[i] is not user_ns_hidden.get(i, nonmatching)) ]
+
+        typelist = parameter_s.split()
+        if typelist:
+            typeset = set(typelist)
+            out = [i for i in out if type(user_ns[i]).__name__ in typeset]
+
+        out.sort()
+        return out
+
+    @skip_doctest
+    @line_magic
+    def who(self, parameter_s=''):
+        """Print all interactive variables, with some minimal formatting.
+
+        If any arguments are given, only variables whose type matches one of
+        these are printed.  For example::
+
+          %who function str
+
+        will only list functions and strings, excluding all other types of
+        variables.  To find the proper type names, simply use type(var) at a
+        command line to see how python prints type names.  For example:
+
+        ::
+
+          In [1]: type('hello')\\
+          Out[1]: <type 'str'>
+
+        indicates that the type name for strings is 'str'.
+
+        ``%who`` always excludes executed names loaded through your configuration
+        file and things which are internal to IPython.
+
+        This is deliberate, as typically you may load many modules and the
+        purpose of %who is to show you only what you've manually defined.
+
+        Examples
+        --------
+
+        Define two variables and list them with who::
+
+          In [1]: alpha = 123
+
+          In [2]: beta = 'test'
+
+          In [3]: %who
+          alpha   beta
+
+          In [4]: %who int
+          alpha
+
+          In [5]: %who str
+          beta
+        """
+
+        varlist = self.who_ls(parameter_s)
+        if not varlist:
+            if parameter_s:
+                print('No variables match your requested type.')
+            else:
+                print('Interactive namespace is empty.')
+            return
+
+        # if we have variables, move on...
+        count = 0
+        for i in varlist:
+            print(i+'\t', end=' ')
+            count += 1
+            if count > 8:
+                count = 0
+                print()
+        print()
+
+    @skip_doctest
+    @line_magic
+    def whos(self, parameter_s=''):
+        """Like %who, but gives some extra information about each variable.
+
+        The same type filtering of %who can be applied here.
+
+        For all variables, the type is printed. Additionally it prints:
+
+          - For {},[],(): their length.
+
+          - For numpy arrays, a summary with shape, number of
+            elements, typecode and size in memory.
+
+          - For DataFrame and Series types: their shape.
+
+          - Everything else: a string representation, snipping their middle if
+            too long.
+
+        Examples
+        --------
+        Define two variables and list them with whos::
+
+          In [1]: alpha = 123
+
+          In [2]: beta = 'test'
+
+          In [3]: df = pd.DataFrame({"a": range(10), "b": range(10,20)})
+
+          In [4]: s = df["a"]
+
+          In [5]: %whos
+          Variable   Type        Data/Info
+          --------------------------------
+          alpha      int         123
+          beta       str         test
+          df         DataFrame   Shape: (10, 2)
+          s          Series      Shape: (10, )
+        """
+
+        varnames = self.who_ls(parameter_s)
+        if not varnames:
+            if parameter_s:
+                print('No variables match your requested type.')
+            else:
+                print('Interactive namespace is empty.')
+            return
+
+        # if we have variables, move on...
+
+        # for these types, show len() instead of data:
+        seq_types = ['dict', 'list', 'tuple']
+
+        # for numpy arrays, display summary info
+        ndarray_type = None
+        if 'numpy' in sys.modules:
+            try:
+                from numpy import ndarray
+            except ImportError:
+                pass
+            else:
+                ndarray_type = ndarray.__name__
+
+        # Find all variable names and types so we can figure out column sizes
+
+        # some types are well known and can be shorter
+        abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
+        def type_name(v):
+            tn = type(v).__name__
+            return abbrevs.get(tn,tn)
+
+        varlist = [self.shell.user_ns[n] for n in varnames]
+
+        typelist = []
+        for vv in varlist:
+            tt = type_name(vv)
+
+            if tt=='instance':
+                typelist.append( abbrevs.get(str(vv.__class__),
+                                             str(vv.__class__)))
+            else:
+                typelist.append(tt)
+
+        # column labels and # of spaces as separator
+        varlabel = 'Variable'
+        typelabel = 'Type'
+        datalabel = 'Data/Info'
+        colsep = 3
+        # variable format strings
+        vformat    = "{0:<{varwidth}}{1:<{typewidth}}"
+        aformat    = "%s: %s elems, type `%s`, %s bytes"
+        # find the size of the columns to format the output nicely
+        varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
+        typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
+        # table header
+        print(varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
+              ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1))
+        # and the table itself
+        kb = 1024
+        Mb = 1048576  # kb**2
+        for vname,var,vtype in zip(varnames,varlist,typelist):
+            print(vformat.format(vname, vtype, varwidth=varwidth, typewidth=typewidth), end=' ')
+            if vtype in seq_types:
+                print("n="+str(len(var)))
+            elif vtype == ndarray_type:
+                vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
+                if vtype==ndarray_type:
+                    # numpy
+                    vsize  = var.size
+                    vbytes = vsize*var.itemsize
+                    vdtype = var.dtype
+
+                if vbytes < 100000:
+                    print(aformat % (vshape, vsize, vdtype, vbytes))
+                else:
+                    print(aformat % (vshape, vsize, vdtype, vbytes), end=' ')
+                    if vbytes < Mb:
+                        print("(%s kb)" % (vbytes / kb,))
+                    else:
+                        print("(%s Mb)" % (vbytes / Mb,))
+            elif vtype in ["DataFrame", "Series"]:
+                # Useful for DataFrames and Series
+                # Ought to work for both pandas and polars
+                print(f"Shape: {var.shape}")
+            else:
+                try:
+                    vstr = str(var)
+                except UnicodeEncodeError:
+                    vstr = var.encode(DEFAULT_ENCODING,
+                                      'backslashreplace')
+                except:
+                    vstr = "<object with id %d (str() failed)>" % id(var)
+                vstr = vstr.replace('\n', '\\n')
+                if len(vstr) < 50:
+                    print(vstr)
+                else:
+                    print(vstr[:25] + "<...>" + vstr[-25:])
+
+    @line_magic
+    def reset(self, parameter_s=''):
+        """Resets the namespace by removing all names defined by the user, if
+        called without arguments, or by removing some types of objects, such
+        as everything currently in IPython's In[] and Out[] containers (see
+        the parameters for details).
+
+        Parameters
+        ----------
+        -f
+            force reset without asking for confirmation.
+        -s
+            'Soft' reset: Only clears your namespace, leaving history intact.
+            References to objects may be kept. By default (without this option),
+            we do a 'hard' reset, giving you a new session and removing all
+            references to objects from the current session.
+        --aggressive
+            Try to aggressively remove modules from sys.modules ; this
+            may allow you to reimport Python modules that have been updated and
+            pick up changes, but can have unintended consequences.
+
+        in
+            reset input history
+        out
+            reset output history
+        dhist
+            reset directory history
+        array
+            reset only variables that are NumPy arrays
+
+        See Also
+        --------
+        reset_selective : invoked as ``%reset_selective``
+
+        Examples
+        --------
+        ::
+
+          In [6]: a = 1
+
+          In [7]: a
+          Out[7]: 1
+
+          In [8]: 'a' in get_ipython().user_ns
+          Out[8]: True
+
+          In [9]: %reset -f
+
+          In [1]: 'a' in get_ipython().user_ns
+          Out[1]: False
+
+          In [2]: %reset -f in
+          Flushing input history
+
+          In [3]: %reset -f dhist in
+          Flushing directory history
+          Flushing input history
+
+        Notes
+        -----
+        Calling this magic from clients that do not implement standard input,
+        such as the ipython notebook interface, will reset the namespace
+        without confirmation.
+        """
+        opts, args = self.parse_options(parameter_s, "sf", "aggressive", mode="list")
+        if "f" in opts:
+            ans = True
+        else:
+            try:
+                ans = self.shell.ask_yes_no(
+                "Once deleted, variables cannot be recovered. Proceed (y/[n])?",
+                default='n')
+            except StdinNotImplementedError:
+                ans = True
+        if not ans:
+            print('Nothing done.')
+            return
+
+        if 's' in opts:                     # Soft reset
+            user_ns = self.shell.user_ns
+            for i in self.who_ls():
+                del(user_ns[i])
+        elif len(args) == 0:                # Hard reset
+            self.shell.reset(new_session=False, aggressive=("aggressive" in opts))
+
+        # reset in/out/dhist/array: previously extensinions/clearcmd.py
+        ip = self.shell
+        user_ns = self.shell.user_ns  # local lookup, heavily used
+
+        for target in args:
+            target = target.lower() # make matches case insensitive
+            if target == 'out':
+                print("Flushing output cache (%d entries)" % len(user_ns['_oh']))
+                self.shell.displayhook.flush()
+
+            elif target == 'in':
+                print("Flushing input history")
+                pc = self.shell.displayhook.prompt_count + 1
+                for n in range(1, pc):
+                    key = '_i'+repr(n)
+                    user_ns.pop(key,None)
+                user_ns.update(dict(_i=u'',_ii=u'',_iii=u''))
+                hm = ip.history_manager
+                # don't delete these, as %save and %macro depending on the
+                # length of these lists to be preserved
+                hm.input_hist_parsed[:] = [''] * pc
+                hm.input_hist_raw[:] = [''] * pc
+                # hm has internal machinery for _i,_ii,_iii, clear it out
+                hm._i = hm._ii = hm._iii = hm._i00 =  u''
+
+            elif target == 'array':
+                # Support cleaning up numpy arrays
+                try:
+                    from numpy import ndarray
+                    # This must be done with items and not iteritems because
+                    # we're going to modify the dict in-place.
+                    for x,val in list(user_ns.items()):
+                        if isinstance(val,ndarray):
+                            del user_ns[x]
+                except ImportError:
+                    print("reset array only works if Numpy is available.")
+
+            elif target == 'dhist':
+                print("Flushing directory history")
+                del user_ns['_dh'][:]
+
+            else:
+                print("Don't know how to reset ", end=' ')
+                print(target + ", please run `%reset?` for details")
+
+        gc.collect()
+
+    @line_magic
+    def reset_selective(self, parameter_s=''):
+        """Resets the namespace by removing names defined by the user.
+
+        Input/Output history are left around in case you need them.
+
+        %reset_selective [-f] regex
+
+        No action is taken if regex is not included
+
+        Options
+          -f : force reset without asking for confirmation.
+
+        See Also
+        --------
+        reset : invoked as ``%reset``
+
+        Examples
+        --------
+        We first fully reset the namespace so your output looks identical to
+        this example for pedagogical reasons; in practice you do not need a
+        full reset::
+
+          In [1]: %reset -f
+
+        Now, with a clean namespace we can make a few variables and use
+        ``%reset_selective`` to only delete names that match our regexp::
+
+          In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
+
+          In [3]: who_ls
+          Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
+
+          In [4]: %reset_selective -f b[2-3]m
+
+          In [5]: who_ls
+          Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
+
+          In [6]: %reset_selective -f d
+
+          In [7]: who_ls
+          Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
+
+          In [8]: %reset_selective -f c
+
+          In [9]: who_ls
+          Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
+
+          In [10]: %reset_selective -f b
+
+          In [11]: who_ls
+          Out[11]: ['a']
+
+        Notes
+        -----
+        Calling this magic from clients that do not implement standard input,
+        such as the ipython notebook interface, will reset the namespace
+        without confirmation.
+        """
+
+        opts, regex = self.parse_options(parameter_s,'f')
+
+        if 'f' in opts:
+            ans = True
+        else:
+            try:
+                ans = self.shell.ask_yes_no(
+                "Once deleted, variables cannot be recovered. Proceed (y/[n])? ",
+                default='n')
+            except StdinNotImplementedError:
+                ans = True
+        if not ans:
+            print('Nothing done.')
+            return
+        user_ns = self.shell.user_ns
+        if not regex:
+            print('No regex pattern specified. Nothing done.')
+            return
+        else:
+            try:
+                m = re.compile(regex)
+            except TypeError as e:
+                raise TypeError('regex must be a string or compiled pattern') from e
+            for i in self.who_ls():
+                if m.search(i):
+                    del(user_ns[i])
+
+    @line_magic
+    def xdel(self, parameter_s=''):
+        """Delete a variable, trying to clear it from anywhere that
+        IPython's machinery has references to it. By default, this uses
+        the identity of the named object in the user namespace to remove
+        references held under other names. The object is also removed
+        from the output history.
+
+        Options
+          -n : Delete the specified name from all namespaces, without
+          checking their identity.
+        """
+        opts, varname = self.parse_options(parameter_s,'n')
+        try:
+            self.shell.del_var(varname, ('n' in opts))
+        except (NameError, ValueError) as e:
+            print(type(e).__name__ +": "+ str(e))
diff --git a/lib/python3.12/site-packages/IPython/core/magics/osm.py b/lib/python3.12/site-packages/IPython/core/magics/osm.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac265978daf23876dec60d381135e270f2fae67e
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/osm.py
@@ -0,0 +1,855 @@
+"""Implementation of magic functions for interaction with the OS.
+
+Note: this module is named 'osm' instead of 'os' to avoid a collision with the
+builtin.
+"""
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import io
+import os
+import pathlib
+import re
+import sys
+from pprint import pformat
+
+from IPython.core import magic_arguments
+from IPython.core import oinspect
+from IPython.core import page
+from IPython.core.alias import AliasError, Alias
+from IPython.core.error import UsageError
+from IPython.core.magic import  (
+    Magics, compress_dhist, magics_class, line_magic, cell_magic, line_cell_magic
+)
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.openpy import source_to_unicode
+from IPython.utils.process import abbrev_cwd
+from IPython.utils.terminal import set_term_title
+from traitlets import Bool
+from warnings import warn
+
+
+@magics_class
+class OSMagics(Magics):
+    """Magics to interact with the underlying OS (shell-type functionality).
+    """
+
+    cd_force_quiet = Bool(False,
+        help="Force %cd magic to be quiet even if -q is not passed."
+    ).tag(config=True)
+
+    def __init__(self, shell=None, **kwargs):
+
+        # Now define isexec in a cross platform manner.
+        self.is_posix = False
+        self.execre = None
+        if os.name == 'posix':
+            self.is_posix = True
+        else:
+            try:
+                winext = os.environ['pathext'].replace(';','|').replace('.','')
+            except KeyError:
+                winext = 'exe|com|bat|py'
+            try:
+                self.execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
+            except re.error:
+                warn("Seems like your pathext environmental "
+                     "variable is malformed. Please check it to "
+                     "enable a proper handle of file extensions "
+                     "managed for your system")
+                winext = 'exe|com|bat|py'
+                self.execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
+
+        # call up the chain
+        super().__init__(shell=shell, **kwargs)
+
+
+    def _isexec_POSIX(self, file):
+        """
+        Test for executable on a POSIX system
+        """
+        if os.access(file.path, os.X_OK):
+            # will fail on maxOS if access is not X_OK
+            return file.is_file()
+        return False
+
+
+
+    def _isexec_WIN(self, file):
+        """
+        Test for executable file on non POSIX system
+        """
+        return file.is_file() and self.execre.match(file.name) is not None
+
+    def isexec(self, file):
+        """
+        Test for executable file on non POSIX system
+        """
+        if self.is_posix:
+            return self._isexec_POSIX(file)
+        else:
+            return self._isexec_WIN(file)
+
+
+    @skip_doctest
+    @line_magic
+    def alias(self, parameter_s=''):
+        """Define an alias for a system command.
+
+        '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
+
+        Then, typing 'alias_name params' will execute the system command 'cmd
+        params' (from your underlying operating system).
+
+        Aliases have lower precedence than magic functions and Python normal
+        variables, so if 'foo' is both a Python variable and an alias, the
+        alias can not be executed until 'del foo' removes the Python variable.
+
+        You can use the %l specifier in an alias definition to represent the
+        whole line when the alias is called.  For example::
+
+          In [2]: alias bracket echo "Input in brackets: <%l>"
+          In [3]: bracket hello world
+          Input in brackets: <hello world>
+
+        You can also define aliases with parameters using %s specifiers (one
+        per parameter)::
+
+          In [1]: alias parts echo first %s second %s
+          In [2]: %parts A B
+          first A second B
+          In [3]: %parts A
+          Incorrect number of arguments: 2 expected.
+          parts is an alias to: 'echo first %s second %s'
+
+        Note that %l and %s are mutually exclusive.  You can only use one or
+        the other in your aliases.
+
+        Aliases expand Python variables just like system calls using ! or !!
+        do: all expressions prefixed with '$' get expanded.  For details of
+        the semantic rules, see PEP-215:
+        https://peps.python.org/pep-0215/.  This is the library used by
+        IPython for variable expansion.  If you want to access a true shell
+        variable, an extra $ is necessary to prevent its expansion by
+        IPython::
+
+          In [6]: alias show echo
+          In [7]: PATH='A Python string'
+          In [8]: show $PATH
+          A Python string
+          In [9]: show $$PATH
+          /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
+
+        You can use the alias facility to access all of $PATH.  See the %rehashx
+        function, which automatically creates aliases for the contents of your
+        $PATH.
+
+        If called with no parameters, %alias prints the current alias table
+        for your system.  For posix systems, the default aliases are 'cat',
+        'cp', 'mv', 'rm', 'rmdir', and 'mkdir', and other platform-specific
+        aliases are added.  For windows-based systems, the default aliases are
+        'copy', 'ddir', 'echo', 'ls', 'ldir', 'mkdir', 'ren', and 'rmdir'.
+
+        You can see the definition of alias by adding a question mark in the
+        end::
+
+          In [1]: cat?
+          Repr: <alias cat for 'cat'>"""
+
+        par = parameter_s.strip()
+        if not par:
+            aliases = sorted(self.shell.alias_manager.aliases)
+            # stored = self.shell.db.get('stored_aliases', {} )
+            # for k, v in stored:
+            #     atab.append(k, v[0])
+
+            print("Total number of aliases:", len(aliases))
+            sys.stdout.flush()
+            return aliases
+
+        # Now try to define a new one
+        try:
+            alias,cmd = par.split(None, 1)
+        except TypeError:
+            print(oinspect.getdoc(self.alias))
+            return
+        
+        try:
+            self.shell.alias_manager.define_alias(alias, cmd)
+        except AliasError as e:
+            print(e)
+    # end magic_alias
+
+    @line_magic
+    def unalias(self, parameter_s=''):
+        """Remove an alias"""
+
+        aname = parameter_s.strip()
+        try:
+            self.shell.alias_manager.undefine_alias(aname)
+        except ValueError as e:
+            print(e)
+            return
+        
+        stored = self.shell.db.get('stored_aliases', {} )
+        if aname in stored:
+            print("Removing %stored alias",aname)
+            del stored[aname]
+            self.shell.db['stored_aliases'] = stored
+
+    @line_magic
+    def rehashx(self, parameter_s=''):
+        """Update the alias table with all executable files in $PATH.
+
+        rehashx explicitly checks that every entry in $PATH is a file
+        with execute access (os.X_OK).
+
+        Under Windows, it checks executability as a match against a
+        '|'-separated string of extensions, stored in the IPython config
+        variable win_exec_ext.  This defaults to 'exe|com|bat'.
+
+        This function also resets the root module cache of module completer,
+        used on slow filesystems.
+        """
+        from IPython.core.alias import InvalidAliasError
+
+        # for the benefit of module completer in ipy_completers.py
+        del self.shell.db['rootmodules_cache']
+
+        path = [os.path.abspath(os.path.expanduser(p)) for p in
+            os.environ.get('PATH','').split(os.pathsep)]
+
+        syscmdlist = []
+        savedir = os.getcwd()
+
+        # Now walk the paths looking for executables to alias.
+        try:
+            # write the whole loop for posix/Windows so we don't have an if in
+            # the innermost part
+            if self.is_posix:
+                for pdir in path:
+                    try:
+                        os.chdir(pdir)
+                    except OSError:
+                        continue
+
+                    # for python 3.6+ rewrite to: with os.scandir(pdir) as dirlist:
+                    dirlist = os.scandir(path=pdir)
+                    for ff in dirlist:
+                        if self.isexec(ff):
+                            fname = ff.name
+                            try:
+                                # Removes dots from the name since ipython
+                                # will assume names with dots to be python.
+                                if not self.shell.alias_manager.is_alias(fname):
+                                    self.shell.alias_manager.define_alias(
+                                        fname.replace('.',''), fname)
+                            except InvalidAliasError:
+                                pass
+                            else:
+                                syscmdlist.append(fname)
+            else:
+                no_alias = Alias.blacklist
+                for pdir in path:
+                    try:
+                        os.chdir(pdir)
+                    except OSError:
+                        continue
+
+                    # for python 3.6+ rewrite to: with os.scandir(pdir) as dirlist:
+                    dirlist = os.scandir(pdir)
+                    for ff in dirlist:
+                        fname = ff.name
+                        base, ext = os.path.splitext(fname)
+                        if self.isexec(ff) and base.lower() not in no_alias:
+                            if ext.lower() == '.exe':
+                                fname = base
+                                try:
+                                    # Removes dots from the name since ipython
+                                    # will assume names with dots to be python.
+                                    self.shell.alias_manager.define_alias(
+                                        base.lower().replace('.',''), fname)
+                                except InvalidAliasError:
+                                    pass
+                                syscmdlist.append(fname)
+
+            self.shell.db['syscmdlist'] = syscmdlist
+        finally:
+            os.chdir(savedir)
+
+    @skip_doctest
+    @line_magic
+    def pwd(self, parameter_s=''):
+        """Return the current working directory path.
+
+        Examples
+        --------
+        ::
+
+          In [9]: pwd
+          Out[9]: '/home/tsuser/sprint/ipython'
+        """
+        try:
+            return os.getcwd()
+        except FileNotFoundError as e:
+            raise UsageError("CWD no longer exists - please use %cd to change directory.") from e
+
+    @skip_doctest
+    @line_magic
+    def cd(self, parameter_s=''):
+        """Change the current working directory.
+
+        This command automatically maintains an internal list of directories
+        you visit during your IPython session, in the variable ``_dh``. The
+        command :magic:`%dhist` shows this history nicely formatted. You can
+        also do ``cd -<tab>`` to see directory history conveniently.
+        Usage:
+
+          - ``cd 'dir'``: changes to directory 'dir'.
+          - ``cd -``: changes to the last visited directory.
+          - ``cd -<n>``: changes to the n-th directory in the directory history.
+          - ``cd --foo``: change to directory that matches 'foo' in history
+          - ``cd -b <bookmark_name>``: jump to a bookmark set by %bookmark
+          - Hitting a tab key after ``cd -b`` allows you to tab-complete
+            bookmark names.
+
+          .. note::
+            ``cd <bookmark_name>`` is enough if there is no directory
+            ``<bookmark_name>``, but a bookmark with the name exists.
+
+        Options:
+
+        -q               Be quiet. Do not print the working directory after the
+                          cd command is executed. By default IPython's cd
+                          command does print this directory, since the default
+                          prompts do not display path information.
+
+        .. note::
+           Note that ``!cd`` doesn't work for this purpose because the shell
+           where ``!command`` runs is immediately discarded after executing
+           'command'.
+
+        Examples
+        --------
+        ::
+
+          In [10]: cd parent/child
+          /home/tsuser/parent/child
+        """
+
+        try:
+            oldcwd = os.getcwd()
+        except FileNotFoundError:
+            # Happens if the CWD has been deleted.
+            oldcwd = None
+
+        numcd = re.match(r'(-)(\d+)$',parameter_s)
+        # jump in directory history by number
+        if numcd:
+            nn = int(numcd.group(2))
+            try:
+                ps = self.shell.user_ns['_dh'][nn]
+            except IndexError:
+                print('The requested directory does not exist in history.')
+                return
+            else:
+                opts = {}
+        elif parameter_s.startswith('--'):
+            ps = None
+            fallback = None
+            pat = parameter_s[2:]
+            dh = self.shell.user_ns['_dh']
+            # first search only by basename (last component)
+            for ent in reversed(dh):
+                if pat in os.path.basename(ent) and os.path.isdir(ent):
+                    ps = ent
+                    break
+
+                if fallback is None and pat in ent and os.path.isdir(ent):
+                    fallback = ent
+
+            # if we have no last part match, pick the first full path match
+            if ps is None:
+                ps = fallback
+
+            if ps is None:
+                print("No matching entry in directory history")
+                return
+            else:
+                opts = {}
+
+
+        else:
+            opts, ps = self.parse_options(parameter_s, 'qb', mode='string')
+        # jump to previous
+        if ps == '-':
+            try:
+                ps = self.shell.user_ns['_dh'][-2]
+            except IndexError as e:
+                raise UsageError('%cd -: No previous directory to change to.') from e
+        # jump to bookmark if needed
+        else:
+            if not os.path.isdir(ps) or 'b' in opts:
+                bkms = self.shell.db.get('bookmarks', {})
+
+                if ps in bkms:
+                    target = bkms[ps]
+                    print('(bookmark:%s) -> %s' % (ps, target))
+                    ps = target
+                else:
+                    if 'b' in opts:
+                        raise UsageError("Bookmark '%s' not found.  "
+                              "Use '%%bookmark -l' to see your bookmarks." % ps)
+
+        # at this point ps should point to the target dir
+        if ps:
+            try:
+                os.chdir(os.path.expanduser(ps))
+                if hasattr(self.shell, 'term_title') and self.shell.term_title:
+                    set_term_title(self.shell.term_title_format.format(cwd=abbrev_cwd()))
+            except OSError:
+                print(sys.exc_info()[1])
+            else:
+                cwd = pathlib.Path.cwd()
+                dhist = self.shell.user_ns['_dh']
+                if oldcwd != cwd:
+                    dhist.append(cwd)
+                    self.shell.db['dhist'] = compress_dhist(dhist)[-100:]
+
+        else:
+            os.chdir(self.shell.home_dir)
+            if hasattr(self.shell, 'term_title') and self.shell.term_title:
+                set_term_title(self.shell.term_title_format.format(cwd="~"))
+            cwd = pathlib.Path.cwd()
+            dhist = self.shell.user_ns['_dh']
+
+            if oldcwd != cwd:
+                dhist.append(cwd)
+                self.shell.db["dhist"] = compress_dhist(dhist)[-100:]
+        if "q" not in opts and not self.cd_force_quiet and self.shell.user_ns["_dh"]:
+            print(self.shell.user_ns["_dh"][-1])
+
+    @line_magic
+    def env(self, parameter_s=''):
+        """Get, set, or list environment variables.
+
+        Usage:\\
+
+          :``%env``: lists all environment variables/values
+          :``%env var``: get value for var
+          :``%env var val``: set value for var
+          :``%env var=val``: set value for var
+          :``%env var=$val``: set value for var, using python expansion if possible
+        """
+        if parameter_s.strip():
+            split = '=' if '=' in parameter_s else ' '
+            bits = parameter_s.split(split)
+            if len(bits) == 1:
+                key = parameter_s.strip()
+                if key in os.environ:
+                    return os.environ[key]
+                else:
+                    err = "Environment does not have key: {0}".format(key)
+                    raise UsageError(err)
+            if len(bits) > 1:
+                return self.set_env(parameter_s)
+        env = dict(os.environ)
+        # hide likely secrets when printing the whole environment
+        for key in list(env):
+            if any(s in key.lower() for s in ('key', 'token', 'secret')):
+                env[key] = '<hidden>'
+
+        return env
+
+    @line_magic
+    def set_env(self, parameter_s):
+        """Set environment variables.  Assumptions are that either "val" is a
+        name in the user namespace, or val is something that evaluates to a
+        string.
+
+        Usage:\\
+          :``%set_env var val``: set value for var
+          :``%set_env var=val``: set value for var
+          :``%set_env var=$val``: set value for var, using python expansion if possible
+        """
+        split = '=' if '=' in parameter_s else ' '
+        bits = parameter_s.split(split, 1)
+        if not parameter_s.strip() or len(bits)<2:
+            raise UsageError("usage is 'set_env var=val'")
+        var = bits[0].strip()
+        val = bits[1].strip()
+        if re.match(r'.*\s.*', var):
+            # an environment variable with whitespace is almost certainly
+            # not what the user intended.  what's more likely is the wrong
+            # split was chosen, ie for "set_env cmd_args A=B", we chose
+            # '=' for the split and should have chosen ' '.  to get around
+            # this, users should just assign directly to os.environ or use
+            # standard magic {var} expansion.
+            err = "refusing to set env var with whitespace: '{0}'"
+            err = err.format(val)
+            raise UsageError(err)
+        os.environ[var] = val
+        print('env: {0}={1}'.format(var,val))
+
+    @line_magic
+    def pushd(self, parameter_s=''):
+        """Place the current dir on stack and change directory.
+
+        Usage:\\
+          %pushd ['dirname']
+        """
+
+        dir_s = self.shell.dir_stack
+        tgt = os.path.expanduser(parameter_s)
+        cwd = os.getcwd().replace(self.shell.home_dir,'~')
+        if tgt:
+            self.cd(parameter_s)
+        dir_s.insert(0,cwd)
+        return self.shell.run_line_magic('dirs', '')
+
+    @line_magic
+    def popd(self, parameter_s=''):
+        """Change to directory popped off the top of the stack.
+        """
+        if not self.shell.dir_stack:
+            raise UsageError("%popd on empty stack")
+        top = self.shell.dir_stack.pop(0)
+        self.cd(top)
+        print("popd ->",top)
+
+    @line_magic
+    def dirs(self, parameter_s=''):
+        """Return the current directory stack."""
+
+        return self.shell.dir_stack
+
+    @line_magic
+    def dhist(self, parameter_s=''):
+        """Print your history of visited directories.
+
+        %dhist       -> print full history\\
+        %dhist n     -> print last n entries only\\
+        %dhist n1 n2 -> print entries between n1 and n2 (n2 not included)\\
+
+        This history is automatically maintained by the %cd command, and
+        always available as the global list variable _dh. You can use %cd -<n>
+        to go to directory number <n>.
+
+        Note that most of time, you should view directory history by entering
+        cd -<TAB>.
+
+        """
+
+        dh = self.shell.user_ns['_dh']
+        if parameter_s:
+            try:
+                args = map(int,parameter_s.split())
+            except:
+                self.arg_err(self.dhist)
+                return
+            if len(args) == 1:
+                ini,fin = max(len(dh)-(args[0]),0),len(dh)
+            elif len(args) == 2:
+                ini,fin = args
+                fin = min(fin, len(dh))
+            else:
+                self.arg_err(self.dhist)
+                return
+        else:
+            ini,fin = 0,len(dh)
+        print('Directory history (kept in _dh)')
+        for i in range(ini, fin):
+            print("%d: %s" % (i, dh[i]))
+
+    @skip_doctest
+    @line_magic
+    def sc(self, parameter_s=''):
+        """Shell capture - run shell command and capture output (DEPRECATED use !).
+
+        DEPRECATED. Suboptimal, retained for backwards compatibility.
+
+        You should use the form 'var = !command' instead. Example:
+
+         "%sc -l myfiles = ls ~" should now be written as
+
+         "myfiles = !ls ~"
+
+        myfiles.s, myfiles.l and myfiles.n still apply as documented
+        below.
+
+        --
+        %sc [options] varname=command
+
+        IPython will run the given command using commands.getoutput(), and
+        will then update the user's interactive namespace with a variable
+        called varname, containing the value of the call.  Your command can
+        contain shell wildcards, pipes, etc.
+
+        The '=' sign in the syntax is mandatory, and the variable name you
+        supply must follow Python's standard conventions for valid names.
+
+        (A special format without variable name exists for internal use)
+
+        Options:
+
+          -l: list output.  Split the output on newlines into a list before
+          assigning it to the given variable.  By default the output is stored
+          as a single string.
+
+          -v: verbose.  Print the contents of the variable.
+
+        In most cases you should not need to split as a list, because the
+        returned value is a special type of string which can automatically
+        provide its contents either as a list (split on newlines) or as a
+        space-separated string.  These are convenient, respectively, either
+        for sequential processing or to be passed to a shell command.
+
+        For example::
+
+            # Capture into variable a
+            In [1]: sc a=ls *py
+
+            # a is a string with embedded newlines
+            In [2]: a
+            Out[2]: 'setup.py\\nwin32_manual_post_install.py'
+
+            # which can be seen as a list:
+            In [3]: a.l
+            Out[3]: ['setup.py', 'win32_manual_post_install.py']
+
+            # or as a whitespace-separated string:
+            In [4]: a.s
+            Out[4]: 'setup.py win32_manual_post_install.py'
+
+            # a.s is useful to pass as a single command line:
+            In [5]: !wc -l $a.s
+              146 setup.py
+              130 win32_manual_post_install.py
+              276 total
+
+            # while the list form is useful to loop over:
+            In [6]: for f in a.l:
+               ...:      !wc -l $f
+               ...:
+            146 setup.py
+            130 win32_manual_post_install.py
+
+        Similarly, the lists returned by the -l option are also special, in
+        the sense that you can equally invoke the .s attribute on them to
+        automatically get a whitespace-separated string from their contents::
+
+            In [7]: sc -l b=ls *py
+
+            In [8]: b
+            Out[8]: ['setup.py', 'win32_manual_post_install.py']
+
+            In [9]: b.s
+            Out[9]: 'setup.py win32_manual_post_install.py'
+
+        In summary, both the lists and strings used for output capture have
+        the following special attributes::
+
+            .l (or .list) : value as list.
+            .n (or .nlstr): value as newline-separated string.
+            .s (or .spstr): value as space-separated string.
+        """
+
+        opts,args = self.parse_options(parameter_s, 'lv')
+        # Try to get a variable name and command to run
+        try:
+            # the variable name must be obtained from the parse_options
+            # output, which uses shlex.split to strip options out.
+            var,_ = args.split('=', 1)
+            var = var.strip()
+            # But the command has to be extracted from the original input
+            # parameter_s, not on what parse_options returns, to avoid the
+            # quote stripping which shlex.split performs on it.
+            _,cmd = parameter_s.split('=', 1)
+        except ValueError:
+            var,cmd = '',''
+        # If all looks ok, proceed
+        split = 'l' in opts
+        out = self.shell.getoutput(cmd, split=split)
+        if 'v' in opts:
+            print('%s ==\n%s' % (var, pformat(out)))
+        if var:
+            self.shell.user_ns.update({var:out})
+        else:
+            return out
+
+    @line_cell_magic
+    def sx(self, line='', cell=None):
+        """Shell execute - run shell command and capture output (!! is short-hand).
+
+        %sx command
+
+        IPython will run the given command using commands.getoutput(), and
+        return the result formatted as a list (split on '\\n').  Since the
+        output is _returned_, it will be stored in ipython's regular output
+        cache Out[N] and in the '_N' automatic variables.
+
+        Notes:
+
+        1) If an input line begins with '!!', then %sx is automatically
+        invoked.  That is, while::
+
+          !ls
+
+        causes ipython to simply issue system('ls'), typing::
+
+          !!ls
+
+        is a shorthand equivalent to::
+
+          %sx ls
+
+        2) %sx differs from %sc in that %sx automatically splits into a list,
+        like '%sc -l'.  The reason for this is to make it as easy as possible
+        to process line-oriented shell output via further python commands.
+        %sc is meant to provide much finer control, but requires more
+        typing.
+
+        3) Just like %sc -l, this is a list with special attributes:
+        ::
+
+          .l (or .list) : value as list.
+          .n (or .nlstr): value as newline-separated string.
+          .s (or .spstr): value as whitespace-separated string.
+
+        This is very useful when trying to use such lists as arguments to
+        system commands."""
+        
+        if cell is None:
+            # line magic
+            return self.shell.getoutput(line)
+        else:
+            opts,args = self.parse_options(line, '', 'out=')
+            output = self.shell.getoutput(cell)
+            out_name = opts.get('out', opts.get('o'))
+            if out_name:
+                self.shell.user_ns[out_name] = output
+            else:
+                return output
+
+    system = line_cell_magic('system')(sx)
+    bang = cell_magic('!')(sx)
+
+    @line_magic
+    def bookmark(self, parameter_s=''):
+        """Manage IPython's bookmark system.
+
+        %bookmark <name>       - set bookmark to current dir
+        %bookmark <name> <dir> - set bookmark to <dir>
+        %bookmark -l           - list all bookmarks
+        %bookmark -d <name>    - remove bookmark
+        %bookmark -r           - remove all bookmarks
+
+        You can later on access a bookmarked folder with::
+
+          %cd -b <name>
+
+        or simply '%cd <name>' if there is no directory called <name> AND
+        there is such a bookmark defined.
+
+        Your bookmarks persist through IPython sessions, but they are
+        associated with each profile."""
+
+        opts,args = self.parse_options(parameter_s,'drl',mode='list')
+        if len(args) > 2:
+            raise UsageError("%bookmark: too many arguments")
+
+        bkms = self.shell.db.get('bookmarks',{})
+
+        if 'd' in opts:
+            try:
+                todel = args[0]
+            except IndexError as e:
+                raise UsageError(
+                    "%bookmark -d: must provide a bookmark to delete") from e
+            else:
+                try:
+                    del bkms[todel]
+                except KeyError as e:
+                    raise UsageError(
+                        "%%bookmark -d: Can't delete bookmark '%s'" % todel) from e
+
+        elif 'r' in opts:
+            bkms = {}
+        elif 'l' in opts:
+            bks = sorted(bkms)
+            if bks:
+                size = max(map(len, bks))
+            else:
+                size = 0
+            fmt = '%-'+str(size)+'s -> %s'
+            print('Current bookmarks:')
+            for bk in bks:
+                print(fmt % (bk, bkms[bk]))
+        else:
+            if not args:
+                raise UsageError("%bookmark: You must specify the bookmark name")
+            elif len(args)==1:
+                bkms[args[0]] = os.getcwd()
+            elif len(args)==2:
+                bkms[args[0]] = args[1]
+        self.shell.db['bookmarks'] = bkms
+
+    @line_magic
+    def pycat(self, parameter_s=''):
+        """Show a syntax-highlighted file through a pager.
+
+        This magic is similar to the cat utility, but it will assume the file
+        to be Python source and will show it with syntax highlighting.
+
+        This magic command can either take a local filename, an url,
+        an history range (see %history) or a macro as argument.
+
+        If no parameter is given, prints out history of current session up to
+        this point. ::
+
+        %pycat myscript.py
+        %pycat 7-27
+        %pycat myMacro
+        %pycat http://www.example.com/myscript.py
+        """
+        try:
+            cont = self.shell.find_user_code(parameter_s, skip_encoding_cookie=False)
+        except (ValueError, IOError):
+            print("Error: no such file, variable, URL, history range or macro")
+            return
+
+        page.page(self.shell.pycolorize(source_to_unicode(cont)))
+
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        '-a', '--append', action='store_true', default=False,
+        help='Append contents of the cell to an existing file. '
+             'The file will be created if it does not exist.'
+    )
+    @magic_arguments.argument(
+        'filename', type=str,
+        help='file to write'
+    )
+    @cell_magic
+    def writefile(self, line, cell):
+        """Write the contents of the cell to a file.
+
+        The file will be overwritten unless the -a (--append) flag is specified.
+        """
+        args = magic_arguments.parse_argstring(self.writefile, line)
+        if re.match(r'^(\'.*\')|(".*")$', args.filename):
+            filename = os.path.expanduser(args.filename[1:-1])
+        else:
+            filename = os.path.expanduser(args.filename)
+            
+        if os.path.exists(filename):
+            if args.append:
+                print("Appending to %s" % filename)
+            else:
+                print("Overwriting %s" % filename)
+        else:
+            print("Writing %s" % filename)
+        
+        mode = 'a' if args.append else 'w'
+        with io.open(filename, mode, encoding='utf-8') as f:
+            f.write(cell)
diff --git a/lib/python3.12/site-packages/IPython/core/magics/packaging.py b/lib/python3.12/site-packages/IPython/core/magics/packaging.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed1c1274f3daa792ef55177369711ed6442df838
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/packaging.py
@@ -0,0 +1,181 @@
+"""Implementation of packaging-related magic functions.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2018 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+import functools
+import os
+import re
+import shlex
+import sys
+from pathlib import Path
+
+from IPython.core.magic import Magics, magics_class, line_magic
+
+
+def is_conda_environment(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        """Return True if the current Python executable is in a conda env"""
+        # TODO: does this need to change on windows?
+        if not Path(sys.prefix, "conda-meta", "history").exists():
+            raise ValueError(
+                "The python kernel does not appear to be a conda environment.  "
+                "Please use ``%pip install`` instead."
+            )
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def _get_conda_like_executable(command):
+    """Find the path to the given executable
+
+    Parameters
+    ----------
+
+    executable: string
+        Value should be: conda, mamba or micromamba
+    """
+    # Check for a environment variable bound to the base executable, both conda and mamba
+    # set these when activating an environment.
+    base_executable = "CONDA_EXE"
+    if "mamba" in command.lower():
+        base_executable = "MAMBA_EXE"
+    if base_executable in os.environ:
+        executable = Path(os.environ[base_executable])
+        if executable.is_file():
+            return str(executable.resolve())
+
+    # Check if there is a conda executable in the same directory as the Python executable.
+    # This is the case within conda's root environment.
+    executable = Path(sys.executable).parent / command
+    if executable.is_file():
+        return str(executable)
+
+    # Otherwise, attempt to extract the executable from conda history.
+    # This applies in any conda environment. Parsing this way is error prone because
+    # different versions of conda and mamba include differing cmd values such as
+    # `conda`, `conda-script.py`, or `path/to/conda`, here use the raw command provided.
+    history = Path(sys.prefix, "conda-meta", "history").read_text(encoding="utf-8")
+    match = re.search(
+        rf"^#\s*cmd:\s*(?P<command>.*{command})\s[create|install]",
+        history,
+        flags=re.MULTILINE,
+    )
+    if match:
+        return match.groupdict()["command"]
+
+    # Fallback: assume the executable is available on the system path.
+    return command
+
+
+CONDA_COMMANDS_REQUIRING_PREFIX = {
+    'install', 'list', 'remove', 'uninstall', 'update', 'upgrade',
+}
+CONDA_COMMANDS_REQUIRING_YES = {
+    'install', 'remove', 'uninstall', 'update', 'upgrade',
+}
+CONDA_ENV_FLAGS = {'-p', '--prefix', '-n', '--name'}
+CONDA_YES_FLAGS = {'-y', '--y'}
+
+
+@magics_class
+class PackagingMagics(Magics):
+    """Magics related to packaging & installation"""
+
+    @line_magic
+    def pip(self, line):
+        """Run the pip package manager within the current kernel.
+
+        Usage:
+          %pip install [pkgs]
+        """
+        python = sys.executable
+        if sys.platform == "win32":
+            python = '"' + python + '"'
+        else:
+            python = shlex.quote(python)
+
+        self.shell.system(" ".join([python, "-m", "pip", line]))
+
+        print("Note: you may need to restart the kernel to use updated packages.")
+
+    def _run_command(self, cmd, line):
+        args = shlex.split(line)
+        command = args[0] if len(args) > 0 else ""
+        args = args[1:] if len(args) > 1 else [""]
+
+        extra_args = []
+
+        # When the subprocess does not allow us to respond "yes" during the installation,
+        # we need to insert --yes in the argument list for some commands
+        stdin_disabled = getattr(self.shell, 'kernel', None) is not None
+        needs_yes = command in CONDA_COMMANDS_REQUIRING_YES
+        has_yes = set(args).intersection(CONDA_YES_FLAGS)
+        if stdin_disabled and needs_yes and not has_yes:
+            extra_args.append("--yes")
+
+        # Add --prefix to point conda installation to the current environment
+        needs_prefix = command in CONDA_COMMANDS_REQUIRING_PREFIX
+        has_prefix = set(args).intersection(CONDA_ENV_FLAGS)
+        if needs_prefix and not has_prefix:
+            extra_args.extend(["--prefix", sys.prefix])
+
+        self.shell.system(" ".join([cmd, command] + extra_args + args))
+        print("\nNote: you may need to restart the kernel to use updated packages.")
+
+    @line_magic
+    @is_conda_environment
+    def conda(self, line):
+        """Run the conda package manager within the current kernel.
+
+        Usage:
+          %conda install [pkgs]
+        """
+        conda = _get_conda_like_executable("conda")
+        self._run_command(conda, line)
+
+    @line_magic
+    @is_conda_environment
+    def mamba(self, line):
+        """Run the mamba package manager within the current kernel.
+
+        Usage:
+          %mamba install [pkgs]
+        """
+        mamba = _get_conda_like_executable("mamba")
+        self._run_command(mamba, line)
+
+    @line_magic
+    @is_conda_environment
+    def micromamba(self, line):
+        """Run the conda package manager within the current kernel.
+
+        Usage:
+          %micromamba install [pkgs]
+        """
+        micromamba = _get_conda_like_executable("micromamba")
+        self._run_command(micromamba, line)
+
+    @line_magic
+    def uv(self, line):
+        """Run the uv package manager within the current kernel.
+
+        Usage:
+          %uv pip install [pkgs]
+        """
+        python = sys.executable
+        if sys.platform == "win32":
+            python = '"' + python + '"'
+        else:
+            python = shlex.quote(python)
+
+        self.shell.system(" ".join([python, "-m", "uv", line]))
+
+        print("Note: you may need to restart the kernel to use updated packages.")
diff --git a/lib/python3.12/site-packages/IPython/core/magics/pylab.py b/lib/python3.12/site-packages/IPython/core/magics/pylab.py
new file mode 100644
index 0000000000000000000000000000000000000000..423498d404c3174dbc2dfe5cd992feea3311ced4
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/core/magics/pylab.py
@@ -0,0 +1,173 @@
+"""Implementation of magic functions for matplotlib/pylab support.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Our own packages
+from traitlets.config.application import Application
+from IPython.core import magic_arguments
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.testing.skipdoctest import skip_doctest
+from warnings import warn
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+magic_gui_arg = magic_arguments.argument(
+    "gui",
+    nargs="?",
+    help="""Name of the matplotlib backend to use such as 'qt' or 'widget'.
+        If given, the corresponding matplotlib backend is used,
+        otherwise it will be matplotlib's default
+        (which you can set in your matplotlib config file).
+        """,
+)
+
+
+@magics_class
+class PylabMagics(Magics):
+    """Magics related to matplotlib's pylab support"""
+
+    @skip_doctest
+    @line_magic
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument('-l', '--list', action='store_true',
+                              help='Show available matplotlib backends')
+    @magic_gui_arg
+    def matplotlib(self, line=''):
+        """Set up matplotlib to work interactively.
+
+        This function lets you activate matplotlib interactive support
+        at any point during an IPython session. It does not import anything
+        into the interactive namespace.
+
+        If you are using the inline matplotlib backend in the IPython Notebook
+        you can set which figure formats are enabled using the following::
+
+            In [1]: from matplotlib_inline.backend_inline import set_matplotlib_formats
+
+            In [2]: set_matplotlib_formats('pdf', 'svg')
+
+        The default for inline figures sets `bbox_inches` to 'tight'. This can
+        cause discrepancies between the displayed image and the identical
+        image created using `savefig`. This behavior can be disabled using the
+        `%config` magic::
+
+            In [3]: %config InlineBackend.print_figure_kwargs = {'bbox_inches':None}
+
+        In addition, see the docstrings of
+        `matplotlib_inline.backend_inline.set_matplotlib_formats` and
+        `matplotlib_inline.backend_inline.set_matplotlib_close` for more information on
+        changing additional behaviors of the inline backend.
+
+        Examples
+        --------
+        To enable the inline backend for usage with the IPython Notebook::
+
+            In [1]: %matplotlib inline
+
+        In this case, where the matplotlib default is TkAgg::
+
+            In [2]: %matplotlib
+            Using matplotlib backend: TkAgg
+
+        But you can explicitly request a different GUI backend::
+
+            In [3]: %matplotlib qt
+
+        You can list the available backends using the -l/--list option::
+
+           In [4]: %matplotlib --list
+           Available matplotlib backends: ['osx', 'qt4', 'qt5', 'gtk3', 'gtk4', 'notebook', 'wx', 'qt', 'nbagg',
+           'gtk', 'tk', 'inline']
+        """
+        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()
+            )
+        else:
+            gui, backend = self.shell.enable_matplotlib(args.gui)
+            self._show_matplotlib_backend(args.gui, backend)
+
+    @skip_doctest
+    @line_magic
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        '--no-import-all', action='store_true', default=None,
+        help="""Prevent IPython from performing ``import *`` into the interactive namespace.
+
+        You can govern the default behavior of this flag with the
+        InteractiveShellApp.pylab_import_all configurable.
+        """
+    )
+    @magic_gui_arg
+    def pylab(self, line=''):
+        """Load numpy and matplotlib to work interactively.
+
+        This function lets you activate pylab (matplotlib, numpy and
+        interactive support) at any point during an IPython session.
+
+        %pylab makes the following imports::
+
+            import numpy
+            import matplotlib
+            from matplotlib import pylab, mlab, pyplot
+            np = numpy
+            plt = pyplot
+
+            from IPython.display import display
+            from IPython.core.pylabtools import figsize, getfigs
+
+            from pylab import *
+            from numpy import *
+
+        If you pass `--no-import-all`, the last two `*` imports will be excluded.
+
+        See the %matplotlib magic for more details about activating matplotlib
+        without affecting the interactive namespace.
+        """
+        args = magic_arguments.parse_argstring(self.pylab, line)
+        if args.no_import_all is None:
+            # get default from Application
+            if Application.initialized():
+                app = Application.instance()
+                try:
+                    import_all = app.pylab_import_all
+                except AttributeError:
+                    import_all = True
+            else:
+                # nothing specified, no app - default True
+                import_all = True
+        else:
+            # invert no-import flag
+            import_all = not args.no_import_all
+
+        gui, backend, clobbered = self.shell.enable_pylab(args.gui, import_all=import_all)
+        self._show_matplotlib_backend(args.gui, backend)
+        print(
+            "%pylab is deprecated, use %matplotlib inline and import the required libraries."
+        )
+        print("Populating the interactive namespace from numpy and matplotlib")
+        if clobbered:
+            warn("pylab import has clobbered these variables: %s"  % clobbered +
+            "\n`%matplotlib` prevents importing * from pylab and numpy"
+            )
+
+    def _show_matplotlib_backend(self, gui, backend):
+        """show matplotlib message backend message"""
+        if not gui or gui == 'auto':
+            print("Using matplotlib backend: %s" % backend)
diff --git a/lib/python3.12/site-packages/IPython/external/__init__.py b/lib/python3.12/site-packages/IPython/external/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..eedc338eb8471eb54c596d671d24e009afc9a134
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/external/__init__.py
@@ -0,0 +1,7 @@
+"""
+This package contains all third-party modules bundled with IPython.
+"""
+
+from typing import List
+
+__all__: List[str] = []
diff --git a/lib/python3.12/site-packages/IPython/external/__pycache__/__init__.cpython-312.pyc b/lib/python3.12/site-packages/IPython/external/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1926f61241735f6bdad1ad55434f8587e6726d6c
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/external/__pycache__/__init__.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/external/__pycache__/pickleshare.cpython-312.pyc b/lib/python3.12/site-packages/IPython/external/__pycache__/pickleshare.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..64b7d7d6562afac9a9f83e6fcee1fbe1e68d2e57
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/external/__pycache__/pickleshare.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/external/__pycache__/qt_for_kernel.cpython-312.pyc b/lib/python3.12/site-packages/IPython/external/__pycache__/qt_for_kernel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fc4e054f6a000f7df6e4e5759cdebdeab2d57d0b
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/external/__pycache__/qt_for_kernel.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/external/__pycache__/qt_loaders.cpython-312.pyc b/lib/python3.12/site-packages/IPython/external/__pycache__/qt_loaders.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..119f39341b787bb4c8885c3004b3a96cc91e5a09
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/external/__pycache__/qt_loaders.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/external/pickleshare.py b/lib/python3.12/site-packages/IPython/external/pickleshare.py
new file mode 100644
index 0000000000000000000000000000000000000000..4aa7d8226ae7f8123bba092dec076c02d954640c
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/external/pickleshare.py
@@ -0,0 +1,303 @@
+"""
+Vendoring of pickleshare, reduced to used functionalities.
+
+---
+
+PickleShare - a small 'shelve' like datastore with concurrency support
+
+Like shelve, a PickleShareDB object acts like a normal dictionary. Unlike
+shelve, many processes can access the database simultaneously. Changing a
+value in database is immediately visible to other processes accessing the
+same database.
+
+Concurrency is possible because the values are stored in separate files. Hence
+the "database" is a directory where *all* files are governed by PickleShare.
+
+Example usage::
+
+    from pickleshare import *
+    db = PickleShareDB('~/testpickleshare')
+    db.clear()
+    print "Should be empty:",db.items()
+    db['hello'] = 15
+    db['aku ankka'] = [1,2,313]
+    db['paths/are/ok/key'] = [1,(5,46)]
+    print db.keys()
+    del db['aku ankka']
+
+This module is certainly not ZODB, but can be used for low-load
+(non-mission-critical) situations where tiny code size trumps the
+advanced features of a "real" object database.
+
+Installation guide: pip install pickleshare
+
+Author: Ville Vainio <vivainio@gmail.com>
+License: MIT open source license.
+
+"""
+
+__version__ = "0.7.5"
+
+from pathlib import Path
+
+
+import os, stat, time
+
+try:
+    import collections.abc as collections_abc
+except ImportError:
+    import collections as collections_abc
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+import errno
+import sys
+
+
+def gethashfile(key):
+    return ("%02x" % abs(hash(key) % 256))[-2:]
+
+
+_sentinel = object()
+
+
+class PickleShareDB(collections_abc.MutableMapping):
+    """The main 'connection' object for PickleShare database"""
+
+    def __init__(self, root):
+        """Return a db object that will manage the specied directory"""
+        if not isinstance(root, str):
+            root = str(root)
+        root = os.path.abspath(os.path.expanduser(root))
+        self.root = Path(root)
+        if not self.root.is_dir():
+            # catching the exception is necessary if multiple processes are concurrently trying to create a folder
+            # exists_ok keyword argument of mkdir does the same but only from Python 3.5
+            try:
+                self.root.mkdir(parents=True)
+            except OSError as e:
+                if e.errno != errno.EEXIST:
+                    raise
+        # cache has { 'key' : (obj, orig_mod_time) }
+        self.cache = {}
+
+    def __getitem__(self, key):
+        """db['key'] reading"""
+        fil = self.root / key
+        try:
+            mtime = fil.stat()[stat.ST_MTIME]
+        except OSError:
+            raise KeyError(key)
+
+        if fil in self.cache and mtime == self.cache[fil][1]:
+            return self.cache[fil][0]
+        try:
+            # The cached item has expired, need to read
+            with fil.open("rb") as f:
+                obj = pickle.loads(f.read())
+        except:
+            raise KeyError(key)
+
+        self.cache[fil] = (obj, mtime)
+        return obj
+
+    def __setitem__(self, key, value):
+        """db['key'] = 5"""
+        fil = self.root / key
+        parent = fil.parent
+        if parent and not parent.is_dir():
+            parent.mkdir(parents=True)
+        # We specify protocol 2, so that we can mostly go between Python 2
+        # and Python 3. We can upgrade to protocol 3 when Python 2 is obsolete.
+        with fil.open("wb") as f:
+            pickle.dump(value, f, protocol=2)
+        try:
+            self.cache[fil] = (value, fil.stat().st_mtime)
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                raise
+
+    def hset(self, hashroot, key, value):
+        """hashed set"""
+        hroot = self.root / hashroot
+        if not hroot.is_dir():
+            hroot.mkdir()
+        hfile = hroot / gethashfile(key)
+        d = self.get(hfile, {})
+        d.update({key: value})
+        self[hfile] = d
+
+    def hget(self, hashroot, key, default=_sentinel, fast_only=True):
+        """hashed get"""
+        hroot = self.root / hashroot
+        hfile = hroot / gethashfile(key)
+
+        d = self.get(hfile, _sentinel)
+        # print "got dict",d,"from",hfile
+        if d is _sentinel:
+            if fast_only:
+                if default is _sentinel:
+                    raise KeyError(key)
+
+                return default
+
+            # slow mode ok, works even after hcompress()
+            d = self.hdict(hashroot)
+
+        return d.get(key, default)
+
+    def hdict(self, hashroot):
+        """Get all data contained in hashed category 'hashroot' as dict"""
+        hfiles = self.keys(hashroot + "/*")
+        hfiles.sort()
+        last = len(hfiles) and hfiles[-1] or ""
+        if last.endswith("xx"):
+            # print "using xx"
+            hfiles = [last] + hfiles[:-1]
+
+        all = {}
+
+        for f in hfiles:
+            # print "using",f
+            try:
+                all.update(self[f])
+            except KeyError:
+                print("Corrupt", f, "deleted - hset is not threadsafe!")
+                del self[f]
+
+            self.uncache(f)
+
+        return all
+
+    def hcompress(self, hashroot):
+        """Compress category 'hashroot', so hset is fast again
+
+        hget will fail if fast_only is True for compressed items (that were
+        hset before hcompress).
+
+        """
+        hfiles = self.keys(hashroot + "/*")
+        all = {}
+        for f in hfiles:
+            # print "using",f
+            all.update(self[f])
+            self.uncache(f)
+
+        self[hashroot + "/xx"] = all
+        for f in hfiles:
+            p = self.root / f
+            if p.name == "xx":
+                continue
+            p.unlink()
+
+    def __delitem__(self, key):
+        """del db["key"]"""
+        fil = self.root / key
+        self.cache.pop(fil, None)
+        try:
+            fil.unlink()
+        except OSError:
+            # notfound and permission denied are ok - we
+            # lost, the other process wins the conflict
+            pass
+
+    def _normalized(self, p):
+        """Make a key suitable for user's eyes"""
+        return str(p.relative_to(self.root)).replace("\\", "/")
+
+    def keys(self, globpat=None):
+        """All keys in DB, or all keys matching a glob"""
+
+        if globpat is None:
+            files = self.root.rglob("*")
+        else:
+            files = self.root.glob(globpat)
+        return [self._normalized(p) for p in files if p.is_file()]
+
+    def __iter__(self):
+        return iter(self.keys())
+
+    def __len__(self):
+        return len(self.keys())
+
+    def uncache(self, *items):
+        """Removes all, or specified items from cache
+
+        Use this after reading a large amount of large objects
+        to free up memory, when you won't be needing the objects
+        for a while.
+
+        """
+        if not items:
+            self.cache = {}
+        for it in items:
+            self.cache.pop(it, None)
+
+    def waitget(self, key, maxwaittime=60):
+        """Wait (poll) for a key to get a value
+
+        Will wait for `maxwaittime` seconds before raising a KeyError.
+        The call exits normally if the `key` field in db gets a value
+        within the timeout period.
+
+        Use this for synchronizing different processes or for ensuring
+        that an unfortunately timed "db['key'] = newvalue" operation
+        in another process (which causes all 'get' operation to cause a
+        KeyError for the duration of pickling) won't screw up your program
+        logic.
+        """
+
+        wtimes = [0.2] * 3 + [0.5] * 2 + [1]
+        tries = 0
+        waited = 0
+        while 1:
+            try:
+                val = self[key]
+                return val
+            except KeyError:
+                pass
+
+            if waited > maxwaittime:
+                raise KeyError(key)
+
+            time.sleep(wtimes[tries])
+            waited += wtimes[tries]
+            if tries < len(wtimes) - 1:
+                tries += 1
+
+    def getlink(self, folder):
+        """Get a convenient link for accessing items"""
+        return PickleShareLink(self, folder)
+
+    def __repr__(self):
+        return "PickleShareDB('%s')" % self.root
+
+
+class PickleShareLink:
+    """A shortdand for accessing nested PickleShare data conveniently.
+
+    Created through PickleShareDB.getlink(), example::
+
+        lnk = db.getlink('myobjects/test')
+        lnk.foo = 2
+        lnk.bar = lnk.foo + 5
+
+    """
+
+    def __init__(self, db, keydir):
+        self.__dict__.update(locals())
+
+    def __getattr__(self, key):
+        return self.__dict__["db"][self.__dict__["keydir"] + "/" + key]
+
+    def __setattr__(self, key, val):
+        self.db[self.keydir + "/" + key] = val
+
+    def __repr__(self):
+        db = self.__dict__["db"]
+        keys = db.keys(self.__dict__["keydir"] + "/*")
+        return "<PickleShareLink '%s': %s>" % (
+            self.__dict__["keydir"],
+            ";".join([Path(k).basename() for k in keys]),
+        )
diff --git a/lib/python3.12/site-packages/IPython/external/qt_for_kernel.py b/lib/python3.12/site-packages/IPython/external/qt_for_kernel.py
new file mode 100644
index 0000000000000000000000000000000000000000..125f4e6d2ae8157c7d019c2d5cc0bd7ca07f4cec
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/external/qt_for_kernel.py
@@ -0,0 +1,124 @@
+"""Import Qt in a manner suitable for an IPython kernel.
+
+This is the import used for the `gui=qt` or `matplotlib=qt` initialization.
+
+Import Priority:
+
+if Qt has been imported anywhere else:
+   use that
+
+if matplotlib has been imported and doesn't support v2 (<= 1.0.1):
+    use PyQt4 @v1
+
+Next, ask QT_API env variable
+
+if QT_API not set:
+    ask matplotlib what it's using. If Qt4Agg or Qt5Agg, then use the
+        version matplotlib is configured with
+
+    else: (matplotlib said nothing)
+        # this is the default path - nobody told us anything
+        try in this order:
+            PyQt default version, PySide, PyQt5
+else:
+    use what QT_API says
+
+    Note that %gui's implementation will always set a `QT_API`, see
+    `IPython.terminal.pt_inputhooks.get_inputhook_name_and_func`
+
+"""
+# NOTE: This is no longer an external, third-party module, and should be
+# considered part of IPython. For compatibility however, it is being kept in
+# IPython/external.
+
+import os
+import sys
+
+from IPython.external.qt_loaders import (
+    load_qt,
+    loaded_api,
+    enum_factory,
+    # QT6
+    QT_API_PYQT6,
+    QT_API_PYSIDE6,
+    # QT5
+    QT_API_PYQT5,
+    QT_API_PYSIDE2,
+    # QT4
+    QT_API_PYQT,
+    QT_API_PYSIDE,
+    # default
+    QT_API_PYQT_DEFAULT,
+)
+
+_qt_apis = (
+    # QT6
+    QT_API_PYQT6,
+    QT_API_PYSIDE6,
+    # QT5
+    QT_API_PYQT5,
+    QT_API_PYSIDE2,
+    # default
+    QT_API_PYQT_DEFAULT,
+)
+
+
+def matplotlib_options(mpl):
+    """Constraints placed on an imported matplotlib."""
+    if mpl is None:
+        return
+    backend = mpl.rcParams.get('backend', None)
+    if backend == 'Qt4Agg':
+        mpqt = mpl.rcParams.get('backend.qt4', None)
+        if mpqt is None:
+            return None
+        if mpqt.lower() == 'pyside':
+            return [QT_API_PYSIDE]
+        elif mpqt.lower() == 'pyqt4':
+            return [QT_API_PYQT_DEFAULT]
+        elif mpqt.lower() == 'pyqt4v2':
+            return [QT_API_PYQT]
+        raise ImportError("unhandled value for backend.qt4 from matplotlib: %r" %
+                          mpqt)
+    elif backend == 'Qt5Agg':
+        mpqt = mpl.rcParams.get('backend.qt5', None)
+        if mpqt is None:
+            return None
+        if mpqt.lower() == 'pyqt5':
+            return [QT_API_PYQT5]
+        raise ImportError("unhandled value for backend.qt5 from matplotlib: %r" %
+                          mpqt)
+
+def get_options():
+    """Return a list of acceptable QT APIs, in decreasing order of preference."""
+    #already imported Qt somewhere. Use that
+    loaded = loaded_api()
+    if loaded is not None:
+        return [loaded]
+
+    mpl = sys.modules.get("matplotlib", None)
+
+    if mpl is not None and tuple(mpl.__version__.split(".")) < ("1", "0", "2"):
+        # 1.0.1 only supports PyQt4 v1
+        return [QT_API_PYQT_DEFAULT]
+
+    qt_api = os.environ.get('QT_API', None)
+    if qt_api is None:
+        #no ETS variable. Ask mpl, then use default fallback path
+        return matplotlib_options(mpl) or [
+            QT_API_PYQT_DEFAULT,
+            QT_API_PYQT6,
+            QT_API_PYSIDE6,
+            QT_API_PYQT5,
+            QT_API_PYSIDE2,
+        ]
+    elif qt_api not in _qt_apis:
+        raise RuntimeError("Invalid Qt API %r, valid values are: %r" %
+                           (qt_api, ', '.join(_qt_apis)))
+    else:
+        return [qt_api]
+
+
+api_opts = get_options()
+QtCore, QtGui, QtSvg, QT_API = load_qt(api_opts)
+enum_helper = enum_factory(QT_API, QtCore)
diff --git a/lib/python3.12/site-packages/IPython/external/qt_loaders.py b/lib/python3.12/site-packages/IPython/external/qt_loaders.py
new file mode 100644
index 0000000000000000000000000000000000000000..87b716582a14dc04892867c16cc579819c771ba4
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/external/qt_loaders.py
@@ -0,0 +1,423 @@
+"""
+This module contains factory functions that attempt
+to return Qt submodules from the various python Qt bindings.
+
+It also protects against double-importing Qt with different
+bindings, which is unstable and likely to crash
+
+This is used primarily by qt and qt_for_kernel, and shouldn't
+be accessed directly from the outside
+"""
+
+import importlib.abc
+import sys
+import os
+import types
+from functools import partial, lru_cache
+import operator
+
+# ### Available APIs.
+# Qt6
+QT_API_PYQT6 = "pyqt6"
+QT_API_PYSIDE6 = "pyside6"
+
+# Qt5
+QT_API_PYQT5 = 'pyqt5'
+QT_API_PYSIDE2 = 'pyside2'
+
+# Qt4
+# NOTE: Here for legacy matplotlib compatibility, but not really supported on the IPython side.
+QT_API_PYQT = "pyqt"  # Force version 2
+QT_API_PYQTv1 = "pyqtv1"  # Force version 2
+QT_API_PYSIDE = "pyside"
+
+QT_API_PYQT_DEFAULT = "pyqtdefault"  # use system default for version 1 vs. 2
+
+api_to_module = {
+    # Qt6
+    QT_API_PYQT6: "PyQt6",
+    QT_API_PYSIDE6: "PySide6",
+    # Qt5
+    QT_API_PYQT5: "PyQt5",
+    QT_API_PYSIDE2: "PySide2",
+    # Qt4
+    QT_API_PYSIDE: "PySide",
+    QT_API_PYQT: "PyQt4",
+    QT_API_PYQTv1: "PyQt4",
+    # default
+    QT_API_PYQT_DEFAULT: "PyQt6",
+}
+
+
+class ImportDenier(importlib.abc.MetaPathFinder):
+    """Import Hook that will guard against bad Qt imports
+    once IPython commits to a specific binding
+    """
+
+    def __init__(self):
+        self.__forbidden = set()
+
+    def forbid(self, module_name):
+        sys.modules.pop(module_name, None)
+        self.__forbidden.add(module_name)
+
+    def find_spec(self, fullname, path, target=None):
+        if path:
+            return
+        if fullname in self.__forbidden:
+            raise ImportError(
+                """
+    Importing %s disabled by IPython, which has
+    already imported an Incompatible QT Binding: %s
+    """
+                % (fullname, loaded_api())
+            )
+
+
+ID = ImportDenier()
+sys.meta_path.insert(0, ID)
+
+
+def commit_api(api):
+    """Commit to a particular API, and trigger ImportErrors on subsequent
+    dangerous imports"""
+    modules = set(api_to_module.values())
+
+    modules.remove(api_to_module[api])
+    for mod in modules:
+        ID.forbid(mod)
+
+
+def loaded_api():
+    """Return which API is loaded, if any
+
+    If this returns anything besides None,
+    importing any other Qt binding is unsafe.
+
+    Returns
+    -------
+    None, 'pyside6', 'pyqt6', 'pyside2', 'pyside', 'pyqt', 'pyqt5', 'pyqtv1'
+    """
+    if sys.modules.get("PyQt6.QtCore"):
+        return QT_API_PYQT6
+    elif sys.modules.get("PySide6.QtCore"):
+        return QT_API_PYSIDE6
+    elif sys.modules.get("PyQt5.QtCore"):
+        return QT_API_PYQT5
+    elif sys.modules.get("PySide2.QtCore"):
+        return QT_API_PYSIDE2
+    elif sys.modules.get("PyQt4.QtCore"):
+        if qtapi_version() == 2:
+            return QT_API_PYQT
+        else:
+            return QT_API_PYQTv1
+    elif sys.modules.get("PySide.QtCore"):
+        return QT_API_PYSIDE
+
+    return None
+
+
+def has_binding(api):
+    """Safely check for PyQt4/5, PySide or PySide2, without importing submodules
+
+    Parameters
+    ----------
+    api : str [ 'pyqtv1' | 'pyqt' | 'pyqt5' | 'pyside' | 'pyside2' | 'pyqtdefault']
+        Which module to check for
+
+    Returns
+    -------
+    True if the relevant module appears to be importable
+    """
+    module_name = api_to_module[api]
+    from importlib.util import find_spec
+
+    required = ['QtCore', 'QtGui', 'QtSvg']
+    if api in (QT_API_PYQT5, QT_API_PYSIDE2, QT_API_PYQT6, QT_API_PYSIDE6):
+        # QT5 requires QtWidgets too
+        required.append('QtWidgets')
+
+    for submod in required:
+        try:
+            spec = find_spec('%s.%s' % (module_name, submod))
+        except ImportError:
+            # Package (e.g. PyQt5) not found
+            return False
+        else:
+            if spec is None:
+                # Submodule (e.g. PyQt5.QtCore) not found
+                return False
+
+    if api == QT_API_PYSIDE:
+        # We can also safely check PySide version
+        import PySide
+
+        return PySide.__version_info__ >= (1, 0, 3)
+
+    return True
+
+
+def qtapi_version():
+    """Return which QString API has been set, if any
+
+    Returns
+    -------
+    The QString API version (1 or 2), or None if not set
+    """
+    try:
+        import sip
+    except ImportError:
+        # as of PyQt5 5.11, sip is no longer available as a top-level
+        # module and needs to be imported from the PyQt5 namespace
+        try:
+            from PyQt5 import sip
+        except ImportError:
+            return
+    try:
+        return sip.getapi('QString')
+    except ValueError:
+        return
+
+
+def can_import(api):
+    """Safely query whether an API is importable, without importing it"""
+    if not has_binding(api):
+        return False
+
+    current = loaded_api()
+    if api == QT_API_PYQT_DEFAULT:
+        return current in [QT_API_PYQT6, None]
+    else:
+        return current in [api, None]
+
+
+def import_pyqt4(version=2):
+    """
+    Import PyQt4
+
+    Parameters
+    ----------
+    version : 1, 2, or None
+        Which QString/QVariant API to use. Set to None to use the system
+        default
+    ImportErrors raised within this function are non-recoverable
+    """
+    # The new-style string API (version=2) automatically
+    # converts QStrings to Unicode Python strings. Also, automatically unpacks
+    # QVariants to their underlying objects.
+    import sip
+
+    if version is not None:
+        sip.setapi('QString', version)
+        sip.setapi('QVariant', version)
+
+    from PyQt4 import QtGui, QtCore, QtSvg
+
+    if QtCore.PYQT_VERSION < 0x040700:
+        raise ImportError("IPython requires PyQt4 >= 4.7, found %s" %
+                          QtCore.PYQT_VERSION_STR)
+
+    # Alias PyQt-specific functions for PySide compatibility.
+    QtCore.Signal = QtCore.pyqtSignal
+    QtCore.Slot = QtCore.pyqtSlot
+
+    # query for the API version (in case version == None)
+    version = sip.getapi('QString')
+    api = QT_API_PYQTv1 if version == 1 else QT_API_PYQT
+    return QtCore, QtGui, QtSvg, api
+
+
+def import_pyqt5():
+    """
+    Import PyQt5
+
+    ImportErrors raised within this function are non-recoverable
+    """
+
+    from PyQt5 import QtCore, QtSvg, QtWidgets, QtGui
+
+    # Alias PyQt-specific functions for PySide compatibility.
+    QtCore.Signal = QtCore.pyqtSignal
+    QtCore.Slot = QtCore.pyqtSlot
+
+    # Join QtGui and QtWidgets for Qt4 compatibility.
+    QtGuiCompat = types.ModuleType('QtGuiCompat')
+    QtGuiCompat.__dict__.update(QtGui.__dict__)
+    QtGuiCompat.__dict__.update(QtWidgets.__dict__)
+
+    api = QT_API_PYQT5
+    return QtCore, QtGuiCompat, QtSvg, api
+
+
+def import_pyqt6():
+    """
+    Import PyQt6
+
+    ImportErrors raised within this function are non-recoverable
+    """
+
+    from PyQt6 import QtCore, QtSvg, QtWidgets, QtGui
+
+    # Alias PyQt-specific functions for PySide compatibility.
+    QtCore.Signal = QtCore.pyqtSignal
+    QtCore.Slot = QtCore.pyqtSlot
+
+    # Join QtGui and QtWidgets for Qt4 compatibility.
+    QtGuiCompat = types.ModuleType("QtGuiCompat")
+    QtGuiCompat.__dict__.update(QtGui.__dict__)
+    QtGuiCompat.__dict__.update(QtWidgets.__dict__)
+
+    api = QT_API_PYQT6
+    return QtCore, QtGuiCompat, QtSvg, api
+
+
+def import_pyside():
+    """
+    Import PySide
+
+    ImportErrors raised within this function are non-recoverable
+    """
+    from PySide import QtGui, QtCore, QtSvg
+    return QtCore, QtGui, QtSvg, QT_API_PYSIDE
+
+def import_pyside2():
+    """
+    Import PySide2
+
+    ImportErrors raised within this function are non-recoverable
+    """
+    from PySide2 import QtGui, QtCore, QtSvg, QtWidgets, QtPrintSupport
+
+    # Join QtGui and QtWidgets for Qt4 compatibility.
+    QtGuiCompat = types.ModuleType('QtGuiCompat')
+    QtGuiCompat.__dict__.update(QtGui.__dict__)
+    QtGuiCompat.__dict__.update(QtWidgets.__dict__)
+    QtGuiCompat.__dict__.update(QtPrintSupport.__dict__)
+
+    return QtCore, QtGuiCompat, QtSvg, QT_API_PYSIDE2
+
+
+def import_pyside6():
+    """
+    Import PySide6
+
+    ImportErrors raised within this function are non-recoverable
+    """
+
+    def get_attrs(module):
+        return {
+            name: getattr(module, name)
+            for name in dir(module)
+            if not name.startswith("_")
+        }
+
+    from PySide6 import QtGui, QtCore, QtSvg, QtWidgets, QtPrintSupport
+
+    # Join QtGui and QtWidgets for Qt4 compatibility.
+    QtGuiCompat = types.ModuleType("QtGuiCompat")
+    QtGuiCompat.__dict__.update(QtGui.__dict__)
+    if QtCore.__version_info__ < (6, 7):
+        QtGuiCompat.__dict__.update(QtWidgets.__dict__)
+        QtGuiCompat.__dict__.update(QtPrintSupport.__dict__)
+    else:
+        QtGuiCompat.__dict__.update(get_attrs(QtWidgets))
+        QtGuiCompat.__dict__.update(get_attrs(QtPrintSupport))
+
+    return QtCore, QtGuiCompat, QtSvg, QT_API_PYSIDE6
+
+
+def load_qt(api_options):
+    """
+    Attempt to import Qt, given a preference list
+    of permissible bindings
+
+    It is safe to call this function multiple times.
+
+    Parameters
+    ----------
+    api_options : List of strings
+        The order of APIs to try. Valid items are 'pyside', 'pyside2',
+        'pyqt', 'pyqt5', 'pyqtv1' and 'pyqtdefault'
+
+    Returns
+    -------
+    A tuple of QtCore, QtGui, QtSvg, QT_API
+    The first three are the Qt modules. The last is the
+    string indicating which module was loaded.
+
+    Raises
+    ------
+    ImportError, if it isn't possible to import any requested
+    bindings (either because they aren't installed, or because
+    an incompatible library has already been installed)
+    """
+    loaders = {
+        # Qt6
+        QT_API_PYQT6: import_pyqt6,
+        QT_API_PYSIDE6: import_pyside6,
+        # Qt5
+        QT_API_PYQT5: import_pyqt5,
+        QT_API_PYSIDE2: import_pyside2,
+        # Qt4
+        QT_API_PYSIDE: import_pyside,
+        QT_API_PYQT: import_pyqt4,
+        QT_API_PYQTv1: partial(import_pyqt4, version=1),
+        # default
+        QT_API_PYQT_DEFAULT: import_pyqt6,
+    }
+
+    for api in api_options:
+
+        if api not in loaders:
+            raise RuntimeError(
+                "Invalid Qt API %r, valid values are: %s" %
+                (api, ", ".join(["%r" % k for k in loaders.keys()])))
+
+        if not can_import(api):
+            continue
+
+        #cannot safely recover from an ImportError during this
+        result = loaders[api]()
+        api = result[-1]  # changed if api = QT_API_PYQT_DEFAULT
+        commit_api(api)
+        return result
+    else:
+        # Clear the environment variable since it doesn't work.
+        if "QT_API" in os.environ:
+            del os.environ["QT_API"]
+
+        raise ImportError(
+            """
+    Could not load requested Qt binding. Please ensure that
+    PyQt4 >= 4.7, PyQt5, PyQt6, PySide >= 1.0.3, PySide2, or
+    PySide6 is available, and only one is imported per session.
+
+    Currently-imported Qt library:                              %r
+    PyQt5 available (requires QtCore, QtGui, QtSvg, QtWidgets): %s
+    PyQt6 available (requires QtCore, QtGui, QtSvg, QtWidgets): %s
+    PySide2 installed:                                          %s
+    PySide6 installed:                                          %s
+    Tried to load:                                              %r
+    """
+            % (
+                loaded_api(),
+                has_binding(QT_API_PYQT5),
+                has_binding(QT_API_PYQT6),
+                has_binding(QT_API_PYSIDE2),
+                has_binding(QT_API_PYSIDE6),
+                api_options,
+            )
+        )
+
+
+def enum_factory(QT_API, QtCore):
+    """Construct an enum helper to account for PyQt5 <-> PyQt6 changes."""
+
+    @lru_cache(None)
+    def _enum(name):
+        # foo.bar.Enum.Entry (PyQt6) <=> foo.bar.Entry (non-PyQt6).
+        return operator.attrgetter(
+            name if QT_API == QT_API_PYQT6 else name.rpartition(".")[0]
+        )(sys.modules[QtCore.__package__])
+
+    return _enum
diff --git a/lib/python3.12/site-packages/IPython/utils/PyColorize.py b/lib/python3.12/site-packages/IPython/utils/PyColorize.py
new file mode 100644
index 0000000000000000000000000000000000000000..76415d01b020499918c89e113a6d83754d4a570e
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/PyColorize.py
@@ -0,0 +1,577 @@
+import keyword
+import os
+import sys
+import token
+import tokenize
+import warnings
+from io import StringIO
+from typing import Any, Type, TypeAlias
+
+import pygments
+from pygments.formatters.terminal256 import Terminal256Formatter
+from pygments.style import Style
+from pygments.styles import get_style_by_name
+from pygments.token import Token, _TokenType
+from functools import cache
+
+from typing import TypedDict
+
+
+TokenStream: TypeAlias = list[tuple[_TokenType, str]]
+
+
+__all__ = ["Parser", "Theme"]
+
+
+class Symbols(TypedDict):
+    top_line: str
+    arrow_body: str
+    arrow_head: str
+
+
+_default_symbols: Symbols = Symbols(
+    top_line="-",
+    arrow_body="-",
+    arrow_head=">",
+)
+
+
+class Theme:
+    name: str
+    base: str | None
+    extra_style: dict[_TokenType, str]
+    symbols: Symbols
+
+    def __init__(
+        self,
+        name: str,
+        base: str | None,
+        extra_style: dict[_TokenType, str],
+        *,
+        symbols: Symbols | None = None,
+    ) -> None:
+        self.name = name
+        self.base = base
+        self.extra_style = extra_style
+        s: Symbols = symbols if symbols is not None else _default_symbols
+        self.symbols = {**_default_symbols, **s}
+        self._formatter = Terminal256Formatter(style=self.as_pygments_style())
+
+    @cache
+    def as_pygments_style(self) -> Type[Style]:
+        if self.base is not None:
+            base_styles = get_style_by_name(self.base).styles
+        else:
+            base_styles = {}
+
+        class MyStyle(Style):
+            styles = {**base_styles, **self.extra_style}
+
+        return MyStyle
+
+    def format(self, stream: TokenStream) -> str:
+        return pygments.format(stream, self._formatter)
+
+    def make_arrow(self, width: int) -> str:
+        """generate the leading arrow in front of traceback or debugger"""
+        if width >= 2:
+            return (
+                self.symbols["arrow_body"] * (width - 2)
+                + self.symbols["arrow_head"]
+                + " "
+            )
+        elif width == 1:
+            return self.symbols["arrow_head"]
+        return ""
+
+
+generate_tokens = tokenize.generate_tokens
+
+
+#############################################################################
+### Python Source Parser (does Highlighting)
+#############################################################################
+
+_KEYWORD = token.NT_OFFSET + 1
+_TEXT = token.NT_OFFSET + 2
+
+# ****************************************************************************
+
+_pygment_token_mapping: dict[int, _TokenType] = {
+    token.NUMBER: Token.Literal.Number,
+    token.OP: Token.Operator,
+    token.STRING: Token.Literal.String,
+    token.COMMENT: Token.Comment,
+    token.NAME: Token.Name,
+    token.ERRORTOKEN: Token.Error,
+    _KEYWORD: Token.Keyword,
+    _TEXT: Token.Text,
+}
+
+# technically BW is not nocolor, we should have a no-style, style
+nocolors_theme = Theme("nocolor", None, {})
+
+
+linux_theme = Theme(
+    "linux",
+    "monokai",
+    {
+        Token.Header: "ansibrightred",
+        Token.LinenoEm: "ansibrightgreen",
+        Token.Lineno: "ansigreen",
+        Token.ValEm: "ansibrightblue",
+        Token.VName: "ansicyan",
+        Token.Caret: "",
+        Token.Filename: "ansibrightgreen",
+        Token.ExcName: "ansibrightred",
+        Token.Topline: "ansibrightred",
+        Token.FilenameEm: "ansigreen",
+        Token.Normal: "",
+        Token.NormalEm: "ansibrightcyan",
+        Token.Line: "ansiyellow",
+        Token.TB.Name: "ansimagenta",
+        Token.TB.NameEm: "ansibrightmagenta",
+        Token.Breakpoint: "",
+        Token.Breakpoint.Enabled: "ansibrightred",
+        Token.Breakpoint.Disabled: "ansired",
+        Token.Prompt: "ansibrightgreen",
+        Token.PromptNum: "ansigreen bold",
+        Token.OutPrompt: "ansibrightred",
+        Token.OutPromptNum: "ansired bold",
+    },
+)
+
+neutral_pygments_equiv = {
+    Token.Header: "ansired",
+    Token.LinenoEm: "ansigreen",
+    Token.Lineno: "ansibrightgreen",
+    Token.ValEm: "ansiblue",
+    Token.VName: "ansicyan",
+    Token.Caret: "",
+    Token.Filename: "ansibrightgreen",
+    Token.FilenameEm: "ansigreen",
+    Token.ExcName: "ansired",
+    Token.Topline: "ansired",
+    Token.Normal: "",
+    Token.NormalEm: "ansicyan",
+    Token.Line: "ansired",
+    Token.TB.Name: "ansibrightmagenta",
+    Token.TB.NameEm: "ansimagenta",
+    Token.Breakpoint: "",
+    Token.Breakpoint.Enabled: "ansibrightred",
+    Token.Breakpoint.Disabled: "ansired",
+    ## specific override of pygments defaults for visibility
+    Token.Number: "ansigreen",
+    Token.Operator: "noinherit",
+    Token.String: "ansiyellow",
+    Token.Name.Function: "ansiblue",
+    Token.Name.Class: "bold ansiblue",
+    Token.Name.Namespace: "bold ansiblue",
+    Token.Name.Variable.Magic: "ansiblue",
+    Token.Prompt: "ansigreen",
+    Token.OutPrompt: "ansired",
+}
+
+
+neutral_pygments_nt = {
+    **neutral_pygments_equiv,
+    Token.PromptNum: "ansigreen bold",
+    Token.OutPromptNum: "ansired bold",
+}
+neutral_pygments_posix = {
+    **neutral_pygments_equiv,
+    Token.PromptNum: "ansibrightgreen bold",
+    Token.OutPromptNum: "ansibrightred bold",
+}
+
+
+neutral_nt = Theme("neutral:nt", "default", neutral_pygments_nt)
+neutral_posix = Theme("neutral:posix", "default", neutral_pygments_posix)
+
+
+# Hack: the 'neutral' colours are not very visible on a dark background on
+# Windows. Since Windows command prompts have a dark background by default, and
+# relatively few users are likely to alter that, we will use the 'Linux' colours,
+# designed for a dark background, as the default on Windows. Changing it here
+# avoids affecting the prompt colours rendered by prompt_toolkit, where the
+# neutral defaults do work OK.
+if os.name == "nt":
+    neutral_theme = neutral_nt
+else:
+    neutral_theme = neutral_posix
+
+
+lightbg_theme = Theme(
+    "lightbg",
+    "pastie",
+    {
+        Token.Header: "ansired",
+        Token.LinenoEm: "ansigreen",
+        Token.Lineno: "ansibrightgreen",
+        Token.ValEm: "ansiblue",
+        Token.VName: "ansicyan",
+        Token.Caret: "",
+        Token.Filename: "ansigreen",
+        Token.FilenameEm: "ansibrightgreen",
+        Token.ExcName: "ansired",
+        Token.Topline: "ansired",
+        Token.Normal: "",
+        Token.NormalEm: "ansicyan",
+        Token.Line: "ansired",
+        Token.TB.Name: "ansibrightmagenta",
+        Token.TB.NameEm: "ansimagenta",
+        Token.Breakpoint: "",
+        Token.Breakpoint.Enabled: "ansibrightred",
+        Token.Breakpoint.Disabled: "ansired",
+        Token.Prompt: "ansibrightblue",
+        Token.PromptNum: "ansiblue bold",
+        Token.OutPrompt: "ansibrightred",
+        Token.OutPromptNum: "ansired bold",
+    },
+)
+
+PRIDE_RED = "#E40303"
+PRIDE_ORANGE = "#FF8C00"
+PRIDE_YELLOW = "#FFED00"
+PRIDE_GREEN = "#008026"
+PRIDE_INDIGO = "#004CFF"
+PRIDE_VIOLET = "#732982"
+pride_theme = Theme(
+    "pride",
+    "pastie",
+    {
+        Token.Header: PRIDE_INDIGO,
+        Token.LinenoEm: f"{PRIDE_GREEN} italic",
+        Token.Lineno: f"{PRIDE_GREEN} bold",
+        Token.ValEm: f"{PRIDE_INDIGO} italic",
+        Token.VName: "ansicyan",
+        Token.Caret: "",
+        Token.Filename: f"{PRIDE_YELLOW}",
+        Token.FilenameEm: f"bg:{PRIDE_VIOLET}",
+        Token.ExcName: f"{PRIDE_ORANGE}",
+        Token.Topline: f"{PRIDE_RED}",
+        Token.Normal: "",
+        Token.NormalEm: "bold",
+        Token.Line: "ansired",
+        Token.TB.Name: "ansibrightmagenta",
+        Token.TB.NameEm: "ansimagenta",
+        Token.Breakpoint: "",
+        Token.Breakpoint.Enabled: "ansibrightred",
+        Token.Breakpoint.Disabled: "ansired",
+        Token.Prompt: "ansibrightblue",
+        Token.Prompt.Continuation.L1: f"ansiwhite bg:{PRIDE_RED}",
+        Token.Prompt.Continuation.L2: f"ansiwhite bg:{PRIDE_ORANGE}",
+        Token.Prompt.Continuation.L3: f"ansiblack bg:{PRIDE_YELLOW}",
+        Token.Prompt.Continuation.L4: f"ansiwhite bg:{PRIDE_GREEN}",
+        Token.Prompt.Continuation.L5: f"ansiwhite bg:{PRIDE_INDIGO}",
+        Token.Prompt.Continuation.L6: f"ansiwhite bg:{PRIDE_VIOLET}",
+        Token.PromptNum: "ansiblue bold",
+        Token.OutPrompt: "ansibrightred",
+        Token.OutPromptNum: "ansired bold",
+    },
+    symbols={"arrow_body": "\u2500", "arrow_head": "\u25b6", "top_line": "\u2500"},
+)
+
+
+C1 = "#D52D00"
+C2 = "#EF7627"
+C3 = "#FF9A56"
+White = "#FFFFFF"
+C5 = "#D162A4"
+C6 = "#B55690"
+C7 = "#A30262"
+
+pl = {
+    # Token.Whitespace: "#bbbbbb",
+    Token.Comment: "#888888",
+    Token.String: C5,
+    Token.String.Escape: C1,
+    Token.Keyword: f"italic {C2}",
+    Token.Name.Class: C2,
+    Token.Name.Exception: C1,
+    Token.Name.Builtin: C3,
+    Token.Name.Variable: C6,
+    Token.Name.Constant: C7,
+    Token.Name.Decorator: C2,
+    Token.Number: C7,
+    Token.Generic.Deleted: f"bg:{C1} #000000",
+    Token.Generic.Emph: "italic",
+    Token.Generic.Strong: "bold",
+    Token.Generic.EmphStrong: "bold italic",
+}
+
+pridel_theme = Theme(
+    "pride:l",
+    None,
+    {
+        Token.Header: C3,
+        Token.LinenoEm: C3,
+        Token.Lineno: C2,
+        Token.ValEm: C2,
+        Token.VName: C2,
+        Token.Caret: "",
+        Token.Filename: C2,
+        Token.FilenameEm: C3,
+        Token.ExcName: C1,
+        Token.Topline: C1,
+        Token.Normal: "",
+        Token.NormalEm: "bold",
+        Token.Line: C2,
+        Token.TB.Name: C6,
+        Token.TB.NameEm: C7,
+        Token.Breakpoint: "",
+        Token.Breakpoint.Enabled: C1,
+        Token.Breakpoint.Disabled: C7,
+        Token.Prompt: C1,
+        Token.PromptNum: C2,
+        Token.Prompt.Continuation: C7,
+        Token.Prompt.Continuation.L1: C2,
+        Token.Prompt.Continuation.L2: C3,
+        Token.Prompt.Continuation.L3: White,
+        Token.Prompt.Continuation.L4: C5,
+        Token.Prompt.Continuation.L5: C6,
+        Token.Prompt.Continuation.L6: C7,
+        Token.OutPrompt: C6,
+        Token.OutPromptNum: C5,
+        **pl,
+    },
+    symbols={"arrow_body": "\u2500", "arrow_head": "\u25b6", "top_line": "\u2500"},
+)
+
+GRUVBOX_VAL_EM = "#D79921"
+GRUVBOX_V_NAME = "#83A598"
+GRUVBOX_FILENAME = "#FBF1C7"
+GRUVBOX_EXCEPTION_NAME = "#FB4934"
+GRUVBOX_TOPLINE = "#CC241D"
+GRUVBOX_BREAKPOINT_ENABLED = "#FB4934"
+GRUVBOX_BREAKPOINT_DISABLED = "#CC241D"
+GRUVBOX_PROMPT = "#689D6A"
+GRUVBOX_PROMPT_NUM = "#8EC07C"
+GRUVBOX_OUT_PROMPT = "#B16286"
+GRUVBOX_OUT_PROMPT_NUM = "#D3869B"
+gruvbox_dark_theme = Theme(
+    "gruvbox-dark",
+    "gruvbox-dark",
+    {
+        Token.Lineno: GRUVBOX_PROMPT_NUM,
+        Token.LinenoEm: f"{GRUVBOX_PROMPT_NUM} bold",
+        Token.ValEm: f"{GRUVBOX_VAL_EM} bold",
+        Token.VName: GRUVBOX_V_NAME,
+        Token.Caret: "",
+        Token.Filename: GRUVBOX_FILENAME,
+        Token.FilenameEm: f"{GRUVBOX_FILENAME} bold",
+        Token.ExcName: f"{GRUVBOX_EXCEPTION_NAME} bold",
+        Token.Topline: GRUVBOX_TOPLINE,
+        Token.Breakpoint.Enabled: GRUVBOX_BREAKPOINT_ENABLED,
+        Token.Breakpoint.Disabled: GRUVBOX_BREAKPOINT_DISABLED,
+        Token.Prompt: GRUVBOX_PROMPT,
+        Token.PromptNum: f"{GRUVBOX_PROMPT_NUM} bold",
+        Token.OutPrompt: GRUVBOX_OUT_PROMPT,
+        Token.OutPromptNum: f"{GRUVBOX_OUT_PROMPT_NUM} bold",
+    },
+    symbols={"arrow_body": "\u2500", "arrow_head": "\u25b6", "top_line": "\u2500"},
+)
+
+theme_table: dict[str, Theme] = {
+    "nocolor": nocolors_theme,
+    "linux": linux_theme,
+    "neutral": neutral_theme,
+    "neutral:nt": neutral_nt,
+    "neutral:posix": neutral_posix,
+    "lightbg": lightbg_theme,
+    "pride": pride_theme,
+    "pride:l": pridel_theme,
+    "gruvbox-dark": gruvbox_dark_theme,
+}
+
+
+class Parser:
+    """Format colored Python source."""
+
+    _theme_name: str
+    out: Any
+    pos: int
+    lines: list[int]
+    raw: str
+
+    def __init__(self, out: Any = sys.stdout, *, theme_name: str | None = None) -> None:
+        """Create a parser with a specified color table and output channel.
+
+        Call format() to process code.
+        """
+
+        assert theme_name is not None
+
+        self.out = out
+        self.pos = 0
+        self.lines = []
+        self.raw = ""
+        if theme_name is not None:
+            if theme_name in ["Linux", "LightBG", "Neutral", "NoColor"]:
+                warnings.warn(
+                    f"Theme names and color schemes are lowercase in IPython 9.0 use {theme_name.lower()} instead",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                theme_name = theme_name.lower()
+        if not theme_name:
+            self.theme_name = "nocolor"
+        else:
+            self.theme_name = theme_name
+
+    @property
+    def theme_name(self) -> str:
+        return self._theme_name
+
+    @theme_name.setter
+    def theme_name(self, value: str) -> None:
+        assert value == value.lower()
+        self._theme_name = value
+
+    @property
+    def style(self) -> str:
+        assert False
+        return self._theme_name
+
+    @style.setter
+    def style(self, val: str) -> None:
+        assert False
+        assert val == val.lower()
+        self._theme_name = val
+
+    def format(self, raw: str, out: Any = None) -> str | None:
+        return self.format2(raw, out)[0]
+
+    def format2(self, raw: str, out: Any = None) -> tuple[str | None, bool]:
+        """Parse and send the colored source.
+
+        If out is not specified, the defaults (given to constructor) are used.
+
+        out should be a file-type object. Optionally, out can be given as the
+        string 'str' and the parser will automatically return the output in a
+        string."""
+
+        string_output = 0
+        if out == "str" or self.out == "str" or isinstance(self.out, StringIO):
+            # XXX - I don't really like this state handling logic, but at this
+            # point I don't want to make major changes, so adding the
+            # isinstance() check is the simplest I can do to ensure correct
+            # behavior.
+            out_old = self.out
+            self.out = StringIO()
+            string_output = 1
+        elif out is not None:
+            self.out = out
+        else:
+            raise ValueError(
+                '`out` or `self.out` should be file-like or the value `"str"`'
+            )
+
+        # Fast return of the unmodified input for nocolor scheme
+        # TODO:
+        if self.theme_name == "nocolor":
+            error = False
+            self.out.write(raw)
+            if string_output:
+                return raw, error
+            return None, error
+
+        # local shorthands
+
+        # Remove trailing whitespace and normalize tabs
+        self.raw = raw.expandtabs().rstrip()
+
+        # store line offsets in self.lines
+        self.lines = [0, 0]
+        pos = 0
+        raw_find = self.raw.find
+        lines_append = self.lines.append
+        while True:
+            pos = raw_find("\n", pos) + 1
+            if not pos:
+                break
+            lines_append(pos)
+        lines_append(len(self.raw))
+
+        # parse the source and write it
+        self.pos = 0
+        text = StringIO(self.raw)
+
+        error = False
+        try:
+            for atoken in generate_tokens(text.readline):
+                self(*atoken)
+        except tokenize.TokenError as ex:
+            msg = ex.args[0]
+            line = ex.args[1][0]
+            self.out.write(
+                theme_table[self.theme_name].format(
+                    [
+                        (Token, "\n\n"),
+                        (
+                            Token.Error,
+                            f"*** ERROR: {msg}{self.raw[self.lines[line] :]}",
+                        ),
+                        (Token, "\n"),
+                    ]
+                )
+            )
+            error = True
+        self.out.write(
+            theme_table[self.theme_name].format(
+                [
+                    (Token, "\n"),
+                ]
+            )
+        )
+
+        if string_output:
+            output = self.out.getvalue()
+            self.out = out_old
+            return (output, error)
+        return (None, error)
+
+    def _inner_call_(
+        self, toktype: int, toktext: str, start_pos: tuple[int, int]
+    ) -> str:
+        """like call but write to a temporary buffer"""
+        srow, scol = start_pos
+
+        # calculate new positions
+        oldpos = self.pos
+        newpos = self.lines[srow] + scol
+        self.pos = newpos + len(toktext)
+
+        # send the original whitespace, if needed
+        if newpos > oldpos:
+            acc = self.raw[oldpos:newpos]
+        else:
+            acc = ""
+
+        # skip indenting tokens
+        if toktype in [token.INDENT, token.DEDENT]:
+            self.pos = newpos
+            return acc
+
+        # map token type to a color group
+        if token.LPAR <= toktype <= token.OP:
+            toktype = token.OP
+        elif toktype == token.NAME and keyword.iskeyword(toktext):
+            toktype = _KEYWORD
+        pyg_tok_type = _pygment_token_mapping.get(toktype, Token.Text)
+
+        # send text, pygments should take care of splitting on newline and resending
+        # the correct self.colors after the new line, which is necessary for pagers
+        acc += theme_table[self.theme_name].format([(pyg_tok_type, toktext)])
+        return acc
+
+    def __call__(
+        self,
+        toktype: int,
+        toktext: str,
+        start_pos: tuple[int, int],
+        end_pos: tuple[int, int],
+        line: str,
+    ) -> None:
+        """Token handler, with syntax highlighting."""
+        self.out.write(self._inner_call_(toktype, toktext, start_pos))
diff --git a/lib/python3.12/site-packages/IPython/utils/__init__.py b/lib/python3.12/site-packages/IPython/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/PyColorize.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/PyColorize.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..adceea9347edbe811c5b38f2c03201473be3658b
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/PyColorize.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_cli.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_cli.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f3f6d30c516610721a71f0051b8864e43206a98a
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_cli.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_common.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_common.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..80deb2320393aea390f3770d152f5dba9c347bbb
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_common.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_emscripten.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_emscripten.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..03fafd16c688c159d32b578af9f2f8fcd710ba24
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_emscripten.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_posix.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_posix.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c1b7274146a25ccecb5f74437d93bbbdee1996c1
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_posix.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_win32.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_win32.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f6404853d8d292976127c00f6fa231b62055c11b
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_win32.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_win32_controller.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_win32_controller.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b0ab8401b4dfab8dff115b61ea9310ac8396aee5
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/_process_win32_controller.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/_sysinfo.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/_sysinfo.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a3c38209bea3622ddebc36ddfecffbb6e0ac1aa5
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/_sysinfo.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/coloransi.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/coloransi.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e466a98dca7caf825d0c7364ec9eff3326ea688d
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/coloransi.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/contexts.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/contexts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78d22cc590d85e869e252e732281b24359a27eb9
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/contexts.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/data.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/data.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6378b5c590f84762b962f949aa06b7031e7855b
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/data.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/docs.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/docs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b82967a2cfa53f99a680350924a386183c58cb49
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/docs.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/eventful.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/eventful.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4390b317ac34647a3a522ac90abfc3b831ed3605
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/eventful.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/importstring.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/importstring.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc8e3bf7860e6313bba79a3c2af8a48e18294518
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/importstring.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/io.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/io.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e5cca6dca994fa280e0685a2942cfa6edb4fa5b
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/io.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/jsonutil.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/jsonutil.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e904b031d94b11c19043210a435ce22a1f191e9
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/jsonutil.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/path.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/path.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5446f943726d967bbf0e021b3221704a742e5116
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/path.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/py3compat.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/py3compat.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccdfb0f7ff40a39919252ab598de137a8421729d
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/py3compat.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/sentinel.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/sentinel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5a2c8354abf7ab65518afb4225520803f6fa2da
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/sentinel.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/sysinfo.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/sysinfo.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c32ac0a633b1f31b10f2db876aaec67e21ceef09
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/sysinfo.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/syspathcontext.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/syspathcontext.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..948572617c670e739666ba79cfa583ea3e08db73
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/syspathcontext.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/terminal.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/terminal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4462bb66e721f0eb5184394ad4d73a5331f7b353
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/terminal.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/text.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/text.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccf458a527abbc634b5913080b29d09e454dee9c
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/text.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/timing.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/timing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5cf370576cbd34f753ad382b69de8c43c8e0a31d
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/timing.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/__pycache__/tokenutil.cpython-312.pyc b/lib/python3.12/site-packages/IPython/utils/__pycache__/tokenutil.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6cdde2afd035ce509a59fb21da6f29152a6f988c
Binary files /dev/null and b/lib/python3.12/site-packages/IPython/utils/__pycache__/tokenutil.cpython-312.pyc differ
diff --git a/lib/python3.12/site-packages/IPython/utils/_process_cli.py b/lib/python3.12/site-packages/IPython/utils/_process_cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..045dc50bbeb4fc475db7285958b98b8d07d572d2
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/_process_cli.py
@@ -0,0 +1,71 @@
+"""cli-specific implementation of process utilities.
+
+cli - Common Language Infrastructure for IronPython. Code
+      can run on any operating system. Check os.name for os-
+      specific settings.
+
+This file is only meant to be imported by process.py, not by end-users.
+
+This file is largely untested. To become a full drop-in process
+interface for IronPython will probably require you to help fill
+in the details.
+"""
+
+# Import cli libraries:
+import clr
+import System
+
+# Import Python libraries:
+import os
+
+# Import IPython libraries:
+from ._process_common import arg_split
+
+
+def system(cmd):
+    """
+    system(cmd) should work in a cli environment on Mac OSX, Linux,
+    and Windows
+    """
+    psi = System.Diagnostics.ProcessStartInfo(cmd)
+    psi.RedirectStandardOutput = True
+    psi.RedirectStandardError = True
+    psi.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal
+    psi.UseShellExecute = False
+    # Start up process:
+    reg = System.Diagnostics.Process.Start(psi)
+
+
+def getoutput(cmd):
+    """
+    getoutput(cmd) should work in a cli environment on Mac OSX, Linux,
+    and Windows
+    """
+    psi = System.Diagnostics.ProcessStartInfo(cmd)
+    psi.RedirectStandardOutput = True
+    psi.RedirectStandardError = True
+    psi.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal
+    psi.UseShellExecute = False
+    # Start up process:
+    reg = System.Diagnostics.Process.Start(psi)
+    myOutput = reg.StandardOutput
+    output = myOutput.ReadToEnd()
+    myError = reg.StandardError
+    error = myError.ReadToEnd()
+    return output
+
+
+def check_pid(pid):
+    """
+    Check if a process with the given PID (pid) exists
+    """
+    try:
+        System.Diagnostics.Process.GetProcessById(pid)
+        # process with given pid is running
+        return True
+    except System.InvalidOperationException:
+        # process wasn't started by this object (but is running)
+        return True
+    except System.ArgumentException:
+        # process with given pid isn't running
+        return False
diff --git a/lib/python3.12/site-packages/IPython/utils/_process_common.py b/lib/python3.12/site-packages/IPython/utils/_process_common.py
new file mode 100644
index 0000000000000000000000000000000000000000..77305853cf8c60f19072051270b7f7ea5ba69711
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/_process_common.py
@@ -0,0 +1,220 @@
+"""Common utilities for the various process_* implementations.
+
+This file is only meant to be imported by the platform-specific implementations
+of subprocess utilities, and it contains tools that are common to all of them.
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2010-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 shlex
+import subprocess
+import sys
+from typing import IO, Any, List, Union
+from collections.abc import Callable
+
+from IPython.utils import py3compat
+
+#-----------------------------------------------------------------------------
+# Function definitions
+#-----------------------------------------------------------------------------
+
+def read_no_interrupt(stream: IO[Any]) -> bytes:
+    """Read from a pipe ignoring EINTR errors.
+
+    This is necessary because when reading from pipes with GUI event loops
+    running in the background, often interrupts are raised that stop the
+    command from completing."""
+    import errno
+
+    try:
+        return stream.read()
+    except IOError as err:
+        if err.errno != errno.EINTR:
+            raise
+
+
+def process_handler(
+    cmd: Union[str, List[str]],
+    callback: Callable[[subprocess.Popen], int | str | bytes],
+    stderr=subprocess.PIPE,
+) -> int | str | bytes:
+    """Open a command in a shell subprocess and execute a callback.
+
+    This function provides common scaffolding for creating subprocess.Popen()
+    calls.  It creates a Popen object and then calls the callback with it.
+
+    Parameters
+    ----------
+    cmd : str or list
+        A command to be executed by the system, using :class:`subprocess.Popen`.
+        If a string is passed, it will be run in the system shell. If a list is
+        passed, it will be used directly as arguments.
+    callback : callable
+        A one-argument function that will be called with the Popen object.
+    stderr : file descriptor number, optional
+        By default this is set to ``subprocess.PIPE``, but you can also pass the
+        value ``subprocess.STDOUT`` to force the subprocess' stderr to go into
+        the same file descriptor as its stdout.  This is useful to read stdout
+        and stderr combined in the order they are generated.
+
+    Returns
+    -------
+    The return value of the provided callback is returned.
+    """
+    sys.stdout.flush()
+    sys.stderr.flush()
+    # On win32, close_fds can't be true when using pipes for stdin/out/err
+    if sys.platform == "win32" and stderr != subprocess.PIPE:
+        close_fds = False
+    else:
+        close_fds = True
+    # Determine if cmd should be run with system shell.
+    shell = isinstance(cmd, str)
+    # On POSIX systems run shell commands with user-preferred shell.
+    executable = None
+    if shell and os.name == 'posix' and 'SHELL' in os.environ:
+        executable = os.environ['SHELL']
+    p = subprocess.Popen(cmd, shell=shell,
+                         executable=executable,
+                         stdin=subprocess.PIPE,
+                         stdout=subprocess.PIPE,
+                         stderr=stderr,
+                         close_fds=close_fds)
+
+    try:
+        out = callback(p)
+    except KeyboardInterrupt:
+        print('^C')
+        sys.stdout.flush()
+        sys.stderr.flush()
+        out = None
+    finally:
+        # Make really sure that we don't leave processes behind, in case the
+        # call above raises an exception
+        # We start by assuming the subprocess finished (to avoid NameErrors
+        # later depending on the path taken)
+        if p.returncode is None:
+            try:
+                p.terminate()
+                p.poll()
+            except OSError:
+                pass
+        # One last try on our way out
+        if p.returncode is None:
+            try:
+                p.kill()
+            except OSError:
+                pass
+
+    return out
+
+
+def getoutput(cmd):
+    """Run a command and return its stdout/stderr as a string.
+
+    Parameters
+    ----------
+    cmd : str or list
+        A command to be executed in the system shell.
+
+    Returns
+    -------
+    output : str
+        A string containing the combination of stdout and stderr from the
+    subprocess, in whatever order the subprocess originally wrote to its
+    file descriptors (so the order of the information in this string is the
+    correct order as would be seen if running the command in a terminal).
+    """
+    out = process_handler(cmd, lambda p: p.communicate()[0], subprocess.STDOUT)
+    if out is None:
+        return ''
+    assert isinstance(out, bytes)
+    return py3compat.decode(out)
+
+
+def getoutputerror(cmd):
+    """Return (standard output, standard error) of executing cmd in a shell.
+
+    Accepts the same arguments as os.system().
+
+    Parameters
+    ----------
+    cmd : str or list
+        A command to be executed in the system shell.
+
+    Returns
+    -------
+    stdout : str
+    stderr : str
+    """
+    return get_output_error_code(cmd)[:2]
+
+def get_output_error_code(cmd):
+    """Return (standard output, standard error, return code) of executing cmd
+    in a shell.
+
+    Accepts the same arguments as os.system().
+
+    Parameters
+    ----------
+    cmd : str or list
+        A command to be executed in the system shell.
+
+    Returns
+    -------
+    stdout : str
+    stderr : str
+    returncode: int
+    """
+
+    out_err, p = process_handler(cmd, lambda p: (p.communicate(), p))
+    if out_err is None:
+        return '', '', p.returncode
+    out, err = out_err
+    return py3compat.decode(out), py3compat.decode(err), p.returncode
+
+def arg_split(s, posix=False, strict=True):
+    """Split a command line's arguments in a shell-like manner.
+
+    This is a modified version of the standard library's shlex.split()
+    function, but with a default of posix=False for splitting, so that quotes
+    in inputs are respected.
+
+    if strict=False, then any errors shlex.split would raise will result in the
+    unparsed remainder being the last element of the list, rather than raising.
+    This is because we sometimes use arg_split to parse things other than
+    command-line args.
+    """
+
+    lex = shlex.shlex(s, posix=posix)
+    lex.whitespace_split = True
+    # Extract tokens, ensuring that things like leaving open quotes
+    # does not cause this to raise.  This is important, because we
+    # sometimes pass Python source through this (e.g. %timeit f(" ")),
+    # and it shouldn't raise an exception.
+    # It may be a bad idea to parse things that are not command-line args
+    # through this function, but we do, so let's be safe about it.
+    lex.commenters='' #fix for GH-1269
+    tokens = []
+    while True:
+        try:
+            tokens.append(next(lex))
+        except StopIteration:
+            break
+        except ValueError:
+            if strict:
+                raise
+            # couldn't parse, get remaining blob as last token
+            tokens.append(lex.token)
+            break
+
+    return tokens
diff --git a/lib/python3.12/site-packages/IPython/utils/_process_emscripten.py b/lib/python3.12/site-packages/IPython/utils/_process_emscripten.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfc2518462393c53363f39fc42676637f8191e99
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/_process_emscripten.py
@@ -0,0 +1,22 @@
+"""Emscripten-specific implementation of process utilities.
+
+This file is only meant to be imported by process.py, not by end-users.
+"""
+
+from ._process_common import arg_split
+
+
+def system(cmd):
+    raise OSError("Not available")
+
+
+def getoutput(cmd):
+    raise OSError("Not available")
+
+
+def check_pid(cmd):
+    raise OSError("Not available")
+
+
+# `arg_split` is still used by magics regardless of whether we are on a posix/windows/emscipten
+__all__ = ["system", "getoutput", "check_pid", "arg_split"]
diff --git a/lib/python3.12/site-packages/IPython/utils/_process_posix.py b/lib/python3.12/site-packages/IPython/utils/_process_posix.py
new file mode 100644
index 0000000000000000000000000000000000000000..da3f00dc9757c0e20a2c0362923a9775608b85ac
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/_process_posix.py
@@ -0,0 +1,194 @@
+"""Posix-specific implementation of process utilities.
+
+This file is only meant to be imported by process.py, not by end-users.
+"""
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib
+import errno
+import os
+import subprocess as sp
+import sys
+
+# Our own
+from ._process_common import getoutput as getoutput, arg_split
+from IPython.utils.encoding import DEFAULT_ENCODING
+
+__all__ = ["getoutput", "arg_split", "system", "check_pid"]
+
+#-----------------------------------------------------------------------------
+# Function definitions
+#-----------------------------------------------------------------------------
+
+class ProcessHandler:
+    """Execute subprocesses under the control of pexpect.
+    """
+    # Timeout in seconds to wait on each reading of the subprocess' output.
+    # This should not be set too low to avoid cpu overusage from our side,
+    # since we read in a loop whose period is controlled by this timeout.
+    read_timeout: float = 0.05
+
+    # Timeout to give a process if we receive SIGINT, between sending the
+    # SIGINT to the process and forcefully terminating it.
+    terminate_timeout: float = 0.2
+
+    # File object where stdout and stderr of the subprocess will be written
+    logfile = None
+
+    # Shell to call for subprocesses to execute
+    _sh: str | None = None
+
+    @property
+    def sh(self) -> str | None:
+        if self._sh is None:
+            import pexpect
+            shell_name = os.environ.get("SHELL", "sh")
+            self._sh = pexpect.which(shell_name)
+            if self._sh is None:
+                raise OSError('"{}" shell not found'.format(shell_name))
+
+        return self._sh
+
+    def __init__(self) -> None:
+        """Arguments are used for pexpect calls."""
+        self.logfile = sys.stdout
+
+    def getoutput(self, cmd: str) -> str | None:
+        """Run a command and return its stdout/stderr as a string.
+
+        Parameters
+        ----------
+        cmd : str
+            A command to be executed in the system shell.
+
+        Returns
+        -------
+        output : str
+            A string containing the combination of stdout and stderr from the
+        subprocess, in whatever order the subprocess originally wrote to its
+        file descriptors (so the order of the information in this string is the
+        correct order as would be seen if running the command in a terminal).
+        """
+        import pexpect
+
+        assert self.sh is not None
+        try:
+            res = pexpect.run(self.sh, args=["-c", cmd])
+            assert isinstance(res, str)
+            return res.replace("\r\n", "\n")
+        except KeyboardInterrupt:
+            print('^C', file=sys.stderr, end='')
+        return None
+
+    def system(self, cmd: str) -> int:
+        """Execute a command in a subshell.
+
+        Parameters
+        ----------
+        cmd : str
+            A command to be executed in the system shell.
+
+        Returns
+        -------
+        int : child's exitstatus
+        """
+        import pexpect
+
+        # Get likely encoding for the output.
+        enc = DEFAULT_ENCODING
+        
+        # Patterns to match on the output, for pexpect.  We read input and
+        # allow either a short timeout or EOF
+        patterns = [pexpect.TIMEOUT, pexpect.EOF]
+        # the index of the EOF pattern in the list.
+        # even though we know it's 1, this call means we don't have to worry if
+        # we change the above list, and forget to change this value:
+        EOF_index = patterns.index(pexpect.EOF)
+        # The size of the output stored so far in the process output buffer.
+        # Since pexpect only appends to this buffer, each time we print we
+        # record how far we've printed, so that next time we only print *new*
+        # content from the buffer.
+        out_size = 0
+        assert self.sh is not None
+        try:
+            # Since we're not really searching the buffer for text patterns, we
+            # can set pexpect's search window to be tiny and it won't matter.
+            # We only search for the 'patterns' timeout or EOF, which aren't in
+            # the text itself.
+            #child = pexpect.spawn(pcmd, searchwindowsize=1)
+            if hasattr(pexpect, 'spawnb'):
+                child = pexpect.spawnb(self.sh, args=['-c', cmd]) # Pexpect-U
+            else:
+                child = pexpect.spawn(self.sh, args=['-c', cmd])  # Vanilla Pexpect
+            flush = sys.stdout.flush
+            while True:
+                # res is the index of the pattern that caused the match, so we
+                # know whether we've finished (if we matched EOF) or not
+                res_idx = child.expect_list(patterns, self.read_timeout)
+                print(child.before[out_size:].decode(enc, 'replace'), end='')
+                flush()
+                if res_idx==EOF_index:
+                    break
+                # Update the pointer to what we've already printed
+                out_size = len(child.before)
+        except KeyboardInterrupt:
+            # We need to send ^C to the process.  The ascii code for '^C' is 3
+            # (the character is known as ETX for 'End of Text', see
+            # curses.ascii.ETX).
+            child.sendline(chr(3))
+            # Read and print any more output the program might produce on its
+            # way out.
+            try:
+                out_size = len(child.before)
+                child.expect_list(patterns, self.terminate_timeout)
+                print(child.before[out_size:].decode(enc, 'replace'), end='')
+                sys.stdout.flush()
+            except KeyboardInterrupt:
+                # Impatient users tend to type it multiple times
+                pass
+            finally:
+                # Ensure the subprocess really is terminated
+                child.terminate(force=True)
+        # add isalive check, to ensure exitstatus is set:
+        child.isalive()
+
+        # We follow the subprocess pattern, returning either the exit status
+        # as a positive number, or the terminating signal as a negative
+        # number.
+        # on Linux, sh returns 128+n for signals terminating child processes on Linux
+        # on BSD (OS X), the signal code is set instead
+        if child.exitstatus is None:
+            # on WIFSIGNALED, pexpect sets signalstatus, leaving exitstatus=None
+            if child.signalstatus is None:
+                # this condition may never occur,
+                # but let's be certain we always return an integer.
+                return 0
+            return -child.signalstatus
+        if child.exitstatus > 128:
+            return -(child.exitstatus - 128)
+        return child.exitstatus
+
+
+# Make system() with a functional interface for outside use.  Note that we use
+# getoutput() from the _common utils, which is built on top of popen(). Using
+# pexpect to get subprocess output produces difficult to parse output, since
+# programs think they are talking to a tty and produce highly formatted output
+# (ls is a good example) that makes them hard.
+system = ProcessHandler().system
+
+
+def check_pid(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except OSError as err:
+        if err.errno == errno.ESRCH:
+            return False
+        elif err.errno == errno.EPERM:
+            # Don't have permission to signal the process - probably means it exists
+            return True
+        raise
+    else:
+        return True
diff --git a/lib/python3.12/site-packages/IPython/utils/_process_win32.py b/lib/python3.12/site-packages/IPython/utils/_process_win32.py
new file mode 100644
index 0000000000000000000000000000000000000000..0600b1ee14c1edfccea4b8a1c79f3b4d159e559b
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/_process_win32.py
@@ -0,0 +1,216 @@
+"""Windows-specific implementation of process utilities.
+
+This file is only meant to be imported by process.py, not by end-users.
+"""
+
+import ctypes
+import os
+import subprocess
+import sys
+import time
+from ctypes import POINTER, c_int
+from ctypes.wintypes import HLOCAL, LPCWSTR
+from subprocess import STDOUT
+from threading import Thread
+from types import TracebackType
+from typing import List, Optional
+
+from . import py3compat
+from ._process_common import arg_split as py_arg_split
+
+from ._process_common import process_handler, read_no_interrupt
+from .encoding import DEFAULT_ENCODING
+
+
+class AvoidUNCPath:
+    """A context manager to protect command execution from UNC paths.
+
+    In the Win32 API, commands can't be invoked with the cwd being a UNC path.
+    This context manager temporarily changes directory to the 'C:' drive on
+    entering, and restores the original working directory on exit.
+
+    The context manager returns the starting working directory *if* it made a
+    change and None otherwise, so that users can apply the necessary adjustment
+    to their system calls in the event of a change.
+
+    Examples
+    --------
+    ::
+        cmd = 'dir'
+        with AvoidUNCPath() as path:
+            if path is not None:
+                cmd = '"pushd %s &&"%s' % (path, cmd)
+            os.system(cmd)
+    """
+
+    def __enter__(self) -> Optional[str]:
+        self.path = os.getcwd()
+        self.is_unc_path = self.path.startswith(r"\\")
+        if self.is_unc_path:
+            # change to c drive (as cmd.exe cannot handle UNC addresses)
+            os.chdir("C:")
+            return self.path
+        else:
+            # We return None to signal that there was no change in the working
+            # directory
+            return None
+
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: TracebackType,
+    ) -> None:
+        if self.is_unc_path:
+            os.chdir(self.path)
+
+
+def _system_body(p: subprocess.Popen) -> int:
+    """Callback for _system."""
+    enc = DEFAULT_ENCODING
+
+    # Dec 2024: in both of these functions, I'm not sure why we .splitlines()
+    # the bytes and then decode each line individually instead of just decoding
+    # the whole thing at once.
+    def stdout_read() -> None:
+        try:
+            assert p.stdout is not None
+            for byte_line in read_no_interrupt(p.stdout).splitlines():
+                line = byte_line.decode(enc, "replace")
+                print(line, file=sys.stdout)
+        except Exception as e:
+            print(f"Error reading stdout: {e}", file=sys.stderr)
+
+    def stderr_read() -> None:
+        try:
+            assert p.stderr is not None
+            for byte_line in read_no_interrupt(p.stderr).splitlines():
+                line = byte_line.decode(enc, "replace")
+                print(line, file=sys.stderr)
+        except Exception as e:
+            print(f"Error reading stderr: {e}", file=sys.stderr)
+
+    stdout_thread = Thread(target=stdout_read)
+    stderr_thread = Thread(target=stderr_read)
+
+    stdout_thread.start()
+    stderr_thread.start()
+
+    # Wait to finish for returncode. Unfortunately, Python has a bug where
+    # wait() isn't interruptible (https://bugs.python.org/issue28168) so poll in
+    # a loop instead of just doing `return p.wait()`
+    while True:
+        result = p.poll()
+        if result is None:
+            time.sleep(0.01)
+        else:
+            break
+
+    # Join the threads to ensure they complete before returning
+    stdout_thread.join()
+    stderr_thread.join()
+
+    return result
+
+
+def system(cmd: str) -> Optional[int]:
+    """Win32 version of os.system() that works with network shares.
+
+    Note that this implementation returns None, as meant for use in IPython.
+
+    Parameters
+    ----------
+    cmd : str or list
+        A command to be executed in the system shell.
+
+    Returns
+    -------
+    int : child process' exit code.
+    """
+    # The controller provides interactivity with both
+    # stdin and stdout
+    # import _process_win32_controller
+    # _process_win32_controller.system(cmd)
+
+    with AvoidUNCPath() as path:
+        if path is not None:
+            cmd = '"pushd %s &&"%s' % (path, cmd)
+        res = process_handler(cmd, _system_body)
+        assert isinstance(res, int | type(None))
+        return res
+    return None
+
+
+def getoutput(cmd: str) -> str:
+    """Return standard output of executing cmd in a shell.
+
+    Accepts the same arguments as os.system().
+
+    Parameters
+    ----------
+    cmd : str or list
+        A command to be executed in the system shell.
+
+    Returns
+    -------
+    stdout : str
+    """
+
+    with AvoidUNCPath() as path:
+        if path is not None:
+            cmd = '"pushd %s &&"%s' % (path, cmd)
+        out = process_handler(cmd, lambda p: p.communicate()[0], STDOUT)
+
+    if out is None:
+        out = b""
+    return py3compat.decode(out)
+
+
+try:
+    windll = ctypes.windll  # type: ignore [attr-defined]
+    CommandLineToArgvW = windll.shell32.CommandLineToArgvW
+    CommandLineToArgvW.arg_types = [LPCWSTR, POINTER(c_int)]
+    CommandLineToArgvW.restype = POINTER(LPCWSTR)
+    LocalFree = windll.kernel32.LocalFree
+    LocalFree.res_type = HLOCAL
+    LocalFree.arg_types = [HLOCAL]
+
+    def arg_split(
+        commandline: str, posix: bool = False, strict: bool = True
+    ) -> List[str]:
+        """Split a command line's arguments in a shell-like manner.
+
+        This is a special version for windows that use a ctypes call to CommandLineToArgvW
+        to do the argv splitting. The posix parameter is ignored.
+
+        If strict=False, process_common.arg_split(...strict=False) is used instead.
+        """
+        # CommandLineToArgvW returns path to executable if called with empty string.
+        if commandline.strip() == "":
+            return []
+        if not strict:
+            # not really a cl-arg, fallback on _process_common
+            return py_arg_split(commandline, posix=posix, strict=strict)
+        argvn = c_int()
+        result_pointer = CommandLineToArgvW(commandline.lstrip(), ctypes.byref(argvn))
+        try:
+            result_array_type = LPCWSTR * argvn.value
+            result = [
+                arg
+                for arg in result_array_type.from_address(
+                    ctypes.addressof(result_pointer.contents)
+                )
+                if arg is not None
+            ]
+        finally:
+            # for side effects
+            _ = LocalFree(result_pointer)
+        return result
+except AttributeError:
+    arg_split = py_arg_split
+
+
+def check_pid(pid: int) -> bool:
+    # OpenProcess returns 0 if no such process (of ours) exists
+    # positive int otherwise
+    return bool(windll.kernel32.OpenProcess(1, 0, pid))
diff --git a/lib/python3.12/site-packages/IPython/utils/_process_win32_controller.py b/lib/python3.12/site-packages/IPython/utils/_process_win32_controller.py
new file mode 100644
index 0000000000000000000000000000000000000000..a62968814a7a58ea22e21ef766925b8fc520b404
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/_process_win32_controller.py
@@ -0,0 +1,574 @@
+"""Windows-specific implementation of process utilities with direct WinAPI.
+
+This file is meant to be used by process.py
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2010-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.
+#-----------------------------------------------------------------------------
+
+
+# stdlib
+import os, sys, threading
+import ctypes, msvcrt
+
+# Win32 API types needed for the API calls
+from ctypes import POINTER
+from ctypes.wintypes import HANDLE, HLOCAL, LPVOID, WORD, DWORD, BOOL, \
+        ULONG, LPCWSTR
+LPDWORD = POINTER(DWORD)
+LPHANDLE = POINTER(HANDLE)
+ULONG_PTR = POINTER(ULONG)
+class SECURITY_ATTRIBUTES(ctypes.Structure):
+    _fields_ = [("nLength", DWORD),
+                ("lpSecurityDescriptor", LPVOID),
+                ("bInheritHandle", BOOL)]
+LPSECURITY_ATTRIBUTES = POINTER(SECURITY_ATTRIBUTES)
+class STARTUPINFO(ctypes.Structure):
+    _fields_ = [("cb", DWORD),
+                ("lpReserved", LPCWSTR),
+                ("lpDesktop", LPCWSTR),
+                ("lpTitle", LPCWSTR),
+                ("dwX", DWORD),
+                ("dwY", DWORD),
+                ("dwXSize", DWORD),
+                ("dwYSize", DWORD),
+                ("dwXCountChars", DWORD),
+                ("dwYCountChars", DWORD),
+                ("dwFillAttribute", DWORD),
+                ("dwFlags", DWORD),
+                ("wShowWindow", WORD),
+                ("cbReserved2", WORD),
+                ("lpReserved2", LPVOID),
+                ("hStdInput", HANDLE),
+                ("hStdOutput", HANDLE),
+                ("hStdError", HANDLE)]
+LPSTARTUPINFO = POINTER(STARTUPINFO)
+class PROCESS_INFORMATION(ctypes.Structure):
+    _fields_ = [("hProcess", HANDLE),
+                ("hThread", HANDLE),
+                ("dwProcessId", DWORD),
+                ("dwThreadId", DWORD)]
+LPPROCESS_INFORMATION = POINTER(PROCESS_INFORMATION)
+
+# Win32 API constants needed
+ERROR_HANDLE_EOF = 38
+ERROR_BROKEN_PIPE = 109
+ERROR_NO_DATA = 232
+HANDLE_FLAG_INHERIT = 0x0001
+STARTF_USESTDHANDLES = 0x0100
+CREATE_SUSPENDED = 0x0004
+CREATE_NEW_CONSOLE = 0x0010
+CREATE_NO_WINDOW = 0x08000000
+STILL_ACTIVE = 259
+WAIT_TIMEOUT = 0x0102
+WAIT_FAILED = 0xFFFFFFFF
+INFINITE = 0xFFFFFFFF
+DUPLICATE_SAME_ACCESS = 0x00000002
+ENABLE_ECHO_INPUT = 0x0004
+ENABLE_LINE_INPUT = 0x0002
+ENABLE_PROCESSED_INPUT = 0x0001
+
+# Win32 API functions needed
+GetLastError = ctypes.windll.kernel32.GetLastError
+GetLastError.argtypes = []
+GetLastError.restype = DWORD
+
+CreateFile = ctypes.windll.kernel32.CreateFileW
+CreateFile.argtypes = [LPCWSTR, DWORD, DWORD, LPVOID, DWORD, DWORD, HANDLE]
+CreateFile.restype = HANDLE
+
+CreatePipe = ctypes.windll.kernel32.CreatePipe
+CreatePipe.argtypes = [POINTER(HANDLE), POINTER(HANDLE),
+        LPSECURITY_ATTRIBUTES, DWORD]
+CreatePipe.restype = BOOL
+
+CreateProcess = ctypes.windll.kernel32.CreateProcessW
+CreateProcess.argtypes = [LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES,
+        LPSECURITY_ATTRIBUTES, BOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFO,
+        LPPROCESS_INFORMATION]
+CreateProcess.restype = BOOL
+
+GetExitCodeProcess = ctypes.windll.kernel32.GetExitCodeProcess
+GetExitCodeProcess.argtypes = [HANDLE, LPDWORD]
+GetExitCodeProcess.restype = BOOL
+
+GetCurrentProcess = ctypes.windll.kernel32.GetCurrentProcess
+GetCurrentProcess.argtypes = []
+GetCurrentProcess.restype = HANDLE
+
+ResumeThread = ctypes.windll.kernel32.ResumeThread
+ResumeThread.argtypes = [HANDLE]
+ResumeThread.restype = DWORD
+
+ReadFile = ctypes.windll.kernel32.ReadFile
+ReadFile.argtypes = [HANDLE, LPVOID, DWORD, LPDWORD, LPVOID]
+ReadFile.restype = BOOL
+
+WriteFile = ctypes.windll.kernel32.WriteFile
+WriteFile.argtypes = [HANDLE, LPVOID, DWORD, LPDWORD, LPVOID]
+WriteFile.restype = BOOL
+
+GetConsoleMode = ctypes.windll.kernel32.GetConsoleMode
+GetConsoleMode.argtypes = [HANDLE, LPDWORD]
+GetConsoleMode.restype = BOOL
+
+SetConsoleMode = ctypes.windll.kernel32.SetConsoleMode
+SetConsoleMode.argtypes = [HANDLE, DWORD]
+SetConsoleMode.restype = BOOL
+
+FlushConsoleInputBuffer = ctypes.windll.kernel32.FlushConsoleInputBuffer
+FlushConsoleInputBuffer.argtypes = [HANDLE]
+FlushConsoleInputBuffer.restype = BOOL
+
+WaitForSingleObject = ctypes.windll.kernel32.WaitForSingleObject
+WaitForSingleObject.argtypes = [HANDLE, DWORD]
+WaitForSingleObject.restype = DWORD
+
+DuplicateHandle = ctypes.windll.kernel32.DuplicateHandle
+DuplicateHandle.argtypes = [HANDLE, HANDLE, HANDLE, LPHANDLE,
+        DWORD, BOOL, DWORD]
+DuplicateHandle.restype = BOOL
+
+SetHandleInformation = ctypes.windll.kernel32.SetHandleInformation
+SetHandleInformation.argtypes = [HANDLE, DWORD, DWORD]
+SetHandleInformation.restype = BOOL
+
+CloseHandle = ctypes.windll.kernel32.CloseHandle
+CloseHandle.argtypes = [HANDLE]
+CloseHandle.restype = BOOL
+
+CommandLineToArgvW = ctypes.windll.shell32.CommandLineToArgvW
+CommandLineToArgvW.argtypes = [LPCWSTR, POINTER(ctypes.c_int)]
+CommandLineToArgvW.restype = POINTER(LPCWSTR)
+
+LocalFree = ctypes.windll.kernel32.LocalFree
+LocalFree.argtypes = [HLOCAL]
+LocalFree.restype = HLOCAL
+
+class AvoidUNCPath:
+    """A context manager to protect command execution from UNC paths.
+
+    In the Win32 API, commands can't be invoked with the cwd being a UNC path.
+    This context manager temporarily changes directory to the 'C:' drive on
+    entering, and restores the original working directory on exit.
+
+    The context manager returns the starting working directory *if* it made a
+    change and None otherwise, so that users can apply the necessary adjustment
+    to their system calls in the event of a change.
+
+    Examples
+    --------
+    ::
+        cmd = 'dir'
+        with AvoidUNCPath() as path:
+            if path is not None:
+                cmd = '"pushd %s &&"%s' % (path, cmd)
+            os.system(cmd)
+    """
+
+    def __enter__(self) -> None:
+        self.path = os.getcwd()
+        self.is_unc_path = self.path.startswith(r"\\")
+        if self.is_unc_path:
+            # change to c drive (as cmd.exe cannot handle UNC addresses)
+            os.chdir("C:")
+            return self.path
+        else:
+            # We return None to signal that there was no change in the working
+            # directory
+            return None
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        if self.is_unc_path:
+            os.chdir(self.path)
+
+
+class Win32ShellCommandController:
+    """Runs a shell command in a 'with' context.
+
+    This implementation is Win32-specific.
+
+    Example:
+        # Runs the command interactively with default console stdin/stdout
+        with ShellCommandController('python -i') as scc:
+            scc.run()
+
+        # Runs the command using the provided functions for stdin/stdout
+        def my_stdout_func(s):
+            # print or save the string 's'
+            write_to_stdout(s)
+        def my_stdin_func():
+            # If input is available, return it as a string.
+            if input_available():
+                return get_input()
+            # If no input available, return None after a short delay to
+            # keep from blocking.
+            else:
+                time.sleep(0.01)
+                return None
+      
+        with ShellCommandController('python -i') as scc:
+            scc.run(my_stdout_func, my_stdin_func)
+    """
+
+    def __init__(self, cmd, mergeout = True):
+        """Initializes the shell command controller.
+
+        The cmd is the program to execute, and mergeout is
+        whether to blend stdout and stderr into one output
+        in stdout. Merging them together in this fashion more
+        reliably keeps stdout and stderr in the correct order
+        especially for interactive shell usage.
+        """
+        self.cmd = cmd
+        self.mergeout = mergeout
+
+    def __enter__(self):
+        cmd = self.cmd
+        mergeout = self.mergeout
+
+        self.hstdout, self.hstdin, self.hstderr = None, None, None
+        self.piProcInfo = None
+        try:
+            p_hstdout, c_hstdout, p_hstderr, \
+                    c_hstderr, p_hstdin, c_hstdin = [None]*6
+
+            # SECURITY_ATTRIBUTES with inherit handle set to True
+            saAttr = SECURITY_ATTRIBUTES()
+            saAttr.nLength = ctypes.sizeof(saAttr)
+            saAttr.bInheritHandle = True
+            saAttr.lpSecurityDescriptor = None
+
+            def create_pipe(uninherit):
+                """Creates a Windows pipe, which consists of two handles.
+
+                The 'uninherit' parameter controls which handle is not
+                inherited by the child process.
+                """
+                handles = HANDLE(), HANDLE()
+                if not CreatePipe(ctypes.byref(handles[0]),
+                            ctypes.byref(handles[1]), ctypes.byref(saAttr), 0):
+                    raise ctypes.WinError()
+                if not SetHandleInformation(handles[uninherit],
+                            HANDLE_FLAG_INHERIT, 0):
+                    raise ctypes.WinError()
+                return handles[0].value, handles[1].value
+
+            p_hstdout, c_hstdout = create_pipe(uninherit=0)
+            # 'mergeout' signals that stdout and stderr should be merged.
+            # We do that by using one pipe for both of them.
+            if mergeout:
+                c_hstderr = HANDLE()
+                if not DuplicateHandle(GetCurrentProcess(), c_hstdout,
+                                GetCurrentProcess(), ctypes.byref(c_hstderr),
+                                0, True, DUPLICATE_SAME_ACCESS):
+                    raise ctypes.WinError()
+            else:
+                p_hstderr, c_hstderr = create_pipe(uninherit=0)
+            c_hstdin,  p_hstdin  = create_pipe(uninherit=1)
+
+            # Create the process object
+            piProcInfo = PROCESS_INFORMATION()
+            siStartInfo = STARTUPINFO()
+            siStartInfo.cb = ctypes.sizeof(siStartInfo)
+            siStartInfo.hStdInput = c_hstdin
+            siStartInfo.hStdOutput = c_hstdout
+            siStartInfo.hStdError = c_hstderr
+            siStartInfo.dwFlags = STARTF_USESTDHANDLES
+            dwCreationFlags = CREATE_SUSPENDED | CREATE_NO_WINDOW # | CREATE_NEW_CONSOLE
+
+            if not CreateProcess(None,
+                    u"cmd.exe /c " + cmd,
+                    None, None, True, dwCreationFlags,
+                    None, None, ctypes.byref(siStartInfo),
+                    ctypes.byref(piProcInfo)):
+                raise ctypes.WinError()
+
+            # Close this process's versions of the child handles
+            CloseHandle(c_hstdin)
+            c_hstdin = None
+            CloseHandle(c_hstdout)
+            c_hstdout = None
+            if c_hstderr is not None:
+                CloseHandle(c_hstderr)
+                c_hstderr = None
+
+            # Transfer ownership of the parent handles to the object
+            self.hstdin = p_hstdin
+            p_hstdin = None
+            self.hstdout = p_hstdout
+            p_hstdout = None
+            if not mergeout:
+                self.hstderr = p_hstderr
+                p_hstderr = None
+            self.piProcInfo = piProcInfo
+
+        finally:
+            if p_hstdin:
+                CloseHandle(p_hstdin)
+            if c_hstdin:
+                CloseHandle(c_hstdin)
+            if p_hstdout:
+                CloseHandle(p_hstdout)
+            if c_hstdout:
+                CloseHandle(c_hstdout)
+            if p_hstderr:
+                CloseHandle(p_hstderr)
+            if c_hstderr:
+                CloseHandle(c_hstderr)
+
+        return self
+
+    def _stdin_thread(self, handle, hprocess, func, stdout_func):
+        exitCode = DWORD()
+        bytesWritten = DWORD(0)
+        while True:
+            #print("stdin thread loop start")
+            # Get the input string (may be bytes or unicode)
+            data = func()
+
+            # None signals to poll whether the process has exited
+            if data is None:
+                #print("checking for process completion")
+                if not GetExitCodeProcess(hprocess, ctypes.byref(exitCode)):
+                    raise ctypes.WinError()
+                if exitCode.value != STILL_ACTIVE:
+                    return
+                # TESTING: Does zero-sized writefile help?
+                if not WriteFile(handle, "", 0,
+                        ctypes.byref(bytesWritten), None):
+                    raise ctypes.WinError()
+                continue
+            #print("\nGot str %s\n" % repr(data), file=sys.stderr)
+
+            # Encode the string to the console encoding
+            if isinstance(data, unicode): #FIXME: Python3
+                data = data.encode('utf_8')
+
+            # What we have now must be a string of bytes
+            if not isinstance(data, str): #FIXME: Python3
+                raise RuntimeError("internal stdin function string error")
+
+            # An empty string signals EOF
+            if len(data) == 0:
+                return
+
+            # In a windows console, sometimes the input is echoed,
+            # but sometimes not. How do we determine when to do this?
+            stdout_func(data)
+            # WriteFile may not accept all the data at once.
+            # Loop until everything is processed
+            while len(data) != 0:
+                #print("Calling writefile")
+                if not WriteFile(handle, data, len(data),
+                        ctypes.byref(bytesWritten), None):
+                    # This occurs at exit
+                    if GetLastError() == ERROR_NO_DATA:
+                        return
+                    raise ctypes.WinError()
+                #print("Called writefile")
+                data = data[bytesWritten.value:]
+
+    def _stdout_thread(self, handle, func):
+        # Allocate the output buffer
+        data = ctypes.create_string_buffer(4096)
+        while True:
+            bytesRead = DWORD(0)
+            if not ReadFile(handle, data, 4096,
+                        ctypes.byref(bytesRead), None):
+                le = GetLastError()
+                if le == ERROR_BROKEN_PIPE:
+                    return
+                else:
+                    raise ctypes.WinError()
+            # FIXME: Python3
+            s = data.value[0:bytesRead.value]
+            #print("\nv: %s" % repr(s), file=sys.stderr)
+            func(s.decode('utf_8', 'replace'))
+
+    def run(self, stdout_func = None, stdin_func = None, stderr_func = None):
+        """Runs the process, using the provided functions for I/O.
+
+        The function stdin_func should return strings whenever a
+        character or characters become available.
+        The functions stdout_func and stderr_func are called whenever
+        something is printed to stdout or stderr, respectively.
+        These functions are called from different threads (but not
+        concurrently, because of the GIL).
+        """
+        if stdout_func is None and stdin_func is None and stderr_func is None:
+            return self._run_stdio()
+
+        if stderr_func is not None and self.mergeout:
+            raise RuntimeError("Shell command was initiated with "
+                    "merged stdin/stdout, but a separate stderr_func "
+                    "was provided to the run() method")
+
+        # Create a thread for each input/output handle
+        stdin_thread = None
+        threads = []
+        if stdin_func:
+            stdin_thread = threading.Thread(target=self._stdin_thread,
+                                args=(self.hstdin, self.piProcInfo.hProcess,
+                                stdin_func, stdout_func))
+        threads.append(threading.Thread(target=self._stdout_thread,
+                                    args=(self.hstdout, stdout_func)))
+        if not self.mergeout:
+            if stderr_func is None:
+                stderr_func = stdout_func
+            threads.append(threading.Thread(target=self._stdout_thread,
+                                        args=(self.hstderr, stderr_func)))
+        # Start the I/O threads and the process
+        if ResumeThread(self.piProcInfo.hThread) == 0xFFFFFFFF:
+            raise ctypes.WinError()
+        if stdin_thread is not None:
+            stdin_thread.start()
+        for thread in threads:
+            thread.start()
+        # Wait for the process to complete
+        if WaitForSingleObject(self.piProcInfo.hProcess, INFINITE) == \
+                    WAIT_FAILED:
+            raise ctypes.WinError()
+        # Wait for the I/O threads to complete
+        for thread in threads:
+            thread.join()
+
+        # Wait for the stdin thread to complete
+        if stdin_thread is not None:
+            stdin_thread.join()
+
+    def _stdin_raw_nonblock(self):
+        """Use the raw Win32 handle of sys.stdin to do non-blocking reads"""
+        # WARNING: This is experimental, and produces inconsistent results.
+        #          It's possible for the handle not to be appropriate for use
+        #          with WaitForSingleObject, among other things.
+        handle = msvcrt.get_osfhandle(sys.stdin.fileno())
+        result = WaitForSingleObject(handle, 100)
+        if result == WAIT_FAILED:
+            raise ctypes.WinError()
+        elif result == WAIT_TIMEOUT:
+            print(".", end='')
+            return None
+        else:
+            data = ctypes.create_string_buffer(256)
+            bytesRead = DWORD(0)
+            print('?', end='')
+
+            if not ReadFile(handle, data, 256,
+                        ctypes.byref(bytesRead), None):
+                raise ctypes.WinError()
+            # This ensures the non-blocking works with an actual console
+            # Not checking the error, so the processing will still work with
+            # other handle types
+            FlushConsoleInputBuffer(handle)
+
+            data = data.value
+            data = data.replace('\r\n', '\n')
+            data = data.replace('\r', '\n')
+            print(repr(data) + " ", end='')
+            return data
+
+    def _stdin_raw_block(self):
+        """Use a blocking stdin read"""
+        # The big problem with the blocking read is that it doesn't
+        # exit when it's supposed to in all contexts. An extra
+        # key-press may be required to trigger the exit.
+        try:
+            data = sys.stdin.read(1)
+            data = data.replace('\r', '\n')
+            return data
+        except WindowsError as we:
+            if we.winerror == ERROR_NO_DATA:
+                # This error occurs when the pipe is closed
+                return None
+            else:
+                # Otherwise let the error propagate
+                raise we
+
+    def _stdout_raw(self, s):
+        """Writes the string to stdout"""
+        print(s, end='', file=sys.stdout)
+        sys.stdout.flush()
+
+    def _stderr_raw(self, s):
+        """Writes the string to stdout"""
+        print(s, end='', file=sys.stderr)
+        sys.stderr.flush()
+
+    def _run_stdio(self):
+        """Runs the process using the system standard I/O.
+
+        IMPORTANT: stdin needs to be asynchronous, so the Python
+                   sys.stdin object is not used. Instead,
+                   msvcrt.kbhit/getwch are used asynchronously.
+        """
+        # Disable Line and Echo mode
+        #lpMode = DWORD()
+        #handle = msvcrt.get_osfhandle(sys.stdin.fileno())
+        #if GetConsoleMode(handle, ctypes.byref(lpMode)):
+        #    set_console_mode = True
+        #    if not SetConsoleMode(handle, lpMode.value &
+        #            ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT)):
+        #        raise ctypes.WinError()
+
+        if self.mergeout:
+            return self.run(stdout_func = self._stdout_raw,
+                    stdin_func = self._stdin_raw_block)
+        else:
+            return self.run(stdout_func = self._stdout_raw,
+                    stdin_func = self._stdin_raw_block,
+                    stderr_func = self._stderr_raw)
+
+        # Restore the previous console mode
+        #if set_console_mode:
+        #    if not SetConsoleMode(handle, lpMode.value):
+        #        raise ctypes.WinError()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.hstdin:
+            CloseHandle(self.hstdin)
+            self.hstdin = None
+        if self.hstdout:
+            CloseHandle(self.hstdout)
+            self.hstdout = None
+        if self.hstderr:
+            CloseHandle(self.hstderr)
+            self.hstderr = None
+        if self.piProcInfo is not None:
+            CloseHandle(self.piProcInfo.hProcess)
+            CloseHandle(self.piProcInfo.hThread)
+            self.piProcInfo = None
+
+
+def system(cmd: str) -> None:
+    """Win32 version of os.system() that works with network shares.
+
+    Note that this implementation returns None, as meant for use in IPython.
+
+    Parameters
+    ----------
+    cmd : str
+        A command to be executed in the system shell.
+
+    Returns
+    -------
+    None : we explicitly do NOT return the subprocess status code, as this
+    utility is meant to be used extensively in IPython, where any return value
+    would trigger : func:`sys.displayhook` calls.
+    """
+    with AvoidUNCPath() as path:
+        if path is not None:
+            cmd = '"pushd %s &&"%s' % (path, cmd)
+        with Win32ShellCommandController(cmd) as scc:
+            scc.run()
+
+
+if __name__ == "__main__":
+    print("Test starting!")
+    #system("cmd")
+    system("python -i")
+    print("Test finished!")
diff --git a/lib/python3.12/site-packages/IPython/utils/_sysinfo.py b/lib/python3.12/site-packages/IPython/utils/_sysinfo.py
new file mode 100644
index 0000000000000000000000000000000000000000..68ce7af09f98bb5008b81ff5b2907d2bed4726e5
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/_sysinfo.py
@@ -0,0 +1,2 @@
+# GENERATED BY setup.py
+commit = "178fef7"
diff --git a/lib/python3.12/site-packages/IPython/utils/capture.py b/lib/python3.12/site-packages/IPython/utils/capture.py
new file mode 100644
index 0000000000000000000000000000000000000000..39ce9ca55f73bfa03d3413e77f8efc82c16df73d
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/capture.py
@@ -0,0 +1,170 @@
+# encoding: utf-8
+"""IO capturing utilities."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import sys
+from io import StringIO
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+
+class RichOutput:
+    def __init__(self, data=None, metadata=None, transient=None, update=False):
+        self.data = data or {}
+        self.metadata = metadata or {}
+        self.transient = transient or {}
+        self.update = update
+
+    def display(self):
+        from IPython.display import publish_display_data
+        publish_display_data(data=self.data, metadata=self.metadata,
+                             transient=self.transient, update=self.update)
+
+    def _repr_mime_(self, mime):
+        if mime not in self.data:
+            return
+        data = self.data[mime]
+        if mime in self.metadata:
+            return data, self.metadata[mime]
+        else:
+            return data
+
+    def _repr_mimebundle_(self, include=None, exclude=None):
+        return self.data, self.metadata
+
+    def _repr_html_(self):
+        return self._repr_mime_("text/html")
+
+    def _repr_latex_(self):
+        return self._repr_mime_("text/latex")
+
+    def _repr_json_(self):
+        return self._repr_mime_("application/json")
+
+    def _repr_javascript_(self):
+        return self._repr_mime_("application/javascript")
+
+    def _repr_png_(self):
+        return self._repr_mime_("image/png")
+
+    def _repr_jpeg_(self):
+        return self._repr_mime_("image/jpeg")
+
+    def _repr_svg_(self):
+        return self._repr_mime_("image/svg+xml")
+
+
+class CapturedIO:
+    """Simple object for containing captured stdout/err and rich display StringIO objects
+
+    Each instance `c` has three attributes:
+
+    - ``c.stdout`` : standard output as a string
+    - ``c.stderr`` : standard error as a string
+    - ``c.outputs``: a list of rich display outputs
+
+    Additionally, there's a ``c.show()`` method which will print all of the
+    above in the same order, and can be invoked simply via ``c()``.
+    """
+
+    def __init__(self, stdout, stderr, outputs=None):
+        self._stdout = stdout
+        self._stderr = stderr
+        if outputs is None:
+            outputs = []
+        self._outputs = outputs
+
+    def __str__(self):
+        return self.stdout
+
+    @property
+    def stdout(self):
+        "Captured standard output"
+        if not self._stdout:
+            return ''
+        return self._stdout.getvalue()
+
+    @property
+    def stderr(self):
+        "Captured standard error"
+        if not self._stderr:
+            return ''
+        return self._stderr.getvalue()
+
+    @property
+    def outputs(self):
+        """A list of the captured rich display outputs, if any.
+
+        If you have a CapturedIO object ``c``, these can be displayed in IPython
+        using::
+
+            from IPython.display import display
+            for o in c.outputs:
+                display(o)
+        """
+        return [ RichOutput(**kargs) for kargs in self._outputs ]
+
+    def show(self):
+        """write my output to sys.stdout/err as appropriate"""
+        sys.stdout.write(self.stdout)
+        sys.stderr.write(self.stderr)
+        sys.stdout.flush()
+        sys.stderr.flush()
+        for kargs in self._outputs:
+            RichOutput(**kargs).display()
+
+    __call__ = show
+
+
+class capture_output:
+    """context manager for capturing stdout/err"""
+    stdout = True
+    stderr = True
+    display = True
+
+    def __init__(self, stdout=True, stderr=True, display=True):
+        self.stdout = stdout
+        self.stderr = stderr
+        self.display = display
+        self.shell = None
+
+    def __enter__(self):
+        from IPython.core.getipython import get_ipython
+        from IPython.core.displaypub import CapturingDisplayPublisher
+        from IPython.core.displayhook import CapturingDisplayHook
+
+        self.sys_stdout = sys.stdout
+        self.sys_stderr = sys.stderr
+
+        if self.display:
+            self.shell = get_ipython()
+            if self.shell is None:
+                self.save_display_pub = None
+                self.display = False
+
+        stdout = stderr = outputs = None
+        if self.stdout:
+            stdout = sys.stdout = StringIO()
+        if self.stderr:
+            stderr = sys.stderr = StringIO()
+        if self.display:
+            self.save_display_pub = self.shell.display_pub
+            self.shell.display_pub = CapturingDisplayPublisher()
+            outputs = self.shell.display_pub.outputs
+            self.save_display_hook = sys.displayhook
+            sys.displayhook = CapturingDisplayHook(shell=self.shell,
+                                                   outputs=outputs)
+
+        return CapturedIO(stdout, stderr, outputs)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        sys.stdout = self.sys_stdout
+        sys.stderr = self.sys_stderr
+        if self.display and self.shell:
+            self.shell.display_pub = self.save_display_pub
+            sys.displayhook = self.save_display_hook
diff --git a/lib/python3.12/site-packages/IPython/utils/coloransi.py b/lib/python3.12/site-packages/IPython/utils/coloransi.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d50d65d3613a313c3083795a0d5c7872ba4dca3
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/coloransi.py
@@ -0,0 +1,9 @@
+# Deprecated/should be removed, but we break older version of ipyparallel
+# https://github.com/ipython/ipyparallel/pull/924
+
+
+# minimal subset of TermColors, removed from IPython
+# not for public consumption, beyond ipyparallel.
+class TermColors:
+    Normal = "\033[0m"
+    Red = "\033[0;31m"
diff --git a/lib/python3.12/site-packages/IPython/utils/contexts.py b/lib/python3.12/site-packages/IPython/utils/contexts.py
new file mode 100644
index 0000000000000000000000000000000000000000..24e54b3e934d25846b4c1a45b3e67d2944e0e045
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/contexts.py
@@ -0,0 +1,60 @@
+# encoding: utf-8
+"""Miscellaneous context managers."""
+
+import warnings
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+class preserve_keys:
+    """Preserve a set of keys in a dictionary.
+
+    Upon entering the context manager the current values of the keys
+    will be saved. Upon exiting, the dictionary will be updated to
+    restore the original value of the preserved keys. Preserved keys
+    which did not exist when entering the context manager will be
+    deleted.
+
+    Examples
+    --------
+
+    >>> d = {'a': 1, 'b': 2, 'c': 3}
+    >>> with preserve_keys(d, 'b', 'c', 'd'):
+    ...     del d['a']
+    ...     del d['b']      # will be reset to 2
+    ...     d['c'] = None   # will be reset to 3
+    ...     d['d'] = 4      # will be deleted
+    ...     d['e'] = 5
+    ...     print(sorted(d.items()))
+    ...
+    [('c', None), ('d', 4), ('e', 5)]
+    >>> print(sorted(d.items()))
+    [('b', 2), ('c', 3), ('e', 5)]
+    """
+
+    def __init__(self, dictionary, *keys):
+        self.dictionary = dictionary
+        self.keys = keys
+
+    def __enter__(self):
+        # Actions to perform upon exiting.
+        to_delete = []
+        to_update = {}
+
+        d = self.dictionary
+        for k in self.keys:
+            if k in d:
+                to_update[k] = d[k]
+            else:
+                to_delete.append(k)
+
+        self.to_delete = to_delete
+        self.to_update = to_update
+
+    def __exit__(self, *exc_info):
+        d = self.dictionary
+
+        for k in self.to_delete:
+            d.pop(k, None)
+        d.update(self.to_update)
diff --git a/lib/python3.12/site-packages/IPython/utils/data.py b/lib/python3.12/site-packages/IPython/utils/data.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab8ebb620267c4c75426979409370aa89689b3cf
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/data.py
@@ -0,0 +1,50 @@
+# encoding: utf-8
+"""Utilities for working with data structures like lists, dicts and tuples.
+"""
+
+#-----------------------------------------------------------------------------
+#  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.
+#-----------------------------------------------------------------------------
+
+import warnings
+from collections.abc import Iterable, Sequence
+from typing import TypeVar
+
+
+T = TypeVar("T")
+
+
+def uniq_stable(elems: Iterable[T]) -> list[T]:
+    """uniq_stable(elems) -> list
+
+    .. deprecated:: 9.8
+        This function is deprecated and will be removed in a future version.
+        It is not used within IPython and was never part of the public API.
+
+    Return from an iterable, a list of all the unique elements in the input,
+    but maintaining the order in which they first appear.
+
+    Note: All elements in the input must be hashable for this routine
+    to work, as it internally uses a set for efficiency reasons.
+    """
+    warnings.warn(
+        "uniq_stable is deprecated since IPython 9.8 and will be removed in a future version. "
+        "It was never part of the public API.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    seen: set[T] = set()
+    result: list[T] = []
+    for x in elems:
+        if x not in seen:
+            seen.add(x)
+            result.append(x)
+    return result
+
+
+def chop(seq: Sequence[T], size: int) -> list[Sequence[T]]:
+    """Chop a sequence into chunks of the given size."""
+    return [seq[i : i + size] for i in range(0, len(seq), size)]
diff --git a/lib/python3.12/site-packages/IPython/utils/decorators.py b/lib/python3.12/site-packages/IPython/utils/decorators.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b685c5e46e2b666d5249c10b21093384098228a
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/decorators.py
@@ -0,0 +1,83 @@
+# encoding: utf-8
+"""Decorators that don't go anywhere else.
+
+This module contains misc. decorators that don't really go with another module
+in :mod:`IPython.utils`. Before putting something here please see if it should
+go into another topical module in :mod:`IPython.utils`.
+"""
+
+#-----------------------------------------------------------------------------
+#  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
+#-----------------------------------------------------------------------------
+from collections.abc import Sequence
+
+from IPython.utils.docs import GENERATING_DOCUMENTATION
+
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+def flag_calls(func):
+    """Wrap a function to detect and flag when it gets called.
+
+    This is a decorator which takes a function and wraps it in a function with
+    a 'called' attribute. wrapper.called is initialized to False.
+
+    The wrapper.called attribute is set to False right before each call to the
+    wrapped function, so if the call fails it remains False.  After the call
+    completes, wrapper.called is set to True and the output is returned.
+
+    Testing for truth in wrapper.called allows you to determine if a call to
+    func() was attempted and succeeded."""
+    
+    # don't wrap twice
+    if hasattr(func, 'called'):
+        return func
+
+    def wrapper(*args,**kw):
+        wrapper.called = False
+        out = func(*args,**kw)
+        wrapper.called = True
+        return out
+
+    wrapper.called = False
+    wrapper.__doc__ = func.__doc__
+    return wrapper
+
+
+def undoc(func):
+    """Mark a function or class as undocumented.
+
+    This is found by inspecting the AST, so for now it must be used directly
+    as @undoc, not as e.g. @decorators.undoc
+    """
+    return func
+
+
+def sphinx_options(
+    show_inheritance: bool = True,
+    show_inherited_members: bool = False,
+    exclude_inherited_from: Sequence[str] = tuple(),
+):
+    """Set sphinx options"""
+
+    def wrapper(func):
+        if not GENERATING_DOCUMENTATION:
+            return func
+
+        func._sphinx_options = dict(
+            show_inheritance=show_inheritance,
+            show_inherited_members=show_inherited_members,
+            exclude_inherited_from=exclude_inherited_from,
+        )
+        return func
+
+    return wrapper
diff --git a/lib/python3.12/site-packages/IPython/utils/dir2.py b/lib/python3.12/site-packages/IPython/utils/dir2.py
new file mode 100644
index 0000000000000000000000000000000000000000..de3730ed3a7a523fda439526087b5db0f6a5c714
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/dir2.py
@@ -0,0 +1,83 @@
+# encoding: utf-8
+"""A fancy version of Python's builtin :func:`dir` function."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import inspect
+import types
+
+
+def safe_hasattr(obj, attr):
+    """In recent versions of Python, hasattr() only catches AttributeError.
+    This catches all errors.
+    """
+    try:
+        getattr(obj, attr)
+        return True
+    except:
+        return False
+
+
+def dir2(obj):
+    """dir2(obj) -> list of strings
+
+    Extended version of the Python builtin dir(), which does a few extra
+    checks.
+
+    This version is guaranteed to return only a list of true strings, whereas
+    dir() returns anything that objects inject into themselves, even if they
+    are later not really valid for attribute access (many extension libraries
+    have such bugs).
+    """
+
+    # Start building the attribute list via dir(), and then complete it
+    # with a few extra special-purpose calls.
+
+    try:
+        words = set(dir(obj))
+    except Exception:
+        # TypeError: dir(obj) does not return a list
+        words = set()
+
+    if safe_hasattr(obj, "__class__"):
+        words |= set(dir(obj.__class__))
+
+    # filter out non-string attributes which may be stuffed by dir() calls
+    # and poor coding in third-party modules
+
+    words = [w for w in words if isinstance(w, str)]
+    return sorted(words)
+
+
+def get_real_method(obj, name):
+    """Like getattr, but with a few extra sanity checks:
+
+    - If obj is a class, ignore everything except class methods
+    - Check if obj is a proxy that claims to have all attributes
+    - Catch attribute access failing with any exception
+    - Check that the attribute is a callable object
+
+    Returns the method or None.
+    """
+    try:
+        canary = getattr(obj, "_ipython_canary_method_should_not_exist_", None)
+    except Exception:
+        return None
+
+    if canary is not None:
+        # It claimed to have an attribute it should never have
+        return None
+
+    try:
+        m = getattr(obj, name, None)
+    except Exception:
+        return None
+
+    if inspect.isclass(obj) and not isinstance(m, types.MethodType):
+        return None
+
+    if callable(m):
+        return m
+
+    return None
diff --git a/lib/python3.12/site-packages/IPython/utils/docs.py b/lib/python3.12/site-packages/IPython/utils/docs.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a97815cdc7c8ba6c2b5c74a8c097b882717cee8
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/docs.py
@@ -0,0 +1,3 @@
+import os
+
+GENERATING_DOCUMENTATION = os.environ.get("IN_SPHINX_RUN", None) == "True"
diff --git a/lib/python3.12/site-packages/IPython/utils/encoding.py b/lib/python3.12/site-packages/IPython/utils/encoding.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7f02bbddec929b05c0661e39057b28c9292c0f3
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/encoding.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+"""
+Utilities for dealing with text encodings
+"""
+
+from __future__ import annotations
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2008-2012  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 locale
+import warnings
+from typing import Any, Literal
+
+
+# to deal with the possibility of sys.std* not being a stream at all
+def get_stream_enc(stream: Any, default: str | None = None) -> str | None:
+    """Return the given stream's encoding or a default.
+
+    There are cases where ``sys.std*`` might not actually be a stream, so
+    check for the encoding attribute prior to returning it, and return
+    a default if it doesn't exist or evaluates as False. ``default``
+    is None if not provided.
+    """
+    if not hasattr(stream, "encoding") or not stream.encoding:
+        return default
+    else:
+        return stream.encoding
+
+
+_sentinel: object = object()
+
+
+# Less conservative replacement for sys.getdefaultencoding, that will try
+# to match the environment.
+# Defined here as central function, so if we find better choices, we
+# won't need to make changes all over IPython.
+def getdefaultencoding(prefer_stream: object | bool = _sentinel) -> str:
+    """Return IPython's guess for the default encoding for bytes as text.
+
+    If prefer_stream is True (default), asks for stdin.encoding first,
+    to match the calling Terminal, but that is often None for subprocesses.
+
+    Then fall back on locale.getpreferredencoding(),
+    which should be a sensible platform default (that respects LANG environment),
+    and finally to sys.getdefaultencoding() which is the most conservative option,
+    and usually UTF8 as of Python 3.
+    """
+    if prefer_stream is not _sentinel:
+        warnings.warn(
+            "getpreferredencoding(prefer_stream=) argument is deprecated since "
+            "IPython 9.0, getdefaultencoding() will take no argument in the "
+            "future. If you rely on `prefer_stream`, please open an issue on "
+            "the IPython repo.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        prefer_stream = True
+    enc: str | None = None
+    if prefer_stream:
+        enc = get_stream_enc(sys.stdin)
+    if not enc or enc == "ascii":
+        try:
+            # There are reports of getpreferredencoding raising errors
+            # in some cases, which may well be fixed, but let's be conservative here.
+            enc = locale.getpreferredencoding()
+        except Exception:
+            pass
+    enc = enc or sys.getdefaultencoding()
+    # On windows `cp0` can be returned to indicate that there is no code page.
+    # Since cp0 is an invalid encoding return instead cp1252 which is the
+    # Western European default.
+    if enc == "cp0":
+        warnings.warn(
+            "Invalid code page cp0 detected - using cp1252 instead."
+            "If cp1252 is incorrect please ensure a valid code page "
+            "is defined for the process.",
+            RuntimeWarning,
+        )
+        return "cp1252"
+    return enc
+
+
+DEFAULT_ENCODING = getdefaultencoding()
diff --git a/lib/python3.12/site-packages/IPython/utils/eventful.py b/lib/python3.12/site-packages/IPython/utils/eventful.py
new file mode 100644
index 0000000000000000000000000000000000000000..837c6e034429e51fd51b52c17090481177670e2b
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/eventful.py
@@ -0,0 +1,5 @@
+from warnings import warn
+
+warn("IPython.utils.eventful has moved to traitlets.eventful", stacklevel=2)
+
+from traitlets.eventful import *
diff --git a/lib/python3.12/site-packages/IPython/utils/frame.py b/lib/python3.12/site-packages/IPython/utils/frame.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d0c1b718976e27278c7f68e2dee33d4b3029a53
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/frame.py
@@ -0,0 +1,94 @@
+# encoding: utf-8
+"""
+Utilities for working with stack frames.
+"""
+
+#-----------------------------------------------------------------------------
+#  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
+from typing import Any
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+def extract_vars(*names,**kw):
+    """Extract a set of variables by name from another frame.
+
+    Parameters
+    ----------
+    *names : str
+        One or more variable names which will be extracted from the caller's
+        frame.
+    **kw : integer, optional
+        How many frames in the stack to walk when looking for your variables.
+        The default is 0, which will use the frame where the call was made.
+
+    Examples
+    --------
+    ::
+
+        In [2]: def func(x):
+           ...:     y = 1
+           ...:     print(sorted(extract_vars('x','y').items()))
+           ...:
+
+        In [3]: func('hello')
+        [('x', 'hello'), ('y', 1)]
+    """
+
+    depth = kw.get('depth',0)
+
+    callerNS = sys._getframe(depth+1).f_locals
+    return dict((k,callerNS[k]) for k in names)
+
+
+def extract_vars_above(*names: list[str]):
+    """Extract a set of variables by name from another frame.
+
+    Similar to extractVars(), but with a specified depth of 1, so that names
+    are extracted exactly from above the caller.
+
+    This is simply a convenience function so that the very common case (for us)
+    of skipping exactly 1 frame doesn't have to construct a special dict for
+    keyword passing."""
+
+    callerNS = sys._getframe(2).f_locals
+    return dict((k,callerNS[k]) for k in names)
+
+
+def debugx(expr: str, pre_msg: str = ""):
+    """Print the value of an expression from the caller's frame.
+
+    Takes an expression, evaluates it in the caller's frame and prints both
+    the given expression and the resulting value (as well as a debug mark
+    indicating the name of the calling function.  The input must be of a form
+    suitable for eval().
+
+    An optional message can be passed, which will be prepended to the printed
+    expr->value pair."""
+
+    cf = sys._getframe(1)
+    print('[DBG:%s] %s%s -> %r' % (cf.f_code.co_name,pre_msg,expr,
+                                   eval(expr,cf.f_globals,cf.f_locals)))
+
+
+# deactivate it by uncommenting the following line, which makes it a no-op
+#def debugx(expr,pre_msg=''): pass
+
+
+def extract_module_locals(depth: int = 0) -> tuple[Any, Any]:
+    """Returns (module, locals) of the function `depth` frames away from the caller"""
+    f = sys._getframe(depth + 1)
+    global_ns = f.f_globals
+    module = sys.modules[global_ns['__name__']]
+    return (module, f.f_locals)
diff --git a/lib/python3.12/site-packages/IPython/utils/generics.py b/lib/python3.12/site-packages/IPython/utils/generics.py
new file mode 100644
index 0000000000000000000000000000000000000000..7680dce716d4391b37b2fe27fb1803a9ca2a5a9d
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/generics.py
@@ -0,0 +1,32 @@
+# encoding: utf-8
+"""Generic functions for extending IPython."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from IPython.core.error import TryNext
+from functools import singledispatch
+
+
+@singledispatch
+def inspect_object(obj: Any) -> None:
+    """Called when you do obj?"""
+    raise TryNext
+
+
+@singledispatch
+def complete_object(obj: Any, prev_completions: list[str]) -> list[str]:
+    """Custom completer dispatching for python objects.
+
+    Parameters
+    ----------
+    obj : object
+        The object to complete.
+    prev_completions : list
+        List of attributes discovered so far.
+    This should return the list of attributes in obj. If you only wish to
+    add to the attributes already discovered normally, return
+    own_attrs + prev_completions.
+    """
+    raise TryNext
diff --git a/lib/python3.12/site-packages/IPython/utils/importstring.py b/lib/python3.12/site-packages/IPython/utils/importstring.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ff369cd30858078b16a60da2fee0d378f29872f
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/importstring.py
@@ -0,0 +1,41 @@
+# encoding: utf-8
+"""
+A simple utility to import something by its string name.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from typing import Any
+
+
+def import_item(name: str) -> Any:
+    """Import and return ``bar`` given the string ``foo.bar``.
+
+    Calling ``bar = import_item("foo.bar")`` is the functional equivalent of
+    executing the code ``from foo import bar``.
+
+    Parameters
+    ----------
+    name : string
+        The fully qualified name of the module/package being imported.
+
+    Returns
+    -------
+    mod : module object
+        The module that was imported.
+    """
+
+    parts = name.rsplit(".", 1)
+    if len(parts) == 2:
+        # called with 'foo.bar....'
+        package, obj = parts
+        module = __import__(package, fromlist=[obj])
+        try:
+            pak = getattr(module, obj)
+        except AttributeError as e:
+            raise ImportError("No module named %s" % obj) from e
+        return pak
+    else:
+        # called with un-dotted string
+        return __import__(parts[0])
diff --git a/lib/python3.12/site-packages/IPython/utils/io.py b/lib/python3.12/site-packages/IPython/utils/io.py
new file mode 100644
index 0000000000000000000000000000000000000000..05889aba0ccd7f4905b4fdab45fdc8dd6338a207
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/io.py
@@ -0,0 +1,135 @@
+# encoding: utf-8
+"""
+IO related utilities.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+
+import atexit
+import os
+import sys
+import tempfile
+from pathlib import Path
+from warnings import warn
+
+from IPython.utils.decorators import undoc
+from .capture import CapturedIO, capture_output
+
+
+class Tee:
+    """A class to duplicate an output stream to stdout/err.
+
+    This works in a manner very similar to the Unix 'tee' command.
+
+    When the object is closed or deleted, it closes the original file given to
+    it for duplication.
+    """
+    # Inspired by:
+    # http://mail.python.org/pipermail/python-list/2007-May/442737.html
+
+    def __init__(self, file_or_name, mode="w", channel='stdout'):
+        """Construct a new Tee object.
+
+        Parameters
+        ----------
+        file_or_name : filename or open filehandle (writable)
+            File that will be duplicated
+        mode : optional, valid mode for open().
+            If a filename was give, open with this mode.
+        channel : str, one of ['stdout', 'stderr']
+        """
+        if channel not in ['stdout', 'stderr']:
+            raise ValueError('Invalid channel spec %s' % channel)
+
+        if hasattr(file_or_name, 'write') and hasattr(file_or_name, 'seek'):
+            self.file = file_or_name
+        else:
+            encoding = None if "b" in mode else "utf-8"
+            self.file = open(file_or_name, mode, encoding=encoding)
+        self.channel = channel
+        self.ostream = getattr(sys, channel)
+        setattr(sys, channel, self)
+        self._closed = False
+
+    def close(self):
+        """Close the file and restore the channel."""
+        self.flush()
+        setattr(sys, self.channel, self.ostream)
+        self.file.close()
+        self._closed = True
+
+    def write(self, data):
+        """Write data to both channels."""
+        self.file.write(data)
+        self.ostream.write(data)
+        self.ostream.flush()
+
+    def flush(self):
+        """Flush both channels."""
+        self.file.flush()
+        self.ostream.flush()
+
+    def __del__(self):
+        if not self._closed:
+            self.close()
+
+    def isatty(self):
+        return False
+
+def ask_yes_no(prompt, default=None, interrupt=None):
+    """Asks a question and returns a boolean (y/n) answer.
+
+    If default is given (one of 'y','n'), it is used if the user input is
+    empty. If interrupt is given (one of 'y','n'), it is used if the user
+    presses Ctrl-C. Otherwise the question is repeated until an answer is
+    given.
+
+    An EOF is treated as the default answer.  If there is no default, an
+    exception is raised to prevent infinite loops.
+
+    Valid answers are: y/yes/n/no (match is not case sensitive)."""
+
+    answers = {'y':True,'n':False,'yes':True,'no':False}
+    ans = None
+    while ans not in answers.keys():
+        try:
+            ans = input(prompt+' ').lower()
+            if not ans:  # response was an empty string
+                ans = default
+        except KeyboardInterrupt:
+            if interrupt:
+                ans = interrupt
+            print("\r")
+        except EOFError:
+            if default in answers.keys():
+                ans = default
+                print()
+            else:
+                raise
+
+    return answers[ans]
+
+
+def temp_pyfile(src, ext='.py'):
+    """Make a temporary python file, return filename and filehandle.
+
+    Parameters
+    ----------
+    src : string or list of strings (no need for ending newlines if list)
+        Source code to be written to the file.
+    ext : optional, string
+        Extension for the generated file.
+
+    Returns
+    -------
+    (filename, open filehandle)
+        It is the caller's responsibility to close the open file and unlink it.
+    """
+    fname = tempfile.mkstemp(ext)[1]
+    with open(Path(fname), "w", encoding="utf-8") as f:
+        f.write(src)
+        f.flush()
+    return fname
diff --git a/lib/python3.12/site-packages/IPython/utils/ipstruct.py b/lib/python3.12/site-packages/IPython/utils/ipstruct.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed112101a36bab4fa112ff8522f37e7c64105611
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/ipstruct.py
@@ -0,0 +1,379 @@
+# encoding: utf-8
+"""A dict subclass that supports attribute style access.
+
+Authors:
+
+* Fernando Perez (original)
+* Brian Granger (refactoring to a dict subclass)
+"""
+
+#-----------------------------------------------------------------------------
+#  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
+#-----------------------------------------------------------------------------
+
+__all__ = ['Struct']
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+
+class Struct(dict):
+    """A dict subclass with attribute style access.
+
+    This dict subclass has a a few extra features:
+
+    * Attribute style access.
+    * Protection of class members (like keys, items) when using attribute
+      style access.
+    * The ability to restrict assignment to only existing keys.
+    * Intelligent merging.
+    * Overloaded operators.
+    """
+    _allownew = True
+    def __init__(self, *args, **kw):
+        """Initialize with a dictionary, another Struct, or data.
+
+        Parameters
+        ----------
+        *args : dict, Struct
+            Initialize with one dict or Struct
+        **kw : dict
+            Initialize with key, value pairs.
+
+        Examples
+        --------
+        >>> s = Struct(a=10,b=30)
+        >>> s.a
+        10
+        >>> s.b
+        30
+        >>> s2 = Struct(s,c=30)
+        >>> sorted(s2.keys())
+        ['a', 'b', 'c']
+        """
+        object.__setattr__(self, '_allownew', True)
+        dict.__init__(self, *args, **kw)
+
+    def __setitem__(self, key, value):
+        """Set an item with check for allownew.
+
+        Examples
+        --------
+        >>> s = Struct()
+        >>> s['a'] = 10
+        >>> s.allow_new_attr(False)
+        >>> s['a'] = 10
+        >>> s['a']
+        10
+        >>> try:
+        ...     s['b'] = 20
+        ... except KeyError:
+        ...     print('this is not allowed')
+        ...
+        this is not allowed
+        """
+        if not self._allownew and key not in self:
+            raise KeyError(
+                "can't create new attribute %s when allow_new_attr(False)" % key)
+        dict.__setitem__(self, key, value)
+
+    def __setattr__(self, key, value):
+        """Set an attr with protection of class members.
+
+        This calls :meth:`self.__setitem__` but convert :exc:`KeyError` to
+        :exc:`AttributeError`.
+
+        Examples
+        --------
+        >>> s = Struct()
+        >>> s.a = 10
+        >>> s.a
+        10
+        >>> try:
+        ...     s.get = 10
+        ... except AttributeError:
+        ...     print("you can't set a class member")
+        ...
+        you can't set a class member
+        """
+        # If key is an str it might be a class member or instance var
+        if isinstance(key, str):
+            # I can't simply call hasattr here because it calls getattr, which
+            # calls self.__getattr__, which returns True for keys in
+            # self._data.  But I only want keys in the class and in
+            # self.__dict__
+            if key in self.__dict__ or hasattr(Struct, key):
+                raise AttributeError(
+                    'attr %s is a protected member of class Struct.' % key
+                )
+        try:
+            self.__setitem__(key, value)
+        except KeyError as e:
+            raise AttributeError(e) from e
+
+    def __getattr__(self, key):
+        """Get an attr by calling :meth:`dict.__getitem__`.
+
+        Like :meth:`__setattr__`, this method converts :exc:`KeyError` to
+        :exc:`AttributeError`.
+
+        Examples
+        --------
+        >>> s = Struct(a=10)
+        >>> s.a
+        10
+        >>> type(s.get)
+        <...method'>
+        >>> try:
+        ...     s.b
+        ... except AttributeError:
+        ...     print("I don't have that key")
+        ...
+        I don't have that key
+        """
+        try:
+            result = self[key]
+        except KeyError as e:
+            raise AttributeError(key) from e
+        else:
+            return result
+
+    def __iadd__(self, other):
+        """s += s2 is a shorthand for s.merge(s2).
+
+        Examples
+        --------
+        >>> s = Struct(a=10,b=30)
+        >>> s2 = Struct(a=20,c=40)
+        >>> s += s2
+        >>> sorted(s.keys())
+        ['a', 'b', 'c']
+        """
+        self.merge(other)
+        return self
+
+    def __add__(self,other):
+        """s + s2 -> New Struct made from s.merge(s2).
+
+        Examples
+        --------
+        >>> s1 = Struct(a=10,b=30)
+        >>> s2 = Struct(a=20,c=40)
+        >>> s = s1 + s2
+        >>> sorted(s.keys())
+        ['a', 'b', 'c']
+        """
+        sout = self.copy()
+        sout.merge(other)
+        return sout
+
+    def __sub__(self,other):
+        """s1 - s2 -> remove keys in s2 from s1.
+
+        Examples
+        --------
+        >>> s1 = Struct(a=10,b=30)
+        >>> s2 = Struct(a=40)
+        >>> s = s1 - s2
+        >>> s
+        {'b': 30}
+        """
+        sout = self.copy()
+        sout -= other
+        return sout
+
+    def __isub__(self,other):
+        """Inplace remove keys from self that are in other.
+
+        Examples
+        --------
+        >>> s1 = Struct(a=10,b=30)
+        >>> s2 = Struct(a=40)
+        >>> s1 -= s2
+        >>> s1
+        {'b': 30}
+        """
+        for k in other.keys():
+            if k in self:
+                del self[k]
+        return self
+
+    def __dict_invert(self, data):
+        """Helper function for merge.
+
+        Takes a dictionary whose values are lists and returns a dict with
+        the elements of each list as keys and the original keys as values.
+        """
+        outdict = {}
+        for k,lst in data.items():
+            if isinstance(lst, str):
+                lst = lst.split()
+            for entry in lst:
+                outdict[entry] = k
+        return outdict
+
+    def dict(self):
+        return self
+
+    def copy(self):
+        """Return a copy as a Struct.
+
+        Examples
+        --------
+        >>> s = Struct(a=10,b=30)
+        >>> s2 = s.copy()
+        >>> type(s2) is Struct
+        True
+        """
+        return Struct(dict.copy(self))
+
+    def hasattr(self, key):
+        """hasattr function available as a method.
+
+        Implemented like has_key.
+
+        Examples
+        --------
+        >>> s = Struct(a=10)
+        >>> s.hasattr('a')
+        True
+        >>> s.hasattr('b')
+        False
+        >>> s.hasattr('get')
+        False
+        """
+        return key in self
+
+    def allow_new_attr(self, allow = True):
+        """Set whether new attributes can be created in this Struct.
+
+        This can be used to catch typos by verifying that the attribute user
+        tries to change already exists in this Struct.
+        """
+        object.__setattr__(self, '_allownew', allow)
+
+    def merge(self, __loc_data__=None, __conflict_solve=None, **kw):
+        """Merge two Structs with customizable conflict resolution.
+
+        This is similar to :meth:`update`, but much more flexible. First, a
+        dict is made from data+key=value pairs. When merging this dict with
+        the Struct S, the optional dictionary 'conflict' is used to decide
+        what to do.
+
+        If conflict is not given, the default behavior is to preserve any keys
+        with their current value (the opposite of the :meth:`update` method's
+        behavior).
+
+        Parameters
+        ----------
+        __loc_data__ : dict, Struct
+            The data to merge into self
+        __conflict_solve : dict
+            The conflict policy dict.  The keys are binary functions used to
+            resolve the conflict and the values are lists of strings naming
+            the keys the conflict resolution function applies to.  Instead of
+            a list of strings a space separated string can be used, like
+            'a b c'.
+        **kw : dict
+            Additional key, value pairs to merge in
+
+        Notes
+        -----
+        The `__conflict_solve` dict is a dictionary of binary functions which will be used to
+        solve key conflicts.  Here is an example::
+
+            __conflict_solve = dict(
+                func1=['a','b','c'],
+                func2=['d','e']
+            )
+
+        In this case, the function :func:`func1` will be used to resolve
+        keys 'a', 'b' and 'c' and the function :func:`func2` will be used for
+        keys 'd' and 'e'.  This could also be written as::
+
+            __conflict_solve = dict(func1='a b c',func2='d e')
+
+        These functions will be called for each key they apply to with the
+        form::
+
+            func1(self['a'], other['a'])
+
+        The return value is used as the final merged value.
+
+        As a convenience, merge() provides five (the most commonly needed)
+        pre-defined policies: preserve, update, add, add_flip and add_s. The
+        easiest explanation is their implementation::
+
+            preserve = lambda old,new: old
+            update   = lambda old,new: new
+            add      = lambda old,new: old + new
+            add_flip = lambda old,new: new + old  # note change of order!
+            add_s    = lambda old,new: old + ' ' + new  # only for str!
+
+        You can use those four words (as strings) as keys instead
+        of defining them as functions, and the merge method will substitute
+        the appropriate functions for you.
+
+        For more complicated conflict resolution policies, you still need to
+        construct your own functions.
+
+        Examples
+        --------
+        This show the default policy:
+
+        >>> s = Struct(a=10,b=30)
+        >>> s2 = Struct(a=20,c=40)
+        >>> s.merge(s2)
+        >>> sorted(s.items())
+        [('a', 10), ('b', 30), ('c', 40)]
+
+        Now, show how to specify a conflict dict:
+
+        >>> s = Struct(a=10,b=30)
+        >>> s2 = Struct(a=20,b=40)
+        >>> conflict = {'update':'a','add':'b'}
+        >>> s.merge(s2,conflict)
+        >>> sorted(s.items())
+        [('a', 20), ('b', 70)]
+        """
+
+        data_dict = dict(__loc_data__,**kw)
+
+        # policies for conflict resolution: two argument functions which return
+        # the value that will go in the new struct
+        preserve = lambda old,new: old
+        update   = lambda old,new: new
+        add      = lambda old,new: old + new
+        add_flip = lambda old,new: new + old  # note change of order!
+        add_s    = lambda old,new: old + ' ' + new
+
+        # default policy is to keep current keys when there's a conflict
+        conflict_solve = dict.fromkeys(self, preserve)
+
+        # the conflict_solve dictionary is given by the user 'inverted': we
+        # need a name-function mapping, it comes as a function -> names
+        # dict. Make a local copy (b/c we'll make changes), replace user
+        # strings for the three builtin policies and invert it.
+        if __conflict_solve:
+            inv_conflict_solve_user = __conflict_solve.copy()
+            for name, func in [('preserve',preserve), ('update',update),
+                               ('add',add), ('add_flip',add_flip),
+                               ('add_s',add_s)]:
+                if name in inv_conflict_solve_user.keys():
+                    inv_conflict_solve_user[func] = inv_conflict_solve_user[name]
+                    del inv_conflict_solve_user[name]
+            conflict_solve.update(self.__dict_invert(inv_conflict_solve_user))
+        for key in data_dict:
+            if key not in self:
+                self[key] = data_dict[key]
+            else:
+                self[key] = conflict_solve[key](self[key],data_dict[key])
+
diff --git a/lib/python3.12/site-packages/IPython/utils/jsonutil.py b/lib/python3.12/site-packages/IPython/utils/jsonutil.py
new file mode 100644
index 0000000000000000000000000000000000000000..2672e09e16970b490a70f003cb1d596e6d20b941
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/jsonutil.py
@@ -0,0 +1,5 @@
+from warnings import warn
+
+warn("IPython.utils.jsonutil has moved to jupyter_client.jsonutil", stacklevel=2)
+
+from jupyter_client.jsonutil import *
diff --git a/lib/python3.12/site-packages/IPython/utils/log.py b/lib/python3.12/site-packages/IPython/utils/log.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9dea91ce90f6d0454e98961e104e292fb6c05bd
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/log.py
@@ -0,0 +1,5 @@
+from warnings import warn
+
+warn("IPython.utils.log has moved to traitlets.log", stacklevel=2)
+
+from traitlets.log import *
diff --git a/lib/python3.12/site-packages/IPython/utils/module_paths.py b/lib/python3.12/site-packages/IPython/utils/module_paths.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e43457e3ed5591b4cf31b60249875231918af58
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/module_paths.py
@@ -0,0 +1,78 @@
+"""Utility functions for finding modules
+
+Utility functions for finding modules on sys.path.
+
+"""
+from __future__ import annotations
+
+#-----------------------------------------------------------------------------
+# Copyright (c) 2011, the IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib imports
+import importlib
+import importlib.abc
+import importlib.util
+import sys
+
+# Third-party imports
+
+# Our own imports
+
+
+#-----------------------------------------------------------------------------
+# Globals and constants
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Local utilities
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+def find_mod(module_name: str) -> str | None | importlib.abc.Loader:
+    """
+    Find module `module_name` on sys.path, and return the path to module `module_name`.
+
+    * If `module_name` refers to a module directory, then return path to `__init__` file.
+        * If `module_name` is a directory without an __init__file, return None.
+
+    * If module is missing or does not have a `.py` or `.pyw` extension, return None.
+        * Note that we are not interested in running bytecode.
+
+    * Otherwise, return the fill path of the module.
+
+    Parameters
+    ----------
+    module_name : str
+
+    Returns
+    -------
+    module_path : str
+        Path to module `module_name`, its __init__.py, or None,
+        depending on above conditions.
+    """
+    spec = importlib.util.find_spec(module_name)
+    if spec is None:
+        return None
+    module_path = spec.origin
+    if module_path is None:
+        if spec.loader is not None and spec.loader in sys.meta_path:
+            return spec.loader
+        return None
+    else:
+        split_path = module_path.split(".")
+        if split_path[-1] in ["py", "pyw"]:
+            return module_path
+        else:
+            return None
diff --git a/lib/python3.12/site-packages/IPython/utils/openpy.py b/lib/python3.12/site-packages/IPython/utils/openpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..7876a1a4988840291d1ec4c5a758b312a2b2fea5
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/openpy.py
@@ -0,0 +1,104 @@
+"""
+Tools to open .py files as Unicode, using the encoding specified within the file,
+as per PEP 263.
+
+Much of the code is taken from the tokenize module in Python 3.2.
+"""
+
+import io
+from io import TextIOWrapper, BytesIO
+from pathlib import Path
+import re
+from tokenize import open, detect_encoding
+
+cookie_re = re.compile(r"coding[:=]\s*([-\w.]+)", re.UNICODE)
+cookie_comment_re = re.compile(r"^\s*#.*coding[:=]\s*([-\w.]+)", re.UNICODE)
+
+def source_to_unicode(txt, errors='replace', skip_encoding_cookie=True):
+    """Converts a bytes string with python source code to unicode.
+
+    Unicode strings are passed through unchanged. Byte strings are checked
+    for the python source file encoding cookie to determine encoding.
+    txt can be either a bytes buffer or a string containing the source
+    code.
+    """
+    if isinstance(txt, str):
+        return txt
+    if isinstance(txt, bytes):
+        buffer = BytesIO(txt)
+    else:
+        buffer = txt
+    try:
+        encoding, _ = detect_encoding(buffer.readline)
+    except SyntaxError:
+        encoding = "ascii"
+    buffer.seek(0)
+    with TextIOWrapper(buffer, encoding, errors=errors, line_buffering=True) as text:
+        text.mode = 'r'
+        if skip_encoding_cookie:
+            return u"".join(strip_encoding_cookie(text))
+        else:
+            return text.read()
+
+def strip_encoding_cookie(filelike):
+    """Generator to pull lines from a text-mode file, skipping the encoding
+    cookie if it is found in the first two lines.
+    """
+    it = iter(filelike)
+    try:
+        first = next(it)
+        if not cookie_comment_re.match(first):
+            yield first
+        second = next(it)
+        if not cookie_comment_re.match(second):
+            yield second
+    except StopIteration:
+        return
+    
+    yield from it
+
+def read_py_file(filename, skip_encoding_cookie=True):
+    """Read a Python file, using the encoding declared inside the file.
+
+    Parameters
+    ----------
+    filename : str
+        The path to the file to read.
+    skip_encoding_cookie : bool
+        If True (the default), and the encoding declaration is found in the first
+        two lines, that line will be excluded from the output.
+
+    Returns
+    -------
+    A unicode string containing the contents of the file.
+    """
+    filepath = Path(filename)
+    with open(filepath) as f:  # the open function defined in this module.
+        if skip_encoding_cookie:
+            return "".join(strip_encoding_cookie(f))
+        else:
+            return f.read()
+
+def read_py_url(url, errors='replace', skip_encoding_cookie=True):
+    """Read a Python file from a URL, using the encoding declared inside the file.
+
+    Parameters
+    ----------
+    url : str
+        The URL from which to fetch the file.
+    errors : str
+        How to handle decoding errors in the file. Options are the same as for
+        bytes.decode(), but here 'replace' is the default.
+    skip_encoding_cookie : bool
+        If True (the default), and the encoding declaration is found in the first
+        two lines, that line will be excluded from the output.
+
+    Returns
+    -------
+    A unicode string containing the contents of the file.
+    """
+    # Deferred import for faster start
+    from urllib.request import urlopen 
+    response = urlopen(url)
+    buffer = io.BytesIO(response.read())
+    return source_to_unicode(buffer, errors, skip_encoding_cookie)
diff --git a/lib/python3.12/site-packages/IPython/utils/path.py b/lib/python3.12/site-packages/IPython/utils/path.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e93d6976f65ff753f11bdf1a411950bdc275a81
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/path.py
@@ -0,0 +1,354 @@
+# encoding: utf-8
+"""
+Utilities for path handling.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import sys
+import errno
+import shutil
+import random
+import glob
+import warnings
+
+from IPython.utils.process import system
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+fs_encoding = sys.getfilesystemencoding()
+
+def _writable_dir(path):
+    """Whether `path` is a directory, to which the user has write access."""
+    return os.path.isdir(path) and os.access(path, os.W_OK)
+
+if sys.platform == 'win32':
+    def _get_long_path_name(path):
+        """Get a long path name (expand ~) on Windows using ctypes.
+
+        Examples
+        --------
+
+        >>> get_long_path_name('c:\\\\docume~1')
+        'c:\\\\Documents and Settings'
+
+        """
+        try:
+            import ctypes
+        except ImportError as e: 
+            raise ImportError('you need to have ctypes installed for this to work') from e
+        _GetLongPathName = ctypes.windll.kernel32.GetLongPathNameW
+        _GetLongPathName.argtypes = [ctypes.c_wchar_p, ctypes.c_wchar_p,
+            ctypes.c_uint ]
+
+        buf = ctypes.create_unicode_buffer(260)
+        rv = _GetLongPathName(path, buf, 260)
+        if rv == 0 or rv > 260:
+            return path
+        else:
+            return buf.value
+else:
+    def _get_long_path_name(path):
+        """Dummy no-op."""
+        return path
+
+
+
+def get_long_path_name(path):
+    """Expand a path into its long form.
+
+    On Windows this expands any ~ in the paths. On other platforms, it is
+    a null operation.
+    """
+    return _get_long_path_name(path)
+
+
+def compress_user(path: str) -> str:
+    """Reverse of :func:`os.path.expanduser`"""
+    home = os.path.expanduser("~")
+    if path.startswith(home):
+        path =  "~" + path[len(home):]
+    return path
+
+def get_py_filename(name):
+    """Return a valid python filename in the current directory.
+
+    If the given name is not a file, it adds '.py' and searches again.
+    Raises IOError with an informative message if the file isn't found.
+    """
+
+    name = os.path.expanduser(name)
+    if os.path.isfile(name):
+        return name
+    if not name.endswith(".py"):
+        py_name = name + ".py"
+        if os.path.isfile(py_name):
+            return py_name
+    raise IOError("File `%r` not found." % name)
+
+
+def filefind(filename: str, path_dirs=None) -> str:
+    """Find a file by looking through a sequence of paths.
+
+    This iterates through a sequence of paths looking for a file and returns
+    the full, absolute path of the first occurrence of the file.  If no set of
+    path dirs is given, the filename is tested as is, after running through
+    :func:`expandvars` and :func:`expanduser`.  Thus a simple call::
+
+        filefind('myfile.txt')
+
+    will find the file in the current working dir, but::
+
+        filefind('~/myfile.txt')
+
+    Will find the file in the users home directory.  This function does not
+    automatically try any paths, such as the cwd or the user's home directory.
+
+    Parameters
+    ----------
+    filename : str
+        The filename to look for.
+    path_dirs : str, None or sequence of str
+        The sequence of paths to look for the file in.  If None, the filename
+        need to be absolute or be in the cwd.  If a string, the string is
+        put into a sequence and the searched.  If a sequence, walk through
+        each element and join with ``filename``, calling :func:`expandvars`
+        and :func:`expanduser` before testing for existence.
+
+    Returns
+    -------
+    path : str
+        returns absolute path to file.
+
+    Raises
+    ------
+    IOError
+    """
+
+    # If paths are quoted, abspath gets confused, strip them...
+    filename = filename.strip('"').strip("'")
+    # If the input is an absolute path, just check it exists
+    if os.path.isabs(filename) and os.path.isfile(filename):
+        return filename
+
+    if path_dirs is None:
+        path_dirs = ("",)
+    elif isinstance(path_dirs, str):
+        path_dirs = (path_dirs,)
+
+    for path in path_dirs:
+        if path == '.': path = os.getcwd()
+        testname = expand_path(os.path.join(path, filename))
+        if os.path.isfile(testname):
+            return os.path.abspath(testname)
+
+    raise IOError("File %r does not exist in any of the search paths: %r" %
+                  (filename, path_dirs) )
+
+
+class HomeDirError(Exception):
+    pass
+
+
+def get_home_dir(require_writable=False) -> str:
+    """Return the 'home' directory, as a unicode string.
+
+    Uses os.path.expanduser('~'), and checks for writability.
+
+    See stdlib docs for how this is determined.
+    For Python <3.8, $HOME is first priority on *ALL* platforms.
+    For Python >=3.8 on Windows, %HOME% is no longer considered.
+
+    Parameters
+    ----------
+    require_writable : bool [default: False]
+        if True:
+            guarantees the return value is a writable directory, otherwise
+            raises HomeDirError
+        if False:
+            The path is resolved, but it is not guaranteed to exist or be writable.
+    """
+
+    homedir = os.path.expanduser('~')
+    # Next line will make things work even when /home/ is a symlink to
+    # /usr/home as it is on FreeBSD, for example
+    homedir = os.path.realpath(homedir)
+
+    if not _writable_dir(homedir) and os.name == 'nt':
+        # expanduser failed, use the registry to get the 'My Documents' folder.
+        try:
+            import winreg as wreg
+            with wreg.OpenKey(
+                wreg.HKEY_CURRENT_USER,
+                r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+            ) as key:
+                homedir = wreg.QueryValueEx(key,'Personal')[0]
+        except:
+            pass
+
+    if (not require_writable) or _writable_dir(homedir):
+        assert isinstance(homedir, str), "Homedir should be unicode not bytes"
+        return homedir
+    else:
+        raise HomeDirError('%s is not a writable dir, '
+                'set $HOME environment variable to override' % homedir)
+
+def get_xdg_dir():
+    """Return the XDG_CONFIG_HOME, if it is defined and exists, else None.
+
+    This is only for non-OS X posix (Linux,Unix,etc.) systems.
+    """
+
+    env = os.environ
+
+    if os.name == "posix":
+        # Linux, Unix, AIX, etc.
+        # use ~/.config if empty OR not set
+        xdg = env.get("XDG_CONFIG_HOME", None) or os.path.join(get_home_dir(), '.config')
+        if xdg and _writable_dir(xdg):
+            assert isinstance(xdg, str)
+            return xdg
+
+    return None
+
+
+def get_xdg_cache_dir():
+    """Return the XDG_CACHE_HOME, if it is defined and exists, else None.
+
+    This is only for non-OS X posix (Linux,Unix,etc.) systems.
+    """
+
+    env = os.environ
+
+    if os.name == "posix":
+        # Linux, Unix, AIX, etc.
+        # use ~/.cache if empty OR not set
+        xdg = env.get("XDG_CACHE_HOME", None) or os.path.join(get_home_dir(), '.cache')
+        if xdg and _writable_dir(xdg):
+            assert isinstance(xdg, str)
+            return xdg
+
+    return None
+
+
+def expand_path(s):
+    """Expand $VARS and ~names in a string, like a shell
+
+    :Examples:
+
+       In [2]: os.environ['FOO']='test'
+
+       In [3]: expand_path('variable FOO is $FOO')
+       Out[3]: 'variable FOO is test'
+    """
+    # This is a pretty subtle hack. When expand user is given a UNC path
+    # on Windows (\\server\share$\%username%), os.path.expandvars, removes
+    # the $ to get (\\server\share\%username%). I think it considered $
+    # alone an empty var. But, we need the $ to remains there (it indicates
+    # a hidden share).
+    if os.name=='nt':
+        s = s.replace('$\\', 'IPYTHON_TEMP')
+    s = os.path.expandvars(os.path.expanduser(s))
+    if os.name=='nt':
+        s = s.replace('IPYTHON_TEMP', '$\\')
+    return s
+
+
+def unescape_glob(string):
+    """Unescape glob pattern in `string`."""
+    def unescape(s):
+        for pattern in '*[]!?':
+            s = s.replace(r'\{0}'.format(pattern), pattern)
+        return s
+    return '\\'.join(map(unescape, string.split('\\\\')))
+
+
+def shellglob(args):
+    """
+    Do glob expansion for each element in `args` and return a flattened list.
+
+    Unmatched glob pattern will remain as-is in the returned list.
+
+    """
+    expanded = []
+    # Do not unescape backslash in Windows as it is interpreted as
+    # path separator:
+    unescape = unescape_glob if sys.platform != 'win32' else lambda x: x
+    for a in args:
+        expanded.extend(glob.glob(a) or [unescape(a)])
+    return expanded
+
+ENOLINK = 1998
+
+def link(src, dst):
+    """Hard links ``src`` to ``dst``, returning 0 or errno.
+
+    Note that the special errno ``ENOLINK`` will be returned if ``os.link`` isn't
+    supported by the operating system.
+    """
+
+    if not hasattr(os, "link"):
+        return ENOLINK
+    link_errno = 0
+    try:
+        os.link(src, dst)
+    except OSError as e:
+        link_errno = e.errno
+    return link_errno
+
+
+def link_or_copy(src, dst):
+    """Attempts to hardlink ``src`` to ``dst``, copying if the link fails.
+
+    Attempts to maintain the semantics of ``shutil.copy``.
+
+    Because ``os.link`` does not overwrite files, a unique temporary file
+    will be used if the target already exists, then that file will be moved
+    into place.
+    """
+
+    if os.path.isdir(dst):
+        dst = os.path.join(dst, os.path.basename(src))
+
+    link_errno = link(src, dst)
+    if link_errno == errno.EEXIST:
+        if os.stat(src).st_ino == os.stat(dst).st_ino:
+            # dst is already a hard link to the correct file, so we don't need
+            # to do anything else. If we try to link and rename the file
+            # anyway, we get duplicate files - see http://bugs.python.org/issue21876
+            return
+
+        new_dst = dst + "-temp-%04X" %(random.randint(1, 16**4), )
+        try:
+            link_or_copy(src, new_dst)
+        except:
+            try:
+                os.remove(new_dst)
+            except OSError:
+                pass
+            raise
+        os.rename(new_dst, dst)
+    elif link_errno != 0:
+        # Either link isn't supported, or the filesystem doesn't support
+        # linking, or 'src' and 'dst' are on different filesystems.
+        shutil.copy(src, dst)
+
+def ensure_dir_exists(path, mode=0o755):
+    """ensure that a directory exists
+
+    If it doesn't exist, try to create it and protect against a race condition
+    if another process is doing the same.
+
+    The default permissions are 755, which differ from os.makedirs default of 777.
+    """
+    if not os.path.exists(path):
+        try:
+            os.makedirs(path, mode=mode)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+    elif not os.path.isdir(path):
+        raise IOError("%r exists but is not a directory" % path)
diff --git a/lib/python3.12/site-packages/IPython/utils/process.py b/lib/python3.12/site-packages/IPython/utils/process.py
new file mode 100644
index 0000000000000000000000000000000000000000..f50cf9ba223a57205a872a1cbb24dc125ad815f0
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/process.py
@@ -0,0 +1,71 @@
+# encoding: utf-8
+"""
+Utilities for working with external processes.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import os
+import shutil
+import sys
+
+if sys.platform == 'win32':
+    from ._process_win32 import system, getoutput, arg_split, check_pid
+elif sys.platform == 'cli':
+    from ._process_cli import system, getoutput, arg_split, check_pid
+elif sys.platform == "emscripten":
+    from ._process_emscripten import system, getoutput, arg_split, check_pid
+else:
+    from ._process_posix import system, getoutput, arg_split, check_pid
+
+from ._process_common import getoutputerror, get_output_error_code, process_handler
+
+
+class FindCmdError(Exception):
+    pass
+
+
+def find_cmd(cmd):
+    """Find absolute path to executable cmd in a cross platform manner.
+
+    This function tries to determine the full path to a command line program
+    using `which` on Unix/Linux/OS X and `win32api` on Windows.  Most of the
+    time it will use the version that is first on the users `PATH`.
+
+    Warning, don't use this to find IPython command line programs as there
+    is a risk you will find the wrong one.  Instead find those using the
+    following code and looking for the application itself::
+
+        import sys
+        argv = [sys.executable, '-m', 'IPython']
+
+    Parameters
+    ----------
+    cmd : str
+        The command line program to look for.
+    """
+    path = shutil.which(cmd)
+    if path is None:
+        raise FindCmdError('command could not be found: %s' % cmd)
+    return path
+
+
+def abbrev_cwd():
+    """ Return abbreviated version of cwd, e.g. d:mydir """
+    cwd = os.getcwd().replace('\\','/')
+    drivepart = ''
+    tail = cwd
+    if sys.platform == 'win32':
+        if len(cwd) < 4:
+            return cwd
+        drivepart,tail = os.path.splitdrive(cwd)
+
+
+    parts = tail.split('/')
+    if len(parts) > 2:
+        tail = '/'.join(parts[-2:])
+
+    return (drivepart + (
+        cwd == '/' and '/' or tail))
diff --git a/lib/python3.12/site-packages/IPython/utils/py3compat.py b/lib/python3.12/site-packages/IPython/utils/py3compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f95321473720677035e9ce14d06ababc361f381
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/py3compat.py
@@ -0,0 +1,59 @@
+# coding: utf-8
+"""Compatibility tricks for Python 3. Mainly to do with unicode.
+
+This file is deprecated and will be removed in a future version.
+"""
+
+import platform
+import builtins as builtin_mod
+
+from .encoding import DEFAULT_ENCODING
+
+
+def decode(s, encoding=None):
+    encoding = encoding or DEFAULT_ENCODING
+    return s.decode(encoding, "replace")
+
+
+def encode(u, encoding=None):
+    encoding = encoding or DEFAULT_ENCODING
+    return u.encode(encoding, "replace")
+
+
+def cast_unicode(s, encoding=None):
+    if isinstance(s, bytes):
+        return decode(s, encoding)
+    return s
+
+
+def safe_unicode(e):
+    """unicode(e) with various fallbacks. Used for exceptions, which may not be
+    safe to call unicode() on.
+    """
+    try:
+        return str(e)
+    except UnicodeError:
+        pass
+
+    try:
+        return repr(e)
+    except UnicodeError:
+        pass
+
+    return "Unrecoverably corrupt evalue"
+
+
+# keep reference to builtin_mod because the kernel overrides that value
+# to forward requests to a frontend.
+def input(prompt=""):
+    return builtin_mod.input(prompt)
+
+
+def execfile(fname, glob, loc=None, compiler=None):
+    loc = loc if (loc is not None) else glob
+    with open(fname, "rb") as f:
+        compiler = compiler or compile
+        exec(compiler(f.read(), fname, "exec"), glob, loc)
+
+
+PYPY = platform.python_implementation() == "PyPy"
diff --git a/lib/python3.12/site-packages/IPython/utils/sentinel.py b/lib/python3.12/site-packages/IPython/utils/sentinel.py
new file mode 100644
index 0000000000000000000000000000000000000000..623c41fb77bdf34631d6386924df30407987f8ca
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/sentinel.py
@@ -0,0 +1,15 @@
+"""Sentinel class for constants with useful reprs"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+class Sentinel:
+    def __init__(self, name: str, module: str, docstring: str | None = None) -> None:
+        self.name = name
+        self.module = module
+        if docstring:
+            self.__doc__ = docstring
+
+    def __repr__(self) -> str:
+        return str(self.module) + "." + self.name
diff --git a/lib/python3.12/site-packages/IPython/utils/strdispatch.py b/lib/python3.12/site-packages/IPython/utils/strdispatch.py
new file mode 100644
index 0000000000000000000000000000000000000000..bbaabe5af6481bfe00bba734a6d3b4faacbb347a
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/strdispatch.py
@@ -0,0 +1,68 @@
+"""String dispatch class to match regexps and dispatch commands.
+"""
+
+# Stdlib imports
+import re
+
+# Our own modules
+from IPython.core.hooks import CommandChainDispatcher
+
+# Code begins
+class StrDispatch:
+    """Dispatch (lookup) a set of strings / regexps for match.
+
+    Example:
+
+    >>> dis = StrDispatch()
+    >>> dis.add_s('hei',34, priority = 4)
+    >>> dis.add_s('hei',123, priority = 2)
+    >>> dis.add_re('h.i', 686)
+    >>> print(list(dis.flat_matches('hei')))
+    [123, 34, 686]
+    """
+
+    def __init__(self):
+        self.strs = {}
+        self.regexs = {}
+
+    def add_s(self, s, obj, priority= 0 ):
+        """ Adds a target 'string' for dispatching """
+
+        chain = self.strs.get(s, CommandChainDispatcher())
+        chain.add(obj,priority)
+        self.strs[s] = chain
+
+    def add_re(self, regex, obj, priority= 0 ):
+        """ Adds a target regexp for dispatching """
+
+        chain = self.regexs.get(regex, CommandChainDispatcher())
+        chain.add(obj,priority)
+        self.regexs[regex] = chain
+
+    def dispatch(self, key):
+        """ Get a seq of Commandchain objects that match key """
+        if key in self.strs:
+            yield self.strs[key]
+
+        for r, obj in self.regexs.items():
+            if re.match(r, key):
+                yield obj
+            else:
+                # print("nomatch",key)  # dbg
+                pass
+
+    def __repr__(self):
+        return "<Strdispatch %s, %s>" % (self.strs, self.regexs)
+
+    def s_matches(self, key):
+        if key not in self.strs:
+             return
+        for el in self.strs[key]:
+            yield el[1]
+
+    def flat_matches(self, key):
+        """ Yield all 'value' targets, without priority """
+        for val in self.dispatch(key):
+            for el in val:
+                yield el[1] # only value, no priority
+        return
diff --git a/lib/python3.12/site-packages/IPython/utils/sysinfo.py b/lib/python3.12/site-packages/IPython/utils/sysinfo.py
new file mode 100644
index 0000000000000000000000000000000000000000..8240ea54e3a77a8f889a99a20c1160f4c522ca9c
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/sysinfo.py
@@ -0,0 +1,120 @@
+# 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() -> 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())
diff --git a/lib/python3.12/site-packages/IPython/utils/syspathcontext.py b/lib/python3.12/site-packages/IPython/utils/syspathcontext.py
new file mode 100644
index 0000000000000000000000000000000000000000..dcc7a634ac53c67b93b38a9d3dd0c9c90869b2b1
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/syspathcontext.py
@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import sys
+from types import TracebackType
+from typing import Literal, Self
+
+import warnings
+
+
+class prepended_to_syspath:
+    """A context for prepending a directory to sys.path for a second."""
+
+    dir: str
+    added: bool
+
+    def __init__(self, dir: str) -> None:
+        self.dir = dir
+        self.added = False
+
+    def __enter__(self) -> Self:
+        if self.dir not in sys.path:
+            sys.path.insert(0, self.dir)
+            self.added = True
+        else:
+            self.added = False
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> Literal[False]:
+        if self.added:
+            try:
+                sys.path.remove(self.dir)
+            except ValueError:
+                pass
+        # Returning False causes any exceptions to be re-raised.
+        return False
diff --git a/lib/python3.12/site-packages/IPython/utils/tempdir.py b/lib/python3.12/site-packages/IPython/utils/tempdir.py
new file mode 100644
index 0000000000000000000000000000000000000000..0efdeb1067a1c57193148329c99c19f859238135
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/tempdir.py
@@ -0,0 +1,59 @@
+"""This module contains classes - NamedFileInTemporaryDirectory, TemporaryWorkingDirectory.
+
+These classes add extra features such as creating a named file in temporary directory and
+creating a context manager for the working directory which is also temporary.
+"""
+
+import os as _os
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+
+class NamedFileInTemporaryDirectory:
+    def __init__(self, filename, mode, bufsize=-1, add_to_syspath=False, **kwds):
+        """
+        Open a file named `filename` in a temporary directory.
+
+        This context manager is preferred over `NamedTemporaryFile` in
+        stdlib `tempfile` when one needs to reopen the file.
+
+        Arguments `mode` and `bufsize` are passed to `open`.
+        Rest of the arguments are passed to `TemporaryDirectory`.
+
+        """
+        self._tmpdir = TemporaryDirectory(**kwds)
+        path = Path(self._tmpdir.name) / filename
+        encoding = None if "b" in mode else "utf-8"
+        self.file = open(path, mode, bufsize, encoding=encoding)
+
+    def cleanup(self):
+        self.file.close()
+        self._tmpdir.cleanup()
+
+    __del__ = cleanup
+
+    def __enter__(self):
+        return self.file
+
+    def __exit__(self, type, value, traceback):
+        self.cleanup()
+
+
+class TemporaryWorkingDirectory(TemporaryDirectory):
+    """
+    Creates a temporary directory and sets the cwd to that directory.
+    Automatically reverts to previous cwd upon cleanup.
+    Usage example:
+
+        with TemporaryWorkingDirectory() as tmpdir:
+            ...
+    """
+
+    def __enter__(self):
+        self.old_wd = Path.cwd()
+        _os.chdir(self.name)
+        return super(TemporaryWorkingDirectory, self).__enter__()
+
+    def __exit__(self, exc, value, tb):
+        _os.chdir(self.old_wd)
+        return super(TemporaryWorkingDirectory, self).__exit__(exc, value, tb)
diff --git a/lib/python3.12/site-packages/IPython/utils/terminal.py b/lib/python3.12/site-packages/IPython/utils/terminal.py
new file mode 100644
index 0000000000000000000000000000000000000000..14ab7a7ce9c81d1e61ed56ab233346d672b8d5c2
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/terminal.py
@@ -0,0 +1,125 @@
+# encoding: utf-8
+"""
+Utilities for working with terminals.
+
+Authors:
+
+* Brian E. Granger
+* Fernando Perez
+* Alexander Belchenko (e-mail: bialix AT ukr.net)
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import sys
+import warnings
+from shutil import get_terminal_size as _get_terminal_size
+
+# This variable is part of the expected API of the module:
+ignore_termtitle = True
+
+
+
+if os.name == 'posix':
+    def _term_clear():
+        os.system('clear')
+elif sys.platform == 'win32':
+    def _term_clear():
+        os.system('cls')
+else:
+    def _term_clear():
+        pass
+
+
+
+def toggle_set_term_title(val):
+    """Control whether set_term_title is active or not.
+
+    set_term_title() allows writing to the console titlebar.  In embedded
+    widgets this can cause problems, so this call can be used to toggle it on
+    or off as needed.
+
+    The default state of the module is for the function to be disabled.
+
+    Parameters
+    ----------
+    val : bool
+        If True, set_term_title() actually writes to the terminal (using the
+        appropriate platform-specific module).  If False, it is a no-op.
+    """
+    global ignore_termtitle
+    ignore_termtitle = not(val)
+
+
+def _set_term_title(*args,**kw):
+    """Dummy no-op."""
+    pass
+
+
+def _restore_term_title():
+    pass
+
+
+_xterm_term_title_saved = False
+
+
+def _set_term_title_xterm(title):
+    """ Change virtual terminal title in xterm-workalikes """
+    global _xterm_term_title_saved
+    # Only save the title the first time we set, otherwise restore will only
+    # go back one title (probably undoing a %cd title change).
+    if not _xterm_term_title_saved:
+        # save the current title to the xterm "stack"
+        sys.stdout.write("\033[22;0t")
+        _xterm_term_title_saved = True
+    sys.stdout.write('\033]0;%s\007' % title)
+
+
+def _restore_term_title_xterm():
+    # Make sure the restore has at least one accompanying set.
+    global _xterm_term_title_saved
+    if not _xterm_term_title_saved:
+        warnings.warn(
+            "Expecting xterm_term_title_saved to be True, but is not; will not restore terminal title.",
+            stacklevel=1,
+        )
+        return
+
+    sys.stdout.write('\033[23;0t') 
+    _xterm_term_title_saved = False
+
+
+if os.name == 'posix':
+    TERM = os.environ.get('TERM','')
+    if TERM.startswith('xterm'):
+        _set_term_title = _set_term_title_xterm
+        _restore_term_title = _restore_term_title_xterm
+elif sys.platform == 'win32':
+    import ctypes
+
+    SetConsoleTitleW = ctypes.windll.kernel32.SetConsoleTitleW
+    SetConsoleTitleW.argtypes = [ctypes.c_wchar_p]
+
+    def _set_term_title(title):
+        """Set terminal title using ctypes to access the Win32 APIs."""
+        SetConsoleTitleW(title)
+
+
+def set_term_title(title):
+    """Set terminal title using the necessary platform-dependent calls."""
+    if ignore_termtitle:
+        return
+    _set_term_title(title)
+
+
+def restore_term_title():
+    """Restore, if possible, terminal title to the original state"""
+    if ignore_termtitle:
+        return
+    _restore_term_title()
+
+
+def get_terminal_size(defaultx: int = 80, defaulty: int = 25) -> tuple[int, int]:
+    return _get_terminal_size((defaultx, defaulty))
diff --git a/lib/python3.12/site-packages/IPython/utils/text.py b/lib/python3.12/site-packages/IPython/utils/text.py
new file mode 100644
index 0000000000000000000000000000000000000000..66feeb4a380ce334e4e2156cf837554ba5190c21
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/text.py
@@ -0,0 +1,651 @@
+"""
+Utilities for working with strings and text.
+
+Inheritance diagram:
+
+.. inheritance-diagram:: IPython.utils.text
+   :parts: 3
+"""
+
+import os
+import re
+import string
+import sys
+import textwrap
+import warnings
+from string import Formatter
+from pathlib import Path
+
+from typing import (
+    List,
+    Dict,
+    Tuple,
+    Optional,
+    cast,
+    Any,
+    Union,
+    TypeVar,
+)
+from collections.abc import Sequence, Mapping, Callable, Iterator
+
+if sys.version_info < (3, 12):
+    from typing import Self
+else:
+    from typing import Self
+
+
+class LSString(str):
+    """String derivative with a special access attributes.
+
+    These are normal strings, but with the special attributes:
+
+        .l (or .list) : value as list (split on newlines).
+        .n (or .nlstr): original value (the string itself).
+        .s (or .spstr): value as whitespace-separated string.
+        .p (or .paths): list of path objects (requires path.py package)
+
+    Any values which require transformations are computed only once and
+    cached.
+
+    Such strings are very useful to efficiently interact with the shell, which
+    typically only understands whitespace-separated options for commands."""
+
+    __list: List[str]
+    __spstr: str
+    __paths: List[Path]
+
+    def get_list(self) -> List[str]:
+        try:
+            return self.__list
+        except AttributeError:
+            self.__list = self.split('\n')
+            return self.__list
+
+    l = list = property(get_list)
+
+    def get_spstr(self) -> str:
+        try:
+            return self.__spstr
+        except AttributeError:
+            self.__spstr = self.replace('\n',' ')
+            return self.__spstr
+
+    s = spstr = property(get_spstr)
+
+    def get_nlstr(self) -> Self:
+        return self
+
+    n = nlstr = property(get_nlstr)
+
+    def get_paths(self) -> List[Path]:
+        try:
+            return self.__paths
+        except AttributeError:
+            self.__paths = [Path(p) for p in self.split('\n') if os.path.exists(p)]
+            return self.__paths
+
+    p = paths = property(get_paths)
+
+# FIXME: We need to reimplement type specific displayhook and then add this
+# back as a custom printer. This should also be moved outside utils into the
+# core.
+
+# def print_lsstring(arg):
+#     """ Prettier (non-repr-like) and more informative printer for LSString """
+#     print("LSString (.p, .n, .l, .s available). Value:")
+#     print(arg)
+#
+#
+# print_lsstring = result_display.register(LSString)(print_lsstring)
+
+
+class SList(list[Any]):
+    """List derivative with a special access attributes.
+
+    These are normal lists, but with the special attributes:
+
+    * .l (or .list) : value as list (the list itself).
+    * .n (or .nlstr): value as a string, joined on newlines.
+    * .s (or .spstr): value as a string, joined on spaces.
+    * .p (or .paths): list of path objects (requires path.py package)
+
+    Any values which require transformations are computed only once and
+    cached."""
+
+    __spstr: str
+    __nlstr: str
+    __paths: List[Path]
+
+    def get_list(self) -> Self:
+        return self
+
+    l = list = property(get_list)
+
+    def get_spstr(self) -> str:
+        try:
+            return self.__spstr
+        except AttributeError:
+            self.__spstr = ' '.join(self)
+            return self.__spstr
+
+    s = spstr = property(get_spstr)
+
+    def get_nlstr(self) -> str:
+        try:
+            return self.__nlstr
+        except AttributeError:
+            self.__nlstr = '\n'.join(self)
+            return self.__nlstr
+
+    n = nlstr = property(get_nlstr)
+
+    def get_paths(self) -> List[Path]:
+        try:
+            return self.__paths
+        except AttributeError:
+            self.__paths = [Path(p) for p in self if os.path.exists(p)]
+            return self.__paths
+
+    p = paths = property(get_paths)
+
+    def grep(
+        self,
+        pattern: Union[str, Callable[[Any], re.Match[str] | None]],
+        prune: bool = False,
+        field: Optional[int] = None,
+    ) -> Self:
+        """Return all strings matching 'pattern' (a regex or callable)
+
+        This is case-insensitive. If prune is true, return all items
+        NOT matching the pattern.
+
+        If field is specified, the match must occur in the specified
+        whitespace-separated field.
+
+        Examples::
+
+            a.grep( lambda x: x.startswith('C') )
+            a.grep('Cha.*log', prune=1)
+            a.grep('chm', field=-1)
+        """
+
+        def match_target(s: str) -> str:
+            if field is None:
+                return s
+            parts = s.split()
+            try:
+                tgt = parts[field]
+                return tgt
+            except IndexError:
+                return ""
+
+        if isinstance(pattern, str):
+            pred = lambda x : re.search(pattern, x, re.IGNORECASE)
+        else:
+            pred = pattern
+        if not prune:
+            return type(self)([el for el in self if pred(match_target(el))])  # type: ignore [no-untyped-call]
+        else:
+            return type(self)([el for el in self if not pred(match_target(el))])  # type: ignore [no-untyped-call]
+
+    def fields(self, *fields: List[str]) -> List[List[str]]:
+        """Collect whitespace-separated fields from string list
+
+        Allows quick awk-like usage of string lists.
+
+        Example data (in var a, created by 'a = !ls -l')::
+
+            -rwxrwxrwx  1 ville None      18 Dec 14  2006 ChangeLog
+            drwxrwxrwx+ 6 ville None       0 Oct 24 18:05 IPython
+
+        * ``a.fields(0)`` is ``['-rwxrwxrwx', 'drwxrwxrwx+']``
+        * ``a.fields(1,0)`` is ``['1 -rwxrwxrwx', '6 drwxrwxrwx+']``
+          (note the joining by space).
+        * ``a.fields(-1)`` is ``['ChangeLog', 'IPython']``
+
+        IndexErrors are ignored.
+
+        Without args, fields() just split()'s the strings.
+        """
+        if len(fields) == 0:
+            return [el.split() for el in self]
+
+        res = SList()
+        for el in [f.split() for f in self]:
+            lineparts = []
+
+            for fd in fields:
+                try:
+                    lineparts.append(el[fd])
+                except IndexError:
+                    pass
+            if lineparts:
+                res.append(" ".join(lineparts))
+
+        return res
+
+    def sort(  # type:ignore[override]
+        self,
+        field: Optional[List[str]] = None,
+        nums: bool = False,
+    ) -> Self:
+        """sort by specified fields (see fields())
+
+        Example::
+
+            a.sort(1, nums = True)
+
+        Sorts a by second field, in numerical order (so that 21 > 3)
+
+        """
+
+        #decorate, sort, undecorate
+        if field is not None:
+            dsu = [[SList([line]).fields(field),  line] for line in self]
+        else:
+            dsu = [[line,  line] for line in self]
+        if nums:
+            for i in range(len(dsu)):
+                numstr = "".join([ch for ch in dsu[i][0] if ch.isdigit()])
+                try:
+                    n = int(numstr)
+                except ValueError:
+                    n = 0
+                dsu[i][0] = n
+
+
+        dsu.sort()
+        return type(self)([t[1] for t in dsu])
+
+
+def indent(instr: str, nspaces: int = 4, ntabs: int = 0, flatten: bool = False) -> str:
+    """Indent a string a given number of spaces or tabstops.
+
+    indent(str, nspaces=4, ntabs=0) -> indent str by ntabs+nspaces.
+
+    Parameters
+    ----------
+    instr : basestring
+        The string to be indented.
+    nspaces : int (default: 4)
+        The number of spaces to be indented.
+    ntabs : int (default: 0)
+        The number of tabs to be indented.
+    flatten : bool (default: False)
+        Whether to scrub existing indentation.  If True, all lines will be
+        aligned to the same indentation.  If False, existing indentation will
+        be strictly increased.
+
+    Returns
+    -------
+    str : string indented by ntabs and nspaces.
+
+    """
+    ind = "\t" * ntabs + " " * nspaces
+    if flatten:
+        pat = re.compile(r'^\s*', re.MULTILINE)
+    else:
+        pat = re.compile(r'^', re.MULTILINE)
+    outstr = re.sub(pat, ind, instr)
+    if outstr.endswith(os.linesep+ind):
+        return outstr[:-len(ind)]
+    else:
+        return outstr
+
+
+def list_strings(arg: Union[str, List[str]]) -> List[str]:
+    """Always return a list of strings, given a string or list of strings
+    as input.
+
+    Examples
+    --------
+    ::
+
+        In [7]: list_strings('A single string')
+        Out[7]: ['A single string']
+
+        In [8]: list_strings(['A single string in a list'])
+        Out[8]: ['A single string in a list']
+
+        In [9]: list_strings(['A','list','of','strings'])
+        Out[9]: ['A', 'list', 'of', 'strings']
+    """
+
+    if isinstance(arg, str):
+        return [arg]
+    else:
+        return arg
+
+
+def marquee(txt: str = "", width: int = 78, mark: str = "*") -> str:
+    """Return the input string centered in a 'marquee'.
+
+    Examples
+    --------
+    ::
+
+        In [16]: marquee('A test',40)
+        Out[16]: '**************** A test ****************'
+
+        In [17]: marquee('A test',40,'-')
+        Out[17]: '---------------- A test ----------------'
+
+        In [18]: marquee('A test',40,' ')
+        Out[18]: '                 A test                 '
+
+    """
+    if not txt:
+        return (mark*width)[:width]
+    nmark = (width-len(txt)-2)//len(mark)//2
+    if nmark < 0: nmark =0
+    marks = mark*nmark
+    return '%s %s %s' % (marks,txt,marks)
+
+
+def format_screen(strng: str) -> str:
+    """Format a string for screen printing.
+
+    This removes some latex-type format codes."""
+    # Paragraph continue
+    par_re = re.compile(r'\\$',re.MULTILINE)
+    strng = par_re.sub('',strng)
+    return strng
+
+
+def dedent(text: str) -> str:
+    """Equivalent of textwrap.dedent that ignores unindented first line.
+
+    This means it will still dedent strings like:
+    '''foo
+    is a bar
+    '''
+
+    For use in wrap_paragraphs.
+    """
+
+    if text.startswith('\n'):
+        # text starts with blank line, don't ignore the first line
+        return textwrap.dedent(text)
+
+    # split first line
+    splits = text.split('\n',1)
+    if len(splits) == 1:
+        # only one line
+        return textwrap.dedent(text)
+
+    first, rest = splits
+    # dedent everything but the first line
+    rest = textwrap.dedent(rest)
+    return '\n'.join([first, rest])
+
+
+def strip_email_quotes(text: str) -> str:
+    """Strip leading email quotation characters ('>').
+
+    Removes any combination of leading '>' interspersed with whitespace that
+    appears *identically* in all lines of the input text.
+
+    Parameters
+    ----------
+    text : str
+
+    Examples
+    --------
+
+    Simple uses::
+
+        In [2]: strip_email_quotes('> > text')
+        Out[2]: 'text'
+
+        In [3]: strip_email_quotes('> > text\\n> > more')
+        Out[3]: 'text\\nmore'
+
+    Note how only the common prefix that appears in all lines is stripped::
+
+        In [4]: strip_email_quotes('> > text\\n> > more\\n> more...')
+        Out[4]: '> text\\n> more\\nmore...'
+
+    So if any line has no quote marks ('>'), then none are stripped from any
+    of them ::
+
+        In [5]: strip_email_quotes('> > text\\n> > more\\nlast different')
+        Out[5]: '> > text\\n> > more\\nlast different'
+    """
+    lines = text.splitlines()
+    strip_len = 0
+
+    for characters in zip(*lines):
+        # Check if all characters in this position are the same
+        if len(set(characters)) > 1:
+            break
+        prefix_char = characters[0]
+
+        if prefix_char in string.whitespace or prefix_char == ">":
+            strip_len += 1
+        else:
+            break
+
+    text = "\n".join([ln[strip_len:] for ln in lines])
+    return text
+
+
+class EvalFormatter(Formatter):
+    """A String Formatter that allows evaluation of simple expressions.
+
+    Note that this version interprets a `:`  as specifying a format string (as per
+    standard string formatting), so if slicing is required, you must explicitly
+    create a slice.
+
+    Note that on Python 3.14+ this version interprets `[]` as indexing operator
+    so you need to use generators instead of list comprehensions, for example:
+    `list(i for i in range(10))`.
+
+    This is to be used in templating cases, such as the parallel batch
+    script templates, where simple arithmetic on arguments is useful.
+
+    Examples
+    --------
+    ::
+
+        In [1]: f = EvalFormatter()
+        In [2]: f.format('{n//4}', n=8)
+        Out[2]: '2'
+
+        In [3]: f.format("{greeting[slice(2,4)]}", greeting="Hello")
+        Out[3]: 'll'
+    """
+
+    def get_field(self, name: str, args: Any, kwargs: Any) -> Tuple[Any, str]:
+        v = eval(name, kwargs, kwargs)
+        return v, name
+
+#XXX: As of Python 3.4, the format string parsing no longer splits on a colon
+# inside [], so EvalFormatter can handle slicing. Once we only support 3.4 and
+# above, it should be possible to remove FullEvalFormatter.
+
+class FullEvalFormatter(Formatter):
+    """A String Formatter that allows evaluation of simple expressions.
+    
+    Any time a format key is not found in the kwargs,
+    it will be tried as an expression in the kwargs namespace.
+    
+    Note that this version allows slicing using [1:2], so you cannot specify
+    a format string. Use :class:`EvalFormatter` to permit format strings.
+    
+    Examples
+    --------
+    ::
+
+        In [1]: f = FullEvalFormatter()
+        In [2]: f.format('{n//4}', n=8)
+        Out[2]: '2'
+
+        In [3]: f.format('{list(range(5))[2:4]}')
+        Out[3]: '[2, 3]'
+
+        In [4]: f.format('{3*2}')
+        Out[4]: '6'
+    """
+    # copied from Formatter._vformat with minor changes to allow eval
+    # and replace the format_spec code with slicing
+    def vformat(
+        self, format_string: str, args: Sequence[Any], kwargs: Mapping[str, Any]
+    ) -> str:
+        result = []
+        conversion: Optional[str]
+        for literal_text, field_name, format_spec, conversion in self.parse(
+            format_string
+        ):
+            # output the literal text
+            if literal_text:
+                result.append(literal_text)
+
+            # if there's a field, output it
+            if field_name is not None:
+                # this is some markup, find the object and do
+                # the formatting
+
+                if format_spec:
+                    # override format spec, to allow slicing:
+                    field_name = ':'.join([field_name, format_spec])
+
+                # eval the contents of the field for the object
+                # to be formatted
+                obj = eval(field_name, dict(kwargs))
+
+                # do any conversion on the resulting object
+                # type issue in typeshed, fined in https://github.com/python/typeshed/pull/11377
+                obj = self.convert_field(obj, conversion)
+
+                # format the object and append to the result
+                result.append(self.format_field(obj, ''))
+
+        return ''.join(result)
+
+
+class DollarFormatter(FullEvalFormatter):
+    """Formatter allowing Itpl style $foo replacement, for names and attribute
+    access only. Standard {foo} replacement also works, and allows full
+    evaluation of its arguments.
+
+    Examples
+    --------
+    ::
+
+        In [1]: f = DollarFormatter()
+        In [2]: f.format('{n//4}', n=8)
+        Out[2]: '2'
+
+        In [3]: f.format('23 * 76 is $result', result=23*76)
+        Out[3]: '23 * 76 is 1748'
+
+        In [4]: f.format('$a or {b}', a=1, b=2)
+        Out[4]: '1 or 2'
+    """
+
+    _dollar_pattern_ignore_single_quote = re.compile(
+        r"(.*?)\$(\$?[\w\.]+)(?=([^']*'[^']*')*[^']*$)"
+    )
+
+    def parse(self, fmt_string: str) -> Iterator[Tuple[Any, Any, Any, Any]]:
+        for literal_txt, field_name, format_spec, conversion in Formatter.parse(
+            self, fmt_string
+        ):
+            # Find $foo patterns in the literal text.
+            continue_from = 0
+            txt = ""
+            for m in self._dollar_pattern_ignore_single_quote.finditer(literal_txt):
+                new_txt, new_field = m.group(1,2)
+                # $$foo --> $foo
+                if new_field.startswith("$"):
+                    txt += new_txt + new_field
+                else:
+                    yield (txt + new_txt, new_field, "", None)
+                    txt = ""
+                continue_from = m.end()
+            
+            # Re-yield the {foo} style pattern
+            yield (txt + literal_txt[continue_from:], field_name, format_spec, conversion)
+
+    def __repr__(self) -> str:
+        return "<DollarFormatter>"
+
+#-----------------------------------------------------------------------------
+# Utils to columnize a list of string
+#-----------------------------------------------------------------------------
+
+
+def _col_chunks(
+    l: List[int], max_rows: int, row_first: bool = False
+) -> Iterator[List[int]]:
+    """Yield successive max_rows-sized column chunks from l."""
+    if row_first:
+        ncols = (len(l) // max_rows) + (len(l) % max_rows > 0)
+        for i in range(ncols):
+            yield [l[j] for j in range(i, len(l), ncols)]
+    else:
+        for i in range(0, len(l), max_rows):
+            yield l[i:(i + max_rows)]
+
+
+def _find_optimal(
+    rlist: List[int], row_first: bool, separator_size: int, displaywidth: int
+) -> Dict[str, Any]:
+    """Calculate optimal info to columnize a list of string"""
+    for max_rows in range(1, len(rlist) + 1):
+        col_widths = list(map(max, _col_chunks(rlist, max_rows, row_first)))
+        sumlength = sum(col_widths)
+        ncols = len(col_widths)
+        if sumlength + separator_size * (ncols - 1) <= displaywidth:
+            break
+    return {'num_columns': ncols,
+            'optimal_separator_width': (displaywidth - sumlength) // (ncols - 1) if (ncols - 1) else 0,
+            'max_rows': max_rows,
+            'column_widths': col_widths
+            }
+
+
+T = TypeVar("T")
+
+
+def _get_or_default(mylist: List[T], i: int, default: T) -> T:
+    """return list item number, or default if don't exist"""
+    if i >= len(mylist):
+        return default
+    else :
+        return mylist[i]
+
+
+def get_text_list(
+    list_: List[str], last_sep: str = " and ", sep: str = ", ", wrap_item_with: str = ""
+) -> str:
+    """
+    Return a string with a natural enumeration of items
+
+    >>> get_text_list(['a', 'b', 'c', 'd'])
+    'a, b, c and d'
+    >>> get_text_list(['a', 'b', 'c'], ' or ')
+    'a, b or c'
+    >>> get_text_list(['a', 'b', 'c'], ', ')
+    'a, b, c'
+    >>> get_text_list(['a', 'b'], ' or ')
+    'a or b'
+    >>> get_text_list(['a'])
+    'a'
+    >>> get_text_list([])
+    ''
+    >>> get_text_list(['a', 'b'], wrap_item_with="`")
+    '`a` and `b`'
+    >>> get_text_list(['a', 'b', 'c', 'd'], " = ", sep=" + ")
+    'a + b + c = d'
+    """
+    if len(list_) == 0:
+        return ''
+    if wrap_item_with:
+        list_ = ['%s%s%s' % (wrap_item_with, item, wrap_item_with) for
+                 item in list_]
+    if len(list_) == 1:
+        return list_[0]
+    return '%s%s%s' % (
+        sep.join(i for i in list_[:-1]),
+        last_sep, list_[-1])
diff --git a/lib/python3.12/site-packages/IPython/utils/timing.py b/lib/python3.12/site-packages/IPython/utils/timing.py
new file mode 100644
index 0000000000000000000000000000000000000000..d87e5fa8ef5f0584f1563e0afd6581f945dea4b7
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/timing.py
@@ -0,0 +1,123 @@
+# encoding: utf-8
+"""
+Utilities for timing code execution.
+"""
+
+#-----------------------------------------------------------------------------
+#  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 time
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+# If possible (Unix), use the resource module instead of time.clock()
+try:
+    import resource
+except ModuleNotFoundError:
+    resource = None  # type: ignore [assignment]
+
+# Some implementations (like jyputerlite) don't have getrusage
+if resource is not None and hasattr(resource, "getrusage"):
+    def clocku():
+        """clocku() -> floating point number
+
+        Return the *USER* CPU time in seconds since the start of the process.
+        This is done via a call to resource.getrusage, so it avoids the
+        wraparound problems in time.clock()."""
+
+        return resource.getrusage(resource.RUSAGE_SELF)[0]
+
+    def clocks():
+        """clocks() -> floating point number
+
+        Return the *SYSTEM* CPU time in seconds since the start of the process.
+        This is done via a call to resource.getrusage, so it avoids the
+        wraparound problems in time.clock()."""
+
+        return resource.getrusage(resource.RUSAGE_SELF)[1]
+
+    def clock():
+        """clock() -> floating point number
+
+        Return the *TOTAL USER+SYSTEM* CPU time in seconds since the start of
+        the process.  This is done via a call to resource.getrusage, so it
+        avoids the wraparound problems in time.clock()."""
+
+        u,s = resource.getrusage(resource.RUSAGE_SELF)[:2]
+        return u+s
+
+    def clock2():
+        """clock2() -> (t_user,t_system)
+
+        Similar to clock(), but return a tuple of user/system times."""
+        return resource.getrusage(resource.RUSAGE_SELF)[:2]
+
+else:
+    # There is no distinction of user/system time under windows, so we just use
+    # time.process_time() for everything...
+    clocku = clocks = clock = time.process_time
+
+    def clock2():
+        """Under windows, system CPU time can't be measured.
+
+        This just returns process_time() and zero."""
+        return time.process_time(), 0.0
+
+    
+def timings_out(reps,func,*args,**kw):
+    """timings_out(reps,func,*args,**kw) -> (t_total,t_per_call,output)
+
+    Execute a function reps times, return a tuple with the elapsed total
+    CPU time in seconds, the time per call and the function's output.
+
+    Under Unix, the return value is the sum of user+system time consumed by
+    the process, computed via the resource module.  This prevents problems
+    related to the wraparound effect which the time.clock() function has.
+
+    Under Windows the return value is in wall clock seconds. See the
+    documentation for the time module for more details."""
+
+    reps = int(reps)
+    assert reps >=1, 'reps must be >= 1'
+    if reps==1:
+        start = clock()
+        out = func(*args,**kw)
+        tot_time = clock()-start
+    else:
+        rng = range(reps-1) # the last time is executed separately to store output
+        start = clock()
+        for dummy in rng: func(*args,**kw)
+        out = func(*args,**kw)  # one last time
+        tot_time = clock()-start
+    av_time = tot_time / reps
+    return tot_time,av_time,out
+
+
+def timings(reps,func,*args,**kw):
+    """timings(reps,func,*args,**kw) -> (t_total,t_per_call)
+
+    Execute a function reps times, return a tuple with the elapsed total CPU
+    time in seconds and the time per call. These are just the first two values
+    in timings_out()."""
+
+    return timings_out(reps,func,*args,**kw)[0:2]
+
+
+def timing(func,*args,**kw):
+    """timing(func,*args,**kw) -> t_total
+
+    Execute a function once, return the elapsed total CPU time in
+    seconds. This is just the first value in timings_out()."""
+
+    return timings_out(1,func,*args,**kw)[0]
+
diff --git a/lib/python3.12/site-packages/IPython/utils/tokenutil.py b/lib/python3.12/site-packages/IPython/utils/tokenutil.py
new file mode 100644
index 0000000000000000000000000000000000000000..0024b807fda53f669305b9e9e2e76f3f9958aa29
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/tokenutil.py
@@ -0,0 +1,200 @@
+"""Token-related utilities"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+from __future__ import annotations
+
+import itertools
+import tokenize
+from io import StringIO
+from keyword import iskeyword
+from tokenize import TokenInfo
+from typing import NamedTuple
+from collections.abc import Generator
+
+
+class Token(NamedTuple):
+    token: int
+    text: str
+    start: int
+    end: int
+    line: str
+
+
+def generate_tokens(readline) -> Generator[TokenInfo, None, None]:
+    """wrap generate_tkens to catch EOF errors"""
+    try:
+        yield from tokenize.generate_tokens(readline)
+    except tokenize.TokenError:
+        # catch EOF error
+        return
+
+
+def generate_tokens_catch_errors(
+    readline, extra_errors_to_catch: list[str] | None = None
+):
+    default_errors_to_catch = [
+        "unterminated string literal",
+        "invalid non-printable character",
+        "after line continuation character",
+    ]
+    assert extra_errors_to_catch is None or isinstance(extra_errors_to_catch, list)
+    errors_to_catch = default_errors_to_catch + (extra_errors_to_catch or [])
+
+    tokens: list[TokenInfo] = []
+    try:
+        for token in tokenize.generate_tokens(readline):
+            tokens.append(token)
+            yield token
+    except tokenize.TokenError as exc:
+        if any(error in exc.args[0] for error in errors_to_catch):
+            if tokens:
+                start = tokens[-1].start[0], tokens[-1].end[0]
+                end = start
+                line = tokens[-1].line
+            else:
+                start = end = (1, 0)
+                line = ""
+            yield TokenInfo(tokenize.ERRORTOKEN, "", start, end, line)
+        else:
+            # Catch EOF
+            raise
+
+
+def line_at_cursor(cell: str, cursor_pos: int = 0) -> tuple[str, int]:
+    """Return the line in a cell at a given cursor position
+
+    Used for calling line-based APIs that don't support multi-line input, yet.
+
+    Parameters
+    ----------
+    cell : str
+        multiline block of text
+    cursor_pos : integer
+        the cursor position
+
+    Returns
+    -------
+    (line, offset): (string, integer)
+        The line with the current cursor, and the character offset of the start of the line.
+    """
+    offset = 0
+    lines = cell.splitlines(True)
+    for line in lines:
+        next_offset = offset + len(line)
+        if not line.endswith("\n"):
+            # If the last line doesn't have a trailing newline, treat it as if
+            # it does so that the cursor at the end of the line still counts
+            # as being on that line.
+            next_offset += 1
+        if next_offset > cursor_pos:
+            break
+        offset = next_offset
+    else:
+        line = ""
+    return line, offset
+
+
+def token_at_cursor(cell: str, cursor_pos: int = 0) -> str:
+    """Get the token at a given cursor
+
+    Used for introspection.
+
+    Function calls are prioritized, so the token for the callable will be returned
+    if the cursor is anywhere inside the call.
+
+    Parameters
+    ----------
+    cell : str
+        A block of Python code
+    cursor_pos : int
+        The location of the cursor in the block where the token should be found
+    """
+    names: list[str] = []
+    call_names: list[str] = []
+    closing_call_name: str | None = None
+    most_recent_outer_name: str | None = None
+
+    offsets = {1: 0}  # lines start at 1
+    intersects_with_cursor = False
+    cur_token_is_name = False
+    tokens: list[Token | None] = [
+        Token(*tup) for tup in generate_tokens(StringIO(cell).readline)
+    ]
+    if not tokens:
+        return ""
+    for prev_tok, (tok, next_tok) in zip(
+        [None] + tokens, itertools.pairwise(tokens + [None])
+    ):
+        # token, text, start, end, line = tup
+        start_line, start_col = tok.start
+        end_line, end_col = tok.end
+        if end_line + 1 not in offsets:
+            # keep track of offsets for each line
+            lines = tok.line.splitlines(True)
+            for lineno, line in enumerate(lines, start_line + 1):
+                if lineno not in offsets:
+                    offsets[lineno] = offsets[lineno - 1] + len(line)
+
+        closing_call_name = None
+
+        offset = offsets[start_line]
+        if offset + start_col > cursor_pos:
+            # current token starts after the cursor,
+            # don't consume it
+            break
+
+        if cur_token_is_name := tok.token == tokenize.NAME and not iskeyword(tok.text):
+            if (
+                names
+                and prev_tok
+                and prev_tok.token == tokenize.OP
+                and prev_tok.text == "."
+            ):
+                names[-1] = "%s.%s" % (names[-1], tok.text)
+            else:
+                names.append(tok.text)
+            if (
+                next_tok is not None
+                and next_tok.token == tokenize.OP
+                and next_tok.text == "="
+            ):
+                # don't inspect the lhs of an assignment
+                names.pop(-1)
+                cur_token_is_name = False
+            if not call_names:
+                most_recent_outer_name = names[-1] if names else None
+        elif tok.token == tokenize.OP:
+            if tok.text == "(" and names:
+                # if we are inside a function call, inspect the function
+                call_names.append(names[-1])
+            elif tok.text == ")" and call_names:
+                # keep track of the most recently popped call_name from the stack
+                closing_call_name = call_names.pop(-1)
+
+        if offsets[end_line] + end_col > cursor_pos:
+            # we found the cursor, stop reading
+            # if the current token intersects directly, use it instead of the call token
+            intersects_with_cursor = offsets[start_line] + start_col <= cursor_pos
+            break
+
+    if cur_token_is_name and intersects_with_cursor:
+        return names[-1]
+    # if the cursor isn't directly over a name token, use the most recent
+    # call name if we can find one
+    elif closing_call_name:
+        # if we're on a ")", use the most recently popped call name
+        return closing_call_name
+    elif call_names:
+        # otherwise, look for the most recent call name in the stack
+        return call_names[-1]
+    elif most_recent_outer_name:
+        # if we've popped all the call names, use the most recently-seen
+        # outer name
+        return most_recent_outer_name
+    elif names:
+        # failing that, use the most recently seen name
+        return names[-1]
+    else:
+        # give up
+        return ""
diff --git a/lib/python3.12/site-packages/IPython/utils/wildcard.py b/lib/python3.12/site-packages/IPython/utils/wildcard.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbef8c5175b1560de52a3c707098685cac6c35fa
--- /dev/null
+++ b/lib/python3.12/site-packages/IPython/utils/wildcard.py
@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+"""Support for wildcard pattern matching in object inspection.
+
+Authors
+-------
+- Jörgen Stenarson <jorgen.stenarson@bostream.nu>
+- Thomas Kluyver
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2005 Jörgen Stenarson <jorgen.stenarson@bostream.nu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+import re
+import types
+
+from IPython.utils.dir2 import dir2
+
+def create_typestr2type_dicts(dont_include_in_type2typestr=["lambda"]):
+    """Return dictionaries mapping lower case typename (e.g. 'tuple') to type
+    objects from the types package, and vice versa."""
+    typenamelist = [tname for tname in dir(types) if tname.endswith("Type")]
+    typestr2type, type2typestr = {}, {}
+
+    for tname in typenamelist:
+        name = tname[:-4].lower()          # Cut 'Type' off the end of the name
+        obj = getattr(types, tname)
+        typestr2type[name] = obj
+        if name not in dont_include_in_type2typestr:
+            type2typestr[obj] = name
+    return typestr2type, type2typestr
+
+typestr2type, type2typestr = create_typestr2type_dicts()
+
+def is_type(obj, typestr_or_type):
+    """is_type(obj, typestr_or_type) verifies if obj is of a certain type. It
+    can take strings or actual python types for the second argument, i.e.
+    'tuple'<->TupleType. 'all' matches all types.
+
+    TODO: Should be extended for choosing more than one type."""
+    if typestr_or_type == "all":
+        return True
+    if type(typestr_or_type) == type:
+        test_type = typestr_or_type
+    else:
+        test_type = typestr2type.get(typestr_or_type, False)
+    if test_type:
+        return isinstance(obj, test_type)
+    return False
+
+def show_hidden(str, show_all=False):
+    """Return true for strings starting with single _ if show_all is true."""
+    return show_all or str.startswith("__") or not str.startswith("_")
+
+def dict_dir(obj):
+    """Produce a dictionary of an object's attributes. Builds on dir2 by
+    checking that a getattr() call actually succeeds."""
+    ns = {}
+    for key in dir2(obj):
+       # This seemingly unnecessary try/except is actually needed
+       # because there is code out there with metaclasses that
+       # create 'write only' attributes, where a getattr() call
+       # will fail even if the attribute appears listed in the
+       # object's dictionary.  Properties can actually do the same
+       # thing.  In particular, Traits use this pattern
+       try:
+           ns[key] = getattr(obj, key)
+       except AttributeError:
+           pass
+    return ns
+
+def filter_ns(ns, name_pattern="*", type_pattern="all", ignore_case=True,
+            show_all=True):
+    """Filter a namespace dictionary by name pattern and item type."""
+    pattern = name_pattern.replace("*",".*").replace("?",".")
+    if ignore_case:
+        reg = re.compile(pattern+"$", re.I)
+    else:
+        reg = re.compile(pattern+"$")
+
+    # Check each one matches regex; shouldn't be hidden; of correct type.
+    return dict((key,obj) for key, obj in ns.items() if reg.match(key) \
+                                            and show_hidden(key, show_all) \
+                                            and is_type(obj, type_pattern) )
+
+def list_namespace(namespace, type_pattern, filter, ignore_case=False, show_all=False):
+    """Return dictionary of all objects in a namespace dictionary that match
+    type_pattern and filter."""
+    pattern_list=filter.split(".")
+    if len(pattern_list) == 1:
+       return filter_ns(namespace, name_pattern=pattern_list[0],
+                        type_pattern=type_pattern,
+                        ignore_case=ignore_case, show_all=show_all)
+    else:
+        # This is where we can change if all objects should be searched or
+        # only modules. Just change the type_pattern to module to search only
+        # modules
+        filtered = filter_ns(namespace, name_pattern=pattern_list[0],
+                            type_pattern="all",
+                            ignore_case=ignore_case, show_all=show_all)
+        results = {}
+        for name, obj in filtered.items():
+            ns = list_namespace(dict_dir(obj), type_pattern,
+                                ".".join(pattern_list[1:]),
+                                ignore_case=ignore_case, show_all=show_all)
+            for inner_name, inner_obj in ns.items():
+                results["%s.%s"%(name,inner_name)] = inner_obj
+        return results