ipython 9.16.0__tar.gz → 9.17.0__tar.gz

{ipython-9.16.0 → ipython-9.17.0}/IPython/__init__.py

@@ -34,10 +34,32 @@ from typing import Any
 # rely on the transitive side effects: they do `import IPython` and then
 # access attribute chains like `IPython.terminal.ipapp.TerminalIPythonApp`,
 # which only resolve because the imports below load those submodules.
-from .core.getipython import get_ipython
+#
+# `embed`, `Application` and `get_ipython` are the exceptions, and are
+# deferred via module `__getattr__` below:
+#
+#  - `embed` drags in the whole terminal / prompt_toolkit stack, by far
+#    the most expensive of these imports, and is only needed by code that
+#    calls `IPython.embed()`;
+#  - `Application` is only a re-export of `traitlets.config.application
+#    .Application`, but importing it pulled in `IPython.core.application`
+#    and with it the crash handler; no known downstream imports it from
+#    here (ipykernel imports `BaseIPythonApplication` from
+#    `IPython.core.application` directly);
+#  - `get_ipython` costs nothing to defer -- `IPython.core.getipython`
+#    ends up imported anyway via `IPython.core.magic` -- but is kept
+#    alongside the others so all three top-level names resolve the same
+#    way.
+#
+# This does mean that code relying on `import IPython` to transitively
+# populate `IPython.terminal.embed` / `IPython.core.application` (or
+# submodules only reachable through them) as a side effect will need to
+# import those submodules explicitly instead. `Application` raises a
+# `DeprecationWarning` when accessed here, both because such code is worth
+# spotting and because the name should be imported from traitlets;
+# `embed` and `get_ipython` stay silent, being widely and legitimately
+# used from here.
 from .core import release
-from .core.application import Application
-from .terminal.embed import embed
 
 from .core.interactiveshell import InteractiveShell
 from .utils.sysinfo import sys_info
@@ -45,6 +67,52 @@ from .utils.frame import extract_module_locals
 
 __all__ = ["start_ipython", "embed", "embed_kernel"]
 
