ipython 9.3.0__py3-none-any.whl → 9.4.0__py3-none-any.whl

IPython/core/debugger.py

@@ -133,6 +133,7 @@ from contextlib import contextmanager
 from functools import lru_cache
 
 from IPython import get_ipython
+from IPython.core.debugger_backport import PdbClosureBackport
 from IPython.utils import PyColorize
 from IPython.utils.PyColorize import TokenStream
 
@@ -140,9 +141,18 @@ from typing import TYPE_CHECKING
 from types import FrameType
 
 # We have to check this directly from sys.argv, config struct not yet available
-from pdb import Pdb as OldPdb
+from pdb import Pdb as _OldPdb
 from pygments.token import Token
 
+
+if sys.version_info < (3, 13):
+
+    class OldPdb(PdbClosureBackport, _OldPdb):
+        pass
+
+else:
+    OldPdb = _OldPdb
+
 if TYPE_CHECKING:
     # otherwise circular import
     from IPython.core.interactiveshell import InteractiveShell

IPython/core/debugger_backport.py

@@ -0,0 +1,206 @@
+"""
+The code in this module is a backport of cPython changes in Pdb
+that were introduced in Python 3.13 by gh-83151: Make closure work on pdb
+https://github.com/python/cpython/pull/111094.
+This file should be removed once IPython drops supports for Python 3.12.
+
+The only changes are:
+- reformatting by darker (black) formatter
+- addition of type-ignore comments to satisfy mypy
+
+Copyright (c) 2001 Python Software Foundation; All Rights Reserved
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001 Python Software Foundation; All Rights Reserved"
+are retained in Python alone or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+"""
+
+import sys
+import types
+import codeop
+import textwrap
+from types import CodeType
+
+
+class PdbClosureBackport:
+    def _exec_in_closure(self, source, globals, locals):  # type: ignore[no-untyped-def]
+        """Run source code in closure so code object created within source
+        can find variables in locals correctly
+        returns True if the source is executed, False otherwise
+        """
+
+        # Determine if the source should be executed in closure. Only when the
+        # source compiled to multiple code objects, we should use this feature.
+        # Otherwise, we can just raise an exception and normal exec will be used.
+
+        code = compile(source, "<string>", "exec")
+        if not any(isinstance(const, CodeType) for const in code.co_consts):
+            return False
+
+        # locals could be a proxy which does not support pop
+        # copy it first to avoid modifying the original locals
+        locals_copy = dict(locals)
+
+        locals_copy["__pdb_eval__"] = {"result": None, "write_back": {}}
+
+        # If the source is an expression, we need to print its value
+        try:
+            compile(source, "<string>", "eval")
+        except SyntaxError:
+            pass
+        else:
+            source = "__pdb_eval__['result'] = " + source
+
+        # Add write-back to update the locals
+        source = (
+            "try:\n"
+            + textwrap.indent(source, "  ")
+            + "\n"
+            + "finally:\n"
+            + "  __pdb_eval__['write_back'] = locals()"
+        )
+
+        # Build a closure source code with freevars from locals like:
+        # def __pdb_outer():
+        #   var = None
+        #   def __pdb_scope():  # This is the code object we want to execute
+        #     nonlocal var
+        #     <source>
+        #   return __pdb_scope.__code__
+        source_with_closure = (
+            "def __pdb_outer():\n"
+            + "\n".join(f"  {var} = None" for var in locals_copy)
+            + "\n"
+            + "  def __pdb_scope():\n"
+            + "\n".join(f"    nonlocal {var}" for var in locals_copy)
+            + "\n"
+            + textwrap.indent(source, "    ")
+            + "\n"
+            + "  return __pdb_scope.__code__"
+        )
+
+        # Get the code object of __pdb_scope()
+        # The exec fills locals_copy with the __pdb_outer() function and we can call
+        # that to get the code object of __pdb_scope()
+        ns = {}
+        try:
+            exec(source_with_closure, {}, ns)
+        except Exception:
+            return False
+        code = ns["__pdb_outer"]()
+
+        cells = tuple(types.CellType(locals_copy.get(var)) for var in code.co_freevars)
+
+        try:
+            exec(code, globals, locals_copy, closure=cells)
+        except Exception:
+            return False
+
+        # get the data we need from the statement
+        pdb_eval = locals_copy["__pdb_eval__"]
+
+        # __pdb_eval__ should not be updated back to locals
+        pdb_eval["write_back"].pop("__pdb_eval__")
+
+        # Write all local variables back to locals
+        locals.update(pdb_eval["write_back"])
+        eval_result = pdb_eval["result"]
+        if eval_result is not None:
+            print(repr(eval_result))
+
+        return True
+
+    def default(self, line):  # type: ignore[no-untyped-def]
+        if line[:1] == "!":
+            line = line[1:].strip()
+        locals = self.curframe_locals
+        globals = self.curframe.f_globals
+        try:
+            buffer = line
+            if (
+                code := codeop.compile_command(line + "\n", "<stdin>", "single")
+            ) is None:
+                # Multi-line mode
+                with self._disable_command_completion():
+                    buffer = line
+                    continue_prompt = "...   "
+                    while (
+                        code := codeop.compile_command(buffer, "<stdin>", "single")
+                    ) is None:
+                        if self.use_rawinput:
+                            try:
+                                line = input(continue_prompt)
+                            except (EOFError, KeyboardInterrupt):
+                                self.lastcmd = ""
+                                print("\n")
+                                return
+                        else:
+                            self.stdout.write(continue_prompt)
+                            self.stdout.flush()
+                            line = self.stdin.readline()
+                            if not len(line):
+                                self.lastcmd = ""
+                                self.stdout.write("\n")
+                                self.stdout.flush()
+                                return
+                            else:
+                                line = line.rstrip("\r\n")
+                        buffer += "\n" + line
+            save_stdout = sys.stdout
+            save_stdin = sys.stdin
+            save_displayhook = sys.displayhook
+            try:
+                sys.stdin = self.stdin
+                sys.stdout = self.stdout
+                sys.displayhook = self.displayhook
+                if not self._exec_in_closure(buffer, globals, locals):
+                    exec(code, globals, locals)
+            finally:
+                sys.stdout = save_stdout
+                sys.stdin = save_stdin
+                sys.displayhook = save_displayhook
+        except:
+            self._error_exc()

