ipython 8.29.0__tar.gz → 8.31.0__tar.gz

{ipython-8.29.0 → ipython-8.31.0}/IPython/core/completer.py

@@ -184,6 +184,7 @@ import glob
 import inspect
 import itertools
 import keyword
+import ast
 import os
 import re
 import string
@@ -347,7 +348,7 @@ def provisionalcompleter(action='ignore'):
         yield
 
 
-def has_open_quotes(s):
+def has_open_quotes(s: str) -> Union[str, bool]:
     """Return whether a string has open quotes.
 
     This simply counts whether the number of quote characters of either type in
@@ -368,7 +369,7 @@ def has_open_quotes(s):
         return False
 
 
-def protect_filename(s, protectables=PROTECTABLES):
+def protect_filename(s: str, protectables: str = PROTECTABLES) -> str:
     """Escape a string to protect certain characters."""
     if set(s) & set(protectables):
         if sys.platform == "win32":
@@ -449,11 +450,11 @@ def completions_sorting_key(word):
 
     if word.startswith('%%'):
         # If there's another % in there, this is something else, so leave it alone
-        if not "%" in word[2:]:
+        if "%" not in word[2:]:
             word = word[2:]
             prio2 = 2
     elif word.startswith('%'):
-        if not "%" in word[1:]:
+        if "%" not in word[1:]:
             word = word[1:]
             prio2 = 1
 
@@ -752,7 +753,7 @@ def completion_matcher(
     priority: Optional[float] = None,
     identifier: Optional[str] = None,
     api_version: int = 1,
-):
+) -> Callable[[Matcher], Matcher]:
     """Adds attributes describing the matcher.
 
     Parameters
@@ -961,8 +962,8 @@ class CompletionSplitter(object):
     def split_line(self, line, cursor_pos=None):
         """Split a line of text with a cursor at the given position.
         """
-        l = line if cursor_pos is None else line[:cursor_pos]
-        return self._delim_re.split(l)[-1]
+        cut_line = line if cursor_pos is None else line[:cursor_pos]
+        return self._delim_re.split(cut_line)[-1]
 
 
 
@@ -1141,8 +1142,13 @@ class Completer(Configurable):
         """
         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)
+    # we simple attribute matching with normal identifiers.
+    _ATTR_MATCH_RE = re.compile(r"(.+)\.(\w*)$")
+
+    def _attr_matches(
+        self, text: str, include_prefix: bool = True
+    ) -> Tuple[Sequence[str], str]:
+        m2 = self._ATTR_MATCH_RE.match(self.line_buffer)
         if not m2:
             return [], ""
         expr, attr = m2.group(1, 2)
@@ -1204,6 +1210,30 @@ class Completer(Configurable):
             "." + attr,
         )
 
+    def _trim_expr(self, code: str) -> str:
+        """
+        Trim the code until it is a valid expression and not a tuple;
+
+        return the trimmed expression for guarded_eval.
+        """
+        while code:
+            code = code[1:]
+            try:
+                res = ast.parse(code)
+            except SyntaxError:
+                continue
+
+            assert res is not None
+            if len(res.body) != 1:
+                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>
+                # as `a,b` would be a tuple, and we actually expect to get only `b`
+                continue
+            return code
+        return ""
+
     def _evaluate_expr(self, expr):
         obj = not_found
         done = False
@@ -1225,14 +1255,14 @@ class Completer(Configurable):
                 # 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 = expr[1:]
+                expr = self._trim_expr(expr)
         return obj
 
 def get__all__entries(obj):
     """returns the strings in the __all__ attribute"""
     try:
         words = getattr(obj, '__all__')
-    except:
+    except Exception:
         return []
 
     return [w for w in words if isinstance(w, str)]
@@ -1362,9 +1392,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.
@@ -1447,7 +1477,7 @@ def match_dict_keys(
         try:
             if not str_key.startswith(prefix_str):
                 continue
-        except (AttributeError, TypeError, UnicodeError) as e:
+        except (AttributeError, TypeError, UnicodeError):
             # Python 3+ TypeError on b'a'.startswith('a') or vice-versa
             continue
 
@@ -1495,7 +1525,7 @@ def cursor_to_position(text:str, line:int, column:int)->int:
     lines = text.split('\n')
     assert line <= len(lines), '{} <= {}'.format(str(line), str(len(lines)))
 
-    return sum(len(l) + 1 for l in lines[:line]) + column
+    return sum(len(line) + 1 for line in lines[:line]) + column
 
 def position_to_cursor(text:str, offset:int)->Tuple[int, int]:
     """
