ipython 9.8.0__tar.gz → 9.10.0__tar.gz

{ipython-9.8.0 → ipython-9.10.0}/IPython/core/async_helpers.py

@@ -136,20 +136,15 @@ def _pseudo_sync_runner(coro):
 
 
 def _should_be_async(cell: str) -> bool:
-    """Detect if a block of code need to be wrapped in an `async def`
+    """Detect if a block of code needs to be wrapped in an `async def`
 
-    Attempt to parse the block of code, it it compile we're fine.
-    Otherwise we  wrap if and try to compile.
-
-    If it works, assume it should be async. Otherwise Return False.
-
-    Not handled yet: If the block of code has a return statement as the top
-    level, it will be seen as async. This is a know limitation.
+    If the code block has a top-level return statement or is otherwise
+    invalid, `False` will be returned.
     """
     try:
         code = compile(
             cell, "<>", "exec", flags=getattr(ast, "PyCF_ALLOW_TOP_LEVEL_AWAIT", 0x0)
         )
         return inspect.CO_COROUTINE & code.co_flags == inspect.CO_COROUTINE
-    except (SyntaxError, MemoryError):
+    except (SyntaxError, ValueError, MemoryError):
         return False

{ipython-9.8.0 → ipython-9.10.0}/IPython/core/completer.py

@@ -2608,8 +2608,8 @@ class IPCompleter(Completer):
         if re.search(r"(?<!\w)(?<!\d\.)([-+]?\d+\.(\d+)?)(?!\w)$", line):
             return self._CompletionContextType.GLOBAL
 
-        # Handle all other attribute matches np.ran, d[0].k, (a,b).count
-        chain_match = re.search(r".*(.+(?<!\s)\.(?:[a-zA-Z]\w*)?)$", line)
+        # Handle all other attribute matches np.ran, d[0].k, (a,b).count, obj._private
+        chain_match = re.search(r".*(.+(?<!\s)\.(?:[a-zA-Z_]\w*)?)$", line)
         if chain_match:
             return self._CompletionContextType.ATTRIBUTE
 

{ipython-9.8.0 → ipython-9.10.0}/IPython/core/history.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import atexit
 import datetime
+import os
 import re
 
 
@@ -689,6 +690,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 +701,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),
@@ -709,6 +713,20 @@ class HistoryManager(HistoryAccessor):
         if self.save_thread is not None:
             self.save_thread.stop()
 
+    @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 +988,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 +1023,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 +1081,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
 

{ipython-9.8.0 → ipython-9.10.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(

{ipython-9.8.0 → ipython-9.10.0}/IPython/core/interactiveshell.py

@@ -2141,7 +2141,7 @@ class InteractiveShell(SingletonConfigurable):
 
     def showtraceback(
         self,
-        exc_tuple: tuple[type[BaseException], BaseException, Any] | None = None,
+        exc_tuple: tuple[type[BaseException], BaseException, AnyType] | None = None,
         filename: str | None = None,
         tb_offset: int | None = None,
         exception_only: bool = False,

{ipython-9.8.0 → ipython-9.10.0}/IPython/core/prefilter.py

@@ -498,7 +498,7 @@ class AutocallChecker(PrefilterChecker):
         if not self.shell.autocall:
             return None
 
-        oinfo = line_info.ofind(self.shell) # This can mutate state via getattr
+        oinfo = self.shell._ofind(line_info.ifun)  # This can mutate state via getattr
         if not oinfo.found:
             return None
 
@@ -610,7 +610,7 @@ class AutoHandler(PrefilterHandler):
         the_rest = line_info.the_rest
         esc     = line_info.esc
         continue_prompt = line_info.continue_prompt
-        obj = line_info.ofind(self.shell).obj
+        obj = self.shell._ofind(line_info.ifun).obj
 
         # This should only be active for single-line input!
         if continue_prompt:

{ipython-9.8.0 → ipython-9.10.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 = 8
+_version_minor = 10
 _version_patch = 0
 _version_extra = ".dev"
 # _version_extra = "b2"

{ipython-9.8.0 → ipython-9.10.0}/IPython/core/splitinput.py

@@ -1,35 +1,21 @@
-# encoding: utf-8
 """
 Simple utility for splitting user input. This is used by both inputsplitter and
 prefilter.