IPython/core/interactiveshell.py

@@ -252,13 +252,23 @@ class ExecutionInfo:
     Stores information about what is going to happen.
     """
     raw_cell = None
+    transformed_cell = None
     store_history = False
     silent = False
     shell_futures = True
     cell_id = None
 
-    def __init__(self, raw_cell, store_history, silent, shell_futures, cell_id):
+    def __init__(
+        self,
+        raw_cell,
+        store_history,
+        silent,
+        shell_futures,
+        cell_id,
+        transformed_cell=None,
+    ):
         self.raw_cell = raw_cell
+        self.transformed_cell = transformed_cell
         self.store_history = store_history
         self.silent = silent
         self.shell_futures = shell_futures
@@ -269,12 +279,18 @@ class ExecutionInfo:
         raw_cell = (
             (self.raw_cell[:50] + "..") if len(self.raw_cell) > 50 else self.raw_cell
         )
+        transformed_cell = (
+            (self.transformed_cell[:50] + "..")
+            if self.transformed_cell and len(self.transformed_cell) > 50
+            else self.transformed_cell
+        )
         return (
-            '<%s object at %x, raw_cell="%s" store_history=%s silent=%s shell_futures=%s cell_id=%s>'
+            '<%s object at %x, raw_cell="%s" transformed_cell="%s" store_history=%s silent=%s shell_futures=%s cell_id=%s>'
             % (
                 name,
                 id(self),
                 raw_cell,
+                transformed_cell,
                 self.store_history,
                 self.silent,
                 self.shell_futures,
@@ -3156,14 +3172,18 @@ class InteractiveShell(SingletonConfigurable):
         except BaseException as e:
             try:
                 info = ExecutionInfo(
-                    raw_cell, store_history, silent, shell_futures, cell_id
+                    raw_cell,
+                    store_history,
+                    silent,
+                    shell_futures,
+                    cell_id,
+                    transformed_cell=transformed_cell,
                 )
                 result = ExecutionResult(info)
                 result.error_in_exec = e
                 self.showtraceback(running_compiled_code=True)
             except:
                 pass
-
         return result
 
     def should_run_async(
@@ -3248,7 +3268,14 @@ class InteractiveShell(SingletonConfigurable):
 
         .. versionadded:: 7.0
         """
