ipython 9.0.0b2__py3-none-any.whl → 9.0.2__py3-none-any.whl

IPython/core/debugger.py

@@ -228,7 +228,12 @@ class Pdb(OldPdb):
     }
 
     def __init__(
-        self, completekey=None, stdin=None, stdout=None, context: int = 5, **kwargs
+        self,
+        completekey=None,
+        stdin=None,
+        stdout=None,
+        context: int | None | str = 5,
+        **kwargs,
     ):
         """Create a new IPython debugger.
 
@@ -251,7 +256,11 @@ class Pdb(OldPdb):
         The possibilities are python version dependent, see the python
         docs for more info.
         """
-
+        # ipdb issue, see https://github.com/ipython/ipython/issues/14811
+        if context is None:
+            context = 5
+        if isinstance(context, str):
+            context = int(context)
         self.context = context
 
         # `kwargs` ensures full compatibility with stdlib's `pdb.Pdb`.
@@ -298,7 +307,10 @@ class Pdb(OldPdb):
         return self._context
 
     @context.setter
-    def context(self, value: int) -> None:
+    def context(self, value: int | str) -> None:
+        # ipdb issue see https://github.com/ipython/ipython/issues/14811
+        if not isinstance(value, int):
+            value = int(value)
         assert isinstance(value, int)
         assert value >= 0
         self._context = value

IPython/core/inputtransformer2.py

@@ -17,6 +17,7 @@ import sys
 import tokenize
 from typing import List, Tuple, Optional, Any
 import warnings
+from textwrap import dedent
 
 from IPython.utils import tokenutil
 
@@ -38,18 +39,11 @@ def leading_empty_lines(lines):
 def leading_indent(lines):
     """Remove leading indentation.
 
-    If the first line starts with a spaces or tabs, the same whitespace will be
-    removed from each following line in the cell.
+    Removes the minimum common leading indentation from all lines.
     """
     if not lines:
         return lines
