ipython 9.4.0__tar.gz → 9.6.0__tar.gz

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

@@ -213,8 +213,12 @@ from typing import (
     Literal,
 )
 
-from IPython.core.guarded_eval import guarded_eval, EvaluationContext
-from IPython.core.error import TryNext
+from IPython.core.guarded_eval import (
+    guarded_eval,
+    EvaluationContext,
+    _validate_policy_overrides,
+)
+from IPython.core.error import TryNext, UsageError
 from IPython.core.inputtransformer2 import ESC_MAGIC
 from IPython.core.latex_symbols import latex_symbols, reverse_latex_symbol
 from IPython.testing.skipdoctest import skip_doctest
@@ -222,7 +226,6 @@ from IPython.utils import generics
 from IPython.utils.PyColorize import theme_table
 from IPython.utils.decorators import sphinx_options
 from IPython.utils.dir2 import dir2, get_real_method
-from IPython.utils.docs import GENERATING_DOCUMENTATION
 from IPython.utils.path import ensure_dir_exists
 from IPython.utils.process import arg_split
 from traitlets import (
@@ -953,7 +956,6 @@ class CompletionSplitter:
         return self._delim_re.split(cut_line)[-1]
 
 
-
 class Completer(Configurable):
 
     greedy = Bool(
@@ -1045,6 +1047,18 @@ class Completer(Configurable):
         """,
     ).tag(config=True)
 
+    @observe("evaluation")
+    def _evaluation_changed(self, _change):
+        _validate_policy_overrides(
+            policy_name=self.evaluation, policy_overrides=self.policy_overrides
+        )
+
+    @observe("policy_overrides")
+    def _policy_overrides_changed(self, _change):
+        _validate_policy_overrides(
+            policy_name=self.evaluation, policy_overrides=self.policy_overrides
+        )
+
     auto_import_method = DottedObjectName(
         default_value="importlib.import_module",
         allow_none=True,
@@ -1113,7 +1127,7 @@ class Completer(Configurable):
         except IndexError:
             return None
 
-    def global_matches(self, text):
+    def global_matches(self, text: str, context: Optional[CompletionContext] = None):
         """Compute matches when text is a simple name.
 
         Return a list of all keywords, built-in functions and names currently
@@ -1123,12 +1137,41 @@ class Completer(Configurable):
         matches = []
         match_append = matches.append
         n = len(text)
-        for lst in [
+
+        search_lists = [
             keyword.kwlist,
             builtin_mod.__dict__.keys(),
             list(self.namespace.keys()),
             list(self.global_namespace.keys()),
-        ]:
+        ]
+        if context and context.full_text.count("\n") > 1:
+            # try to evaluate on full buffer
+            previous_lines = "\n".join(
+                context.full_text.split("\n")[: context.cursor_line]
+            )
+            if previous_lines:
+                all_code_lines_before_cursor = (
+                    self._extract_code(previous_lines) + "\n" + text
+                )
+                context = EvaluationContext(
+                    globals=self.global_namespace,
+                    locals=self.namespace,
+                    evaluation=self.evaluation,
+                    auto_import=self._auto_import,
+                    policy_overrides=self.policy_overrides,
+                )
+                try:
+                    obj = guarded_eval(
+                        all_code_lines_before_cursor,
+                        context,
+                    )
+                except Exception as e:
+                    if self.debug:
+                        warnings.warn(f"Evaluation exception {e}")
+
+                search_lists.append(list(context.transient_locals.keys()))
+
+        for lst in search_lists:
             for word in lst:
                 if word[:n] == text and word != "__builtins__":
                     match_append(word)
@@ -1143,6 +1186,7 @@ class Completer(Configurable):
             for word in shortened.keys():
                 if word[:n] == text and word != "__builtins__":
                     match_append(shortened[word])
+
         return matches
 
     def attr_matches(self, text):
@@ -1205,8 +1249,15 @@ class Completer(Configurable):
         else:
             return code
 
+    def _extract_code(self, line: str):
+        """No-op in Completer, but can be used in subclasses to customise behaviour"""
+        return line
+
     def _attr_matches(
-        self, text: str, include_prefix: bool = True
+        self,
+        text: str,
+        include_prefix: bool = True,
+        context: Optional[CompletionContext] = None,
     ) -> tuple[Sequence[str], str]:
         m2 = self._ATTR_MATCH_RE.match(text)
         if not m2:
@@ -1219,7 +1270,19 @@ class Completer(Configurable):
 
         obj = self._evaluate_expr(expr)
         if obj is not_found:
-            return [], ""
+            if context:
+                # try to evaluate on full buffer
+                previous_lines = "\n".join(
+                    context.full_text.split("\n")[: context.cursor_line]
+                )
+                if previous_lines:
+                    all_code_lines_before_cursor = (
+                        self._extract_code(previous_lines) + "\n" + expr
+                    )
+                    obj = self._evaluate_expr(all_code_lines_before_cursor)
+
+            if obj is not_found:
+                return [], ""
 
         if self.limit_to__all__ and hasattr(obj, '__all__'):
             words = get__all__entries(obj)
@@ -1313,14 +1376,23 @@ class Completer(Configurable):
                     ),
                 )
                 done = True