-        info = ExecutionInfo(raw_cell, store_history, silent, shell_futures, cell_id)
+        info = ExecutionInfo(
+            raw_cell,
+            store_history,
+            silent,
+            shell_futures,
+            cell_id,
+            transformed_cell=transformed_cell,
+        )
         result = ExecutionResult(info)
 
         if (not raw_cell) or raw_cell.isspace():

IPython/core/magics/execution.py

@@ -20,6 +20,7 @@ import shlex
 import sys
 import time
 import timeit
+import signal
 from typing import Dict, Any
 from ast import (
     Assign,
@@ -1257,8 +1258,15 @@ class ExecutionMagics(Magics):
         if return_result:
             return timeit_result
 
-    @skip_doctest
     @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",
+    )
+    @skip_doctest
     @needs_local_scope
     @line_cell_magic
     @output_can_be_silenced
@@ -1329,9 +1337,34 @@ class ExecutionMagics(Magics):
                 Wall time: 0.00 s
                 Compiler : 0.78 s
         """
-        # fail immediately if the given expression can't be compiled
+        line_present = False
+        # Try to parse --no-raise-error if present, else ignore unrecognized args
+        try:
+            args = magic_arguments.parse_argstring(self.time, line)
+        except UsageError as e:
+            # Only ignore UsageError if caused by unrecognized arguments
+            # We'll manually check for --no-raise-error and remove it from line
+            line_present = True
+
+            # Check if --no-raise-error is present
+            no_raise_error = "--no-raise-error" in line
+
+            if no_raise_error:
+                # Remove --no-raise-error while preserving the rest of the line structure
+                line = re.sub(r"\s*--no-raise-error\s*", " ", line).strip()
+                # Clean up any double spaces
+                line = re.sub(r"\s+", " ", line)
+
+            class Args:
+                def __init__(self, no_raise_error):
+                    self.no_raise_error = no_raise_error
+
+            args = Args(no_raise_error)
+        else:
+            if not hasattr(args, "no_raise_error"):
+                args.no_raise_error = False
 
-        if line and cell:
+        if line_present and cell:
             raise UsageError("Can't use statement directly after '%%time'!")
 
         if cell:
@@ -1376,13 +1409,24 @@ class ExecutionMagics(Magics):
         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 Exception:
-                self.shell.showtraceback()
-                return
+            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()
@@ -1393,11 +1437,16 @@ class ExecutionMagics(Magics):
                 if expr_val is not None:
                     code_2 = self.shell.compile(expr_val, source, 'eval')
                     out = eval(code_2, glob, local_ns)
-            except Exception:
-                self.shell.showtraceback()
-                return
+            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
@@ -1416,6 +1465,10 @@ class ExecutionMagics(Magics):
             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
@@ -1514,7 +1567,7 @@ class ExecutionMagics(Magics):
         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.

IPython/core/magics/namespace.py

@@ -361,6 +361,9 @@ class NamespaceMagics(Magics):
           - For numpy arrays, a summary with shape, number of
             elements, typecode and size in memory.
 
+          - For objects that have shape attribute, primarily dataframe and series like
+            objects, will print the shape.
+
           - Everything else: a string representation, snipping their middle if
             too long.
 
@@ -372,11 +375,17 @@ class NamespaceMagics(Magics):
 
           In [2]: beta = 'test'
 
-          In [3]: %whos
+          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)
@@ -441,9 +450,7 @@ class NamespaceMagics(Magics):
         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:
+            if vtype == ndarray_type:
                 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
                 if vtype==ndarray_type:
                     # numpy
@@ -458,7 +465,14 @@ class NamespaceMagics(Magics):
                     if vbytes < Mb:
                         print('(%s kb)' % (vbytes/kb,))
                     else:
-                        print('(%s Mb)' % (vbytes/Mb,))
+                        print("(%s Mb)" % (vbytes / Mb,))
+            elif hasattr(var, "shape"):
+                # Useful for DataFrames and Series
+                # Ought to work for both pandas and polars
+                print(f"Shape: {var.shape}")
+            elif hasattr(var, "__len__"):
+                ## types that can be used in len function
+                print(var if isinstance(var, str) else f"n={len(var)}")
             else:
                 try:
                     vstr = str(var)

IPython/core/magics/script.py

@@ -11,6 +11,7 @@ import os
 import signal
 import sys
 import time
+from codecs import getincrementaldecoder
 from subprocess import CalledProcessError
 from threading import Thread
 
@@ -227,15 +228,21 @@ class ScriptMagics(Magics):
                 return await stream.read(e.consumed)
 
         async def _handle_stream(stream, stream_arg, file_object):
+            should_break = False
+            decoder = getincrementaldecoder("utf-8")(errors="replace")
             while True:
-                chunk = (await _readchunk(stream)).decode("utf8", errors="replace")
+                chunk = decoder.decode(await _readchunk(stream))
                 if not chunk:
                     break
+                    chunk = decoder.decode("", final=True)
+                    should_break = True
                 if stream_arg:
                     self.shell.user_ns[stream_arg] = chunk
                 else:
                     file_object.write(chunk)
                     file_object.flush()
+                if should_break:
+                    break
 
         async def _stream_communicate(process, cell):
             process.stdin.write(cell)

IPython/core/release.py

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

IPython/extensions/autoreload.py

@@ -73,6 +73,30 @@ The following magic commands are provided:
 
     Mark module 'foo' to not be autoreloaded.
 
+Import Conflict Resolution
+==========================
+
+In ``%autoreload 3`` mode, the extension tracks ``from X import Y`` style imports
+and intelligently resolves conflicts when the same name is imported multiple ways.
+
+Import tracking occurs after successful code execution, ensuring that only valid
+imports are tracked. This approach handles edge cases such as:
+
+- Importing a name that doesn't initially exist in a module, then adding that name
+  to the module and importing it again
+- Conflicts between aliased imports (``from X import Y as Z``) and direct imports
+  (``from X import Z``)
+
+When conflicts occur:
+
+- If you first do ``from X import Y as Z`` then later ``from X import Z``,
+  the extension will switch to reloading ``Z`` instead of ``Y`` under the name ``Z``.
+
+- Similarly, if you first do ``from X import Z`` then later ``from X import Y as Z``,
+  the extension will switch to reloading ``Y`` as ``Z`` instead of the original ``Z``.
+
+- The most recent successful import always takes precedence in conflict resolution.
+
 Caveats
 =======
 
@@ -127,6 +151,7 @@ __skip_doctest__ = True
 # Imports
 # -----------------------------------------------------------------------------
 
+import ast
 import os
 import sys
 import traceback
@@ -171,6 +196,9 @@ class ModuleReloader:
         # Deduper reloader
         self.deduper_reloader = DeduperReloader()
 
+        # Persistent import tracker for from-imports
+        self.import_from_tracker = ImportFromTracker({}, {})
+
         # Cache module modification times
         self.check(check_all=True, do_reload=False)
 
@@ -193,6 +221,10 @@ class ModuleReloader:
             pass
         self.modules[module_name] = True
 
+    def clear_import_tracker(self):
+        """Clear the persistent import tracker state"""
+        self.import_from_tracker = ImportFromTracker({}, {})
+
     def aimport_module(self, module_name):
         """Import a module, and mark it reloadable
 