-
-Authors:
-
-* Brian Granger
-* Fernando Perez
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 import re
 import sys
+import warnings
 
-from IPython.utils import py3compat
-from IPython.utils.encoding import get_stream_enc
 from IPython.core.oinspect import OInfo
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Main function
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 # RegExp for splitting line contents into pre-char//first word-method//rest.
 # For clarity, each group in on one line.
@@ -42,22 +28,25 @@ from IPython.core.oinspect import OInfo
 # ! and !! trigger if they are first char(s) *or* follow an indent
 # ? triggers as first or last char.
 
-line_split = re.compile(r"""
+line_split = re.compile(
+    r"""
              ^(\s*)               # any leading space
              ([,;/%]|!!?|\?\??)?  # escape character or characters
              \s*(%{0,2}[\w\.\*]*)     # function/method, possibly with leading %
                                   # to correctly treat things like '?%magic'
              (.*?$|$)             # rest of line
-             """, re.VERBOSE)
+             """,
+    re.VERBOSE,
+)
 
 
-def split_user_input(line, pattern=None):
+def split_user_input(
+    line: str, pattern: re.Pattern[str] | None = None
+) -> tuple[str, str, str, str]:
     """Split user input into initial whitespace, escape character, function part
     and the rest.
     """
-    # We need to ensure that the rest of this routine deals only with unicode
-    encoding = get_stream_enc(sys.stdin, 'utf-8')
-    line = py3compat.cast_unicode(line, encoding)
+    assert isinstance(line, str)
 
     if pattern is None:
         pattern = line_split
@@ -65,11 +54,11 @@ def split_user_input(line, pattern=None):
     if not match:
         # print("match failed for line '%s'" % line)
         try:
-            ifun, the_rest = line.split(None,1)
+            ifun, the_rest = line.split(None, 1)
         except ValueError:
             # print("split failed for line '%s'" % line)
-            ifun, the_rest = line, u''
-        pre = re.match(r'^(\s*)(.*)',line).groups()[0]
+            ifun, the_rest = line, ""
+        pre = re.match(r"^(\s*)(.*)", line).groups()[0]
         esc = ""
     else:
         pre, esc, ifun, the_rest = match.groups()
@@ -111,15 +100,27 @@ class LineInfo:
     raw_the_rest
       the_rest without whitespace stripped.
     """
-    def __init__(self, line, continue_prompt=False):
-        self.line            = line
+
+    line: str
+    continue_prompt: bool
+    pre: str
+    esc: str
+    ifun: str
+    raw_the_rest: str
+    the_rest: str
+    pre_char: str
+    pre_whitespace: str
+
+    def __init__(self, line: str, continue_prompt: bool = False) -> None:
+        assert isinstance(line, str)
+        self.line = line
         self.continue_prompt = continue_prompt
         self.pre, self.esc, self.ifun, self.raw_the_rest = split_user_input(line)
         self.the_rest = self.raw_the_rest.lstrip()
 
-        self.pre_char       = self.pre.strip()
+        self.pre_char = self.pre.strip()
         if self.pre_char:
-            self.pre_whitespace = '' # No whitespace allowed before esc chars
+            self.pre_whitespace = ""  # No whitespace allowed before esc chars
         else:
             self.pre_whitespace = self.pre
 
@@ -135,11 +136,20 @@ class LineInfo:
 
         Does cache the results of the call, so can be called multiple times
         without worrying about *further* damaging state.
+
+        .. deprecated:: 9.8
+            Use ``shell._ofind(line_info.ifun)`` directly instead.
         """
+        warnings.warn(
+            "LineInfo.ofind() is deprecated since IPython 9.9. "
+            "Use shell._ofind(line_info.ifun) directly instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         return ip._ofind(self.ifun)
 
-    def __str__(self):
-        return "LineInfo [%s|%s|%s|%s]" %(self.pre, self.esc, self.ifun, self.the_rest)
+    def __str__(self) -> str:
+        return "LineInfo [%s|%s|%s|%s]" % (self.pre, self.esc, self.ifun, self.the_rest)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<" + str(self) + ">"

{ipython-9.8.0 → ipython-9.10.0}/IPython/core/tips.py

@@ -107,6 +107,16 @@ else:
         ]
     )
 