@@ -2112,7 +2142,7 @@ class IPCompleter(Completer):
         result["suppress"] = is_magic_prefix and bool(result["completions"])
         return result
 
-    def magic_matches(self, text: str):
+    def magic_matches(self, text: str) -> List[str]:
         """Match magics.
 
         .. deprecated:: 8.6
@@ -2469,7 +2499,8 @@ class IPCompleter(Completer):
         # parenthesis before the cursor
         # e.g. for "foo (1+bar(x), pa<cursor>,a=1)", the candidate is "foo"
         tokens = regexp.findall(self.text_until_cursor)
-        iterTokens = reversed(tokens); openPar = 0
+        iterTokens = reversed(tokens)
+        openPar = 0
 
         for token in iterTokens:
             if token == ')':
@@ -2489,7 +2520,8 @@ class IPCompleter(Completer):
             try:
                 ids.append(next(iterTokens))
                 if not isId(ids[-1]):
-                    ids.pop(); break
+                    ids.pop()
+                    break
                 if not next(iterTokens) == '.':
                     break
             except StopIteration:
@@ -3215,7 +3247,7 @@ class IPCompleter(Completer):
                 else:
                     api_version = _get_matcher_api_version(matcher)
                     raise ValueError(f"Unsupported API version {api_version}")
-            except:
+            except BaseException:
                 # Show the ugly traceback if the matcher causes an
                 # exception, but do NOT crash the kernel!
                 sys.excepthook(*sys.exc_info())

{ipython-8.29.0 → ipython-8.31.0}/IPython/core/crashhandler.py

@@ -24,14 +24,17 @@ import traceback
 from pprint import pformat
 from pathlib import Path
 
+import builtins as builtin_mod
+
 from IPython.core import ultratb
+from IPython.core.application import Application
 from IPython.core.release import author_email
 from IPython.utils.sysinfo import sys_info
-from IPython.utils.py3compat import input
 
 from IPython.core.release import __version__ as version
 
-from typing import Optional
+from typing import Optional, Dict
+import types
 
 #-----------------------------------------------------------------------------
 # Code
@@ -84,7 +87,7 @@ Extra-detailed tracebacks for bug-reporting purposes can be enabled via:
 """
 
 
-class CrashHandler(object):
+class CrashHandler:
     """Customizable crash handlers for IPython applications.
 
     Instances of this class provide a :meth:`__call__` method which can be
@@ -95,10 +98,11 @@ class CrashHandler(object):
 
     message_template = _default_message_template
     section_sep = '\n\n'+'*'*75+'\n\n'
+    info: Dict[str, Optional[str]]
 
     def __init__(
         self,
-        app,
+        app: Application,
         contact_name: Optional[str] = None,
         contact_email: Optional[str] = None,
         bug_tracker: Optional[str] = None,
@@ -142,10 +146,14 @@ class CrashHandler(object):
                     bug_tracker = bug_tracker,
                     crash_report_fname = self.crash_report_fname)
 
-
-    def __call__(self, etype, evalue, etb):
+    def __call__(
+        self,
+        etype: type[BaseException],
+        evalue: BaseException,
+        etb: types.TracebackType,
+    ) -> None:
         """Handle an exception, call for compatible with sys.excepthook"""
-        
+
         # do not allow the crash handler to be called twice without reinstalling it
         # this prevents unlikely errors in the crash handling from entering an
         # infinite loop.
@@ -155,21 +163,23 @@ class CrashHandler(object):
         color_scheme = 'NoColor'
 
         # Use this ONLY for developer debugging (keep commented out for release)
-        #color_scheme = 'Linux'   # dbg
-        try:
-            rptdir = self.app.ipython_dir
-        except:
+        # color_scheme = 'Linux'   # dbg
+        ipython_dir = getattr(self.app, "ipython_dir", None)
+        if ipython_dir is not None:
+            assert isinstance(ipython_dir, str)
+            rptdir = Path(ipython_dir)
+        else:
             rptdir = Path.cwd()
-        if rptdir is None or not Path.is_dir(rptdir):
+        if not rptdir.is_dir():
             rptdir = Path.cwd()
         report_name = rptdir / self.crash_report_fname
         # write the report filename into the instance dict so it can get
         # properly expanded out in the user message template
-        self.crash_report_fname = report_name
-        self.info['crash_report_fname'] = report_name
+        self.crash_report_fname = str(report_name)
+        self.info["crash_report_fname"] = str(report_name)
         TBhandler = ultratb.VerboseTB(
             color_scheme=color_scheme,
-            long_header=1,
+            long_header=True,
             call_pdb=self.call_pdb,
         )
         if self.call_pdb:
@@ -195,11 +205,11 @@ class CrashHandler(object):
             print(self.message_template.format(**self.info), file=sys.stderr)
 
             # Construct report on disk
-            report.write(self.make_report(traceback))
+            report.write(self.make_report(str(traceback)))
 
-        input("Hit <Enter> to quit (your terminal may close):")
+        builtin_mod.input("Hit <Enter> to quit (your terminal may close):")
 
-    def make_report(self,traceback):
+    def make_report(self, traceback: str) -> str:
         """Return a string containing a crash report."""
 
         sec_sep = self.section_sep
@@ -211,8 +221,8 @@ class CrashHandler(object):
         try:
             config = pformat(self.app.config)
             rpt_add(sec_sep)
-            rpt_add('Application name: %s\n\n' % self.app_name)
-            rpt_add('Current user configuration structure:\n\n')
+            rpt_add("Application name: %s\n\n" % self.app.name)
+            rpt_add("Current user configuration structure:\n\n")
             rpt_add(config)
         except:
             pass
@@ -221,7 +231,9 @@ class CrashHandler(object):
         return ''.join(report)
 
 
-def crash_handler_lite(etype, evalue, tb):
+def crash_handler_lite(
+    etype: type[BaseException], evalue: BaseException, tb: types.TracebackType
+) -> None:
     """a light excepthook, adding a small message to the usual traceback"""
     traceback.print_exception(etype, evalue, tb)
     

{ipython-8.29.0 → ipython-8.31.0}/IPython/core/debugger.py

@@ -550,7 +550,7 @@ class Pdb(OldPdb):
         So if frame is self.current_frame we instead return self.curframe_locals
 
         """