@@ -237,7 +269,7 @@ class ModuleReloader:
 
         return py_filename, pymtime
 
-    def check(self, check_all=False, do_reload=True):
+    def check(self, check_all=False, do_reload=True, execution_info=None):
         """Check whether some modules need to be reloaded."""
 
         if not self.enabled and not check_all:
@@ -248,6 +280,10 @@ class ModuleReloader:
         else:
             modules = list(self.modules.keys())
 
+        # Use the persistent import_from_tracker
+        import_from_tracker = (
+            self.import_from_tracker if self.import_from_tracker.imports_froms else None
+        )
         for modname in modules:
             m = sys.modules.get(modname, None)
 
@@ -275,7 +311,13 @@ class ModuleReloader:
                 self._report(f"Reloading '{modname}'.")
                 try:
                     if self.autoload_obj:
-                        superreload(m, reload, self.old_objects, self.shell)
+                        superreload(
+                            m,
+                            reload,
+                            self.old_objects,
+                            self.shell,
+                            import_from_tracker=import_from_tracker,
+                        )
                     # if not using autoload, check if deduperreload is viable for this module
                     elif self.deduper_reloader.maybe_reload_module(m):
                         pass
@@ -427,6 +469,59 @@ mod_attrs = [
 ]
 
 
+class ImportFromTracker:
+    def __init__(self, imports_froms: dict, symbol_map: dict):
+        self.imports_froms = imports_froms
+        # symbol_map maps original_name -> list of resolved_names
+        self.symbol_map = {}
+        if symbol_map:
+            for module_name, mappings in symbol_map.items():
+                self.symbol_map[module_name] = {}
+                for original_name, resolved_names in mappings.items():
+                    if isinstance(resolved_names, list):
+                        self.symbol_map[module_name][original_name] = resolved_names[:]
+                    else:
+                        self.symbol_map[module_name][original_name] = [resolved_names]
+        else:
+            self.symbol_map = symbol_map or {}
+
+    def add_import(
+        self, module_name: str, original_name: str, resolved_name: str
+    ) -> None:
+        """Add an import, handling conflicts with existing imports.
+
+        This method is called after successful code execution, so we know the import is valid.
+        """
+        if module_name not in self.imports_froms:
+            self.imports_froms[module_name] = []
+        if module_name not in self.symbol_map:
+            self.symbol_map[module_name] = {}
+
+        # Check if there's already a different mapping for the same resolved_name from a different original_name
+        # We need to remove any conflicting mappings
+        for orig_name, res_names in list(self.symbol_map[module_name].items()):
+            if resolved_name in res_names and orig_name != original_name:
+                # Remove the conflicting resolved_name from the other original_name's list
+                res_names.remove(resolved_name)
+                if (
+                    not res_names
+                ):  # If the list is now empty, remove the original_name entirely
+                    if orig_name in self.imports_froms[module_name]:
+                        self.imports_froms[module_name].remove(orig_name)
+                    del self.symbol_map[module_name][orig_name]
+
+        # Add the new mapping
+        if original_name not in self.imports_froms[module_name]:
+            self.imports_froms[module_name].append(original_name)
+
+        if original_name not in self.symbol_map[module_name]:
+            self.symbol_map[module_name][original_name] = []
+
+        # Add the resolved_name if it's not already in the list
+        if resolved_name not in self.symbol_map[module_name][original_name]:
+            self.symbol_map[module_name][original_name].append(resolved_name)
+
+
 def append_obj(module, d, name, obj, autoload=False):
     in_module = hasattr(obj, "__module__") and obj.__module__ == module.__name__
     if autoload:
@@ -445,7 +540,9 @@ def append_obj(module, d, name, obj, autoload=False):
     return True
 
 
-def superreload(module, reload=reload, old_objects=None, shell=None):
+def superreload(
+    module, reload=reload, old_objects=None, shell=None, import_from_tracker=None
+):
     """Enhanced version of the builtin reload function.
 
     superreload remembers objects previously in the module, and
@@ -486,18 +583,34 @@ def superreload(module, reload=reload, old_objects=None, shell=None):
         module.__dict__.update(old_dict)
         raise
 
-    # iterate over all objects and update functions & classes
     for name, new_obj in list(module.__dict__.items()):
         key = (module.__name__, name)
         if key not in old_objects:
             # here 'shell' acts both as a flag and as an output var
+            imports_froms = (
+                import_from_tracker.imports_froms if import_from_tracker else None
+            )
+            symbol_map = import_from_tracker.symbol_map if import_from_tracker else None
             if (
                 shell is None
                 or name == "Enum"
                 or not append_obj(module, old_objects, name, new_obj, True)
+                or (
+                    imports_froms
+                    and module.__name__ in imports_froms
+                    and "*" not in imports_froms[module.__name__]
+                    and name not in imports_froms[module.__name__]
+                )
             ):
                 continue
-            shell.user_ns[name] = new_obj
+
+            # Handle symbol mapping - now supporting multiple resolved names per original name
+            if symbol_map and name in symbol_map.get(module.__name__, {}):
+                resolved_names = symbol_map.get(module.__name__, {})[name]
+                for resolved_name in resolved_names:
+                    shell.user_ns[resolved_name] = new_obj
+            else:
+                shell.user_ns[name] = new_obj
 
         new_refs = []
         for old_ref in old_objects[key]:
@@ -727,6 +840,9 @@ class AutoreloadMagics(Magics):
                     self.shell.push({top_name: top_module})
 
     def pre_run_cell(self, info):
+        # Store the execution info for later use in post_execute_hook
+        self._last_execution_info = info
+
         if self._reloader.enabled:
             try:
                 self._reloader.check()
@@ -734,7 +850,20 @@ class AutoreloadMagics(Magics):
                 pass
 
     def post_execute_hook(self):
-        """Cache the modification times of any modules imported in this execution"""
+        """Cache the modification times of any modules imported in this execution and track imports"""
+
+        # Track imports from the recently executed code if autoreload 3 is enabled
+        if self._reloader.enabled and self._reloader.autoload_obj:
+            # Use the stored execution info
+            if (
+                hasattr(self, "_last_execution_info")
+                and self._last_execution_info
+                and self._last_execution_info.transformed_cell
+            ):
+                self._track_imports_from_code(
+                    self._last_execution_info.transformed_cell
+                )
+
         newly_loaded_modules = set(sys.modules) - self.loaded_modules
         for modname in newly_loaded_modules:
             _, pymtime = self._reloader.filename_and_mtime(sys.modules[modname])
@@ -743,6 +872,36 @@ class AutoreloadMagics(Magics):
 
         self.loaded_modules.update(newly_loaded_modules)
 
+    def _track_imports_from_code(self, code: str) -> None:
+        """Track import statements from executed code"""
+        try:
+            tree = ast.parse(code)
+
+            for node in ast.walk(tree):
+                # Handle "from X import Y" style imports
+                if isinstance(node, ast.ImportFrom):
+                    mod = node.module
+
+                    # Skip relative imports that don't have a module name
+                    if mod is None:
+                        continue
+
+                    for name in node.names:
+                        # name.name is going to be actual name that we want to import from module
+                        # name.asname is Z in the case of from X import Y as Z
+                        # we should update Z in the shell in this situation, so track it too.
+                        original_name = name.name
+                        resolved_name = name.asname if name.asname else name.name
+
+                        # Since the code executed successfully, we know this import is valid
+                        self._reloader.import_from_tracker.add_import(
+                            mod, original_name, resolved_name
+                        )
+        except (SyntaxError, ValueError):
+            # If there's a syntax error, skip import tracking
+            # (though this shouldn't happen since the code already executed successfully)
+            pass
+
 
 def load_ipython_extension(ip):
     """Load the extension in IPython."""

IPython/extensions/deduperreload/deduperreload.py

@@ -432,16 +432,7 @@ class DeduperReloader(DeduperReloaderPatchingMixin):
                     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__
+                global_env = ns.__dict__
                 if not isinstance(global_env, dict):
                     global_env = dict(global_env)
                 exec(func_code, global_env, local_env)  # type: ignore[arg-type]

IPython/utils/_sysinfo.py

@@ -1,2 +1,2 @@
 # GENERATED BY setup.py
-commit = "e87cb2a40"
+commit = "67f7d8b8b"

{ipython-9.3.0.dist-info → ipython-9.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipython
-Version: 9.3.0
+Version: 9.4.0
 Summary: IPython: Productive Interactive Computing
 Author: The IPython Development Team
 Author-email: ipython-dev@python.org

{ipython-9.3.0.dist-info → ipython-9.4.0.dist-info}/RECORD

@@ -13,7 +13,8 @@ IPython/core/compilerop.py,sha256=tA8xHh10gp85brI2OYmvl7kW0TgDghdKbzmZE7nS4sw,69
 IPython/core/completer.py,sha256=xczIOWv2i6fKjt2neeSLCeMvBMPIV-OQbE7ggBQB_PU,129815
 IPython/core/completerlib.py,sha256=C_1uFwR4eiqIsemMRbluMQV1WJ3qSfnGxO01PsGSpr8,12641
 IPython/core/crashhandler.py,sha256=8-kyI6aNkqbaB_lBlbNKAOFv34HDBCpLggMfiu4oIDg,8747
-IPython/core/debugger.py,sha256=I3LA4HQFEP5cy-kbbRvJqlLlSgVHSWBbp0cbPs3nU8M,41806
+IPython/core/debugger.py,sha256=ZVvFEIby6pBAd1Cv5MfZ8EX3lY3il-v2eT2Z4JwubD8,41991
+IPython/core/debugger_backport.py,sha256=qP96tVbfH7wpOFIjhuFyFVVM1zIgCGbP1AyQzOBfw28,8216
 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=r9AeMqllLicJvY8JfrGTQMkyxz37QT7X_RwwXxNk7R0,2185
@@ -30,7 +31,7 @@ IPython/core/history.py,sha256=5hmGOe1H93tCtWj_d8HdFixDCr0kdEqahGJ-zUo03RQ,41183
 IPython/core/historyapp.py,sha256=5H38INsWXRacscKz_5PQHYrEnHEayDtc1D1qcSyHRBU,5847
 IPython/core/hooks.py,sha256=xBWTZqycxZi97yj01IFc-SoJBzV5B73IoDHbAAlKUpQ,5193
 IPython/core/inputtransformer2.py,sha256=7sRleytrcAbp5PZMOrDw59MjUAGXg5BbaRbPkSW83-I,28909
-IPython/core/interactiveshell.py,sha256=nFDmQXdbYO85nExVC_OhCwyvu1mtImI7RNsWxSNo7dw,159075
+IPython/core/interactiveshell.py,sha256=LYa9QAz74ljvILU-UIymV-VsXZBczrDegSftUZ24-pM,159746
 IPython/core/latex_symbols.py,sha256=DzFecvqWVSsdN7vWAsp0mlYAHRDQKfZGAmvuDUh0M-s,30127
 IPython/core/logger.py,sha256=Iwe4xKMmxEdvSwHYPMfsTWkmdaqVCgvZT3R3I3qTmrU,8436
 IPython/core/macro.py,sha256=OhvXWNhLe393rI2wTpMgbUVHWSnmC_ycHiYqzqSHXZU,1726
@@ -44,7 +45,7 @@ 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=7T2aiCX5S_TTkk9TYSdLgJR90mt0IAtGO8eUJ6DNNNE,1505
+IPython/core/release.py,sha256=ecwU1SOd6rB87PaUvxEoHsxQCLFEAtebo2_pvVgvA0A,1505
 IPython/core/shellapp.py,sha256=oZIzj_sqIXrN3qyyhinZ1gLXvFviKYHkmS4H3wVEb74,19307
 IPython/core/splitinput.py,sha256=bAX1puQjvYB-otJyqiqeOhWj6dooWuQeNVx2YdaKQs8,5006
 IPython/core/tbtools.py,sha256=X4iB5zKAT2y4TK1R9l3d3kiW5htrzKn3qxalFFe2xzI,16880
@@ -58,21 +59,21 @@ IPython/core/magics/basic.py,sha256=uFkd-gTzlSVkNDSu8Rg4fbS_IK2raEhx1SYA6kWZ4hg,
 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=4DAQBezVAwtKiHaCvX14cKsfzhJF2xh8IFKRkC4XrUo,62408
+IPython/core/magics/execution.py,sha256=YKsyU9cUxAyAquyWVzw5iNH7h-OY-UYHRm4eJoz5XKI,64512
 IPython/core/magics/extension.py,sha256=Jj6OlkM71PS0j1HfEMDc-jU2Exwo9Ff_K0nD7e_W4N0,2477
 IPython/core/magics/history.py,sha256=Aw9gBzK4AJbe-gvRdMW7n-_zxxHuMyHvHJtRDuCwwug,12629
 IPython/core/magics/logging.py,sha256=VuDiF5QZrgzTT7Lr1NkkMCtUM1EHoGCw2pYlKsSQc4Q,6867
-IPython/core/magics/namespace.py,sha256=2jAK2L7_NH58Ibk_YnHoQI1IYIrto9SZTMfmps0e1mo,24825
+IPython/core/magics/namespace.py,sha256=uqWM77PbbpOYvQOYMqCwJJrnJwXVIw4abju9Q7cxas0,25446
 IPython/core/magics/osm.py,sha256=mNlHBS8ZEMf687nDpLGYKj6aC-i_r7d9iUTFKw6WtY4,30695
 IPython/core/magics/packaging.py,sha256=5m2pt1bkosMdiQxB46hDdD4KisfPJpNnebCqMnygodE,6030
 IPython/core/magics/pylab.py,sha256=BBRczZ0khoZB5NPipgvVtOWYpdkLatB9mQFYzyg-vpg,6624
-IPython/core/magics/script.py,sha256=o0kBs9SpbR0MLOmVMh5e3r7gTFuH5U4yKQ37yBadtaI,13286
+IPython/core/magics/script.py,sha256=zv-BwLsqAeVsgwCEnO3mr4HoSM6aFz6eaH_KPmM2uJM,13570
 IPython/core/profile/README_STARTUP,sha256=Y47GtYQkWy6pdzkqylUNL6eBSZMUIRGwTxXPUF_BBBc,371
 IPython/extensions/__init__.py,sha256=V4vSllFd18CVUvDTbXLYqfwTFmPXUiQZGCs5LX2IliE,78
-IPython/extensions/autoreload.py,sha256=_qU6PNtAm93J2UqtD3TMA68rj9wUWJPXfqb_VidrOCM,24571
+IPython/extensions/autoreload.py,sha256=XnNxSE8d4cxvBGyvz2YJwySRsIOZe6WXRT9TUPWBd88,31724
 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.py,sha256=5BWnzqfoScQ3a1RTN3wZpxKGXVU_Oxo7P4rQoJfRrI0,24134
 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
@@ -142,7 +143,7 @@ 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=08M3HsNfrqEo6YkNSl9dN69UHyrECgtABfkCQUrexqk,45
+IPython/utils/_sysinfo.py,sha256=dBl2xAoPkJnjAen7HGklkADaXbyQjQc9sk00mQOwoCA,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
@@ -174,11 +175,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.3.0.data/data/share/man/man1/ipython.1,sha256=PVdQP2hHmHyUEwzLOPcgavnCe9jTDVrM1jKZt4cnF_Q,2058
-ipython-9.3.0.dist-info/licenses/COPYING.rst,sha256=NBr8vXKYh7cEb-e5j8T07f867Y048G7v2bMGcPBD3xc,1639
-ipython-9.3.0.dist-info/licenses/LICENSE,sha256=4OOQdI7UQKuJPKHxNaiKkgqvVAnbuQpbQnx1xeUSaPs,1720
-ipython-9.3.0.dist-info/METADATA,sha256=PLMXmc_ptvho0DnNgFp4AFEqUxL3ikB9OaYqtJbgfzw,4431
-ipython-9.3.0.dist-info/WHEEL,sha256=aCYgKU6ypALRDRz4OvLmTVj8mlMrXZlQylkgDKtOmfQ,90
-ipython-9.3.0.dist-info/entry_points.txt,sha256=z5BEEohWgg0SHdgdeNABf4T3fu-lr9W6F_bWOQHLdVs,83
-ipython-9.3.0.dist-info/top_level.txt,sha256=PKjvHtNCBZ9EHTmd2mwJ1J_k3j0F6D1lTFzIcJFFPEU,8
-ipython-9.3.0.dist-info/RECORD,,
+ipython-9.4.0.data/data/share/man/man1/ipython.1,sha256=PVdQP2hHmHyUEwzLOPcgavnCe9jTDVrM1jKZt4cnF_Q,2058
+ipython-9.4.0.dist-info/licenses/COPYING.rst,sha256=NBr8vXKYh7cEb-e5j8T07f867Y048G7v2bMGcPBD3xc,1639
+ipython-9.4.0.dist-info/licenses/LICENSE,sha256=4OOQdI7UQKuJPKHxNaiKkgqvVAnbuQpbQnx1xeUSaPs,1720
+ipython-9.4.0.dist-info/METADATA,sha256=d4dTcreyYD_4S0OE3JSqst9kT1pRCroTCNNwdInBiZY,4431
+ipython-9.4.0.dist-info/WHEEL,sha256=_2vT4RZnosDS5yjNeAMuEbJY3SAaKsQTuZHmdWSC-aI,90
+ipython-9.4.0.dist-info/entry_points.txt,sha256=z5BEEohWgg0SHdgdeNABf4T3fu-lr9W6F_bWOQHLdVs,83
+ipython-9.4.0.dist-info/top_level.txt,sha256=PKjvHtNCBZ9EHTmd2mwJ1J_k3j0F6D1lTFzIcJFFPEU,8
+ipython-9.4.0.dist-info/RECORD,,

{ipython-9.3.0.dist-info → ipython-9.4.0.dist-info}/WHEEL

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