ipython 8.26.0__tar.gz → 8.28.0__tar.gz

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/completer.py

@@ -898,7 +898,7 @@ def rectify_completions(text: str, completions: _IC, *, _debug: bool = False) ->
         new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
         if c._origin == 'jedi':
             seen_jedi.add(new_text)
-        elif c._origin == 'IPCompleter.python_matches':
+        elif c._origin == "IPCompleter.python_matcher":
             seen_python_matches.add(new_text)
         yield Completion(new_start, new_end, new_text, type=c.type, _origin=c._origin, signature=c.signature)
     diff = seen_python_matches.difference(seen_jedi)
@@ -1139,15 +1139,18 @@ class Completer(Configurable):
         with a __getattr__ hook is evaluated.
 
         """
+        return self._attr_matches(text)[0]
+
+    def _attr_matches(self, text, include_prefix=True) -> Tuple[Sequence[str], str]:
         m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer)
         if not m2:
-            return []
+            return [], ""
         expr, attr = m2.group(1, 2)
 
         obj = self._evaluate_expr(expr)
 
         if obj is not_found:
-            return []
+            return [], ""
 
         if self.limit_to__all__ and hasattr(obj, '__all__'):
             words = get__all__entries(obj)
@@ -1170,28 +1173,36 @@ class Completer(Configurable):
         # reconciliator would know that we intend to append to rather than
         # replace the input text; this requires refactoring to return range
         # which ought to be replaced (as does jedi).
-        tokens = _parse_tokens(expr)
-        rev_tokens = reversed(tokens)
-        skip_over = {tokenize.ENDMARKER, tokenize.NEWLINE}
-        name_turn = True
-
-        parts = []
-        for token in rev_tokens:
-            if token.type in skip_over:
-                continue
-            if token.type == tokenize.NAME and name_turn:
-                parts.append(token.string)
-                name_turn = False
-            elif token.type == tokenize.OP and token.string == "." and not name_turn:
-                parts.append(token.string)
-                name_turn = True
-            else:
-                # short-circuit if not empty nor name token
-                break
+        if include_prefix:
+            tokens = _parse_tokens(expr)
+            rev_tokens = reversed(tokens)
+            skip_over = {tokenize.ENDMARKER, tokenize.NEWLINE}
+            name_turn = True
+
+            parts = []
+            for token in rev_tokens:
+                if token.type in skip_over:
+                    continue
+                if token.type == tokenize.NAME and name_turn:
+                    parts.append(token.string)
+                    name_turn = False
+                elif (
+                    token.type == tokenize.OP and token.string == "." and not name_turn
+                ):
+                    parts.append(token.string)
+                    name_turn = True
+                else:
+                    # short-circuit if not empty nor name token
+                    break
 
-        prefix_after_space = "".join(reversed(parts))
+            prefix_after_space = "".join(reversed(parts))
+        else:
+            prefix_after_space = ""
 
-        return ["%s.%s" % (prefix_after_space, w) for w in words if w[:n] == attr]
+        return (
+            ["%s.%s" % (prefix_after_space, w) for w in words if w[:n] == attr],
+            "." + attr,
+        )
 
     def _evaluate_expr(self, expr):
         obj = not_found
@@ -1973,9 +1984,8 @@ class IPCompleter(Completer):
                 *self.magic_arg_matchers,
                 self.custom_completer_matcher,
                 self.dict_key_matcher,
-                # TODO: convert python_matches to v2 API
                 self.magic_matcher,
-                self.python_matches,
+                self.python_matcher,
                 self.file_matcher,
                 self.python_func_kw_matcher,
             ]
@@ -2316,9 +2326,42 @@ class IPCompleter(Completer):
             else:
                 return iter([])
 
+    @context_matcher()
+    def python_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
+        """Match attributes or global python names"""
+        text = context.line_with_cursor
+        if "." in text:
+            try:
+                matches, fragment = self._attr_matches(text, include_prefix=False)
+                if text.endswith(".") and self.omit__names:
+                    if self.omit__names == 1:
+                        # true if txt is _not_ a __ name, false otherwise:
+                        no__name = lambda txt: re.match(r".*\.__.*?__", txt) is None
+                    else:
+                        # true if txt is _not_ a _ name, false otherwise:
+                        no__name = (
+                            lambda txt: re.match(r"\._.*?", txt[txt.rindex(".") :])
+                            is None
+                        )
+                    matches = filter(no__name, matches)
+                return _convert_matcher_v1_result_to_v2(
+                    matches, type="attribute", fragment=fragment
+                )
+            except NameError:
+                # catches <undefined attributes>.<tab>
+                matches = []
+                return _convert_matcher_v1_result_to_v2(matches, type="attribute")
+        else:
+            matches = self.global_matches(context.token)
+            # TODO: maybe distinguish between functions, modules and just "variables"
+            return _convert_matcher_v1_result_to_v2(matches, type="variable")
+
     @completion_matcher(api_version=1)
     def python_matches(self, text: str) -> Iterable[str]:
-        """Match attributes or global python names"""
+        """Match attributes or global python names.
+
+        .. deprecated:: 8.27
+            You can use :meth:`python_matcher` instead."""
         if "." in text:
             try:
                 matches = self.attr_matches(text)

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/debugger.py

@@ -14,14 +14,35 @@ Among other things, this subclass of PDB:
  - hide frames in tracebacks based on `__tracebackhide__`
  - allows to skip frames based on `__debuggerskip__`
 
+
+Global Configuration
+--------------------
+
+The IPython debugger will by read the global ``~/.pdbrc`` file.
+That is to say you can list all comands supported by ipdb in your `~/.pdbrc`
+configuration file, to globally configure pdb.
+
+Example::
+
+   # ~/.pdbrc
+   skip_predicates debuggerskip false
+   skip_hidden false
+   context 25
+
+Features
+--------
+
+The IPython debugger can hide and skip frames when printing or moving through
+the stack. This can have a performance impact, so can be configures.
+
 The skipping and hiding frames are configurable via the `skip_predicates`
 command.
 
 By default, frames from readonly files will be hidden, frames containing
-``__tracebackhide__=True`` will be hidden.
+``__tracebackhide__ = True`` will be hidden.
 
-Frames containing ``__debuggerskip__`` will be stepped over, frames who's parent
-frames value of ``__debuggerskip__`` is ``True`` will be skipped.
+Frames containing ``__debuggerskip__`` will be stepped over, frames whose parent
+frames value of ``__debuggerskip__`` is ``True`` will also be skipped.
 
     >>> def helpers_helper():
     ...     pass
@@ -1070,7 +1091,9 @@ class Pdb(OldPdb):
                 raise ValueError()
             self.context = new_context
         except ValueError:
-            self.error("The 'context' command requires a positive integer argument.")
+            self.error(
+                f"The 'context' command requires a positive integer argument (current value {self.context})."
+            )
 
 
 class InterruptiblePdb(Pdb):

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/display.py

@@ -41,7 +41,11 @@ from warnings import warn
 
 def __getattr__(name):
     if name in _deprecated_names:
-        warn(f"Importing {name} from IPython.core.display is deprecated since IPython 7.14, please import from IPython display", DeprecationWarning, stacklevel=2)
+        warn(
+            f"Importing {name} from IPython.core.display is deprecated since IPython 7.14, please import from IPython.display",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         return getattr(display_functions, name)
 
     if name in globals().keys():

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/magics/packaging.py

@@ -9,6 +9,7 @@
 #-----------------------------------------------------------------------------
 
 import functools
+import os
 import re
 import shlex
 import sys
@@ -41,6 +42,16 @@ def _get_conda_like_executable(command):
     executable: string
         Value should be: conda, mamba or micromamba
     """