-    m = _indent_re.match(lines[0])
-    if not m or lines[0].strip().startswith("#"):
-        return lines
-    space = m.group(0)
-    n = len(space)
-    return [l[n:] if l.startswith(space) else l
-            for l in lines]
+    return dedent("".join(lines)).splitlines(keepends=True)
 
 class PromptStripper:
     """Remove matching input prompts from a block of input.

IPython/core/interactiveshell.py

@@ -329,6 +329,7 @@ class InteractiveShell(SingletonConfigurable):
 
     _instance = None
     _user_ns: dict
+    _sys_modules_keys: set[str, AnyType]
 
     inspector: oinspect.Inspector
 
@@ -764,7 +765,9 @@ class InteractiveShell(SingletonConfigurable):
         if not new == new.lower():
             warn(
                 f"`TerminalInteractiveShell.colors` is now lowercase: `{new.lower()}`,"
-                " non lowercase, may invalid in the future."
+                " non lowercase, may be invalid in the future.",
+                DeprecationWarning,
+                stacklevel=2,
             )
         return new.lower()
 
@@ -781,7 +784,8 @@ class InteractiveShell(SingletonConfigurable):
             )
 
         try:
-            self.inspector.set_theme_name(self.colors)
+            # Deprecation in 9.0, colors should always be lower
+            self.inspector.set_theme_name(self.colors.lower())
         except Exception:
             warn(
                 "Error changing object inspector color schemes.\n%s"
@@ -804,20 +808,19 @@ class InteractiveShell(SingletonConfigurable):
 
         self.dir_stack = []
 
-    def init_logger(self):
+    def init_logger(self) -> None:
         self.logger = Logger(self.home_dir, logfname='ipython_log.py',
                              logmode='rotate')
 
-    def init_logstart(self):
+    def init_logstart(self) -> None:
         """Initialize logging in case it was requested at the command line.
         """
         if self.logappend:
-            self.magic('logstart %s append' % self.logappend)
+            self.run_line_magic("logstart", f"{self.logappend} append")
         elif self.logfile:
-            self.magic('logstart %s' % self.logfile)
+            self.run_line_magic("logstart", self.logfile)
         elif self.logstart:
-            self.magic('logstart')
-
+            self.run_line_magic("logstart", "")
 
     def init_builtins(self):
         # A single, static flag that we set to True.  Its presence indicates

IPython/core/magic.py

@@ -672,10 +672,11 @@ class Magics(Configurable):
             argv = arg_split(arg_str, posix, strict)
             # Do regular option processing
             try:
-                opts,args = getopt(argv, opt_str, long_opts)
+                opts, args = getopt(argv, opt_str, long_opts)
             except GetoptError as e:
                 raise UsageError(
-                    '%s ( allowed: "%s" %s)' % (e.msg, opt_str, " ".join(long_opts))
+                    '%s (allowed: "%s"%s)'
+                    % (e.msg, opt_str, " ".join(("",) + long_opts) if long_opts else "")
                 ) from e
             for o, a in opts:
                 if mode == "string" and preserve_non_opts:

IPython/core/magics/code.py

@@ -193,7 +193,7 @@ class CodeMagics(Magics):
 
           -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 as the
+          Python.  If this option is given, the raw input as typed at the
           command line is used instead.
           
           -f: force overwrite.  If file exists, %save will prompt for overwrite

IPython/core/oinspect.py

@@ -401,7 +401,13 @@ class Inspector(Configurable):
         parent=None,
         config=None,
     ):
-        assert theme_name == theme_name.lower(), theme_name
+        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()
         self._theme_name = theme_name
         super(Inspector, self).__init__(parent=parent, config=config)
         self.parser = PyColorize.Parser(out="str", theme_name=theme_name)

IPython/core/release.py

@@ -17,10 +17,10 @@
 # version
 _version_major = 9
 _version_minor = 0
-_version_patch = 0
+_version_patch = 2
 _version_extra = ".dev"
-_version_extra = "b2"
-# _version_extra = ""  # Uncomment this for full releases
+# _version_extra = "b2"
+_version_extra = ""  # Uncomment this for full releases
 
 # Construct full version string from these.
 _ver = [_version_major, _version_minor, _version_patch]

IPython/core/tbtools.py

@@ -401,7 +401,13 @@ class TBTools:
                 stacklevel=2,
             )
             theme_name = color_scheme
-        assert theme_name.lower() == theme_name, theme_name
+        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()
         # Whether to call the interactive pdb debugger after printing
         # tracebacks or not
         super().__init__()

IPython/core/tips.py

@@ -71,12 +71,12 @@ _tips: Any = {
         "Run your doctests from within IPython for development and debugging. The special %doctest_mode command toggles a mode where the prompt, output and exceptions display matches as closely as possible that of the default Python interpreter.",
         "You can use `files = !ls *.png`",
         "Use the IPython.lib.demo.Demo class to load any Python script as an interactive demo.",
-        "Put a ‘;’ at the end of a line to suppress the printing of output.",
+        "Put a ';' at the end of a line to suppress the printing of output.",
         "You can use Ctrl-O to force a new line in terminal IPython",
         "Use `object?` to see the help on `object`, `object??` to view it's source",
         "`?` alone on a line will brings up IPython's help",
         "You can use `%hist` to view history, see the options with `%history?`",
-        "You can change the edditing mode of IPython to behave more like vi, or emacs.",
+        "You can change the editing mode of IPython to behave more like vi, or emacs.",
         "IPython 9.0+ have hooks to integrate AI/LLM completions.",
         "Use `%timeit` or `%%timeit`, and the  `-r`, `-n`, and `-o` options to easily profile your code.",
         "Use `ipython --help-all | less` to view all the IPython configurations options.",
@@ -91,11 +91,17 @@ if os.name == "nt":
             "We can't show you all tips on windows as sometime Unicode characters crash windows console, please help us debug it."
         ]
     )
+    # unicode may crash windows console, so we filter out tips with non-ASCII characters.
+    _tips["every_year"] = {
+        k: v
+        for k, v in _tips["every_year"].items()
+        if all(ord(char) < 128 for char in v)
+    }
 else:
     _tips["random"].extend(
         [
             "You can use latex or unicode completion, `\\alpha<tab>` will insert the α symbol.",
-            "You can find how to type a latext symbol by back completing it `\\θ<tab>` will expand to `\\theta`.",
+            "You can find how to type a latex symbol by back completing it `\\θ<tab>` will expand to `\\theta`.",
             "You can find how to type a unicode symbol by back completing it `\\Ⅷ<tab>` will expand to `\\ROMAN NUMERAL EIGHT`.",
             "IPython support combining unicode identifiers, F\\vec<tab> will become F⃗, usefull for physics equations. Play with \\dot \\ddot and others.",
         ]

IPython/extensions/deduperreload/deduperreload.py

@@ -0,0 +1,608 @@
+from __future__ import annotations
+import ast
+import builtins
+import contextlib
+import itertools
+import os
+import platform
+import sys
+import textwrap
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Generator, Iterable, NamedTuple, cast
+
+from IPython.extensions.deduperreload.deduperreload_patching import (
+    DeduperReloaderPatchingMixin,
+)
+
+if TYPE_CHECKING:
+    TDefinitionAst = (
+        ast.FunctionDef
+        | ast.AsyncFunctionDef
+        | ast.Import
+        | ast.ImportFrom
+        | ast.Assign
+        | ast.AnnAssign
+    )
+
+
+def get_module_file_name(module: ModuleType | str) -> str:
+    """Returns the module's file path, or the empty string if it's inaccessible"""
+    if (mod := sys.modules.get(module) if isinstance(module, str) else module) is None:
+        return ""
+    return getattr(mod, "__file__", "") or ""
+
+
+def compare_ast(node1: ast.AST | list[ast.AST], node2: ast.AST | list[ast.AST]) -> bool:
+    """Checks if node1 and node2 have identical AST structure/values, apart from some attributes"""
+    if type(node1) is not type(node2):
+        return False
+
+    if isinstance(node1, ast.AST):
+        for k, v in node1.__dict__.items():
+            if k in (
+                "lineno",
+                "end_lineno",
+                "col_offset",
+                "end_col_offset",
+                "ctx",
+                "parent",
+            ):
+                continue
+            if not hasattr(node2, k) or not compare_ast(v, getattr(node2, k)):
+                return False
+        return True
+
+    elif isinstance(node1, list) and isinstance(  # type:ignore [redundant-expr]
+        node2, list
+    ):
+        return len(node1) == len(node2) and all(
+            compare_ast(n1, n2) for n1, n2 in zip(node1, node2)
+        )
+    else:
+        return node1 == node2
+
+
+class DependencyNode(NamedTuple):
+    """
+    Each node represents a function.
+    qualified_name: string which represents the namespace/name of the function
+    abstract_syntax_tree: subtree of the overall module which corresponds to this function
+
+    qualified_name is of the structure: (namespace1, namespace2, ..., name)
+
+    For example, foo() in the following would be represented as (A, B, foo):
+
+    class A:
+        class B:
+            def foo():
+                pass
+    """
+
+    qualified_name: tuple[str, ...]
+    abstract_syntax_tree: ast.AST
+
+
+class GatherResult(NamedTuple):
+    import_defs: list[tuple[tuple[str, ...], ast.Import | ast.ImportFrom]] = []
+    assign_defs: list[tuple[tuple[str, ...], ast.Assign | ast.AnnAssign]] = []
+    function_defs: list[
+        tuple[tuple[str, ...], ast.FunctionDef | ast.AsyncFunctionDef]
+    ] = []
+    classes: dict[str, ast.ClassDef] = {}
+    unfixable: list[ast.AST] = []
+
+    @classmethod
+    def create(cls) -> GatherResult:
+        return cls([], [], [], {}, [])
+
+    def all_defs(self) -> Iterable[tuple[tuple[str, ...], TDefinitionAst]]:
+        return itertools.chain(self.import_defs, self.assign_defs, self.function_defs)
+
+    def inplace_merge(self, other: GatherResult) -> None:
+        self.import_defs.extend(other.import_defs)
+        self.assign_defs.extend(other.assign_defs)
+        self.function_defs.extend(other.function_defs)
+        self.classes.update(other.classes)
+        self.unfixable.extend(other.unfixable)
+
+
+class ConstexprDetector(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.is_constexpr = True
+        self._allow_builtins_exceptions = True
+
+    @contextlib.contextmanager
+    def disallow_builtins_exceptions(self) -> Generator[None, None, None]:
+        prev_allow = self._allow_builtins_exceptions
+        self._allow_builtins_exceptions = False
+        try:
+            yield
+        finally:
+            self._allow_builtins_exceptions = prev_allow
+
+    def visit_Attribute(self, node: ast.Attribute) -> None:
+        with self.disallow_builtins_exceptions():
+            self.visit(node.value)
+
+    def visit_Name(self, node: ast.Name) -> None:
+        if self._allow_builtins_exceptions and hasattr(builtins, node.id):
+            return
+        self.is_constexpr = False
+
+    def visit(self, node: ast.AST) -> None:
+        if not self.is_constexpr:
+            # can short-circuit if we've already detected that it's not a constexpr
+            return
+        super().visit(node)
+
+    def __call__(self, node: ast.AST) -> bool:
+        self.is_constexpr = True
+        self.visit(node)
+        return self.is_constexpr
+
+
+class AutoreloadTree:
+    """
+    Recursive data structure to keep track of reloadable functions/methods. Each object corresponds to a specific scope level.
+    children: classes inside given scope, maps class name to autoreload tree for that class's scope
+    funcs_to_autoreload: list of function names that can be autoreloaded in given scope.
+    new_nested_classes: Classes getting added in new autoreload cycle
+    """
+
+    def __init__(self) -> None:
+        self.children: dict[str, AutoreloadTree] = {}
+        self.defs_to_reload: list[tuple[tuple[str, ...], ast.AST]] = []
+        self.defs_to_delete: set[str] = set()
+        self.new_nested_classes: dict[str, ast.AST] = {}
+
+    def traverse_prefixes(self, prefixes: list[str]) -> AutoreloadTree:
+        """
+        Return ref to the AutoreloadTree at the namespace specified by prefixes
+        """
+        cur = self
+        for prefix in prefixes:
+            if prefix not in cur.children:
+                cur.children[prefix] = AutoreloadTree()
+            cur = cur.children[prefix]
+        return cur
+
+
+class DeduperReloader(DeduperReloaderPatchingMixin):
+    """
+    This version of autoreload detects when we can leverage targeted recompilation of a subset of a module and patching
+    existing function/method objects to reflect these changes.
+
+    Detects what functions/methods can be reloaded by recursively comparing the old/new AST of module-level classes,
+    module-level classes' methods, recursing through nested classes' methods. If other changes are made, original
+    autoreload algorithm is called directly.
+    """
+
+    def __init__(self) -> None:
+        self._to_autoreload: AutoreloadTree = AutoreloadTree()
+        self.source_by_modname: dict[str, str] = {}
+        self.dependency_graph: dict[tuple[str, ...], list[DependencyNode]] = {}
+        self._enabled = True
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled and platform.python_implementation() == "CPython"
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self._enabled = value
+
+    def update_sources(self) -> None:
+        """
+        Update dictionary source_by_modname with current modules' source codes.
+        """
+        if not self.enabled:
+            return
+        for new_modname in sys.modules.keys() - self.source_by_modname.keys():
+            new_module = sys.modules[new_modname]
+            if (
+                (fname := get_module_file_name(new_module))
+                is None  # type:ignore [redundant-expr]
+                or "site-packages" in fname
+                or "dist-packages" in fname
+                or not os.access(fname, os.R_OK)
+            ):
+                self.source_by_modname[new_modname] = ""
+                continue
+            with open(fname, "r") as f:
+                try:
+                    self.source_by_modname[new_modname] = f.read()
+                except Exception:
+                    self.source_by_modname[new_modname] = ""
+
+    constexpr_detector = ConstexprDetector()
+
+    @staticmethod
+    def is_enum_subclass(node: ast.Module | ast.ClassDef) -> bool:
+        if isinstance(node, ast.Module):
+            return False
+        for base in node.bases:
+            if isinstance(base, ast.Name) and base.id == "Enum":
+                return True
+            elif (
+                isinstance(base, ast.Attribute)
+                and base.attr == "Enum"
+                and isinstance(base.value, ast.Name)
+                and base.value.id == "enum"
+            ):
+                return True
+        return False
+
+    @classmethod
+    def is_constexpr_assign(
+        cls, node: ast.AST, parent_node: ast.Module | ast.ClassDef
+    ) -> bool:
+        if not isinstance(node, (ast.Assign, ast.AnnAssign)) or node.value is None:
+            return False
+        if cls.is_enum_subclass(parent_node):
+            return False
+        for target in node.targets if isinstance(node, ast.Assign) else [node.target]:
+            if not isinstance(target, ast.Name):
+                return False
+        return cls.constexpr_detector(node.value)
+
+    @classmethod
+    def _gather_children(
+        cls, body: list[ast.stmt], parent_node: ast.Module | ast.ClassDef
+    ) -> GatherResult:
+        """
+        Given list of ast elements, return:
+        1. dict mapping function names to their ASTs.
+        2. dict mapping class names to their ASTs.
+        3. list of any other ASTs.
+        """
+        result = GatherResult.create()
+        for ast_node in body:
+            ast_elt: ast.expr | ast.stmt = ast_node
+            while isinstance(ast_elt, ast.Expr):
+                ast_elt = ast_elt.value
+            if isinstance(ast_elt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                result.function_defs.append(((ast_elt.name,), ast_elt))
+            elif isinstance(ast_elt, (ast.Import, ast.ImportFrom)):
+                result.import_defs.append(
+                    (tuple(name.asname or name.name for name in ast_elt.names), ast_elt)
+                )
+            elif isinstance(ast_elt, ast.ClassDef):
+                result.classes[ast_elt.name] = ast_elt
+            elif isinstance(ast_elt, ast.If):
+                result.unfixable.append(ast_elt.test)
+                result.inplace_merge(cls._gather_children(ast_elt.body, parent_node))
+                result.inplace_merge(cls._gather_children(ast_elt.orelse, parent_node))
+            elif isinstance(ast_elt, (ast.AsyncWith, ast.With)):
+                result.unfixable.extend(ast_elt.items)
+                result.inplace_merge(cls._gather_children(ast_elt.body, parent_node))
+            elif isinstance(ast_elt, ast.Try):
+                result.inplace_merge(cls._gather_children(ast_elt.body, parent_node))
+                result.inplace_merge(cls._gather_children(ast_elt.orelse, parent_node))
+                result.inplace_merge(
+                    cls._gather_children(ast_elt.finalbody, parent_node)
+                )
+                for handler in ast_elt.handlers:
+                    if handler.type is not None:
+                        result.unfixable.append(handler.type)
+                    result.inplace_merge(
+                        cls._gather_children(handler.body, parent_node)
+                    )
+            elif not isinstance(ast_elt, (ast.Ellipsis, ast.Pass)):
+                if cls.is_constexpr_assign(ast_elt, parent_node):
+                    assert isinstance(ast_elt, (ast.Assign, ast.AnnAssign))
+                    targets = (
+                        ast_elt.targets
+                        if isinstance(ast_elt, ast.Assign)
+                        else [ast_elt.target]
+                    )
+                    result.assign_defs.append(
+                        (
+                            tuple(cast(ast.Name, target).id for target in targets),
+                            ast_elt,
+                        )
+                    )
+                else:
+                    result.unfixable.append(ast_elt)
+        return result
+
+    def detect_autoreload(
+        self,
+        old_node: ast.Module | ast.ClassDef,
+        new_node: ast.Module | ast.ClassDef,
+        prefixes: list[str] | None = None,
+    ) -> bool:
+        """
+        Returns
+        -------
+        `True` if we can run our targeted autoreload algorithm safely.
+        `False` if we should instead use IPython's original autoreload implementation.
+        """
+        if not self.enabled:
+            return False
+        prefixes = prefixes or []
+
+        old_result = self._gather_children(old_node.body, old_node)
+        new_result = self._gather_children(new_node.body, new_node)
+        old_defs_by_name: dict[str, ast.AST] = {
+            name: ast_def for names, ast_def in old_result.all_defs() for name in names
+        }
+        new_defs_by_name: dict[str, ast.AST] = {
+            name: ast_def for names, ast_def in new_result.all_defs() for name in names
+        }
+
+        if not compare_ast(old_result.unfixable, new_result.unfixable):
+            return False
+
+        cur = self._to_autoreload.traverse_prefixes(prefixes)
+        for names, new_ast_def in new_result.all_defs():
+            names_to_reload = []
+            for name in names:
+                if new_defs_by_name[name] is not new_ast_def:
+                    continue
+                if name not in old_defs_by_name or not compare_ast(
+                    new_ast_def, old_defs_by_name[name]
+                ):
+                    names_to_reload.append(name)
+            if names_to_reload:
+                cur.defs_to_reload.append((tuple(names), new_ast_def))
+        cur.defs_to_delete |= set(old_defs_by_name.keys()) - set(
+            new_defs_by_name.keys()
+        )
+        for name, new_ast_def_class in new_result.classes.items():
+            if name not in old_result.classes:
+                cur.new_nested_classes[name] = new_ast_def_class
+            elif not compare_ast(
+                new_ast_def_class, old_result.classes[name]
+            ) and not self.detect_autoreload(
+                old_result.classes[name], new_ast_def_class, prefixes + [name]
+            ):
+                return False
+        return True
+
+    def _check_dependents(self) -> bool:
+        """
+        If a decorator function is modified, we should similarly reload the functions which are decorated by this
+        decorator. Iterate through the Dependency Graph to find such cases in the given AutoreloadTree.
+        """
+        for node in self._check_dependents_inner():
+            self._add_node_to_autoreload_tree(node)
+        return True
+
+    def _add_node_to_autoreload_tree(self, node: DependencyNode) -> None:
+        """
+        Given a node of the dependency graph, add decorator dependencies to the autoreload tree.
+        """
+        if len(node.qualified_name) == 0:
+            return
+        cur = self._to_autoreload.traverse_prefixes(list(node.qualified_name[:-1]))
+        if node.abstract_syntax_tree is not None:
+            cur.defs_to_reload.append(
+                ((node.qualified_name[-1],), node.abstract_syntax_tree)
+            )
+
+    def _check_dependents_inner(
+        self, prefixes: list[str] | None = None
+    ) -> list[DependencyNode]:
+        prefixes = prefixes or []
+        cur = self._to_autoreload.traverse_prefixes(prefixes)
+        ans = []
+        for (func_name, *_), _ in cur.defs_to_reload:
+            node = tuple(prefixes + [func_name])
+            ans.extend(self._gen_dependents(node))
+        for class_name in cur.new_nested_classes:
+            ans.extend(self._check_dependents_inner(prefixes + [class_name]))
+        return ans
+
+    def _gen_dependents(self, qualname: tuple[str, ...]) -> list[DependencyNode]:
+        ans = []
+        if qualname not in self.dependency_graph:
+            return []
+        for elt in self.dependency_graph[qualname]:
+            ans.extend(self._gen_dependents(elt.qualified_name))
+            ans.append(elt)
+        return ans
+
+    def _patch_namespace_inner(
+        self, ns: ModuleType | type, prefixes: list[str] | None = None
+    ) -> bool:
+        """
+        This function patches module functions and methods. Specifically, only objects with their name in
+        self.to_autoreload will be considered for patching. If an object has been marked to be autoreloaded,
+        new_source_code gets executed in the old version's global environment. Then, replace the old function's
+        attributes with the new function's attributes.
+        """
+        prefixes = prefixes or []
+        cur = self._to_autoreload.traverse_prefixes(prefixes)
+        namespace_to_check = ns
+        for prefix in prefixes:
+            namespace_to_check = namespace_to_check.__dict__[prefix]
+        for names, new_ast_def in cur.defs_to_reload:
+            local_env: dict[str, Any] = {}
+            if (
+                isinstance(new_ast_def, (ast.FunctionDef, ast.AsyncFunctionDef))
+                and (name := names[0]) in namespace_to_check.__dict__
+            ):
+                assert len(names) == 1
+                to_patch_to = namespace_to_check.__dict__[name]
+                if isinstance(to_patch_to, (staticmethod, classmethod)):
+                    to_patch_to = to_patch_to.__func__
+                # exec new source code using old function's (obj) globals environment.
+                func_code = textwrap.dedent(ast.unparse(new_ast_def))
+                if is_method := (len(prefixes) > 0):
+                    func_code = "class __autoreload_class__:\n" + textwrap.indent(
+                        func_code, "    "
+                    )
+                global_env = namespace_to_check.__dict__
+                if hasattr(to_patch_to, "__globals__"):
+                    global_env = to_patch_to.__globals__
+                elif isinstance(to_patch_to, property):
+                    if to_patch_to.fget is not None:
+                        global_env = to_patch_to.fget.__globals__
+                    elif to_patch_to.fset is not None:
+                        global_env = to_patch_to.fset.__globals__
+                    elif to_patch_to.fdel is not None:
+                        global_env = to_patch_to.fdel.__globals__
+                if not isinstance(global_env, dict):
+                    global_env = dict(global_env)
+                exec(func_code, global_env, local_env)  # type: ignore[arg-type]
+                # local_env contains the function exec'd from  new version of function
+                if is_method:
+                    to_patch_from = getattr(local_env["__autoreload_class__"], name)
+                else:
+                    to_patch_from = local_env[name]
+                if isinstance(to_patch_from, (staticmethod, classmethod)):
+                    to_patch_from = to_patch_from.__func__
+                if isinstance(to_patch_to, property) and isinstance(
+                    to_patch_from, property
+                ):
+                    for attr in ("fget", "fset", "fdel"):
+                        if (
+                            getattr(to_patch_to, attr) is None
+                            or getattr(to_patch_from, attr) is None
+                        ):
+                            self.try_patch_attr(to_patch_to, to_patch_from, attr)
+                        else:
+                            self.patch_function(
+                                getattr(to_patch_to, attr),
+                                getattr(to_patch_from, attr),
+                                is_method,
+                            )
+                elif not isinstance(to_patch_to, property) and not isinstance(
+                    to_patch_from, property
+                ):
+                    self.patch_function(to_patch_to, to_patch_from, is_method)
+                else:
+                    raise ValueError(
+                        "adding or removing property decorations not supported"
+                    )
+            else:
+                exec(
+                    ast.unparse(new_ast_def),
+                    ns.__dict__ | namespace_to_check.__dict__,
+                    local_env,
+                )
+                for name in names:
+                    setattr(namespace_to_check, name, local_env[name])
+        cur.defs_to_reload.clear()
+        for name in cur.defs_to_delete:
+            try:
+                delattr(namespace_to_check, name)
+            except (AttributeError, TypeError, ValueError):
+                # give up on deleting the attribute, let the stale one dangle
+                pass
+        cur.defs_to_delete.clear()
+        for class_name, class_ast_node in cur.new_nested_classes.items():
+            local_env_class: dict[str, Any] = {}
+            exec(
+                ast.unparse(class_ast_node),
+                ns.__dict__ | namespace_to_check.__dict__,
+                local_env_class,
+            )
+            setattr(namespace_to_check, class_name, local_env_class[class_name])
+        cur.new_nested_classes.clear()
+        for class_name in cur.children.keys():
+            if not self._patch_namespace(ns, prefixes + [class_name]):
+                return False
+        cur.children.clear()
+        return True
+
+    def _patch_namespace(
+        self, ns: ModuleType | type, prefixes: list[str] | None = None
+    ) -> bool:
+        """
+        Wrapper for patching all elements in a namespace as specified by the to_autoreload member variable.
+        Returns `true` if patching was successful, and `false` if unsuccessful.
+        """
+        try:
+            return self._patch_namespace_inner(ns, prefixes=prefixes)
+        except Exception:
+            return False
+
+    def maybe_reload_module(self, module: ModuleType) -> bool:
+        """
+        Uses Deduperreload to try to update a module.
+        Returns `true` on success and `false` on failure.
+        """
+        if not self.enabled:
+            return False
+        if not (modname := getattr(module, "__name__", None)):
+            return False
+        if (fname := get_module_file_name(module)) is None:
+            return False
+        with open(fname, "r") as f:
+            new_source_code = f.read()
+        patched_flag = False
+        if old_source_code := self.source_by_modname.get(modname):
+            # get old/new module ast
+            try:
+                old_module_ast = ast.parse(old_source_code)
+                new_module_ast = ast.parse(new_source_code)
+            except Exception:
+                return False
+            # detect if we are able to use our autoreload algorithm
+            ctx = contextlib.suppress()
+            with ctx:
+                self._build_dependency_graph(new_module_ast)
+                if (
+                    self.detect_autoreload(old_module_ast, new_module_ast)
+                    and self._check_dependents()
+                    and self._patch_namespace(module)
+                ):
+                    patched_flag = True
+
+        self.source_by_modname[modname] = new_source_code
+        self._to_autoreload = AutoreloadTree()
+        return patched_flag
+
+    def _separate_name(
+        self,
+        decorator: ast.Attribute | ast.Name | ast.Call | ast.expr,
+        accept_calls: bool,
+    ) -> list[str] | None:
+        """
+        Generates a qualified name for a given decorator by finding its relative namespace.
+        """
+        if isinstance(decorator, ast.Name):
+            return [decorator.id]
+        elif isinstance(decorator, ast.Call):
+            if accept_calls:
+                return self._separate_name(decorator.func, False)
+            else:
+                return None
+        if not isinstance(decorator, ast.Attribute):
+            return None
+        if pref := self._separate_name(decorator.value, False):
+            return pref + [decorator.attr]
+        else:
+            return None
+
+    def _gather_dependents(
+        self, body: list[ast.stmt], body_prefixes: list[str] | None = None
+    ) -> bool:
+        body_prefixes = body_prefixes or []
+        for ast_node in body:
+            ast_elt: ast.expr | ast.stmt = ast_node
+            if isinstance(ast_elt, ast.ClassDef):
+                self._gather_dependents(ast_elt.body, body_prefixes + [ast_elt.name])
+                continue
+            if not isinstance(ast_elt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            qualified_name = tuple(body_prefixes + [ast_elt.name])
+            cur_dependency_node = DependencyNode(qualified_name, ast_elt)
+            for decorator in ast_elt.decorator_list:
+                decorator_path = self._separate_name(decorator, True)
+                if not decorator_path:
+                    continue
+                decorator_path_tuple = tuple(decorator_path)
+                self.dependency_graph.setdefault(decorator_path_tuple, []).append(
+                    cur_dependency_node
+                )
+        return True
+
+    def _build_dependency_graph(self, new_ast: ast.Module | ast.ClassDef) -> bool:
+        """
+        Wrapper function for generating dependency graph given some AST.
+        Returns `true` on success. Returns `false` on failure.
+        Currently, only returns `true` as we do not block on failure to build this graph.
+        """
+        return self._gather_dependents(new_ast.body)

IPython/extensions/deduperreload/deduperreload_patching.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+import ctypes
+import sys
+from typing import Any
+
+NOT_FOUND: object = object()
+_MAX_FIELD_SEARCH_OFFSET = 50
+
+if sys.maxsize > 2**32:
+    WORD_TYPE: type[ctypes.c_int32] | type[ctypes.c_int64] = ctypes.c_int64
+    WORD_N_BYTES = 8
+else:
+    WORD_TYPE = ctypes.c_int32
+    WORD_N_BYTES = 4
+
+
+class DeduperReloaderPatchingMixin:
+    @staticmethod
+    def infer_field_offset(
+        obj: object,
+        field: str,
+    ) -> int:
+        field_value = getattr(obj, field, NOT_FOUND)
+        if field_value is NOT_FOUND:
+            return -1
+        obj_addr = ctypes.c_void_p.from_buffer(ctypes.py_object(obj)).value
+        field_addr = ctypes.c_void_p.from_buffer(ctypes.py_object(field_value)).value
+        if obj_addr is None or field_addr is None:
+            return -1
+        ret = -1
+        for offset in range(1, _MAX_FIELD_SEARCH_OFFSET):
+            if (
+                ctypes.cast(
+                    obj_addr + WORD_N_BYTES * offset, ctypes.POINTER(WORD_TYPE)
+                ).contents.value
+                == field_addr
+            ):
+                ret = offset
+                break
+        return ret
+
+    @classmethod
+    def try_write_readonly_attr(
+        cls,
+        obj: object,
+        field: str,
+        new_value: object,
+        offset: int | None = None,
+    ) -> None:
+        prev_value = getattr(obj, field, NOT_FOUND)
+        if prev_value is NOT_FOUND:
+            return
+        if offset is None:
+            offset = cls.infer_field_offset(obj, field)
+        if offset == -1:
+            return
+        obj_addr = ctypes.c_void_p.from_buffer(ctypes.py_object(obj)).value
+        new_value_addr = ctypes.c_void_p.from_buffer(ctypes.py_object(new_value)).value
+        if obj_addr is None or new_value_addr is None:
+            return
+        if prev_value is not None:
+            ctypes.pythonapi.Py_DecRef(ctypes.py_object(prev_value))
+        if new_value is not None:
+            ctypes.pythonapi.Py_IncRef(ctypes.py_object(new_value))
+        ctypes.cast(
+            obj_addr + WORD_N_BYTES * offset, ctypes.POINTER(WORD_TYPE)
+        ).contents.value = new_value_addr
+
+    @classmethod
+    def try_patch_readonly_attr(
+        cls,
+        old: object,
+        new: object,
+        field: str,
+        new_is_value: bool = False,
+        offset: int = -1,
+    ) -> None:
+
+        old_value = getattr(old, field, NOT_FOUND)
+        new_value = new if new_is_value else getattr(new, field, NOT_FOUND)
+        if old_value is NOT_FOUND or new_value is NOT_FOUND:
+            return
+        elif old_value is new_value:
+            return
+        elif old_value is not None and offset < 0:
+            offset = cls.infer_field_offset(old, field)
+        elif offset < 0:
+            assert not new_is_value
+            assert new_value is not None
+            offset = cls.infer_field_offset(new, field)
+        cls.try_write_readonly_attr(old, field, new_value, offset=offset)
+
+    @classmethod
+    def try_patch_attr(
+        cls,
+        old: object,
+        new: object,
+        field: str,
+        new_is_value: bool = False,
+        offset: int = -1,
+    ) -> None:
+        try:
+            setattr(old, field, new if new_is_value else getattr(new, field))
+        except (AttributeError, TypeError, ValueError):
+            cls.try_patch_readonly_attr(old, new, field, new_is_value, offset)
+
+    @classmethod
+    def patch_function(
+        cls, to_patch_to: Any, to_patch_from: Any, is_method: bool
+    ) -> None:
+        new_freevars = []
+        new_closure = []
+        for i, v in enumerate(to_patch_to.__code__.co_freevars):
+            if v not in to_patch_from.__code__.co_freevars or v == "__class__":
+                new_freevars.append(v)
+                new_closure.append(to_patch_to.__closure__[i])
+        for i, v in enumerate(to_patch_from.__code__.co_freevars):
+            if v not in new_freevars:
+                new_freevars.append(v)
+                new_closure.append(to_patch_from.__closure__[i])
+        code_with_new_freevars = to_patch_from.__code__.replace(
+            co_freevars=tuple(new_freevars)
+        )
+        # lambdas may complain if there is more than one freevar
+        cls.try_patch_attr(
+            to_patch_to, code_with_new_freevars, "__code__", new_is_value=True
+        )
+        offset = -1
+        if to_patch_to.__closure__ is None and to_patch_from.__closure__ is not None:
+            offset = cls.infer_field_offset(to_patch_from, "__closure__")
+        cls.try_patch_readonly_attr(
+            to_patch_to,
+            tuple(new_closure) or None,
+            "__closure__",
+            new_is_value=True,
+            offset=offset,
+        )
+        for attr in ("__defaults__", "__kwdefaults__", "__doc__", "__dict__"):
+            cls.try_patch_attr(to_patch_to, to_patch_from, attr)
+        if is_method:
+            cls.try_patch_readonly_attr(to_patch_to, to_patch_from, "__self__")

IPython/terminal/interactiveshell.py

@@ -1030,6 +1030,12 @@ class TerminalInteractiveShell(InteractiveShell):
 
     _inputhook = None
     def inputhook(self, context):
+        warn(
+            "inputkook seem unused, and marked for deprecation/Removal as of IPython 9.0. "
+            "Please open an issue if you are using it.",
+            category=PendingDeprecationWarning,
+            stacklevel=2,
+        )
         if self._inputhook is not None:
             self._inputhook(context)
 

IPython/terminal/pt_inputhooks/qt.py

@@ -50,7 +50,6 @@ def inputhook(context):
         except AttributeError:  # Only for Qt>=5.14.
             pass
         _appref = app = QtGui.QApplication([" "])
-        _eventloop = QtCore.QEventLoop(app)
 
         # "reclaim" IPython sys.excepthook after event loop starts
         # without this, it defaults back to BaseIPythonApplication.excepthook
@@ -58,6 +57,9 @@ def inputhook(context):
         # formatting and look like "bug in IPython".
         QtCore.QTimer.singleShot(0, _reclaim_excepthook)
 
+    if _eventloop is None:
+        _eventloop = QtCore.QEventLoop(app)
+
     if sys.platform == 'win32':
         # The QSocketNotifier method doesn't appear to work on Windows.
         # Use polling instead.

IPython/terminal/ptutils.py

@@ -169,6 +169,7 @@ class IPythonPTCompleter(Completer):
             adjusted_text = _adjust_completion_text_based_on_context(
                 c.text, body, offset
             )
+            min_elide = 30 if self.shell is None else self.shell.min_elide
             if c.type == "function":
                 yield Completion(
                     adjusted_text,
@@ -176,7 +177,7 @@ class IPythonPTCompleter(Completer):
                     display=_elide(
                         display_text + "()",
                         body[c.start : c.end],
-                        min_elide=self.shell.min_elide,
+                        min_elide=min_elide,
                     ),
                     display_meta=c.type + c.signature,
                 )
@@ -187,7 +188,7 @@ class IPythonPTCompleter(Completer):
                     display=_elide(
                         display_text,
                         body[c.start : c.end],
-                        min_elide=self.shell.min_elide,
+                        min_elide=min_elide,
                     ),
                     display_meta=c.type,
                 )

IPython/terminal/shortcuts/__init__.py

@@ -203,7 +203,7 @@ AUTO_SUGGEST_BINDINGS = [
     Binding(
         auto_suggest.accept,
         ["right"],
-        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode & is_cursor_at_the_end_of_line",
     ),
     Binding(
         auto_suggest.accept_word,

IPython/utils/PyColorize.py

@@ -3,6 +3,7 @@ import os
 import sys
 import token
 import tokenize
+import warnings
 from io import StringIO
 from typing import TypeAlias
 
@@ -353,7 +354,6 @@ class Parser:
         Call format() to process code.
         """
 
