ipython 9.3.0__tar.gz → 9.4.0__tar.gz

{ipython-9.3.0 → ipython-9.4.0}/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-9.4.0/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-9.3.0 → ipython-9.4.0}/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-9.3.0 → ipython-9.4.0}/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-9.3.0 → ipython-9.4.0}/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-9.3.0 → ipython-9.4.0}/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-9.3.0 → ipython-9.4.0}/IPython/core/release.py

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