ipython 9.6.0__tar.gz → 9.8.0__tar.gz

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

@@ -85,9 +85,9 @@ You will find that the following are experimental:
 
 We welcome any feedback on these new API, and we also encourage you to try this
 module in debug mode (start IPython with ``--Completer.debug=True``) in order
-to have extra logging information if :any:`jedi` is crashing, or if current
+to have extra logging information if :mod:`jedi` is crashing, or if current
 IPython completer pending deprecations are returning results not yet handled
-by :any:`jedi`
+by :mod:`jedi`
 
 Using Jedi for tab completion allow snippets like the following to work without
 having to execute any code:
@@ -99,7 +99,7 @@ Tab completion will be able to infer that ``myvar[1]`` is a real number without
 executing almost any code unlike the deprecated :any:`IPCompleter.greedy`
 option.
 
-Be sure to update :any:`jedi` to the latest stable version or to try the
+Be sure to update :mod:`jedi` to the latest stable version or to try the
 current development version to get better completions.
 
 Matchers
@@ -149,7 +149,7 @@ More precisely, the API allows to omit ``matcher_api_version`` for v1 Matchers,
 and requires a literal ``2`` for v2 Matchers.
 
 Once the API stabilises future versions may relax the requirement for specifying
-``matcher_api_version`` by switching to :any:`functools.singledispatch`, therefore
+``matcher_api_version`` by switching to :func:`functools.singledispatch`, therefore
 please do not rely on the presence of ``matcher_api_version`` for any purposes.
 
 Suppression of competing matchers
@@ -201,17 +201,14 @@ from dataclasses import dataclass
 from functools import cached_property, partial
 from types import SimpleNamespace
 from typing import (
-    Iterable,
-    Iterator,
     Union,
     Any,
-    Sequence,
     Optional,
     TYPE_CHECKING,
-    Sized,
     TypeVar,
     Literal,
 )