-        if frame is self.curframe:
+        if frame is getattr(self, "curframe", None):
             return self.curframe_locals
         else:
             return frame.f_locals

{ipython-8.29.0 → ipython-8.31.0}/IPython/core/display.py

@@ -16,7 +16,8 @@ from copy import deepcopy
 from os.path import splitext
 from pathlib import Path, PurePath
 
-from IPython.utils.py3compat import cast_unicode
+from typing import Optional
+
 from IPython.testing.skipdoctest import skip_doctest
 from . import display_functions
 
@@ -518,7 +519,7 @@ class SVG(DisplayObject):
     _read_flags = 'rb'
     # wrap data in a property, which extracts the <svg> tag, discarding
     # document headers
-    _data = None
+    _data: Optional[str] = None
 
     @property
     def data(self):
@@ -540,8 +541,10 @@ class SVG(DisplayObject):
             # fallback on the input, trust the user
             # but this is probably an error.
             pass
-        svg = cast_unicode(svg)
-        self._data = svg
+        if isinstance(svg, bytes):
+            self._data = svg.decode(errors="replace")
+        else:
+            self._data = svg
 
     def _repr_svg_(self):
         return self._data_and_metadata()

{ipython-8.29.0 → ipython-8.31.0}/IPython/core/formatters.py

@@ -1,6 +1,61 @@
 # -*- coding: utf-8 -*-
 """Display formatters.
 
+This module defines the base instances in order to implement custom
+formatters/mimetypes
+got objects:
+
+As we want to see internal IPython working we are going to use the following
+function to diaply objects instead of the normal print or display method:
+
+    >>> ip = get_ipython()
+    >>> ip.display_formatter.format(...)
+    ({'text/plain': 'Ellipsis'}, {})
+
+This return a tuple with the mimebumdle for the current object, and the
+associated metadata.
+
+
+We can now define our own formatter and register it:
+
+
+    >>> from IPython.core.formatters import BaseFormatter, FormatterABC
+
+
+    >>> class LLMFormatter(BaseFormatter):
+    ...
+    ...     format_type = 'x-vendor/llm'
+    ...     print_method = '_repr_llm_'
+    ...     _return_type = (dict, str)
+
+    >>> llm_formatter = LLMFormatter(parent=ip.display_formatter)
+
+    >>> ip.display_formatter.formatters[LLMFormatter.format_type] = llm_formatter
+
+Now any class that define `_repr_llm_` will return a x-vendor/llm as part of
+it's display data:
+
+    >>> class A:
+    ...
+    ...     def _repr_llm_(self, *kwargs):
+    ...         return 'This a A'
+    ...
+
+    >>> ip.display_formatter.format(A())
+    ({'text/plain': '<IPython.core.formatters.A at ...>', 'x-vendor/llm': 'This a A'}, {})
+
+As usual, you can register methods for third party types (see
+:ref:`third_party_formatting`)
+
+    >>> def llm_int(obj):
+    ...      return 'This is the integer %s, in between %s and %s'%(obj, obj-1, obj+1)
+
+    >>> llm_formatter.for_type(int, llm_int)
+
+    >>> ip.display_formatter.format(42)
+    ({'text/plain': '42', 'x-vendor/llm': 'This is the integer 42, in between 41 and 43'}, {})
+
+
 Inheritance diagram:
 
 .. inheritance-diagram:: IPython.core.formatters
@@ -37,9 +92,10 @@ class DisplayFormatter(Configurable):
     active_types = List(Unicode(),
         help="""List of currently active mime-types to display.
         You can use this to set a white-list for formats to display.
