ipython 9.9.0__tar.gz → 9.11.0__tar.gz

{ipython-9.9.0 → ipython-9.11.0}/IPython/__init__.py

@@ -27,13 +27,13 @@ import warnings
 #-----------------------------------------------------------------------------
 
 # Don't forget to also update setup.py when this changes!
-if sys.version_info < (3, 11):
+if sys.version_info < (3, 12):
     raise ImportError(
         """
+IPython 9.x supports Python 3.12 and above, following SPEC0
 IPython 8.31+ supports Python 3.11 and above, following SPEC0
 IPython 8.19+ supports Python 3.10 and above, following SPEC0.
 IPython 8.13+ supports Python 3.9 and above, following NEP 29.
-IPython 8.0-8.12 supports Python 3.8 and above, following NEP 29.
 When using Python 2.7, please install IPython 5.x LTS Long Term Support version.
 Python 3.3 and 3.4 were supported up to IPython 6.x.
 Python 3.5 was supported with IPython 7.0 to 7.9.

{ipython-9.9.0 → ipython-9.11.0}/IPython/core/completer.py

@@ -243,11 +243,7 @@ import __main__
 
 from typing import cast
 
-if sys.version_info < (3, 12):
-    from typing_extensions import TypedDict, Protocol
-    from typing import NotRequired, TypeAlias, TypeGuard
-else:
-    from typing import TypedDict, NotRequired, Protocol, TypeAlias, TypeGuard
+from typing import TypedDict, NotRequired, Protocol, TypeAlias, TypeGuard
 
 
 # skip module docstests
@@ -274,7 +270,7 @@ except ImportError:
 # write this). With below range we cover them all, with a density of ~67%
 # biggest next gap we consider only adds up about 1% density and there are 600
 # gaps that would need hard coding.
-_UNICODE_RANGES = [(32, 0x323B0), (0xE0001, 0xE01F0)]
+_UNICODE_RANGES = [(32, 0x3347A), (0xE0001, 0xE01F0)]
 
 # Public API
 __all__ = ["Completer", "IPCompleter"]

{ipython-9.9.0 → ipython-9.11.0}/IPython/core/events.py

@@ -15,10 +15,14 @@ events and the arguments which will be passed to them.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, Iterable
+from typing import TYPE_CHECKING, Any, Callable, Iterable, TypeVar
 
 if TYPE_CHECKING:
-    from IPython.core.interactiveshell import InteractiveShell
+    from IPython.core.interactiveshell import (
+        ExecutionInfo,
+        ExecutionResult,
+        InteractiveShell,
+    )
 
 
 class EventManager:
@@ -106,7 +110,10 @@ class EventManager:
 # event_name -> prototype mapping
 available_events: dict[str, Callable[..., Any]] = {}
 
-def _define_event(callback_function: Callable[..., Any]) -> Callable[..., Any]:
+_CallbackT = TypeVar("_CallbackT", bound=Callable[..., Any])
+
+def _define_event(callback_function: _CallbackT) -> _CallbackT:
+    """Decorator to register a function as an available event prototype."""
     available_events[callback_function.__name__] = callback_function
     return callback_function
 
@@ -127,7 +134,7 @@ def pre_execute() -> None:
     pass
 
 @_define_event
-def pre_run_cell(info: Any) -> None:
+def pre_run_cell(info: ExecutionInfo) -> None:
     """Fires before user-entered code runs.
 
     Parameters
@@ -147,7 +154,7 @@ def post_execute() -> None:
     pass
 
 @_define_event
-def post_run_cell(result: Any) -> None:
+def post_run_cell(result: ExecutionResult) -> None:
     """Fires after user-entered code runs.
 
     Parameters

{ipython-9.9.0 → ipython-9.11.0}/IPython/core/guarded_eval.py

@@ -32,10 +32,7 @@ from IPython.utils.decorators import undoc
 import types
 from typing import Self, LiteralString, get_type_hints
 
-if sys.version_info < (3, 12):
-    from typing_extensions import TypeAliasType
-else:
-    from typing import TypeAliasType
+from typing import TypeAliasType
 
 
 @undoc

{ipython-9.9.0 → ipython-9.11.0}/IPython/core/history.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import atexit
 import datetime
+import os
 import re
 
 
@@ -38,6 +39,8 @@ from IPython.utils.decorators import undoc
 from typing import Tuple, Optional, TYPE_CHECKING
 from collections.abc import Iterable
 import typing
+import typing as t
+from typing import cast
 from warnings import warn
 from weakref import ref, WeakSet
 
@@ -89,6 +92,9 @@ class DummyDB:
     def __exit__(self, *args, **kwargs):  # type: ignore [no-untyped-def]
         pass
 
+    def close(self, *args, **kwargs):  # type: ignore [no-untyped-def]
+        pass
+
 
 @decorator
 def only_when_enabled(f, self, *a, **kw):  # type: ignore [no-untyped-def]
@@ -343,6 +349,10 @@ class HistoryAccessor(HistoryAccessorBase):
         # success! reset corrupt db count
         self._corrupt_db_counter = 0
 
+    def __del__(self) -> None:
+        if hasattr(self, "db"):
+            self.db.close()
+
     def writeout_cache(self) -> None:
         """Overridden by HistoryManager to dump the cache before certain
         database lookups."""
@@ -689,6 +699,7 @@ class HistoryManager(HistoryAccessor):
             )
             self.hist_file = ":memory:"
 
+        self.using_thread = False
         if self.enabled and self.hist_file != ":memory:":
             self.save_thread = HistorySavingThread(self)
             try:
@@ -699,6 +710,8 @@ class HistoryManager(HistoryAccessor):
                     exc_info=True,
                 )
                 self.hist_file = ":memory:"
+            else:
+                self.using_thread = True
         self._instances.add(self)
         assert len(HistoryManager._instances) <= HistoryManager._max_inst, (
             len(HistoryManager._instances),
@@ -708,6 +721,21 @@ class HistoryManager(HistoryAccessor):
     def __del__(self) -> None:
         if self.save_thread is not None:
             self.save_thread.stop()
+        HistoryAccessor.__del__(self)
+
+    @classmethod
+    def _stop_thread(cls) -> None:
+        # Used before forking so the thread isn't running at fork
+        for inst in cls._instances:
+            if inst.save_thread is not None:
+                inst.save_thread.stop()
+                inst.save_thread = None
+
+    def _restart_thread_if_stopped(self) -> None:
+        # Start the thread again after it was stopped for forking
+        if self.save_thread is None and self.using_thread:
+            self.save_thread = HistorySavingThread(self)
+            self.save_thread.start()
 
     def _get_hist_file_name(self, profile: Optional[str] = None) -> Path:
         """Get default history file name based on the Shell's profile.
@@ -970,8 +998,10 @@ class HistoryManager(HistoryAccessor):
             self.db_input_cache.append((line_num, source, source_raw))
             # Trigger to flush cache and write to DB.
             if len(self.db_input_cache) >= self.db_cache_size:
-                if self.save_flag:
-                    self.save_flag.set()
+                if self.using_thread:
+                    self._restart_thread_if_stopped()
+                    if self.save_flag is not None:
+                        self.save_flag.set()
 
         # update the auto _i variables
         self._iii = self._ii
@@ -1003,8 +1033,10 @@ class HistoryManager(HistoryAccessor):
 
         with self.db_output_cache_lock:
             self.db_output_cache.append((line_num, output))
-        if self.db_cache_size <= 1 and self.save_flag is not None:
-            self.save_flag.set()
+        if self.db_cache_size <= 1 and self.using_thread:
+            self._restart_thread_if_stopped()
+            if self.save_flag is not None:
+                self.save_flag.set()
 
     def _writeout_input_cache(self, conn: sqlite3.Connection) -> None:
         with conn:
@@ -1059,6 +1091,10 @@ class HistoryManager(HistoryAccessor):
                 self.db_output_cache = []
 
 
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(before=HistoryManager._stop_thread)
+
+
 from collections.abc import Callable, Iterator
 from weakref import ReferenceType
 
@@ -1105,7 +1141,7 @@ class HistorySavingThread(threading.Thread):
                 if hm() is not None:
                     self.db = sqlite3.connect(
                         str(hm().hist_file),  # type: ignore [union-attr]
-                        **hm().connection_options,  # type: ignore [union-attr]
+                        **cast(dict[str, t.Any], hm().connection_options),  # type: ignore [union-attr]
                     )
             while True:
                 self.save_flag.wait()

{ipython-9.9.0 → ipython-9.11.0}/IPython/core/inputtransformer2.py

@@ -67,9 +67,47 @@ class PromptStripper:
     If any prompt is found on the first two lines,
     prompts will be stripped from the rest of the block.
     """
-    def __init__(self, prompt_re, initial_re=None):
+    def __init__(self, prompt_re, initial_re=None, *, doctest=False):
         self.prompt_re = prompt_re
         self.initial_re = initial_re or prompt_re
+        self.doctest = doctest
+        if doctest:
+            # Doctest/xdoctest prompts may be indented (e.g. "    >>>").
+            # We only treat "..." as a continuation prompt when the same pasted
+            # block contains at least one ">>>" line, to avoid ambiguity with the
+            # Python Ellipsis literal.
+            self._doctest_initial_re = re.compile(r'^\s*>>>')
+            self._doctest_ps1_re = re.compile(r'^\s*>>>\s?')
+            self._doctest_ps2_re = re.compile(r'^\s*\.\.\.\s?')
+
+            # Very small state machine to detect triple-quoted strings in the
+            # *same* input block (e.g. user typed """ then pasted doctest).
+            # We preserve literal >>> / ... inside triple-quoted strings.
+            self._triple_quote_re = re.compile(r"(?<!\\)(\"\"\"|''')")
+
+
+    def _triple_quote_mask(self, lines: List[str]) -> List[bool]:
+        """
+        Return a boolean mask: True if the corresponding line is considered
+        inside a triple-quoted string literal.
+
+        This is intentionally heuristic (fast + good enough for paste handling).
+        """
+        mask: List[bool] = []
+        in_triple: str | None = None  # either ''' or """
+        for line in lines:
+            mask.append(in_triple is not None)
+            # Toggle state for each occurrence of """ or ''' in the line.
+            for m in self._triple_quote_re.finditer(line):
+                q = m.group(1)
+                if in_triple is None:
+                    in_triple = q
+                    mask[-1] = True  # current line is inside triple quotes
+                elif in_triple == q:
+                    in_triple = None
+                # else: ignore mismatched triple quote while inside
+        return mask
+
 
     def _strip(self, lines):
         return [self.prompt_re.sub('', l, count=1) for l in lines]