-            except Exception as e:
+            except (SyntaxError, TypeError) as e:
                 if self.debug:
-                    print("Evaluation exception", e)
+                    warnings.warn(f"Trimming because of {e}")
+                # TypeError can show up with something like `+ d`
+                # where `d` is a dictionary.
+
                 # trim the expression to remove any invalid prefix
                 # e.g. user starts `(d[`, so we get `expr = '(d'`,
                 # where parenthesis is not closed.
                 # TODO: make this faster by reusing parts of the computation?
                 expr = self._trim_expr(expr)
+            except Exception as e:
+                if self.debug:
+                    warnings.warn(f"Evaluation exception {e}")
+                done = True
+        if self.debug:
+            warnings.warn(f"Resolved to {obj}")
         return obj
 
     @property
@@ -1331,6 +1403,7 @@ class Completer(Configurable):
             self._auto_import_func = import_item(self.auto_import_method)
         return self._auto_import_func
 
+
 def get__all__entries(obj):
     """returns the strings in the __all__ attribute"""
     try:
@@ -2224,6 +2297,57 @@ class IPCompleter(Completer):
             "suppress": False,
         }
 
+    def _extract_code(self, line: str) -> str:
+        """Extract code from magics if any."""
+
+        if not line:
+            return line
+        maybe_magic, *rest = line.split(maxsplit=1)
+        if not rest:
+            return line
+        args = rest[0]
+        known_magics = self.shell.magics_manager.lsmagic()
+        line_magics = known_magics["line"]
+        magic_name = maybe_magic.lstrip(self.magic_escape)
+        if magic_name not in line_magics:
+            return line
+
+        if not maybe_magic.startswith(self.magic_escape):
+            all_variables = [*self.namespace.keys(), *self.global_namespace.keys()]
+            if magic_name in all_variables:
+                # short circuit if we see a line starting with say `time`
+                # but time is defined as a variable (in addition to being
+                # a magic). In these cases users need to use explicit `%time`.
+                return line
+
+        magic_method = line_magics[magic_name]
+
+        try:
+            if magic_name == "timeit":
+                opts, stmt = magic_method.__self__.parse_options(
+                    args,
+                    "n:r:tcp:qov:",
+                    posix=False,
+                    strict=False,
+                    preserve_non_opts=True,
+                )
+                return stmt
+            elif magic_name == "prun":
+                opts, stmt = magic_method.__self__.parse_options(
+                    args, "D:l:rs:T:q", list_all=True, posix=False
+                )
+                return stmt
+            elif hasattr(magic_method, "parser") and getattr(
+                magic_method, "has_arguments", False
+            ):
+                # e.g. %debug, %time
+                args, extra = magic_method.parser.parse_argstring(args, partial=True)
+                return " ".join(extra)
+        except UsageError:
+            return line
+
+        return line
+
     @context_matcher()
     def magic_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
         """Match magics."""