-        
+
         Most users will not need to change this value.
-        """).tag(config=True)
+        """,
+    ).tag(config=True)
 
     @default('active_types')
     def _active_types_default(self):
@@ -144,7 +200,7 @@ class DisplayFormatter(Configurable):
         """
         format_dict = {}
         md_dict = {}
-        
+
         if self.ipython_display_formatter(obj):
             # object handled itself, don't proceed
             return {}, {}
@@ -176,18 +232,18 @@ class DisplayFormatter(Configurable):
                 continue
             if exclude and format_type in exclude:
                 continue
-            
+
             md = None
             try:
                 data = formatter(obj)
             except:
                 # FIXME: log the exception
                 raise
-            
+
             # formatters can return raw data or (data, metadata)
             if isinstance(data, tuple) and len(data) == 2:
                 data, md = data
-            
+
             if data is not None:
                 format_dict[format_type] = data
             if md is not None:
@@ -252,7 +308,7 @@ class FormatterABC(metaclass=abc.ABCMeta):
 
     # Is the formatter enabled...
     enabled = True
-    
+
     @abc.abstractmethod
     def __call__(self, obj):
         """Return a JSON'able representation of the object.
@@ -278,12 +334,15 @@ def _get_type(obj):
     return getattr(obj, '__class__', None) or type(obj)
 
 
-_raise_key_error = Sentinel('_raise_key_error', __name__, 
-"""
+_raise_key_error = Sentinel(
+    "_raise_key_error",
+    __name__,
+    """
 Special value to raise a KeyError
 
 Raise KeyError in `BaseFormatter.pop` if passed as the default value to `pop`
-""")
+""",
+)
 
 
 class BaseFormatter(Configurable):
@@ -329,7 +388,7 @@ class BaseFormatter(Configurable):
     # The deferred-import type-specific printers.
     # Map (modulename, classname) pairs to the format functions.
     deferred_printers = Dict().tag(config=True)
-    
+
     @catch_format_error
     def __call__(self, obj):
         """Compute the format for an object."""
@@ -348,7 +407,7 @@ class BaseFormatter(Configurable):
             return None
         else:
             return None
-    
+
     def __contains__(self, typ):
         """map in to lookup_by_type"""
         try:
@@ -357,7 +416,7 @@ class BaseFormatter(Configurable):
             return False
         else:
             return True
-    
+
     def _check_return(self, r, obj):
         """Check that a return value is appropriate
 
@@ -372,7 +431,7 @@ class BaseFormatter(Configurable):
                 (self.format_type, type(r), self._return_type, _safe_repr(obj)),
                 FormatterWarning
             )
-    
+
     def lookup(self, obj):
         """Look up the formatter for a given instance.
 
@@ -395,7 +454,7 @@ class BaseFormatter(Configurable):
             return self.singleton_printers[obj_id]
         # then lookup by type
         return self.lookup_by_type(_get_type(obj))
-    
+
     def lookup_by_type(self, typ):
         """Look up the registered formatter for a type.
 
@@ -426,7 +485,7 @@ class BaseFormatter(Configurable):
             for cls in pretty._get_mro(typ):
                 if cls in self.type_printers or self._in_deferred_types(cls):
                     return self.type_printers[cls]
-        
+
         # If we have reached here, the lookup failed.
         raise KeyError("No registered printer for {0!r}".format(typ))
 
@@ -459,15 +518,15 @@ class BaseFormatter(Configurable):
         if isinstance(typ, str):
             type_module, type_name = typ.rsplit('.', 1)
             return self.for_type_by_name(type_module, type_name, func)
-        
+
         try:
             oldfunc = self.lookup_by_type(typ)
         except KeyError:
             oldfunc = None
-        
+
         if func is not None:
             self.type_printers[typ] = func
-        
+
         return oldfunc
 
     def for_type_by_name(self, type_module, type_name, func=None):
@@ -501,16 +560,16 @@ class BaseFormatter(Configurable):
             this will be the previous value (to enable restoring later).
         """
         key = (type_module, type_name)