@@ -77,6 +115,57 @@ class PromptStripper:
     def __call__(self, lines):
         if not lines:
             return lines
+
+        if self.doctest:
+            triple_mask = self._triple_quote_mask(lines)
+
+            # Detect doctest prompts only outside triple-quoted strings.
+            has_doctest_outside = any(
+                (not in_triple) and self._doctest_initial_re.match(l)
+                for l, in_triple in zip(lines, triple_mask)
+            )
+            if not has_doctest_outside:
+                return lines
+
+            out_lines: List[str] = []
+            stripped_mask: List[bool] = []
+
+            for l, in_triple in zip(lines, triple_mask):
+                if in_triple:
+                    out_lines.append(l)
+                    stripped_mask.append(False)
+                    continue
+
+                if self._doctest_ps1_re.match(l):
+                    new_l = self._doctest_ps1_re.sub('', l, count=1)
+                elif self._doctest_ps2_re.match(l):
+                    new_l = self._doctest_ps2_re.sub('', l, count=1)
+                else:
+                    new_l = l
+                out_lines.append(new_l)
+                stripped_mask.append(new_l != l)
+
+            # Dedent only the non-triple-quoted segments where stripping occurred.
+            dedented: List[str] = []
+            i = 0
+            while i < len(out_lines):
+                j = i
+                in_triple = triple_mask[i]
+                while j < len(out_lines) and triple_mask[j] == in_triple:
+                    j += 1
+
+                segment = out_lines[i:j]
+                seg_stripped = any(stripped_mask[i:j])
+
+                if (not in_triple) and seg_stripped:
+                    dedented.extend(dedent(''.join(segment)).splitlines(keepends=True))
+                else:
+                    dedented.extend(segment)
+
+                i = j
+
+            return dedented
+
         if self.initial_re.match(lines[0]) or \
                 (len(lines) > 1 and self.prompt_re.match(lines[1])):
             return self._strip(lines)