+# Check if argcomplete is installed and add tip
+try:
+    import argcomplete
+
+    _tips["random"].append(
+        "Run `activate-global-python-argcomplete` from your shell to enable CLI completion for IPython"
+    )
+except ModuleNotFoundError:
+    pass
+
 
 def pick_tip() -> str:
     current_date = datetime.now()

{ipython-9.8.0 → ipython-9.10.0}/IPython/extensions/autoreload.py

@@ -327,6 +327,10 @@ class ModuleReloader:
                         del self.failed[py_filename]
                 except:
                     if not self.hide_errors:
+                        logger = logging.getLogger("autoreload")
+                        logger.exception(
+                            f"Failed to reload module '{modname}' from file '{py_filename}'"
+                        )
                         print(
                             "[autoreload of {} failed: {}]".format(
                                 modname, traceback.format_exc(10)

{ipython-9.8.0 → ipython-9.10.0}/IPython/extensions/deduperreload/deduperreload.py

@@ -3,6 +3,7 @@ import ast
 import builtins
 import contextlib
 import itertools
+import logging
 import os
 import pickle
 import platform
@@ -209,11 +210,19 @@ class DeduperReloader(DeduperReloaderPatchingMixin):
             ):
                 self.source_by_modname[new_modname] = ""
                 continue
-            with open(fname, "r") as f:
-                try:
+            # Skip binary files (e.g., .so, .pyd, .pyo)
+            if not fname.endswith(".py"):
+                self.source_by_modname[new_modname] = ""
+                continue
+            try:
+                with open(fname, "r") as f:
                     self.source_by_modname[new_modname] = f.read()
-                except Exception:
-                    self.source_by_modname[new_modname] = ""
+            except Exception as e:
+                logger = logging.getLogger("autoreload")
+                logger.exception(
+                    f"Failed to read module file '{fname}' for module '{new_modname}': {type(e).__name__}"
+                )
+                self.source_by_modname[new_modname] = ""
 
     constexpr_detector = ConstexprDetector()
 
@@ -542,8 +551,15 @@ class DeduperReloader(DeduperReloaderPatchingMixin):
             return False
         if (fname := get_module_file_name(module)) is None:
             return False
-        with open(fname, "r") as f:
-            new_source_code = f.read()
+        try:
+            with open(fname, "r") as f:
+                new_source_code = f.read()
+        except Exception as e:
+            logger = logging.getLogger("autoreload")
+            logger.exception(
+                f"Failed to read module file '{fname}' for module '{modname}': {type(e).__name__}"
+            )
+            return False
         patched_flag = False
         if old_source_code := self.source_by_modname.get(modname):
             # get old/new module ast

{ipython-9.8.0 → ipython-9.10.0}/IPython/extensions/deduperreload/deduperreload_patching.py

@@ -7,12 +7,7 @@ NOT_FOUND: object = object()
 NULL: 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
+POINTER_N_BYTES = ctypes.sizeof(ctypes.c_void_p)
 
 
 class DeduperReloaderPatchingMixin:
@@ -32,7 +27,7 @@ class DeduperReloaderPatchingMixin:
         for offset in range(1, _MAX_FIELD_SEARCH_OFFSET):
             if (
                 ctypes.cast(
-                    obj_addr + WORD_N_BYTES * offset, ctypes.POINTER(WORD_TYPE)
+                    obj_addr + POINTER_N_BYTES * offset, ctypes.POINTER(ctypes.c_void_p)
                 ).contents.value
                 == field_addr
             ):
@@ -69,7 +64,7 @@ class DeduperReloaderPatchingMixin:
         if new_value not in (None, NULL):
             ctypes.pythonapi.Py_IncRef(ctypes.py_object(new_value))
         ctypes.cast(
-            obj_addr + WORD_N_BYTES * offset, ctypes.POINTER(WORD_TYPE)
+            obj_addr + POINTER_N_BYTES * offset, ctypes.POINTER(ctypes.c_void_p)
         ).contents.value = new_value_addr
 
     @classmethod

{ipython-9.8.0 → ipython-9.10.0}/IPython/lib/pretty.py

@@ -109,6 +109,14 @@ from IPython.utils.py3compat import PYPY
 
 from typing import Dict
 
+# Allow pretty-printing of functions with PEP-649 annotations
+if sys.version_info >= (3, 14):
+    from annotationlib import Format
+    from functools import partial
+
+    signature = partial(signature, annotation_format=Format.FORWARDREF)
+
+
 __all__ = ['pretty', 'pprint', 'PrettyPrinter', 'RepresentationPrinter',
     'for_type', 'for_type_by_name', 'RawText', 'RawStringLiteral', 'CallExpression']
 

{ipython-9.8.0 → ipython-9.10.0}/IPython/terminal/shortcuts/__init__.py

@@ -635,4 +635,5 @@ UNASSIGNED_ALLOWED_COMMANDS = [
     nc.forward_char,
     nc.forward_word,
     nc.unix_line_discard,
+    nc.unix_word_rubout,
 ]

{ipython-9.8.0 → ipython-9.10.0}/IPython/utils/_sysinfo.py

@@ -1,2 +1,2 @@
 # GENERATED BY setup.py
-commit = "2fc1f45"
+commit = "178fef7"

{ipython-9.8.0/ipython.egg-info → ipython-9.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipython
-Version: 9.8.0
+Version: 9.10.0
 Summary: IPython: Productive Interactive Computing
 Author: The IPython Development Team
 Author-email: ipython-dev@python.org
@@ -70,7 +70,8 @@ Requires-Dist: trio>=0.1.0; extra == "test-extra"
 Provides-Extra: matplotlib
 Requires-Dist: matplotlib>3.9; extra == "matplotlib"
 Provides-Extra: all
-Requires-Dist: ipython[doc,matplotlib,test,test_extra]; extra == "all"
+Requires-Dist: ipython[doc,matplotlib,terminal,test,test_extra]; extra == "all"
+Requires-Dist: argcomplete>=3.0; extra == "all"
 Dynamic: author
 Dynamic: author-email
 Dynamic: license-file

{ipython-9.8.0 → ipython-9.10.0}/docs/source/conf.py

@@ -92,6 +92,12 @@ intersphinx_mapping = get_intersphinx_mapping(
     }
 )
 
+# External links configuration (replaces custom github extension)
+extlinks = {
+    "ghissue": ("https://github.com/ipython/ipython/issues/%s/", "#%s"),
+    "ghpull": ("https://github.com/ipython/ipython/pull/%s/", "PR #%s"),
+}
+
 
 # Options for HTML output
 # -----------------------

{ipython-9.8.0 → ipython-9.10.0}/docs/source/install/install.rst

@@ -78,6 +78,32 @@ The quickest way to get up and running with IPython is to install it with pip:
 That's it.
 
 
+Optional: Command-line completion
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+IPython supports command-line completion via the ``argcomplete`` package.
+To enable tab completion for IPython and other Python programs that support
+argcomplete, install IPython with the ``terminal`` extra:
+
+.. code-block:: bash
+
+    $ pip install ipython[all]
+    $ activate-global-python-argcomplete
+
+Alternatively, you can install argcomplete separately:
+
+.. code-block:: bash
+
+    $ pip install argcomplete
+    $ activate-global-python-argcomplete
+
+This will enable shell completion for all Python programs that support argcomplete,
+including IPython. Note that you may need to restart your shell for the changes
+to take effect.
+
+For more information, see the `argcomplete documentation <https://github.com/kislyuk/argcomplete>`_.
+
+
 .. _devinstall:
 
 Installing the development version

{ipython-9.8.0 → ipython-9.10.0}/docs/source/sphinx.toml

@@ -13,11 +13,11 @@ extensions = [
     "sphinx.ext.inheritance_diagram",
     "sphinx.ext.intersphinx",
     "sphinx.ext.graphviz",
+    "sphinx.ext.extlinks",  # for easy GitHub links
     "sphinxcontrib.jquery",
     "IPython.sphinxext.ipython_console_highlighting",
     "IPython.sphinxext.ipython_directive",
     "sphinx.ext.napoleon",  # to preprocess docstrings
-    "github",  # for easy GitHub links
     "magics",
     "configtraits",
 ]