+
+# Nothing below is cached in `globals()`: the lookups stay lazy on every
+# access, so that the `Application` warning keeps firing instead of only
+# on the first access, and so that these names never silently turn into
+# plain module attributes that later code could mistake for eagerly
+# imported ones.
+#
+# `Application` is deliberately absent from `_lazy_attrs`, and hence from
+# `__dir__`: anything that walks `dir(IPython)` and getattr()s the result
+# -- our own module completer does, and so do other introspection tools --
+# would otherwise trigger its `DeprecationWarning` without any code
+# actually wanting the name. Explicit `IPython.Application` access still
+# resolves, and still warns, which is the access we want to hear about.
+_lazy_attrs = frozenset({"embed", "get_ipython"})
+
+
+def __getattr__(name: str) -> Any:
+    if name == "embed":
+        from .terminal.embed import embed
+
+        return embed
+    if name == "get_ipython":
+        from .core.getipython import get_ipython
+
+        return get_ipython
+    if name == "Application":
+        warnings.warn(
+            "`IPython.Application` is only a re-export of"
+            " `traitlets.config.application.Application`; import it from"
+            " traitlets directly. Accessing it here triggers an import of"
+            " `IPython.core.application`, which is no longer imported when"
+            " IPython is -- import that module explicitly if you rely on"
+            " that import happening, in particular if you also rely on other"
+            " submodules being transitively imported as a side effect.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        from .core.application import Application
+
+        return Application
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return [*globals(), *_lazy_attrs]
+
 # Release data
 __author__ = '{} <{}>'.format(release.author, release.author_email)
 __license__  = release.license

ipython-9.17.0/IPython/core/_dunder_ops.py

@@ -0,0 +1,65 @@
+"""Mapping from AST operator nodes to the dunder methods that implement them.
+
+This lives in its own module, rather than in `IPython.core.guarded_eval` where
+it is mostly used, so that the terminal shortcut filters can resolve operators
+in a filter expression without importing the whole of `guarded_eval` -- and
+with it `typing_extensions`, `dataclasses` and `inspect` -- on every startup.
+
+The names are re-exported from `IPython.core.guarded_eval`, which remains
+their documented home.
+"""
+
+import ast
+from collections.abc import Mapping
+from typing import Any
+
+__all__ = [
+    "BINARY_OP_DUNDERS",
+    "COMP_OP_DUNDERS",
+    "UNARY_OP_DUNDERS",
+]
+
+BINARY_OP_DUNDERS: dict[type[ast.operator], tuple[str]] = {
+    ast.Add: ("__add__",),
+    ast.Sub: ("__sub__",),
+    ast.Mult: ("__mul__",),
+    ast.Div: ("__truediv__",),
+    ast.FloorDiv: ("__floordiv__",),
+    ast.Mod: ("__mod__",),
+    ast.Pow: ("__pow__",),
+    ast.LShift: ("__lshift__",),
+    ast.RShift: ("__rshift__",),
+    ast.BitOr: ("__or__",),
+    ast.BitXor: ("__xor__",),
+    ast.BitAnd: ("__and__",),
+    ast.MatMult: ("__matmul__",),
+}
+
+COMP_OP_DUNDERS: dict[type[ast.cmpop], tuple[str, ...]] = {
+    ast.Eq: ("__eq__",),
+    ast.NotEq: ("__ne__", "__eq__"),
+    ast.Lt: ("__lt__", "__gt__"),
+    ast.LtE: ("__le__", "__ge__"),
+    ast.Gt: ("__gt__", "__lt__"),
+    ast.GtE: ("__ge__", "__le__"),
+    ast.In: ("__contains__",),
+    # Note: ast.Is, ast.IsNot, ast.NotIn are handled specially
+}
+
+UNARY_OP_DUNDERS: dict[type[ast.unaryop], tuple[str, ...]] = {
+    ast.USub: ("__neg__",),
+    ast.UAdd: ("__pos__",),
+    # we have to check both __inv__ and __invert__!
+    ast.Invert: ("__invert__", "__inv__"),
+    ast.Not: ("__not__",),
+}
+
+
+def _find_dunder(
+    node_op: ast.AST, dunders: Mapping[type[Any], tuple[str, ...]]
+) -> tuple[str, ...] | None:
+    dunder = None
+    for op, candidate_dunder in dunders.items():
+        if isinstance(node_op, op):
+            dunder = candidate_dunder
+    return dunder

{ipython-9.16.0 → ipython-9.17.0}/IPython/core/alias.py

@@ -28,7 +28,6 @@ from traitlets.config.configurable import Configurable
 from .error import UsageError
 
 from traitlets import List, Instance
-from logging import error
 
 
 #-----------------------------------------------------------------------------
@@ -226,6 +225,7 @@ class AliasManager(Configurable):
         try:
             self.define_alias(name, cmd)
         except AliasError as e:
+            from logging import error
             error("Invalid alias: %s" % e)
 
     def define_alias(self, name, cmd):

{ipython-9.16.0 → ipython-9.17.0}/IPython/core/application.py

@@ -13,9 +13,7 @@ object and then create the configurable objects, passing the config to them.
 
 import atexit
 from copy import deepcopy
-import logging
 import os
-import shutil
 import sys
 
 from pathlib import Path
@@ -31,6 +29,15 @@ from traitlets import (
     default, observe,
 )
 
+# Values of `logging.DEBUG` and `logging.CRITICAL`, inlined so that this
+# module -- which is on the IPython startup path -- does not have to import
+# `logging` just to spell two integers. The `logging` levels are part of its
+# documented public API and cannot change; `tests/test_application.py`
+# asserts these copies do not drift from it.
+LOGGING_DEBUG = 10
+LOGGING_CRITICAL = 50
+
+
 if os.name == "nt":
     # %PROGRAMDATA% is not safe by default, require opt-in to trust it
     programdata = os.environ.get("PROGRAMDATA", None)
@@ -86,11 +93,11 @@ if isinstance(Application.flags, dict):
 base_flags.update(
     dict(
         debug=(
-            {"Application": {"log_level": logging.DEBUG}},
+            {"Application": {"log_level": LOGGING_DEBUG}},
             "set log level to logging.DEBUG (maximize logging output)",
         ),
         quiet=(
-            {"Application": {"log_level": logging.CRITICAL}},
+            {"Application": {"log_level": LOGGING_CRITICAL}},
             "set log level to logging.CRITICAL (minimize logging output)",
         ),
         init=(
@@ -305,6 +312,7 @@ class BaseIPythonApplication(Application):
                 get_ipython_package_dir(), "config", "profile", "README"
             )
             if not os.path.exists(readme) and os.path.exists(readme_src):
+                import shutil
                 shutil.copy(readme_src, readme)
             for d in ("extensions", "nbextensions"):
                 path = os.path.join(new, d)

{ipython-9.16.0 → ipython-9.17.0}/IPython/core/async_helpers.py

@@ -10,10 +10,15 @@ explicitly to actually raise a SyntaxError and stay as close as possible to
 Python semantics.
 """
 
+from __future__ import annotations
+
 import ast
-import asyncio
 import inspect
 from functools import wraps
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import asyncio
 
 _asyncio_event_loop: asyncio.AbstractEventLoop | None = None
 
@@ -31,6 +36,11 @@ def get_asyncio_loop():
 
     .. versionadded:: 8.0
     """
+    # asyncio (and everything it drags in) is only imported the first
+    # time an event loop is actually needed, rather than on every
+    # IPython startup.
+    import asyncio
+
     try:
         return asyncio.get_running_loop()
     except RuntimeError:
@@ -81,6 +91,8 @@ class _AsyncIOProxy:
             # return a threadsafe wrapper onto the _current_ asyncio loop
             @wraps(attr)
             def _wrapped(*args, **kwargs):
+                import asyncio
+
                 concurrent_future = asyncio.run_coroutine_threadsafe(
                     attr(*args, **kwargs), self._event_loop
                 )

{ipython-9.16.0 → ipython-9.17.0}/IPython/core/compilerop.py

@@ -35,7 +35,6 @@ import __future__
 from ast import PyCF_ONLY_AST
 import codeop
 import functools
-import hashlib
 import linecache
 import operator
 from contextlib import contextmanager
@@ -60,6 +59,7 @@ def code_name(code: str, number: int = 0) -> str:
 
     This now expects code to be unicode.
     """
+    import hashlib
     hash_digest = hashlib.sha1(code.encode("utf-8"), usedforsecurity=False).hexdigest()
     # Include the number and 12 characters of the hash in the name.  It's
     # pretty much impossible that in a single session we'll have collisions

{ipython-9.16.0 → ipython-9.17.0}/IPython/core/completer.py

@@ -192,8 +192,6 @@ import string
 import sys
 import tokenize
 import time
-import unicodedata
-import uuid
 import warnings
 from ast import literal_eval
 from collections import defaultdict
@@ -210,18 +208,12 @@ from typing import (
 )
 from collections.abc import Iterable, Iterator, Sequence, Sized
 
-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,
     SystemAssign,
     make_tokens_by_line,
 )
-from IPython.core.latex_symbols import latex_symbols, reverse_latex_symbol
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils import generics
 from IPython.utils.PyColorize import theme_table
@@ -269,6 +261,19 @@ def _get_jedi() -> ModuleType:
     import jedi.api.helpers
 
     jedi.settings.case_insensitive_completion = False
+
+    # parso, which jedi parses with, logs copiously at DEBUG level; without
+    # this those records reach the user's session whenever IPython runs with
+    # a debug log level. This lived at the top of `IPython.core.logger` --
+    # a module about `%logstart` session transcripts, nothing to do with
+    # jedi -- where it worked only because that module happened to be
+    # imported eagerly at startup. Configure it where jedi itself is
+    # configured instead, which is still before any parso record can be
+    # emitted, since parso is only reached through jedi.
+    import logging
+
+    logging.getLogger("parso").setLevel(logging.WARNING)
+
     return jedi
 
 
@@ -1064,12 +1069,16 @@ class Completer(Configurable):
 
     @observe("evaluation")
     def _evaluation_changed(self, _change):
+        from IPython.core.guarded_eval import _validate_policy_overrides
+
         _validate_policy_overrides(
             policy_name=self.evaluation, policy_overrides=self.policy_overrides
         )
 
     @observe("policy_overrides")
     def _policy_overrides_changed(self, _change):
+        from IPython.core.guarded_eval import _validate_policy_overrides
+
         _validate_policy_overrides(
             policy_name=self.evaluation, policy_overrides=self.policy_overrides
         )
@@ -1149,6 +1158,8 @@ class Completer(Configurable):
         defined in self.namespace or self.global_namespace that match.
 
         """
+        from IPython.core.guarded_eval import EvaluationContext, guarded_eval
+
         matches = []
         match_append = matches.append
         n = len(text)
@@ -1374,6 +1385,8 @@ class Completer(Configurable):
         return ""
 
     def _evaluate_expr(self, expr):
+        from IPython.core.guarded_eval import EvaluationContext, guarded_eval
+
         obj = not_found
         done = False
         while not done and expr:
@@ -1766,6 +1779,8 @@ def back_unicode_name_matches(text: str) -> tuple[str, Sequence[str]]:
     - a sequence (of 1), name for the match Unicode character, preceded by
         backslash, or empty if no match.
     """
+    import unicodedata
+
     if len(text)<2:
         return '', ()
     maybe_slash = text[-2]
@@ -1791,6 +1806,8 @@ def back_latex_name_matcher(context: CompletionContext) -> SimpleMatcherResult:
 
     This does ``\\ℵ`` -> ``\\aleph``
     """
+    from IPython.core.latex_symbols import reverse_latex_symbol
+
 
     text = context.text_until_cursor
     no_match = {
@@ -2432,6 +2449,8 @@ class IPCompleter(Completer):
         texts = text.strip().split()
 
         if len(texts) > 0 and (texts[0] == 'config' or texts[0] == '%config'):
+            # Only instantiated magics are configurable; load the lazy ones.
+            self.shell.magics_manager.load_all_lazy_magics()
             # get all configuration classes
             classes = sorted({ c for c in self.shell.configurables
                                    if c.__class__.class_traits(config=True)
@@ -3025,6 +3044,7 @@ class IPCompleter(Completer):
         .. deprecated:: 8.6
             You can use :meth:`dict_key_matcher` instead.
         """
+        from IPython.core.guarded_eval import EvaluationContext, guarded_eval
 
         # Short-circuit on closed dictionary (regular expression would
         # not match anyway, but would take quite a while).
@@ -3148,6 +3168,8 @@ class IPCompleter(Completer):
         Works only on valid python 3 identifier, or on combining characters that
         will combine to form a valid identifier.
         """
+        import unicodedata
+
 
         text = context.text_until_cursor
 
@@ -3189,6 +3211,8 @@ class IPCompleter(Completer):
         .. deprecated:: 8.6
             You can use :meth:`latex_name_matcher` instead.
         """
+        from IPython.core.latex_symbols import latex_symbols
+
         slashpos = text.rfind('\\')
         if slashpos > -1:
             s = text[slashpos:]
@@ -3316,6 +3340,8 @@ class IPCompleter(Completer):
             completions are coming from different sources this function does not
             ensure that each completion object will only be present once.
         """
+        import uuid
+
         warnings.warn("_complete is a provisional API (as of IPython 6.0). "
                       "It may change without warnings. "
                       "Use in corresponding context manager.",
@@ -3832,6 +3858,8 @@ class IPCompleter(Completer):
 
         The list is lazily initialized on first access.
         """
+        import unicodedata
+
         if self._unicode_names is None:
             names = []
             for c in range(0,0x10FFFF + 1):
@@ -3845,6 +3873,8 @@ class IPCompleter(Completer):
 
 
 def _unicode_name_compute(ranges: list[tuple[int, int]]) -> list[str]:
+    import unicodedata
+
     names = []
     for start,stop in ranges:
         for c in range(start, stop) :

{ipython-9.16.0 → ipython-9.17.0}/IPython/core/display.py

@@ -8,11 +8,7 @@ from __future__ import annotations
 from enum import Enum
 from dataclasses import dataclass, KW_ONLY
 from binascii import b2a_base64, hexlify
-import html
-import json
-import mimetypes
 import os
-import struct
 import warnings
 from copy import deepcopy
 from os.path import splitext
@@ -639,6 +635,7 @@ class JSON(DisplayObject):
         if isinstance(data, str):
             if self.filename is None and self.url is None:
                 warnings.warn("JSON expects JSONable dict or list, not JSON strings")
+            import json
             data = json.loads(data)
         self._data = data
 
@@ -800,6 +797,7 @@ def _pngxy(data):
     """read the (width, height) from a PNG header"""
     ihdr = data.index(b'IHDR')
     # next 8 bytes are width/height
+    import struct
     return struct.unpack('>ii', data[ihdr+4:ihdr+12])
 
 
@@ -807,6 +805,7 @@ def _jpegxy(data):
     """read the (width, height) from a JPEG header"""
     # adapted from http://www.64lines.com/jpeg-width-height
 
+    import struct
     idx = 4
     while True:
         block_size = struct.unpack('>H', data[idx:idx+2])[0]
@@ -825,11 +824,13 @@ def _jpegxy(data):
 
 def _gifxy(data):
     """read the (width, height) from a GIF header"""
+    import struct
     return struct.unpack('<HH', data[6:10])
 
 
 def _webpxy(data):
     """read the (width, height) from a WEBP header"""
+    import struct
     if data[12:16] == b"VP8 ":
         width, height = struct.unpack("<HH", data[24:30])
         width = width & 0x3FFF
@@ -1055,6 +1056,7 @@ class Image(DisplayObject):
 
     def _repr_html_(self):
         if not self.embed:
+            import html
             width = height = klass = alt = ""
             if self.width:
                 width = ' width="%d"' % self.width
@@ -1225,6 +1227,7 @@ class Video(DisplayObject):
         # External URLs and potentially local files are not embedded into the
         # notebook output.
         if not self.embed:
+            import html
             url = self.url if self.url is not None else self.filename
             output = """<video src="{}" {} {} {}>
       Your browser does not support the <code>video</code> element.
@@ -1235,6 +1238,8 @@ class Video(DisplayObject):
         mimetype = self.mimetype
         if self.filename is not None:
             if not mimetype:
+                import mimetypes
+
                 mimetype, _ = mimetypes.guess_type(self.filename)
 
             with open(self.filename, 'rb') as f:

{ipython-9.16.0 → ipython-9.17.0}/IPython/core/display_functions.py

@@ -208,10 +208,10 @@ def display(
       - `_repr_png_`: return raw PNG data, or a tuple (see below).
       - `_repr_svg_`: return raw SVG data as a string, or a tuple (see below).
       - `_repr_latex_`: return LaTeX commands in a string surrounded by "$",
-                        or a tuple (see below).
+        or a tuple (see below).
       - `_repr_mimebundle_`: return a full mimebundle containing the mapping
-                             from all mimetypes to data.
-                             Use this for any mime-type not listed above.
+        from all mimetypes to data.
+        Use this for any mime-type not listed above.
 
     The above functions may also return the object's metadata alonside the
     data.  If the metadata is available, the functions will return a tuple

{ipython-9.16.0 → ipython-9.17.0}/IPython/core/displayhook.py

@@ -15,7 +15,6 @@ from traitlets.config.configurable import Configurable
 from traitlets import Instance, Float
 from warnings import warn
 
-from .history import HistoryOutput
 
 # TODO: Move the various attributes (cache_size, [others now moved]). Some
 # of these are also attributes of InteractiveShell. They should be on ONE object
@@ -248,6 +247,7 @@ class DisplayHook(Configurable):
 
     def log_output(self, format_dict):
         """Log the output."""
+        from .history import HistoryOutput
         self.shell.history_manager.outputs[self.prompt_count].append(
             HistoryOutput(output_type="execute_result", bundle=format_dict)
         )

{ipython-9.16.0 → ipython-9.17.0}/IPython/core/doctb.py

@@ -1,16 +1,14 @@
-import inspect
+from __future__ import annotations
+
 import linecache
 import sys
 from collections.abc import Sequence
 from types import TracebackType
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from collections.abc import Callable
 
-import stack_data
-from pygments.formatters.terminal256 import Terminal256Formatter
 from pygments.token import Token
 
-from IPython.utils.PyColorize import Theme, TokenStream, theme_table
 from IPython.utils.terminal import get_terminal_size
 
 from .tbtools import (
@@ -23,6 +21,11 @@ from .tbtools import (
     nullrepr,
 )
 
+if TYPE_CHECKING:
+    import stack_data
+
+    from IPython.utils.PyColorize import Theme, TokenStream
+
 INDENT_SIZE = 8
 
 
@@ -41,6 +44,8 @@ def _format_traceback_lines(
     ----------
     lines : list[Line | LineGap]
     """
+    import stack_data
+
     numbers_width = INDENT_SIZE - 1
     tokens: TokenStream = [(Token, "\n")]
 
@@ -136,6 +141,10 @@ class DocTB(TBTools):
 
     def format_record(self, frame_info: FrameInfo) -> str:
         """Format a single stack frame"""
+        import stack_data
+
+        from IPython.utils.PyColorize import theme_table
+
         assert isinstance(frame_info, FrameInfo)
 
         if isinstance(frame_info._sd, stack_data.RepeatedFrames):
@@ -153,6 +162,7 @@ class DocTB(TBTools):
         indent: str = " " * INDENT_SIZE
 
         assert isinstance(frame_info.lineno, int)
+        import inspect
         args, varargs, varkw, locals_ = inspect.getargvalues(frame_info.frame)
         if frame_info.executing is not None:
             func = frame_info.executing.code_qualname()
@@ -238,6 +248,7 @@ class DocTB(TBTools):
         return result
 
     def prepare_header(self, etype: str) -> str:
+        from IPython.utils.PyColorize import theme_table
         width = min(75, get_terminal_size()[0])
         head = theme_table[self._theme_name].format(
             [
@@ -252,6 +263,7 @@ class DocTB(TBTools):
         return head
 
     def format_exception(self, etype: Any, evalue: Any) -> Any:
+        from IPython.utils.PyColorize import theme_table
         # Get (safely) a string form of the exception info
         try:
             etype_str, evalue_str = map(str, (etype, evalue))
@@ -289,6 +301,8 @@ class DocTB(TBTools):
         This may be called multiple times by Python 3 exception chaining
         (PEP 3134).
         """
+        from IPython.utils.PyColorize import theme_table
+
         # some locals
         orig_etype = etype
         try:
@@ -323,12 +337,18 @@ class DocTB(TBTools):
         return [[head] + frames + formatted_exception]
 
     def get_records(self, etb: TracebackType, context: int, tb_offset: int) -> Any:
+        import stack_data
+
+        from IPython.utils.PyColorize import theme_table
+
         assert context == 1, context
         assert etb is not None
         context = context - 1
         after = context // 2
         before = context - after
         if self.has_colors:
+            from pygments.formatters.terminal256 import Terminal256Formatter
+
             base_style = theme_table[self._theme_name].as_pygments_style()
             # stack_data ships without type annotations
             style = stack_data.style_with_executing_node(  # type: ignore[no-untyped-call]
@@ -349,6 +369,7 @@ class DocTB(TBTools):
         tbs = []
         while cf is not None:
             try:
+                import inspect
                 mod = inspect.getmodule(cf.tb_frame)
                 if mod is not None:
                     mod_name = mod.__name__
@@ -377,6 +398,8 @@ class DocTB(TBTools):
         context: int = 1,
     ) -> list[str]:
         """Return a nice text document describing the traceback."""
+        from IPython.utils.PyColorize import theme_table
+
         assert context > 0
         assert context == 1, context
         formatted_exceptions: list[list[str]] = self.format_exception_as_a_whole(

{ipython-9.16.0 → ipython-9.17.0}/IPython/core/formatters.py

@@ -66,7 +66,6 @@ Inheritance diagram:
 
 import abc
 import sys
-import traceback
 import warnings
 from io import StringIO
 
@@ -286,6 +285,7 @@ def catch_format_error(method):
             if ip is not None:
                 ip.showtraceback(exc_info)
             else:
+                import traceback
                 traceback.print_exception(*exc_info)
             return self._check_return(None, args[0])
         return self._check_return(r, args[0])