@@ -84,7 +173,8 @@ class PromptStripper:
 
 classic_prompt = PromptStripper(
     prompt_re=re.compile(r'^(>>>|\.\.\.)( |$)'),
-    initial_re=re.compile(r'^>>>( |$)')
+    initial_re=re.compile(r'^>>>( |$)'),
+    doctest=True,
 )
 
 ipython_prompt = PromptStripper(
@@ -266,24 +356,8 @@ class MagicAssign(TokenTransformBase):
 class SystemAssign(TokenTransformBase):
     """Transformer for assignments from system commands (a = !foo)"""
     @classmethod
-    def find_pre_312(cls, tokens_by_line):
-        for line in tokens_by_line:
-            assign_ix = _find_assign_op(line)
-            if (assign_ix is not None) \
-                    and not line[assign_ix].line.strip().startswith('=') \
-                    and (len(line) >= assign_ix + 2) \
-                    and (line[assign_ix + 1].type == tokenize.ERRORTOKEN):
-                ix = assign_ix + 1
-
-                while ix < len(line) and line[ix].type == tokenize.ERRORTOKEN:
-                    if line[ix].string == '!':
-                        return cls(line[ix].start)
-                    elif not line[ix].string.isspace():
-                        break
-                    ix += 1
-
-    @classmethod
-    def find_post_312(cls, tokens_by_line):
+    def find(cls, tokens_by_line):
+        """Find the first system assignment (a = !foo) in the cell."""
         for line in tokens_by_line:
             assign_ix = _find_assign_op(line)
             if (
@@ -295,13 +369,6 @@ class SystemAssign(TokenTransformBase):
             ):
                 return cls(line[assign_ix + 1].start)
 
-    @classmethod
-    def find(cls, tokens_by_line):
-        """Find the first system assignment (a = !foo) in the cell."""
-        if sys.version_info < (3, 12):
-            return cls.find_pre_312(tokens_by_line)
-        return cls.find_post_312(tokens_by_line)
-
     def transform(self, lines: List[str]):
         """Transform a system assignment found by the ``find()`` classmethod.
         """

{ipython-9.9.0 → ipython-9.11.0}/IPython/core/interactiveshell.py

@@ -22,6 +22,7 @@ import re
 import runpy
 import shutil
 import subprocess
+from subprocess import CalledProcessError
 import sys
 import tempfile
 import traceback
@@ -37,6 +38,7 @@ from typing import List as ListType, Any as AnyType
 from typing import Literal, Optional, Tuple
 from collections.abc import Sequence
 from warnings import warn
+import textwrap
 
 from IPython.external.pickleshare import PickleShareDB
 
@@ -90,7 +92,7 @@ from IPython.utils.decorators import undoc
 from IPython.utils.io import ask_yes_no
 from IPython.utils.ipstruct import Struct
 from IPython.utils.path import ensure_dir_exists, get_home_dir, get_py_filename
-from IPython.utils.process import getoutput, system
+from IPython.utils.process import get_output_error_code, getoutput, system
 from IPython.utils.strdispatch import StrDispatch
 from IPython.utils.syspathcontext import prepended_to_syspath
 from IPython.utils.text import DollarFormatter, LSString, SList, format_screen
@@ -538,6 +540,14 @@ class InteractiveShell(SingletonConfigurable):
 
     quiet = Bool(False).tag(config=True)
 
+    system_raise_on_error = Bool(False, help=
+        """
+        Raise an exception on non-zero exit status from shell commands executed
+        via the `!` operator. When set to True, shell commands that fail will raise
+        CalledProcessError, similar to the behavior of %%script magics.
+        """
+    ).tag(config=True)
+
     history_length = Integer(10000,
         help='Total length of command history'
     ).tag(config=True)
@@ -1014,6 +1024,18 @@ class InteractiveShell(SingletonConfigurable):
 
     @property
     def banner(self):
+        if (when := os.environ.get("SOURCE_DATE_EPOCH", None)) is not None:
+            from datetime import datetime
+
+            date = datetime.fromtimestamp(int(when))
+            return textwrap.dedent(
+                f"""
+            Python 3.y.z | Packaged with love | (main, {date.strftime("%A, %d %B %Y")}) [Compiler]
+            Type 'copyright', 'credits' or 'license' for more information
+            IPython 9.y.z -- An enhanced Interactive Python. Type '?' for help.
+            Tip: unset SOURCE_DATE_EPOCH to restore dynamic banner.
+            """
+            ).lstrip()
         banner = self.banner1
         if self.profile and self.profile != 'default':
             banner += '\nIPython profile: %s\n' % self.profile
@@ -2118,8 +2140,7 @@ class InteractiveShell(SingletonConfigurable):
         sys.last_type = etype
         sys.last_value = value
         sys.last_traceback = tb
-        if sys.version_info >= (3, 12):
-            sys.last_exc = value
+        sys.last_exc = value
 
         return etype, value, tb
 
@@ -2647,7 +2668,12 @@ class InteractiveShell(SingletonConfigurable):
         # we explicitly do NOT return the subprocess status code, because
         # a non-None value would trigger :func:`sys.displayhook` calls.
         # Instead, we store the exit_code in user_ns.
-        self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
+        exit_code = system(self.var_expand(cmd, depth=1))
+        self.user_ns['_exit_code'] = exit_code
+
+        # Raise an exception if the command failed and system_raise_on_error is True
+        if self.system_raise_on_error and exit_code != 0:
+            raise CalledProcessError(exit_code, cmd)
 
     def system_raw(self, cmd):
         """Call the given cmd in a subprocess using os.system on Windows or
@@ -2713,6 +2739,10 @@ class InteractiveShell(SingletonConfigurable):
         # but raising SystemExit(_exit_code) will give status 254!
         self.user_ns['_exit_code'] = ec
 
+        # Raise an exception if the command failed and system_raise_on_error is True
+        if self.system_raise_on_error and ec != 0:
+            raise CalledProcessError(ec, cmd)
+
     # use piped system by default, because it is better behaved
     system = system_piped
 
@@ -2738,11 +2768,27 @@ class InteractiveShell(SingletonConfigurable):
         if cmd.rstrip().endswith('&'):
             # this is *far* from a rigorous test
             raise OSError("Background processes not supported.")
-        out = getoutput(self.var_expand(cmd, depth=depth+1))
+
+        # Get output and exit code
+        expanded_cmd = self.var_expand(cmd, depth=depth+1)
+        if self.system_raise_on_error:
+            # Use get_output_error_code to get the exit code
+            out_str, err_str, exit_code = get_output_error_code(expanded_cmd)
+            # Combine stdout and stderr as getoutput does
+            out_combined = out_str if not err_str else out_str + err_str
+            self.user_ns['_exit_code'] = exit_code
+
+            # Raise an exception if the command failed
+            if exit_code != 0:
+                raise CalledProcessError(exit_code, cmd)
+        else:
+            # Use the original getoutput for backward compatibility
+            out_combined = getoutput(expanded_cmd)
+
         if split:
-            out = SList(out.splitlines())
+            out = SList(out_combined.splitlines())
         else:
-            out = LSString(out)
+            out = LSString(out_combined)
         return out
 
     #-------------------------------------------------------------------------