+from collections.abc import Iterable, Iterator, Sequence, Sized
 
 from IPython.core.guarded_eval import (
     guarded_eval,
@@ -247,7 +244,8 @@ import __main__
 from typing import cast
 
 if sys.version_info < (3, 12):
-    from typing_extensions import TypedDict, NotRequired, Protocol, TypeAlias, TypeGuard
+    from typing_extensions import TypedDict, Protocol
+    from typing import NotRequired, TypeAlias, TypeGuard
 else:
     from typing import TypedDict, NotRequired, Protocol, TypeAlias, TypeGuard
 
@@ -489,7 +487,7 @@ class Completion:
         It will also raise unless use in proper context manager.
 
     This act as a middle ground :any:`Completion` object between the
-    :any:`jedi.api.classes.Completion` object and the Prompt Toolkit completion
+    :class:`jedi.api.classes.Completion` object and the Prompt Toolkit completion
     object. While Jedi need a lot of information about evaluator and how the
     code should be ran/inspected, PromptToolkit (and other frontend) mostly
     need user facing information.
@@ -860,7 +858,7 @@ def rectify_completions(text: str, completions: _IC, *, _debug: bool = False) ->
 
     Notes
     -----
-    :any:`jedi.api.classes.Completion` s returned by Jedi may not have the same start and end, though
+    :class:`jedi.api.classes.Completion` s returned by Jedi may not have the same start and end, though
     the Jupyter Protocol requires them to behave like so. This will readjust
     the completion to have the same ``start`` and ``end`` by padding both
     extremities with surrounding text.
@@ -990,9 +988,9 @@ class Completer(Configurable):
           no item/attribute evaluation, no access to locals/globals,
           no evaluation of any operations or comparisons.
         - ``limited``: access to all namespaces, evaluation of hard-coded methods
-          (for example: :any:`dict.keys`, :any:`object.__getattr__`,
-          :any:`object.__getitem__`) on allow-listed objects (for example:
-          :any:`dict`, :any:`list`, :any:`tuple`, ``pandas.Series``),
+          (for example: :py:meth:`dict.keys`, :py:meth:`object.__getattr__`,
+          :py:meth:`object.__getitem__`) on allow-listed objects (for example:
+          :py:class:`dict`, :py:class:`list`, :py:class:`tuple`, ``pandas.Series``),
         - ``unsafe``: evaluation of all methods and function calls but not of
           syntax with side-effects like `del x`,
         - ``dangerous``: completely arbitrary evaluation; does not support auto-import.
@@ -1352,6 +1350,8 @@ class Completer(Configurable):
             assert res is not None
             if len(res.body) != 1:
                 continue
+            if not isinstance(res.body[0], ast.Expr):
+                continue
             expr = res.body[0].value
             if isinstance(expr, ast.Tuple) and not code[-1] == ")":
                 # we skip implicit tuple, like when trimming `fun(a,b`<completion>
@@ -1538,9 +1538,9 @@ def match_dict_keys(
         # All checks passed!
         return True
 
-    filtered_key_is_final: dict[Union[str, bytes, int, float], _DictKeyState] = (
-        defaultdict(lambda: _DictKeyState.BASELINE)
-    )
+    filtered_key_is_final: dict[
+        Union[str, bytes, int, float], _DictKeyState
+    ] = defaultdict(lambda: _DictKeyState.BASELINE)
 
     for k in keys:
         # If at least one of the matches is not final, mark as undetermined.
@@ -2211,6 +2211,17 @@ class IPCompleter(Completer):
         #  starts with `/home/`, `C:\`, etc)
 
         text = context.token
+        code_until_cursor = self._extract_code(context.text_until_cursor)
+        completion_type = self._determine_completion_context(code_until_cursor)
+        in_cli_context = self._is_completing_in_cli_context(code_until_cursor)
+        if (
+            completion_type == self._CompletionContextType.ATTRIBUTE
+            and not in_cli_context
+        ):
+            return {
+                "completions": [],
+                "suppress": False,
+            }
 
         # chars that require escaping with backslash - i.e. chars
         # that readline treats incorrectly as delimiters, but we
@@ -2480,7 +2491,8 @@ class IPCompleter(Completer):
         )
         return {
             "completions": matches,
-            # static analysis should not suppress other matchers
+            # static analysis should not suppress other matcher
+            # NOTE: file_matcher is automatically suppressed on attribute completions
             "suppress": False,
         }
 
@@ -2597,12 +2609,47 @@ class IPCompleter(Completer):
             return self._CompletionContextType.GLOBAL
 
         # Handle all other attribute matches np.ran, d[0].k, (a,b).count
-        chain_match = re.search(r".*(.+\.(?:[a-zA-Z]\w*)?)$", line)
+        chain_match = re.search(r".*(.+(?<!\s)\.(?:[a-zA-Z]\w*)?)$", line)
         if chain_match:
             return self._CompletionContextType.ATTRIBUTE
 
         return self._CompletionContextType.GLOBAL
 
+    def _is_completing_in_cli_context(self, text: str) -> bool:
+        """
+        Determine if we are completing in a CLI alias, line magic, or bang expression context.
+        """
+        stripped = text.lstrip()
+        if stripped.startswith("!") or stripped.startswith("%"):
+            return True
+        # Check for CLI aliases
+        try:
+            tokens = stripped.split(None, 1)
+            if not tokens:
+                return False
+            first_token = tokens[0]
+
+            # Must have arguments after the command for this to apply
+            if len(tokens) < 2:
+                return False
+
+            # Check if first token is a known alias
+            if not any(
+                alias[0] == first_token for alias in self.shell.alias_manager.aliases
+            ):
+                return False
+
+            try:
+                if first_token in self.shell.user_ns:
+                    # There's a variable defined, so the alias is overshadowed
+                    return False
+            except (AttributeError, KeyError):
+                pass
+
+            return True
+        except Exception:
+            return False
+
     def _is_in_string_or_comment(self, text):
         """
         Determine if the cursor is inside a string or comment.
@@ -2724,7 +2771,11 @@ class IPCompleter(Completer):
         """Match attributes or global python names"""
         text = context.text_until_cursor
         text = self._extract_code(text)
-        completion_type = self._determine_completion_context(text)
+        in_cli_context = self._is_completing_in_cli_context(text)
+        if in_cli_context:
+            completion_type = self._CompletionContextType.GLOBAL
+        else:
+            completion_type = self._determine_completion_context(text)
         if completion_type == self._CompletionContextType.ATTRIBUTE:
             try:
                 matches, fragment = self._attr_matches(
@@ -2741,9 +2792,10 @@ class IPCompleter(Completer):
                             is None
                         )
                     matches = filter(no__name, matches)
-                return _convert_matcher_v1_result_to_v2(
+                matches = _convert_matcher_v1_result_to_v2(
                     matches, type="attribute", fragment=fragment
                 )
+                return matches
             except NameError:
                 # catches <undefined attributes>.<tab>
                 return SimpleMatcherResult(completions=[], suppress=False)
@@ -3253,7 +3305,7 @@ class IPCompleter(Completer):
 
         .. note::
 
-            If ``IPCompleter.debug`` is :any:`True` will yield a ``--jedi/ipython--``
+            If ``IPCompleter.debug`` is :py:data:`True` will yield a ``--jedi/ipython--``
             fake Completion token to distinguish completion returned by Jedi
             and usual IPython completion.
 

{ipython-9.6.0 → ipython-9.8.0}/IPython/core/debugger.py

@@ -275,6 +275,10 @@ class Pdb(OldPdb):
 
         # `kwargs` ensures full compatibility with stdlib's `pdb.Pdb`.
         OldPdb.__init__(self, completekey, stdin, stdout, **kwargs)
+        # Python 3.15+ should define this, so no need to initialize
+        # this avoids some getattr(self, 'curframe')
+        if sys.version_info < (3, 15):
+            self.curframe = None
 
         # IPython changes...
         self.shell = get_ipython()
@@ -609,7 +613,7 @@ class Pdb(OldPdb):
         So if frame is self.current_frame we instead return self.curframe_locals
 
         """
-        if frame is getattr(self, "curframe", None):
+        if frame is self.curframe:
             return self.curframe_locals
         else:
             return frame.f_locals
@@ -728,6 +732,7 @@ class Pdb(OldPdb):
 
         new_line, err = self.parser.format2(line, "str")
         if not err:
+            assert new_line is not None
             line = new_line
 
         bp = None

{ipython-9.6.0 → ipython-9.8.0}/IPython/core/display_functions.py

@@ -137,7 +137,7 @@ def display(
     -------
     handle: DisplayHandle
         Returns a handle on updatable displays for use with :func:`update_display`,
-        if `display_id` is given. Returns :any:`None` if no `display_id` is given
+        if `display_id` is given. Returns :py:data:`None` if no `display_id` is given
         (default).
 
     Examples

{ipython-9.6.0 → ipython-9.8.0}/IPython/core/displayhook.py

@@ -63,7 +63,7 @@ class DisplayHook(Configurable):
 
     @property
     def prompt_count(self):
-        return self.shell.execution_count
+        return self.shell.execution_count - 1
 
     #-------------------------------------------------------------------------
     # Methods used in __call__. Override these methods to modify the behavior
@@ -127,7 +127,7 @@ class DisplayHook(Configurable):
         """
         # Use write, not print which adds an extra space.
         sys.stdout.write(self.shell.separate_out)
-        outprompt = 'Out[{}]: '.format(self.shell.execution_count)
+        outprompt = 'Out[{}]: '.format(self.shell.execution_count - 1)
         if self.do_full_cache:
             sys.stdout.write(outprompt)
 

{ipython-9.6.0 → ipython-9.8.0}/IPython/core/displaypub.py

@@ -149,7 +149,7 @@ class DisplayPublisher(Configurable):
 
         outputs = self.shell.history_manager.outputs
 
-        target_execution_count = self.shell.execution_count
+        target_execution_count = self.shell.execution_count - 1
         if self._in_post_execute:
             # We're in post_execute, so this is likely a matplotlib flush
             # Use execution_count - 1 to associate with the cell that created the plot

{ipython-9.6.0 → ipython-9.8.0}/IPython/core/doctb.py

@@ -3,7 +3,8 @@ import linecache
 import sys
 from collections.abc import Sequence
 from types import TracebackType
-from typing import Any, Callable, Optional
+from typing import Any, Optional
+from collections.abc import Callable
 
 import stack_data
 from pygments.formatters.terminal256 import Terminal256Formatter

{ipython-9.6.0 → ipython-9.8.0}/IPython/core/events.py

@@ -13,6 +13,13 @@ events and the arguments which will be passed to them.
    This API is experimental in IPython 2.0, and may be revised in future versions.
 """
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Iterable
+
+if TYPE_CHECKING:
+    from IPython.core.interactiveshell import InteractiveShell
+
 
 class EventManager:
     """Manage a collection of events and a sequence of callbacks for each.
@@ -25,7 +32,12 @@ class EventManager:
        This API is experimental in IPython 2.0, and may be revised in future versions.
     """
 
-    def __init__(self, shell, available_events, print_on_error=True):
+    def __init__(
+        self,
+        shell: InteractiveShell,
+        available_events: Iterable[str],
+        print_on_error: bool = True,
+    ) -> None:
         """Initialise the :class:`CallbackManager`.
 
         Parameters
@@ -38,10 +50,12 @@ class EventManager:
             A boolean flag to set whether the EventManager will print a warning which a event errors.
         """
         self.shell = shell
-        self.callbacks = {n:[] for n in available_events}
+        self.callbacks: dict[str, list[Callable[..., Any]]] = {
+            n: [] for n in available_events
+        }
         self.print_on_error = print_on_error
     
-    def register(self, event, function):
+    def register(self, event: str, function: Callable[..., Any]) -> None:
         """Register a new event callback.
 
         Parameters
@@ -64,14 +78,14 @@ class EventManager:
         if function not in self.callbacks[event]:
             self.callbacks[event].append(function)
     
-    def unregister(self, event, function):
+    def unregister(self, event: str, function: Callable[..., Any]) -> None:
         """Remove a callback from the given event."""
         if function in self.callbacks[event]:
             return self.callbacks[event].remove(function)
 
         raise ValueError('Function {!r} is not registered as a {} callback'.format(function, event))
 
-    def trigger(self, event, *args, **kwargs):
+    def trigger(self, event: str, *args: Any, **kwargs: Any) -> None:
         """Call callbacks for ``event``.
 
         Any additional arguments are passed to all callbacks registered for this
@@ -90,9 +104,9 @@ class EventManager:
                 self.shell.showtraceback()
 
 # event_name -> prototype mapping
-available_events = {}
+available_events: dict[str, Callable[..., Any]] = {}
 
-def _define_event(callback_function):
+def _define_event(callback_function: Callable[..., Any]) -> Callable[..., Any]:
     available_events[callback_function.__name__] = callback_function
     return callback_function
 
@@ -104,7 +118,7 @@ def _define_event(callback_function):
 # ------------------------------------------------------------------------------
 
 @_define_event
-def pre_execute():
+def pre_execute() -> None:
     """Fires before code is executed in response to user/frontend action.
 
     This includes comm and widget messages and silent execution, as well as user
@@ -113,7 +127,7 @@ def pre_execute():
     pass
 
 @_define_event
-def pre_run_cell(info):
+def pre_run_cell(info: Any) -> None:
     """Fires before user-entered code runs.
 
     Parameters
@@ -124,7 +138,7 @@ def pre_run_cell(info):
     pass
 
 @_define_event
-def post_execute():
+def post_execute() -> None:
     """Fires after code is executed in response to user/frontend action.
 
     This includes comm and widget messages and silent execution, as well as user
@@ -133,7 +147,7 @@ def post_execute():
     pass
 
 @_define_event
-def post_run_cell(result):
+def post_run_cell(result: Any) -> None:
     """Fires after user-entered code runs.
 
     Parameters
@@ -144,7 +158,7 @@ def post_run_cell(result):
     pass
 
 @_define_event
-def shell_initialized(ip):
+def shell_initialized(ip: InteractiveShell) -> None:
     """Fires after initialisation of :class:`~IPython.core.interactiveshell.InteractiveShell`.
 
     This is before extensions and startup scripts are loaded, so it can only be

{ipython-9.6.0 → ipython-9.8.0}/IPython/core/formatters.py

@@ -366,7 +366,7 @@ class BaseFormatter(Configurable):
     dictionaries is through the :meth:`for_type` and :meth:`for_type_by_name`
     methods.
 
-    If no function/callable is found to compute the format data, ``None`` is
+    If no function/callable is found to compute the format data, :py:data:`None` is
     returned and this format type is not used.
     """