-
         assert theme_name is not None
 
         self.out = out
@@ -361,7 +361,13 @@ class Parser:
         self.lines = None
         self.raw = None
         if theme_name is not None:
-            assert theme_name == theme_name.lower()
+            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:

IPython/utils/_sysinfo.py

@@ -1,2 +1,2 @@
 # GENERATED BY setup.py
-commit = "20b9e8efe"
+commit = "9970f5e4b"

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"

{ipython-9.0.0b2.dist-info → ipython-9.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ipython
-Version: 9.0.0b2
+Version: 9.0.2
 Summary: IPython: Productive Interactive Computing
 Author: The IPython Development Team
 Author-email: ipython-dev@python.org

{ipython-9.0.0b2.dist-info → ipython-9.0.2.dist-info}/RECORD

@@ -13,7 +13,7 @@ IPython/core/compilerop.py,sha256=tA8xHh10gp85brI2OYmvl7kW0TgDghdKbzmZE7nS4sw,69
 IPython/core/completer.py,sha256=grT260S45DxAthhOeZZfp1YmZRhCKwvXstvxRnxMytQ,120548
 IPython/core/completerlib.py,sha256=C_1uFwR4eiqIsemMRbluMQV1WJ3qSfnGxO01PsGSpr8,12641
 IPython/core/crashhandler.py,sha256=8-kyI6aNkqbaB_lBlbNKAOFv34HDBCpLggMfiu4oIDg,8747
-IPython/core/debugger.py,sha256=JikRcF51mtHHH0oqDADBVrvnOi4wwiEAnFKq1oe8p00,41406
+IPython/core/debugger.py,sha256=I3LA4HQFEP5cy-kbbRvJqlLlSgVHSWBbp0cbPs3nU8M,41806
 IPython/core/display.py,sha256=wQgVFY_U1O-a-jJSLb00nJ9m2w9-NsBhEBGnQUcWUd0,41129
 IPython/core/display_functions.py,sha256=hlj1gXXrcIQU_ita03dHFesltOCViP1N3RcoLtLuyFI,12407
 IPython/core/display_trap.py,sha256=31jM26B3PhNSLJhpyRHuTWscObwVMOlH9PDC2v8HmsU,2098
@@ -29,14 +29,14 @@ IPython/core/guarded_eval.py,sha256=dQXW-e3wM6z9WGcszdJLhqiK0UCii303GOOXd3z3ze8,
 IPython/core/history.py,sha256=aTBJxCtZ_gPPJbzhAj6bOqII8AJClVWTH7xZX44m5jk,40602
 IPython/core/historyapp.py,sha256=xVVF2UmWH7UUYg6L4bmpMnSgC1C7QXwNEDbQ1Waedkc,5871
 IPython/core/hooks.py,sha256=xBWTZqycxZi97yj01IFc-SoJBzV5B73IoDHbAAlKUpQ,5193
-IPython/core/inputtransformer2.py,sha256=90eWEZMKJdPTnRHCENGGp5BLDg4jn1a2PP-WCJzgUmg,29108
-IPython/core/interactiveshell.py,sha256=aqyzXD2VXYsTs9_OmcNCRkw3lClPKL4eBPU1Nohl8y8,153561
+IPython/core/inputtransformer2.py,sha256=7sRleytrcAbp5PZMOrDw59MjUAGXg5BbaRbPkSW83-I,28909
+IPython/core/interactiveshell.py,sha256=uAGkI0JslwYzc2WEhl3R38gqLG2w9xQpAJjhLuCVZ0g,153787
 IPython/core/latex_symbols.py,sha256=DzFecvqWVSsdN7vWAsp0mlYAHRDQKfZGAmvuDUh0M-s,30127
 IPython/core/logger.py,sha256=Iwe4xKMmxEdvSwHYPMfsTWkmdaqVCgvZT3R3I3qTmrU,8436
 IPython/core/macro.py,sha256=OhvXWNhLe393rI2wTpMgbUVHWSnmC_ycHiYqzqSHXZU,1726
-IPython/core/magic.py,sha256=QWXILCerTOrO5VD8Qr4GoUt_0l-oNXz3ZCLKuCpx8aU,28919
+IPython/core/magic.py,sha256=sUPVeVSk70aGVaPXncrSJxYJU8u_6YGCnR3folx8wys,28967
 IPython/core/magic_arguments.py,sha256=utkhQzGmn9Uw-ye33VO9P8ryP1L6ghkPcCdmhjri8K0,9701
-IPython/core/oinspect.py,sha256=h7Q-2gcB-UomOa0RG2q03DvWQ-5y4-2oLBC2GCKOmVU,40008
+IPython/core/oinspect.py,sha256=_C6tUncGVHmaU89_chHRknQJ264mDYxzsNxeHNYFOao,40280
 IPython/core/page.py,sha256=P8Dmo0MjUq71DEnIPM_kaSGZoKTaPkrk4sUuM4I6HDA,11788
 IPython/core/payload.py,sha256=uHcwG5Ahm3fnz2dsIKbzYK_lHOilqfen0IhQffOUQbE,1763
 IPython/core/payloadpage.py,sha256=xGz4Ov82-0lmhKSIlM-kyIa50COk-ojB7tXLkGIRnPw,1177
@@ -44,18 +44,18 @@ IPython/core/prefilter.py,sha256=JHQ3feaD4bhoBDqZcEgmlDjQ2sfRXC1DNjgJhpaMU7E,257
 IPython/core/profileapp.py,sha256=bFMFIyehxeF9pDUtxw_6D3b0nxeqsupKTe7XhH7GMkc,10711
 IPython/core/profiledir.py,sha256=-vjOa1I_UajMZJblJRYXh16Y0RaAUn5a2swQBsw2qEU,8459
 IPython/core/pylabtools.py,sha256=LfNV9xCJ3flCfJXmv1NaCRYj9jZDtHAQ5oSEHWo3Gmg,17376
-IPython/core/release.py,sha256=0CxBJbsL5-EJCviE2KKYKeQNnbHDFmymlO-I7ccgIwQ,1505
+IPython/core/release.py,sha256=Xh10_c3N-D5TcMiswCtqiR5brz6KpxliDhScbJLcRuI,1505
 IPython/core/shellapp.py,sha256=oZIzj_sqIXrN3qyyhinZ1gLXvFviKYHkmS4H3wVEb74,19307
 IPython/core/splitinput.py,sha256=bAX1puQjvYB-otJyqiqeOhWj6dooWuQeNVx2YdaKQs8,5006
-IPython/core/tbtools.py,sha256=Ykn8800kc2B2Z3UX91mDXUvR_px_PzmTo3LuSfJwre8,16608
-IPython/core/tips.py,sha256=E-M8aYtcQfARpyyjqTuuoXaKdUEH4dKD_YZYf3jWHVA,5939
+IPython/core/tbtools.py,sha256=X4iB5zKAT2y4TK1R9l3d3kiW5htrzKn3qxalFFe2xzI,16880
+IPython/core/tips.py,sha256=EBvLHsSwa5EwXjIJDotgm_t5r_dWWvnkJy-e1WvphoU,6164
 IPython/core/ultratb.py,sha256=ItaUt56wPnptv6f5ecbcBR3FtHljTDoIRHKsU-ZWGqI,46265
 IPython/core/usage.py,sha256=agrZE5eZIvJnXoqI8VV9e-oWZx5LbLxUq9MdQpEyts4,13542
 IPython/core/magics/__init__.py,sha256=pkd-UfzjDGp5UHuFKjw192vZnigpTP9ftXzG3oLdiS8,1619
 IPython/core/magics/ast_mod.py,sha256=06OoRO7Z7Jzfc-cflf8Z3wyqF17fkYv6fJ_Nw4d7eQE,10295
 IPython/core/magics/auto.py,sha256=yEouIjsQ6LmfSEfNvkZbNmNDFl19KLRnaJciYdR7a1A,4816
 IPython/core/magics/basic.py,sha256=hvqMBRbn4rwvjDhjuZkZotMV__oSRpmKc08zQy81QhM,22356
-IPython/core/magics/code.py,sha256=iPjF0eW3A2VkQj2bOLA6qgptDpYsGpnnQ14U-jxPGrU,28144
+IPython/core/magics/code.py,sha256=h_dho9niPvtf_IpoOZf5GAD6CYbT0EQGsfLfutyX-7I,28144
 IPython/core/magics/config.py,sha256=QBL5uY7m-Q7C46mO3q1Yio9s73w1TnI9y__j5E-j44Y,4881
 IPython/core/magics/display.py,sha256=STRq66GlZwcvFyBxbkqslclpP_s9LnqD0ew9Z3S4-Jo,3130
 IPython/core/magics/execution.py,sha256=KHggud3yvtJ-w7PX7qXRF7Y9IsBqS8sZmzgzdmoP1YI,61879
@@ -71,6 +71,9 @@ IPython/core/profile/README_STARTUP,sha256=Y47GtYQkWy6pdzkqylUNL6eBSZMUIRGwTxXPU
 IPython/extensions/__init__.py,sha256=V4vSllFd18CVUvDTbXLYqfwTFmPXUiQZGCs5LX2IliE,78
 IPython/extensions/autoreload.py,sha256=_qU6PNtAm93J2UqtD3TMA68rj9wUWJPXfqb_VidrOCM,24571
 IPython/extensions/storemagic.py,sha256=ths8PLtGmYZAYaibRuS1QetLm1Xu1soyGwehBjayByg,8168
+IPython/extensions/deduperreload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+IPython/extensions/deduperreload/deduperreload.py,sha256=jh4sa6b9w2zO4PQRUtPwAFtVUlSJwPKRAQg4q_csh9s,24680
+IPython/extensions/deduperreload/deduperreload_patching.py,sha256=xOaws3UV5KmaAK8yZ3qtQO45w_5Ntkt_qZTcZ1psszY,4934
 IPython/external/__init__.py,sha256=-EQHbuUnBe1RS1_CwaLGzNSZQsCJsrxHW_r15smvVW0,126
 IPython/external/pickleshare.py,sha256=Zs0Hq8IXbf51RNFCr1AFxZKtlhfPJMM3b1WD4sNB670,9974
 IPython/external/qt_for_kernel.py,sha256=ROLfN-NcA_h-ZgZsm9pBW1y57I_gxnJmOdpRwvpw8DA,3442
@@ -93,11 +96,11 @@ IPython/sphinxext/ipython_directive.py,sha256=hOQCdWx2N7WzBJVHMw7qVvAwLJxBZJxFCE
 IPython/terminal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 IPython/terminal/debugger.py,sha256=0LdBmCKVHKNGpmBKdb4bBgKlyuTVyfz2Dg2Y8wE4FTM,6937
 IPython/terminal/embed.py,sha256=9PnL6nL6mOklg77Zrn6bqw9TUswjH2d7VNRtcuAi0FI,16122
-IPython/terminal/interactiveshell.py,sha256=Tqvby5MaqG2HYY829UCYHHHv5r5jomeKMoxEaaei09Y,39684
+IPython/terminal/interactiveshell.py,sha256=yd-33C6tvN0Oc-_ftLbhPMmq6HufyNUo7fygO753p5k,39931
 IPython/terminal/ipapp.py,sha256=d2Rog4DRkVv0_fReqZOuorKMXAtEqsCskwPejtjj0Lg,12512
 IPython/terminal/magics.py,sha256=49ZVJzbAUkG_EFpebxIBEqm3tEClvqefoeM6QnxGrrk,7705
 IPython/terminal/prompts.py,sha256=5IoXb-pXA4MWu3gAfEuyIwZUbDg6mxxJuMkOqRBmYa0,4555
-IPython/terminal/ptutils.py,sha256=oyQrcrctdHIyaNsKgiHYd6IeigSrYna9P8AGv9psw2Q,8014
+IPython/terminal/ptutils.py,sha256=6PWDVPuBzpMxLdl_jqK7QtdnYVoVIjUP4Vl1JpFZFoM,8067
 IPython/terminal/pt_inputhooks/__init__.py,sha256=jB7MOn9ZtC5qcq9RnCu9kbxjysP5YrN9KbXeYIx79Q4,3606
 IPython/terminal/pt_inputhooks/asyncio.py,sha256=ffxVjt0RIsh0yYzcPDpSTrhWv5JDNRBTof0OlJgksFU,1271
 IPython/terminal/pt_inputhooks/glut.py,sha256=CchyzpkfAqVytLzuKv_XWsU4rmAJXCgxBksACM2bk2s,4999
@@ -106,10 +109,10 @@ IPython/terminal/pt_inputhooks/gtk3.py,sha256=_MuZIjZuLsW2i4vvUjNQh9u4xIU8kcITyJ
 IPython/terminal/pt_inputhooks/gtk4.py,sha256=r_MxCT7a0nTHZtqyuZpPgCW2Cl7iuomC0PjgFteSL9c,557
 IPython/terminal/pt_inputhooks/osx.py,sha256=TnndyR_SPbmWC_A--0ORB06rhH7IS2_7kjphfPcRqXo,4448
 IPython/terminal/pt_inputhooks/pyglet.py,sha256=wDDQDgilvK9uzwGB3XyAqcf8LfKr-Lc_NMAzunZMu_Y,2371
-IPython/terminal/pt_inputhooks/qt.py,sha256=mdPInyP_AXl3OiKsuCnwaaPHCQuBcny7YiULMqB5wyo,3451
+IPython/terminal/pt_inputhooks/qt.py,sha256=ivVQu3UzzfGGeuowh6lNeVtuOJOL7g_VTKcgMG8JHpM,3479
 IPython/terminal/pt_inputhooks/tk.py,sha256=FjejvtwbvpeBZLoBCci1RDo_jWD5qElMy7PP-atd8j4,3651
 IPython/terminal/pt_inputhooks/wx.py,sha256=9yI52lDSZ3O_5Gww_3IeenEk_3PepLIME3Onh4X3kW0,7126
-IPython/terminal/shortcuts/__init__.py,sha256=QlXJBs_B6Sb_rla9-m2Mtn5b69LjUPGXFBI9On8cmDY,18532
+IPython/terminal/shortcuts/__init__.py,sha256=irSX9mwHzeLDQ95fXRGdZxduRknwATtESvm2NIov7KU,18563
 IPython/terminal/shortcuts/auto_match.py,sha256=9uT1fDb-c4Ew7TSIs_zET1jSxDlbfWGluxfW_pj39tk,3066
 IPython/terminal/shortcuts/auto_suggest.py,sha256=dJGZGymi8xEmCurPYsqYeWHMP5kfqcnCcezDdBlv9wk,23177
 IPython/terminal/shortcuts/filters.py,sha256=MgRTQWq8YfIyWvMASuQ9BGKq5RQwiEY5trSyMnMtJAo,10998
@@ -131,7 +134,7 @@ IPython/testing/plugin/test_example.txt,sha256=CGM8aZIYHlePDdAnR1yX3MfDGu0OceZpU
 IPython/testing/plugin/test_exampleip.txt,sha256=5gLcj8iCk-WCOGz0ObpQpuZMhGwS1jUMyH3mouGxQJI,814
 IPython/testing/plugin/test_ipdoctest.py,sha256=Lc3qQdZ3amXf9EKA7JlXf30b3BzP8RwdNS9-SMRe2P0,1907
 IPython/testing/plugin/test_refs.py,sha256=y-Y2Q8niRIbaanbwpIzvEwwaHkJfAq10HYfb4bAXHBc,715
-IPython/utils/PyColorize.py,sha256=kdxL1H7O3xKF7VUt22Sqr_GllCpemZ8458ekNCksiX0,15230
+IPython/utils/PyColorize.py,sha256=VyNAE6pgw8sCrS2-1v4p30TZIHe6SFz_0YqLUdsOc4k,15553
 IPython/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 IPython/utils/_process_cli.py,sha256=tJWYMEgNYgeMx9v-n3YLbKW0tPbFtpczfDH28RC3n4A,2020
 IPython/utils/_process_common.py,sha256=hMFRGOJh-n-uBcSAOnr2qetQXAthMVpS8mwRcZuQqlo,7306
@@ -139,8 +142,9 @@ IPython/utils/_process_emscripten.py,sha256=lGLQb2IgmanNtb502KflfuKIhgOF119Ji3cw
 IPython/utils/_process_posix.py,sha256=aOEtguhS3vdWngBpws1XQURO8Ozqd5gRiCk9VLky6tA,7502
 IPython/utils/_process_win32.py,sha256=Pcf6ZiqMbqDT79edzegE_AX3D367UtE8bbhT41no54A,6775
 IPython/utils/_process_win32_controller.py,sha256=hi2eR7mLbl3TTMCVbgps85GppxdtYbhOYK_l13WvYaM,21343
-IPython/utils/_sysinfo.py,sha256=lRLokemEP_hVMNVbW8zAXf6B8ZCegFZl7rwfHJs5o1U,45
+IPython/utils/_sysinfo.py,sha256=k_tFtBwenx5P8zcV-6FTx5UbGvbQ9A6h5D7WevWmHoI,45
 IPython/utils/capture.py,sha256=h5yL5Lxq8bgO1SFpoNDYjEi6mh1IW_2X9CE7vOsUxE4,5137
+IPython/utils/coloransi.py,sha256=CML-SkzLa7oaIK1qypb3uwcfPXDeKHxZQiMJ0IWvUY0,293
 IPython/utils/contexts.py,sha256=w5_uXc0WTU3KKV1kcCW9A0_Mz5mGRoeGWMq_P_eo-Dg,1610
 IPython/utils/data.py,sha256=36VVGY1b0JG7_zSdbVSy8IzLqM0uT-uB12TBYWgd1lI,1015
 IPython/utils/decorators.py,sha256=qsYLskFlT2bB_Q-87ttBA56lAf-knWLOe5WiOwPdXFE,2680
@@ -170,11 +174,11 @@ IPython/utils/text.py,sha256=6s-y4KvDmnJxLs0urf5D-1auZGSnj2xmXgQ-9jVu0N8,18788
 IPython/utils/timing.py,sha256=nND-ZUBkHWfYevvbRG-YfOSIFczz_epzMqWK5PH6nqA,4275
 IPython/utils/tokenutil.py,sha256=x6KQ6ZCGOY7j5GQcr7byJRZSBFgyBcfkTiLtjxkl9f8,6552
 IPython/utils/wildcard.py,sha256=6EEc3OEYp-IuSoidL6nwpaHg--GxnzbAJTmFiz77CNE,4612
-ipython-9.0.0b2.data/data/share/man/man1/ipython.1,sha256=PVdQP2hHmHyUEwzLOPcgavnCe9jTDVrM1jKZt4cnF_Q,2058
-ipython-9.0.0b2.dist-info/COPYING.rst,sha256=NBr8vXKYh7cEb-e5j8T07f867Y048G7v2bMGcPBD3xc,1639
-ipython-9.0.0b2.dist-info/LICENSE,sha256=4OOQdI7UQKuJPKHxNaiKkgqvVAnbuQpbQnx1xeUSaPs,1720
-ipython-9.0.0b2.dist-info/METADATA,sha256=RfZOkmtXPv5oBzosTeWtFtms_bj5UV-5XVGfw369YU8,4256
-ipython-9.0.0b2.dist-info/WHEEL,sha256=OD3CZ31UWfp_hGz-1fPUpTR7Tv5ndR05pV1l1CfXGfg,92
-ipython-9.0.0b2.dist-info/entry_points.txt,sha256=z5BEEohWgg0SHdgdeNABf4T3fu-lr9W6F_bWOQHLdVs,83
-ipython-9.0.0b2.dist-info/top_level.txt,sha256=PKjvHtNCBZ9EHTmd2mwJ1J_k3j0F6D1lTFzIcJFFPEU,8
-ipython-9.0.0b2.dist-info/RECORD,,
+ipython-9.0.2.data/data/share/man/man1/ipython.1,sha256=PVdQP2hHmHyUEwzLOPcgavnCe9jTDVrM1jKZt4cnF_Q,2058
+ipython-9.0.2.dist-info/COPYING.rst,sha256=NBr8vXKYh7cEb-e5j8T07f867Y048G7v2bMGcPBD3xc,1639
+ipython-9.0.2.dist-info/LICENSE,sha256=4OOQdI7UQKuJPKHxNaiKkgqvVAnbuQpbQnx1xeUSaPs,1720
+ipython-9.0.2.dist-info/METADATA,sha256=7S5uSfcEcaNZ9JJsCMTJ_lBitQ-QnvsIZjPLk6DZc6Q,4254
+ipython-9.0.2.dist-info/WHEEL,sha256=RnOlZk4WRTvz4xhLM2LyBNUiU6tTosLZam4r642KGVM,90
+ipython-9.0.2.dist-info/entry_points.txt,sha256=z5BEEohWgg0SHdgdeNABf4T3fu-lr9W6F_bWOQHLdVs,83
+ipython-9.0.2.dist-info/top_level.txt,sha256=PKjvHtNCBZ9EHTmd2mwJ1J_k3j0F6D1lTFzIcJFFPEU,8
+ipython-9.0.2.dist-info/RECORD,,

{ipython-9.0.0b2.dist-info → ipython-9.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (9.0.0b2)
+Generator: setuptools (9.0.2)
 Root-Is-Purelib: true
 Tag: py3-none-any