-        
+
         try:
             oldfunc = self.lookup_by_type("%s.%s" % key)
         except KeyError:
             oldfunc = None
-        
+
         if func is not None:
             self.deferred_printers[key] = func
         return oldfunc
-    
+
     def pop(self, typ, default=_raise_key_error):
         """Pop a formatter for the given type.
 
@@ -529,7 +588,7 @@ class BaseFormatter(Configurable):
         ------
         KeyError if the type is not registered and default is not specified.
         """
-        
+
         if isinstance(typ, str):
             typ_key = tuple(typ.rsplit('.',1))
             if typ_key not in self.deferred_printers:
@@ -599,14 +658,14 @@ class PlainTextFormatter(BaseFormatter):
     # This subclass ignores this attribute as it always need to return
     # something.
     enabled = Bool(True).tag(config=False)
-    
+
     max_seq_length = Integer(pretty.MAX_SEQ_LENGTH,
         help="""Truncate large collections (lists, dicts, tuples, sets) to this size.
-        
+
         Set to 0 to disable truncation.
-        """
+        """,
     ).tag(config=True)
-    
+
     # Look for a _repr_pretty_ methods to use for pretty printing.
     print_method = ObjectName('_repr_pretty_')
 
@@ -775,7 +834,7 @@ class PNGFormatter(BaseFormatter):
     format_type = Unicode('image/png')
 
     print_method = ObjectName('_repr_png_')
-    
+
     _return_type = (bytes, str)
 
 
@@ -829,7 +888,7 @@ class JSONFormatter(BaseFormatter):
     _return_type = (list, dict)
 
     print_method = ObjectName('_repr_json_')
-    
+
     def _check_return(self, r, obj):
         """Check that a return value is appropriate
 
@@ -887,19 +946,19 @@ class PDFFormatter(BaseFormatter):
 
 class IPythonDisplayFormatter(BaseFormatter):
     """An escape-hatch Formatter for objects that know how to display themselves.
-    
+
     To define the callables that compute the representation of your
     objects, define a :meth:`_ipython_display_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this. Unlike mime-type displays, this method should not return anything,
     instead calling any appropriate display methods itself.
-    
+
     This display formatter has highest priority.
     If it fires, no other display formatter will be called.
 
     Prior to IPython 6.1, `_ipython_display_` was the only way to display custom mime-types
     without registering a new Formatter.
-    
+
     IPython 6.1 introduces `_repr_mimebundle_` for displaying custom mime-types,
     so `_ipython_display_` should only be used for objects that require unusual
     display patterns, such as multiple display calls.
@@ -943,7 +1002,7 @@ class MimeBundleFormatter(BaseFormatter):
     """
     print_method = ObjectName('_repr_mimebundle_')
     _return_type = dict
-    
+
     def _check_return(self, r, obj):
         r = super(MimeBundleFormatter, self)._check_return(r, obj)
         # always return (data, metadata):

{ipython-8.29.0 → ipython-8.31.0}/IPython/core/guarded_eval.py

@@ -44,20 +44,17 @@ else:
 
 @undoc
 class HasGetItem(Protocol):
-    def __getitem__(self, key) -> None:
-        ...
+    def __getitem__(self, key) -> None: ...
 
 
 @undoc
 class InstancesHaveGetItem(Protocol):
-    def __call__(self, *args, **kwargs) -> HasGetItem:
-        ...
+    def __call__(self, *args, **kwargs) -> HasGetItem: ...
 
 
 @undoc
 class HasGetAttr(Protocol):
-    def __getattr__(self, key) -> None:
-        ...
+    def __getattr__(self, key) -> None: ...
 
 
 @undoc
@@ -329,9 +326,9 @@ class EvaluationContext(NamedTuple):
     #: Global namespace
     globals: dict
     #: Evaluation policy identifier
-    evaluation: Literal[
-        "forbidden", "minimal", "limited", "unsafe", "dangerous"
-    ] = "forbidden"
+    evaluation: Literal["forbidden", "minimal", "limited", "unsafe", "dangerous"] = (
+        "forbidden"
+    )
     #: Whether the evaluation of code takes place inside of a subscript.
     #: Useful for evaluating ``:-1, 'col'`` in ``df[:-1, 'col']``.
     in_subscript: bool = False