@@ -2235,7 +2359,7 @@ class IPCompleter(Completer):
         line_magics = lsm['line']
         cell_magics = lsm['cell']
         pre = self.magic_escape
-        pre2 = pre+pre
+        pre2 = pre + pre
 
         explicit_magic = text.startswith(pre)
 
@@ -2599,10 +2723,13 @@ class IPCompleter(Completer):
     def python_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
         """Match attributes or global python names"""
         text = context.text_until_cursor
+        text = self._extract_code(text)
         completion_type = self._determine_completion_context(text)
         if completion_type == self._CompletionContextType.ATTRIBUTE:
             try:
-                matches, fragment = self._attr_matches(text, include_prefix=False)
+                matches, fragment = self._attr_matches(
+                    text, include_prefix=False, context=context
+                )
                 if text.endswith(".") and self.omit__names:
                     if self.omit__names == 1:
                         # true if txt is _not_ a __ name, false otherwise:
@@ -2621,7 +2748,10 @@ class IPCompleter(Completer):
                 # catches <undefined attributes>.<tab>
                 return SimpleMatcherResult(completions=[], suppress=False)
         else:
-            matches = self.global_matches(context.token)
+            try:
+                matches = self.global_matches(context.token, context=context)
+            except TypeError:
+                matches = self.global_matches(context.token)
             # TODO: maybe distinguish between functions, modules and just "variables"
             return SimpleMatcherResult(
                 completions=[
@@ -3456,7 +3586,7 @@ class IPCompleter(Completer):
             full_text=full_text,
             cursor_position=cursor_pos,
             cursor_line=cursor_line,
-            token=text,
+            token=self._extract_code(text),
             limit=MATCHES_LIMIT,
         )
 

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

@@ -353,6 +353,26 @@ class Pdb(OldPdb):
         self.initial_frame = frame
         return super().set_trace(frame)
 
+    def get_stack(self, *args, **kwargs):
+        stack, pos = super().get_stack(*args, **kwargs)
+        if len(stack) >= 0 and self._is_internal_frame(stack[0][0]):
+            stack.pop(0)
+            pos -= 1
+        return stack, pos
+
+    def _is_internal_frame(self, frame):
+        """Determine if this frame should be skipped as internal"""
+        filename = frame.f_code.co_filename
+
+        # Skip bdb.py runcall and internal operations
+        if filename.endswith("bdb.py"):
+            func_name = frame.f_code.co_name
+            # Skip internal bdb operations but allow breakpoint hits
+            if func_name in ("runcall", "run", "runeval"):
+                return True
+
+        return False
+
     def _hidden_predicate(self, frame):
         """
         Given a frame return whether it it should be hidden or not by IPython.
@@ -754,7 +774,7 @@ class Pdb(OldPdb):
                             bp,
                             (Token.LinenoEm, num),
                             (Token, " "),
-                            # TODO: invsetigate Toke.Line here
+                            # TODO: investigate Token.Line here
                             (Token, colored_line),
                         ]
                     )
@@ -1087,6 +1107,21 @@ class Pdb(OldPdb):
                         ]
                     )
                 )
+        if self.skip and self.is_skipped_module(frame.f_globals.get("__name__", "")):
+            print(
+                self.theme.format(
+                    [
+                        (
+                            Token.ExcName,
+                            "    [... skipped 1 ignored module(s)]",
+                        ),
+                        (Token, "\n"),
+                    ]
+                )
+            )
+
+            return False
+
         return super().stop_here(frame)
 
     def do_up(self, arg):
@@ -1094,10 +1129,10 @@ class Pdb(OldPdb):
         Move the current frame count (default one) levels up in the
         stack trace (to an older frame).
 
-        Will skip hidden frames.
+        Will skip hidden frames and ignored modules.
         """
         # modified version of upstream that skips
-        # frames with __tracebackhide__
+        # frames with __tracebackhide__ and ignored modules
         if self.curindex == 0:
             self.error("Oldest frame")
             return
@@ -1106,15 +1141,27 @@ class Pdb(OldPdb):
         except ValueError:
             self.error("Invalid frame count (%s)" % arg)
             return
-        skipped = 0
+
+        hidden_skipped = 0
+        module_skipped = 0
+
         if count < 0:
             _newframe = 0
         else:
             counter = 0
             hidden_frames = self.hidden_frames(self.stack)
+
             for i in range(self.curindex - 1, -1, -1):
-                if hidden_frames[i] and self.skip_hidden:
-                    skipped += 1
+                should_skip_hidden = hidden_frames[i] and self.skip_hidden
+                should_skip_module = self.skip and self.is_skipped_module(
+                    self.stack[i][0].f_globals.get("__name__", "")
+                )
+
+                if should_skip_hidden or should_skip_module:
+                    if should_skip_hidden:
+                        hidden_skipped += 1
+                    if should_skip_module:
+                        module_skipped += 1
                     continue
                 counter += 1
                 if counter >= count:
@@ -1122,19 +1169,21 @@ class Pdb(OldPdb):
             else:
                 # if no break occurred.
                 self.error(
-                    "all frames above hidden, use `skip_hidden False` to get get into those."
+                    "all frames above skipped (hidden frames and ignored modules). Use `skip_hidden False` for hidden frames or unignore_module for ignored modules."
                 )
                 return
 
             _newframe = i
         self._select_frame(_newframe)
-        if skipped:
+
+        total_skipped = hidden_skipped + module_skipped
+        if total_skipped:
             print(
                 self.theme.format(
                     [
                         (
                             Token.ExcName,
-                            f"    [... skipped {skipped} hidden frame(s)]",
+                            f"    [... skipped {total_skipped} frame(s): {hidden_skipped} hidden frames + {module_skipped} ignored modules]",
                         ),
                         (Token, "\n"),
                     ]
@@ -1146,7 +1195,7 @@ class Pdb(OldPdb):
         Move the current frame count (default one) levels down in the
         stack trace (to a newer frame).
 
-        Will skip hidden frames.
+        Will skip hidden frames and ignored modules.
         """
         if self.curindex + 1 == len(self.stack):
             self.error("Newest frame")
@@ -1160,28 +1209,39 @@ class Pdb(OldPdb):
             _newframe = len(self.stack) - 1
         else:
             counter = 0
-            skipped = 0
+            hidden_skipped = 0
+            module_skipped = 0
             hidden_frames = self.hidden_frames(self.stack)
+
             for i in range(self.curindex + 1, len(self.stack)):
-                if hidden_frames[i] and self.skip_hidden:
-                    skipped += 1
+                should_skip_hidden = hidden_frames[i] and self.skip_hidden
+                should_skip_module = self.skip and self.is_skipped_module(
+                    self.stack[i][0].f_globals.get("__name__", "")
+                )
+
+                if should_skip_hidden or should_skip_module:
+                    if should_skip_hidden:
+                        hidden_skipped += 1
+                    if should_skip_module:
+                        module_skipped += 1
                     continue
                 counter += 1
                 if counter >= count:
                     break
             else:
                 self.error(
-                    "all frames below hidden, use `skip_hidden False` to get get into those."
+                    "all frames below skipped (hidden frames and ignored modules). Use `skip_hidden False` for hidden frames or unignore_module for ignored modules."
                 )
                 return
 
-            if skipped:
+            total_skipped = hidden_skipped + module_skipped
+            if total_skipped:
                 print(
                     self.theme.format(
                         [
                             (
                                 Token.ExcName,
-                                f"    [... skipped {skipped} hidden frame(s)]",
+                                f"    [... skipped {total_skipped} frame(s): {hidden_skipped} hidden frames + {module_skipped} ignored modules]",
                             ),
                             (Token, "\n"),
                         ]
@@ -1194,6 +1254,67 @@ class Pdb(OldPdb):
     do_d = do_down
     do_u = do_up
 
+    def _show_ignored_modules(self):
+        """Display currently ignored modules."""
+        if self.skip:
+            print(f"Currently ignored modules: {sorted(self.skip)}")
+        else:
+            print("No modules are currently ignored.")
+
+    def do_ignore_module(self, arg):
+        """ignore_module <module_name>
+
+        Add a module to the list of modules to skip when navigating frames.
+        When a module is ignored, the debugger will automatically skip over
+        frames from that module.
+
+        Supports wildcard patterns using fnmatch syntax:
+
+        Usage:
+            ignore_module threading     # Skip threading module frames
+            ignore_module asyncio.\\*    # Skip all asyncio submodules
+            ignore_module \\*.tests      # Skip all test modules
+            ignore_module               # List currently ignored modules
+        """
+
+        if self.skip is None:
+            self.skip = set()
+
+        module_name = arg.strip()
+
+        if not module_name:
+            self._show_ignored_modules()
+            return
+
+        self.skip.add(module_name)
+
+    def do_unignore_module(self, arg):
+        """unignore_module <module_name>
+
+        Remove a module from the list of modules to skip when navigating frames.
+        This will allow the debugger to step into frames from the specified module.
+
+        Usage:
+            unignore_module threading   # Stop ignoring threading module frames
+            unignore_module asyncio.\\*  # Remove asyncio.* pattern
+            unignore_module             # List currently ignored modules
+        """
+
+        if self.skip is None:
+            self.skip = set()
+
+        module_name = arg.strip()
+
+        if not module_name:
+            self._show_ignored_modules()
+            return
+
+        try:
+            self.skip.remove(module_name)
+        except KeyError:
+            print(f"Module {module_name} is not currently ignored")
+            self._show_ignored_modules()
+
     def do_context(self, context: str):
         """context number_of_lines
         Set the number of lines of source code to show when displaying

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

@@ -43,6 +43,9 @@ class DisplayPublisher(Configurable):
     def __init__(self, shell=None, *args, **kwargs):
         self.shell = shell
         self._is_publishing = False
+        self._in_post_execute = False
+        if self.shell:
+            self._setup_execution_tracking()
         super().__init__(*args, **kwargs)
 
     def _validate_data(self, data, metadata=None):
@@ -62,6 +65,19 @@ class DisplayPublisher(Configurable):
             if not isinstance(metadata, dict):
                 raise TypeError("metadata must be a dict, got: %r" % data)
 
+    def _setup_execution_tracking(self):
+        """Set up hooks to track execution state"""
+        self.shell.events.register("post_execute", self._on_post_execute)
+        self.shell.events.register("pre_execute", self._on_pre_execute)
+
+    def _on_post_execute(self):
+        """Called at start of post_execute phase"""
+        self._in_post_execute = True
+
+    def _on_pre_execute(self):
+        """Called at start of pre_execute phase"""
+        self._in_post_execute = False
+
     # use * to indicate transient, update are keyword-only
     def publish(
         self,
@@ -133,7 +149,13 @@ class DisplayPublisher(Configurable):
 
         outputs = self.shell.history_manager.outputs
 
-        outputs[self.shell.execution_count].append(
+        target_execution_count = self.shell.execution_count
+        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
+            target_execution_count = self.shell.execution_count - 1
+
+        outputs[target_execution_count].append(
             HistoryOutput(output_type="display_data", bundle=data)
         )