+    # Check for a environment variable bound to the base executable, both conda and mamba
+    # set these when activating an environment.
+    base_executable = "CONDA_EXE"
+    if "mamba" in command.lower():
+        base_executable = "MAMBA_EXE"
+    if base_executable in os.environ:
+        executable = Path(os.environ[base_executable])
+        if executable.is_file():
+            return str(executable.resolve())
+
     # Check if there is a conda executable in the same directory as the Python executable.
     # This is the case within conda's root environment.
     executable = Path(sys.executable).parent / command
@@ -48,10 +59,12 @@ def _get_conda_like_executable(command):
         return str(executable)
 
     # Otherwise, attempt to extract the executable from conda history.
-    # This applies in any conda environment.
+    # This applies in any conda environment. Parsing this way is error prone because
+    # different versions of conda and mamba include differing cmd values such as
+    # `conda`, `conda-script.py`, or `path/to/conda`, here use the raw command provided.
     history = Path(sys.prefix, "conda-meta", "history").read_text(encoding="utf-8")
     match = re.search(
-        rf"^#\s*cmd:\s*(?P<command>.*{executable})\s[create|install]",
+        rf"^#\s*cmd:\s*(?P<command>.*{command})\s[create|install]",
         history,
         flags=re.MULTILINE,
     )

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/magics/pylab.py

@@ -100,7 +100,7 @@ class PylabMagics(Magics):
                 % _list_matplotlib_backends_and_gui_loops()
             )
         else:
-            gui, backend = self.shell.enable_matplotlib(args.gui.lower() if isinstance(args.gui, str) else args.gui)
+            gui, backend = self.shell.enable_matplotlib(args.gui)
             self._show_matplotlib_backend(args.gui, backend)
 
     @skip_doctest

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/prefilter.py

@@ -476,8 +476,8 @@ class PythonOpsChecker(PrefilterChecker):
         any python operator, we should simply execute the line (regardless of
         whether or not there's a possible autocall expansion).  This avoids
         spurious (and very confusing) geattr() accesses."""
-        if line_info.the_rest and line_info.the_rest[0] in '!=()<>,+*/%^&|':
-            return self.prefilter_manager.get_handler_by_name('normal')
+        if line_info.the_rest and line_info.the_rest[0] in "!=()<>,+*/%^&|":
+            return self.prefilter_manager.get_handler_by_name("normal")
         else:
             return None
 
@@ -512,6 +512,8 @@ class AutocallChecker(PrefilterChecker):
             callable(oinfo.obj)
             and (not self.exclude_regexp.match(line_info.the_rest))
             and self.function_name_regexp.match(line_info.ifun)
+            and line_info.raw_the_rest.startswith(" ")
+            or not line_info.raw_the_rest.strip()
         ):
             return self.prefilter_manager.get_handler_by_name("auto")
         else:

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/profiledir.py

@@ -14,6 +14,8 @@ from ..paths import get_ipython_package_dir
 from ..utils.path import expand_path, ensure_dir_exists
 from traitlets import Unicode, Bool, observe
 
+from typing import Optional
+
 #-----------------------------------------------------------------------------
 # Module errors
 #-----------------------------------------------------------------------------
@@ -68,18 +70,31 @@ class ProfileDir(LoggingConfigurable):
         self.pid_dir = os.path.join(new, self.pid_dir_name)
         self.static_dir = os.path.join(new, self.static_dir_name)
         self.check_dirs()
-    
-    def _mkdir(self, path, mode=None):
+
+    def _mkdir(self, path: str, mode: Optional[int] = None) -> bool:
         """ensure a directory exists at a given path
 
         This is a version of os.mkdir, with the following differences:
 
-        - returns True if it created the directory, False otherwise
+        - returns whether the directory has been created or not.
         - ignores EEXIST, protecting against race conditions where
           the dir may have been created in between the check and
           the creation
         - sets permissions if requested and the dir already exists
+
+        Parameters
+        ----------
+        path: str
+            path of the dir to create
+        mode: int
+            see `mode` of `os.mkdir`
+
+        Returns
+        -------
+        bool:
+            returns True if it created the directory, False otherwise
         """
+
         if os.path.exists(path):
             if mode and os.stat(path).st_mode != mode:
                 try:
@@ -109,16 +124,20 @@ class ProfileDir(LoggingConfigurable):
     
     @observe('startup_dir')
     def check_startup_dir(self, change=None):
-        self._mkdir(self.startup_dir)
-
-        readme = os.path.join(self.startup_dir, 'README')
-        src = os.path.join(get_ipython_package_dir(), u'core', u'profile', u'README_STARTUP')
-
-        if not os.path.exists(src):
-            self.log.warning("Could not copy README_STARTUP to startup dir. Source file %s does not exist.", src)
-
-        if os.path.exists(src) and not os.path.exists(readme):
-            shutil.copy(src, readme)
+        if self._mkdir(self.startup_dir):
+            readme = os.path.join(self.startup_dir, "README")
+            src = os.path.join(
+                get_ipython_package_dir(), "core", "profile", "README_STARTUP"
+            )
+
+            if os.path.exists(src):
+                if not os.path.exists(readme):
+                    shutil.copy(src, readme)
+            else:
+                self.log.warning(
+                    "Could not copy README_STARTUP to startup dir. Source file %s does not exist.",
+                    src,
+                )
 
     @observe('security_dir')
     def check_security_dir(self, change=None):

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/release.py

@@ -16,7 +16,7 @@
 # release.  'dev' as a _version_extra string means this is a development
 # version
 _version_major = 8
-_version_minor = 26
+_version_minor = 28
 _version_patch = 0
 _version_extra = ".dev"
 # _version_extra = "rc1"

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/splitinput.py

@@ -76,7 +76,7 @@ def split_user_input(line, pattern=None):
 
     # print('line:<%s>' % line)  # dbg
     # print('pre <%s> ifun <%s> rest <%s>' % (pre,ifun.strip(),the_rest))  # dbg
-    return pre, esc or '', ifun.strip(), the_rest.lstrip()
+    return pre, esc or "", ifun.strip(), the_rest
 
 
 class LineInfo(object):
@@ -107,11 +107,15 @@ class LineInfo(object):
 
     the_rest
       Everything else on the line.
+
+    raw_the_rest
+      the_rest without whitespace stripped.
     """
     def __init__(self, line, continue_prompt=False):
         self.line            = line
         self.continue_prompt = continue_prompt
-        self.pre, self.esc, self.ifun, self.the_rest = split_user_input(line)
+        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()
         if self.pre_char:
@@ -136,3 +140,6 @@ class LineInfo(object):
 
     def __str__(self):
         return "LineInfo [%s|%s|%s|%s]" %(self.pre, self.esc, self.ifun, self.the_rest)
+
+    def __repr__(self):
+        return "<" + str(self) + ">"

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/tests/test_completer.py

@@ -462,7 +462,10 @@ class TestCompleter(unittest.TestCase):
                 matches = c.all_completions("TestClass.")
                 assert len(matches) > 2, (jedi_status, matches)
                 matches = c.all_completions("TestClass.a")
-                assert matches == ['TestClass.a', 'TestClass.a1'], jedi_status
+                if jedi_status:
+                    assert matches == ["TestClass.a", "TestClass.a1"], jedi_status
+                else:
+                    assert matches == [".a", ".a1"], jedi_status
 
     @pytest.mark.xfail(
         sys.version_info.releaselevel in ("alpha",),
@@ -594,7 +597,7 @@ class TestCompleter(unittest.TestCase):
                 ip.Completer.use_jedi = True
                 with provisionalcompleter():
                     completions = ip.Completer.completions(line, cursor_pos)
-                self.assertIn(completion, completions)
+                self.assertIn(completion, list(completions))
 
         with provisionalcompleter():
             _(
@@ -622,7 +625,7 @@ class TestCompleter(unittest.TestCase):
             _(
                 "assert str.star",
                 14,
-                "str.startswith",
+                ".startswith",
                 "Should have completed on `assert str.star`: %s",
                 Completion(11, 14, "startswith"),
             )
@@ -633,6 +636,13 @@ class TestCompleter(unittest.TestCase):
                 "Should have completed on `d['a b'].str`: %s",
                 Completion(9, 12, "strip"),
             )
+            _(
+                "a.app",
+                4,
+                ".append",
+                "Should have completed on `a.app`: %s",
+                Completion(2, 4, "append"),
+            )
 
     def test_omit__names(self):
         # also happens to test IPCompleter as a configurable
@@ -647,8 +657,8 @@ class TestCompleter(unittest.TestCase):
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip.")
-            self.assertIn("ip.__str__", matches)
-            self.assertIn("ip._hidden_attr", matches)
+            self.assertIn(".__str__", matches)
+            self.assertIn("._hidden_attr", matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip.', 3))
@@ -661,7 +671,7 @@ class TestCompleter(unittest.TestCase):
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip.")
-            self.assertNotIn("ip.__str__", matches)
+            self.assertNotIn(".__str__", matches)
             # self.assertIn('ip._hidden_attr', matches)
 
             # c.use_jedi = True
@@ -675,8 +685,8 @@ class TestCompleter(unittest.TestCase):
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip.")
-            self.assertNotIn("ip.__str__", matches)
-            self.assertNotIn("ip._hidden_attr", matches)
+            self.assertNotIn(".__str__", matches)
+            self.assertNotIn("._hidden_attr", matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip.', 3))
@@ -686,7 +696,7 @@ class TestCompleter(unittest.TestCase):
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip._x.")
-            self.assertIn("ip._x.keys", matches)
+            self.assertIn(".keys", matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip._x.', 6))
@@ -697,7 +707,7 @@ class TestCompleter(unittest.TestCase):
 
     def test_limit_to__all__False_ok(self):
         """
-        Limit to all is deprecated, once we remove it this test can go away. 
+        Limit to all is deprecated, once we remove it this test can go away.
         """
         ip = get_ipython()
         c = ip.Completer
@@ -708,7 +718,7 @@ class TestCompleter(unittest.TestCase):
         cfg.IPCompleter.limit_to__all__ = False
         c.update_config(cfg)
         s, matches = c.complete("d.")
-        self.assertIn("d.x", matches)
+        self.assertIn(".x", matches)
 
     def test_get__all__entries_ok(self):
         class A:

{ipython-8.26.0 → ipython-8.28.0}/IPython/core/tests/test_debugger.py

@@ -59,40 +59,43 @@ def test_ipdb_magics():
 
     First, set up some test functions and classes which we can inspect.
 
-    >>> class ExampleClass(object):
-    ...    """Docstring for ExampleClass."""
-    ...    def __init__(self):
-    ...        """Docstring for ExampleClass.__init__"""
-    ...        pass
-    ...    def __str__(self):
-    ...        return "ExampleClass()"
-
-    >>> def example_function(x, y, z="hello"):
-    ...     """Docstring for example_function."""
-    ...     pass
+    In [1]: class ExampleClass(object):
+       ...:    """Docstring for ExampleClass."""
+       ...:    def __init__(self):
+       ...:        """Docstring for ExampleClass.__init__"""
+       ...:        pass
+       ...:    def __str__(self):
+       ...:        return "ExampleClass()"
 
-    >>> old_trace = sys.gettrace()
+    In [2]: def example_function(x, y, z="hello"):
+       ...:     """Docstring for example_function."""
+       ...:     pass
 
-    Create a function which triggers ipdb.
+    In [3]: old_trace = sys.gettrace()
 
-    >>> def trigger_ipdb():
-    ...    a = ExampleClass()
-    ...    debugger.Pdb().set_trace()
+    Create a function which triggers ipdb.
 
-    >>> with PdbTestInput([
-    ...    'pdef example_function',
-    ...    'pdoc ExampleClass',
-    ...    'up',
-    ...    'down',
-    ...    'list',
-    ...    'pinfo a',
-    ...    'll',
-    ...    'continue',
-    ... ]):
-    ...     trigger_ipdb()
-    --Return--
-    None
-    > <doctest ...>(3)trigger_ipdb()
+    In [4]: def trigger_ipdb():
+       ...:    a = ExampleClass()
+       ...:    debugger.Pdb().set_trace()
+
+    Run ipdb with faked input & check output. Because of a difference between
+    Python 3.13 & older versions, the first bit of the output is inconsistent.
+    We need to use ... to accommodate that, so the examples have to use IPython
+    prompts so that ... is distinct from the Python PS2 prompt.
+
+    In [5]: with PdbTestInput([
+       ...:    'pdef example_function',
+       ...:    'pdoc ExampleClass',
+       ...:    'up',
+       ...:    'down',
+       ...:    'list',
+       ...:    'pinfo a',
+       ...:    'll',
+       ...:    'continue',
+       ...: ]):
+       ...:     trigger_ipdb()
+    ...> <doctest ...>(3)trigger_ipdb()
           1 def trigger_ipdb():
           2    a = ExampleClass()
     ----> 3    debugger.Pdb().set_trace()
@@ -112,8 +115,7 @@ def test_ipdb_magics():
          10 ]):
     ---> 11     trigger_ipdb()
     <BLANKLINE>
-    ipdb> down
-    None
+    ipdb> down...
     > <doctest ...>(3)trigger_ipdb()
           1 def trigger_ipdb():
           2    a = ExampleClass()
@@ -136,10 +138,10 @@ def test_ipdb_magics():
     ----> 3    debugger.Pdb().set_trace()
     <BLANKLINE>
     ipdb> continue
-    
-    Restore previous trace function, e.g. for coverage.py    
-    
-    >>> sys.settrace(old_trace)
+
+    Restore previous trace function, e.g. for coverage.py
+
+    In [6]: sys.settrace(old_trace)
     '''
 
 def test_ipdb_magics2():
@@ -495,15 +497,26 @@ def test_decorator_skip_with_breakpoint():
                 child.expect_exact(line)
             child.sendline("")
 
-        # as the filename does not exists, we'll rely on the filename prompt
-        child.expect_exact("47     bar(3, 4)")
-
-        for input_, expected in [
-            (f"b {name}.py:3", ""),
-            ("step", "1---> 3     pass # should not stop here except"),
-            ("step", "---> 38 @pdb_skipped_decorator"),
-            ("continue", ""),
-        ]:
+        # From 3.13, set_trace()/breakpoint() stop on the line where they're
+        # called, instead of the next line.
+        if sys.version_info >= (3, 13):
+            child.expect_exact("--> 46     ipdb.set_trace()")
+            extra_step = [("step", "--> 47     bar(3, 4)")]
+        else:
+            child.expect_exact("--> 47     bar(3, 4)")
+            extra_step = []
+
+        for input_, expected in (
+            [
+                (f"b {name}.py:3", ""),
+            ]
+            + extra_step
+            + [
+                ("step", "1---> 3     pass # should not stop here except"),
+                ("step", "---> 38 @pdb_skipped_decorator"),
+                ("continue", ""),
+            ]
+        ):
             child.expect("ipdb>")
             child.sendline(input_)
             child.expect_exact(input_)