ipython 9.4.0__tar.gz → 9.5.0__tar.gz

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

@@ -213,7 +213,11 @@ from typing import (
     Literal,
 )
 
-from IPython.core.guarded_eval import guarded_eval, EvaluationContext
+from IPython.core.guarded_eval import (
+    guarded_eval,
+    EvaluationContext,
+    _validate_policy_overrides,
+)
 from IPython.core.error import TryNext
 from IPython.core.inputtransformer2 import ESC_MAGIC
 from IPython.core.latex_symbols import latex_symbols, reverse_latex_symbol
@@ -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,
@@ -1313,14 +1327,19 @@ class Completer(Configurable):
                     ),
                 )
                 done = True
-            except Exception as e:
-                if self.debug:
-                    print("Evaluation exception", e)
+            except (SyntaxError, TypeError):
+                # 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:
+                    print("Evaluation exception", e)
+                done = True
         return obj
 
     @property
@@ -1331,6 +1350,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:

{ipython-9.4.0 → ipython-9.5.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),
                         ]
                     )

{ipython-9.4.0 → ipython-9.5.0}/IPython/core/guarded_eval.py

@@ -1,5 +1,5 @@
 from copy import copy
-from inspect import isclass, signature, Signature
+from inspect import isclass, signature, Signature, getmodule
 from typing import (
     Annotated,
     AnyStr,
@@ -21,6 +21,7 @@ import builtins
 import collections
 import operator
 import sys
+import warnings
 from functools import cached_property
 from dataclasses import dataclass, field
 from types import MethodDescriptorType, ModuleType
@@ -122,14 +123,24 @@ class EvaluationPolicy:
 def _get_external(module_name: str, access_path: Sequence[str]):
     """Get value from external module given a dotted access path.
 
+    Only gets value if the module is already imported.
+
     Raises:
     * `KeyError` if module is removed not found, and
     * `AttributeError` if access path does not match an exported object
     """
-    member_type = sys.modules[module_name]
-    for attr in access_path:
-        member_type = getattr(member_type, attr)
-    return member_type
+    try:
+        member_type = sys.modules[module_name]
+        # standard module
+        for attr in access_path:
+            member_type = getattr(member_type, attr)
+        return member_type
+    except (KeyError, AttributeError):
+        # handle modules in namespace packages
+        module_path = ".".join([module_name, *access_path])
+        if module_path in sys.modules:
+            return sys.modules[module_path]
+        raise
 
 
 def _has_original_dunder_external(
@@ -139,18 +150,26 @@ def _has_original_dunder_external(
     method_name: str,
 ):
     if module_name not in sys.modules:
-        # LBYLB as it is faster
-        return False
+        full_module_path = ".".join([module_name, *access_path])
+        if full_module_path not in sys.modules:
+            # LBYLB as it is faster
+            return False
     try:
         member_type = _get_external(module_name, access_path)
         value_type = type(value)
         if type(value) == member_type:
             return True
+        if isinstance(member_type, ModuleType):
+            value_module = getmodule(value_type)
+            if not value_module or not value_module.__name__:
+                return False
+            if value_module.__name__.startswith(member_type.__name__):
+                return True
         if method_name == "__getattribute__":
             # we have to short-circuit here due to an unresolved issue in
             # `isinstance` implementation: https://bugs.python.org/issue32683
             return False
-        if isinstance(value, member_type):
+        if not isinstance(member_type, ModuleType) and isinstance(value, member_type):
             method = getattr(value_type, method_name, None)
             member_method = getattr(member_type, method_name, None)
             if member_method == method:
@@ -185,35 +204,47 @@ def _has_original_dunder(
     return False
 
 
+def _coerce_path_to_tuples(
+    allow_list: set[tuple[str, ...] | str],
+) -> set[tuple[str, ...]]:
+    """Replace dotted paths on the provided allow-list with tuples."""
+    return {
+        path if isinstance(path, tuple) else tuple(path.split("."))
+        for path in allow_list
+    }
+
+
 @undoc
 @dataclass
 class SelectivePolicy(EvaluationPolicy):
     allowed_getitem: set[InstancesHaveGetItem] = field(default_factory=set)
-    allowed_getitem_external: set[tuple[str, ...]] = field(default_factory=set)
+    allowed_getitem_external: set[tuple[str, ...] | str] = field(default_factory=set)
 
     allowed_getattr: set[MayHaveGetattr] = field(default_factory=set)
-    allowed_getattr_external: set[tuple[str, ...]] = field(default_factory=set)
+    allowed_getattr_external: set[tuple[str, ...] | str] = field(default_factory=set)
 
     allowed_operations: set = field(default_factory=set)
-    allowed_operations_external: set[tuple[str, ...]] = field(default_factory=set)
+    allowed_operations_external: set[tuple[str, ...] | str] = field(default_factory=set)
 
     _operation_methods_cache: dict[str, set[Callable]] = field(
         default_factory=dict, init=False
     )
 
     def can_get_attr(self, value, attr):
+        allowed_getattr_external = _coerce_path_to_tuples(self.allowed_getattr_external)
+
         has_original_attribute = _has_original_dunder(
             value,
             allowed_types=self.allowed_getattr,
             allowed_methods=self._getattribute_methods,
-            allowed_external=self.allowed_getattr_external,
+            allowed_external=allowed_getattr_external,
             method_name="__getattribute__",
         )
         has_original_attr = _has_original_dunder(
             value,
             allowed_types=self.allowed_getattr,
             allowed_methods=self._getattr_methods,
-            allowed_external=self.allowed_getattr_external,
+            allowed_external=allowed_getattr_external,
             method_name="__getattr__",
         )
 
@@ -245,7 +276,7 @@ class SelectivePolicy(EvaluationPolicy):
                 return True  # pragma: no cover
 
             # Properties in subclasses of allowed types may be ok if not changed
-            for module_name, *access_path in self.allowed_getattr_external:
+            for module_name, *access_path in allowed_getattr_external:
                 try:
                     external_class = _get_external(module_name, access_path)
                     external_class_attr_val = getattr(external_class, attr)
@@ -257,15 +288,19 @@ class SelectivePolicy(EvaluationPolicy):
 
     def can_get_item(self, value, item):
         """Allow accessing `__getiitem__` of allow-listed instances unless it was not modified."""
+        allowed_getitem_external = _coerce_path_to_tuples(self.allowed_getitem_external)
         return _has_original_dunder(
             value,
             allowed_types=self.allowed_getitem,
             allowed_methods=self._getitem_methods,
-            allowed_external=self.allowed_getitem_external,
+            allowed_external=allowed_getitem_external,
             method_name="__getitem__",
         )
 
     def can_operate(self, dunders: tuple[str, ...], a, b=None):
+        allowed_operations_external = _coerce_path_to_tuples(
+            self.allowed_operations_external
+        )
         objects = [a]
         if b is not None:
             objects.append(b)
@@ -275,7 +310,7 @@ class SelectivePolicy(EvaluationPolicy):
                     obj,
                     allowed_types=self.allowed_operations,
                     allowed_methods=self._operator_dunder_methods(dunder),
-                    allowed_external=self.allowed_operations_external,
+                    allowed_external=allowed_operations_external,
                     method_name=dunder,
                 )
                 for dunder in dunders
@@ -315,15 +350,16 @@ class _DummyNamedTuple(NamedTuple):
     """Used internally to retrieve methods of named tuple instance."""
 
 
+EvaluationPolicyName = Literal["forbidden", "minimal", "limited", "unsafe", "dangerous"]
+
+
 class EvaluationContext(NamedTuple):
     #: Local namespace
     locals: dict
     #: Global namespace
     globals: dict
     #: Evaluation policy identifier
-    evaluation: Literal["forbidden", "minimal", "limited", "unsafe", "dangerous"] = (
-        "forbidden"
-    )
+    evaluation: EvaluationPolicyName = "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
@@ -470,11 +506,24 @@ def get_policy(context: EvaluationContext) -> EvaluationPolicy:
     for key, value in context.policy_overrides.items():
         if hasattr(policy, key):
             setattr(policy, key, value)
-        else:
-            print(f"Incorrect policy override key: {key}")
     return policy
 
 
+def _validate_policy_overrides(
+    policy_name: EvaluationPolicyName, policy_overrides: dict
+) -> bool:
+    policy = EVALUATION_POLICIES[policy_name]
+
+    all_good = True
+    for key, value in policy_overrides.items():
+        if not hasattr(policy, key):
+            warnings.warn(
+                f"Override {key!r} is not valid with {policy_name!r} evaluation policy"
+            )
+            all_good = False
+    return all_good
+
+
 def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
     """Evaluate AST node in provided context.
 
@@ -586,7 +635,12 @@ def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
         dunders = _find_dunder(node.op, UNARY_OP_DUNDERS)
         if dunders:
             if policy.can_operate(dunders, value):
-                return getattr(value, dunders[0])()
+                try:
+                    return getattr(value, dunders[0])()
+                except AttributeError:
+                    raise TypeError(
+                        f"bad operand type for unary {node.op}: {type(value)}"
+                    )
             else:
                 raise GuardRejection(
                     f"Operation (`{dunders}`) for",

{ipython-9.4.0 → ipython-9.5.0}/IPython/core/history.py

@@ -590,7 +590,7 @@ class HistoryOutput:
     output_type: typing.Literal[
         "out_stream", "err_stream", "display_data", "execute_result"
     ]
-    bundle: typing.Dict[str, str]
+    bundle: typing.Dict[str, str | list[str]]
 
 
 class HistoryManager(HistoryAccessor):

{ipython-9.4.0 → ipython-9.5.0}/IPython/core/interactiveshell.py

@@ -3063,11 +3063,11 @@ class InteractiveShell(SingletonConfigurable):
                     output_stream = outputs[-1]
             if output_stream is None:
                 output_stream = HistoryOutput(
-                    output_type=output_type, bundle={"stream": ""}
+                    output_type=output_type, bundle={"stream": []}
                 )
                 outputs_by_counter[execution_count].append(output_stream)
 
-            output_stream.bundle["stream"] += data  # Append to existing stream
+            output_stream.bundle["stream"].append(data)  # Append to existing stream
             return result
 
         stream.write = write

{ipython-9.4.0 → ipython-9.5.0}/IPython/core/magics/basic.py

@@ -4,6 +4,7 @@
 from logging import error
 import io
 import os
+import platform
 from pprint import pformat
 import sys
 from warnings import warn
@@ -571,9 +572,11 @@ Currently the magic system has the following functions:""",
             for output in outputs[execution_count]:
                 for mime_type, data in output.bundle.items():
                     if output.output_type == "out_stream":
-                        cell.outputs.append(v4.new_output("stream", text=[data]))
+                        text = data if isinstance(data, list) else [data]
+                        cell.outputs.append(v4.new_output("stream", text=text))
                     elif output.output_type == "err_stream":
-                        err_output = v4.new_output("stream", text=[data])
+                        text = data if isinstance(data, list) else [data]
+                        err_output = v4.new_output("stream", text=text)
                         err_output.name = "stderr"
                         cell.outputs.append(err_output)
                     elif output.output_type == "execute_result":
@@ -601,10 +604,44 @@ Currently the magic system has the following functions:""",
                 )
             cells.append(cell)
 
-        nb = v4.new_notebook(cells=cells)
+        kernel_language_info = self._get_kernel_language_info()
+
+        nb = v4.new_notebook(
+            cells=cells,
+            metadata={
+                "kernelspec": {
+                    "display_name": "Python 3 (ipykernel)",
+                    "language": "python",
+                    "name": "python3",
+                },
+                "language_info": kernel_language_info
+                or {
+                    "codemirror_mode": {
+                        "name": "ipython",
+                        "version": sys.version_info[0],
+                    },
+                    "file_extension": ".py",
+                    "mimetype": "text/x-python",
+                    "name": "python",
+                    "nbconvert_exporter": "python",
+                    "pygments_lexer": "ipython3",
+                    "version": platform.python_version(),
+                },
+            },
+        )
         with io.open(outfname, "w", encoding="utf-8") as f:
             write(nb, f, version=4)
 
+    def _get_kernel_language_info(self) -> dict | None:
+        """Get language info from kernel, useful when used in Jupyter Console where kernels exist."""
+        if not hasattr(self.shell, "kernel"):
+            return
+        if not hasattr(self.shell.kernel, "language_info"):
+            return
+        if not isinstance(self.shell.kernel.language_info, dict):
+            return
+        return self.shell.kernel.language_info
+
 @magics_class
 class AsyncMagics(BasicMagics):
 

{ipython-9.4.0 → ipython-9.5.0}/IPython/core/magics/namespace.py

@@ -361,8 +361,7 @@ class NamespaceMagics(Magics):
           - For numpy arrays, a summary with shape, number of
             elements, typecode and size in memory.
 
-          - For objects that have shape attribute, primarily dataframe and series like
-            objects, will print the shape.
+          - For DataFrame and Series types: their shape.
 
           - Everything else: a string representation, snipping their middle if
             too long.
@@ -450,7 +449,9 @@ class NamespaceMagics(Magics):
         Mb = 1048576  # kb**2
         for vname,var,vtype in zip(varnames,varlist,typelist):
             print(vformat.format(vname, vtype, varwidth=varwidth, typewidth=typewidth), end=' ')
-            if vtype == ndarray_type:
+            if vtype in seq_types:
+                print("n="+str(len(var)))
+            elif vtype == ndarray_type:
                 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
                 if vtype==ndarray_type:
                     # numpy
@@ -463,16 +464,13 @@ class NamespaceMagics(Magics):
                 else:
                     print(aformat % (vshape, vsize, vdtype, vbytes), end=' ')
                     if vbytes < Mb:
-                        print('(%s kb)' % (vbytes/kb,))
+                        print("(%s kb)" % (vbytes / kb,))
                     else:
                         print("(%s Mb)" % (vbytes / Mb,))
-            elif hasattr(var, "shape"):
+            elif vtype in ["DataFrame", "Series"]:
                 # Useful for DataFrames and Series
                 # Ought to work for both pandas and polars
                 print(f"Shape: {var.shape}")
-            elif hasattr(var, "__len__"):
-                ## types that can be used in len function
-                print(var if isinstance(var, str) else f"n={len(var)}")
             else:
                 try:
                     vstr = str(var)

{ipython-9.4.0 → ipython-9.5.0}/IPython/core/magics/script.py

@@ -237,7 +237,7 @@ class ScriptMagics(Magics):
                     chunk = decoder.decode("", final=True)
                     should_break = True
                 if stream_arg:
-                    self.shell.user_ns[stream_arg] = chunk
+                    self.shell.user_ns[stream_arg] += chunk
                 else:
                     file_object.write(chunk)
                     file_object.flush()
@@ -259,6 +259,11 @@ class ScriptMagics(Magics):
         argv = arg_split(line, posix=not sys.platform.startswith("win"))
         args, cmd = self.shebang.parser.parse_known_args(argv)
 
+        if args.out:
+            self.shell.user_ns[args.out] = ""
+        if args.err:
+            self.shell.user_ns[args.err] = ""
+
         try:
             p = in_thread(
                 asyncio.create_subprocess_exec(

{ipython-9.4.0 → ipython-9.5.0}/IPython/core/release.py

@@ -16,7 +16,7 @@
 # release.  'dev' as a _version_extra string means this is a development
 # version
 _version_major = 9
-_version_minor = 4
+_version_minor = 5
 _version_patch = 0
 _version_extra = ".dev"
 # _version_extra = "b2"

{ipython-9.4.0 → ipython-9.5.0}/IPython/core/ultratb.py

@@ -363,11 +363,8 @@ class ListTB(TBTools):
                                 [(Token.Caret, s + "^"), (Token, "\n")]
                             )
                         )
-
-            try:
-                assert hasattr(value, "msg")
                 s = value.msg
-            except Exception:
+            else:
                 s = self._some_str(value)
             if s:
                 output_list.append(

{ipython-9.4.0 → ipython-9.5.0}/IPython/extensions/deduperreload/deduperreload.py

@@ -4,6 +4,7 @@ import builtins
 import contextlib
 import itertools
 import os
+import pickle
 import platform
 import sys
 import textwrap
@@ -25,7 +26,7 @@ if TYPE_CHECKING:
     )
 
 
-def get_module_file_name(module: ModuleType | str) -> str:
+def get_module_file_name(module: ModuleType | str) -> str | None:
     """Returns the module's file path, or the empty string if it's inaccessible"""
     if (mod := sys.modules.get(module) if isinstance(module, str) else module) is None:
         return ""
@@ -200,8 +201,7 @@ class DeduperReloader(DeduperReloaderPatchingMixin):
         for new_modname in sys.modules.keys() - self.source_by_modname.keys():
             new_module = sys.modules[new_modname]
             if (
-                (fname := get_module_file_name(new_module))
-                is None  # type:ignore [redundant-expr]
+                (fname := get_module_file_name(new_module)) is None
                 or "site-packages" in fname
                 or "dist-packages" in fname
                 or not os.access(fname, os.R_OK)
@@ -287,7 +287,7 @@ class DeduperReloader(DeduperReloaderPatchingMixin):
                     result.inplace_merge(
                         cls._gather_children(handler.body, parent_node)
                     )
-            elif not isinstance(ast_elt, (ast.Ellipsis, ast.Pass)):
+            elif not isinstance(ast_elt, (ast.Constant, ast.Pass)):
                 if cls.is_constexpr_assign(ast_elt, parent_node):
                     assert isinstance(ast_elt, (ast.Assign, ast.AnnAssign))
                     targets = (
@@ -416,7 +416,11 @@ class DeduperReloader(DeduperReloaderPatchingMixin):
         namespace_to_check = ns
         for prefix in prefixes:
             namespace_to_check = namespace_to_check.__dict__[prefix]
+        seen_names: set[str] = set()
         for names, new_ast_def in cur.defs_to_reload:
+            if len(names) == 1 and names[0] in seen_names:
+                continue
+            seen_names.update(names)
             local_env: dict[str, Any] = {}
             if (
                 isinstance(new_ast_def, (ast.FunctionDef, ast.AsyncFunctionDef))
@@ -435,37 +439,54 @@ class DeduperReloader(DeduperReloaderPatchingMixin):
                 global_env = ns.__dict__
                 if not isinstance(global_env, dict):
                     global_env = dict(global_env)
-                exec(func_code, global_env, local_env)  # type: ignore[arg-type]
-                # local_env contains the function exec'd from  new version of function
-                if is_method:
-                    to_patch_from = getattr(local_env["__autoreload_class__"], name)
-                else:
-                    to_patch_from = local_env[name]
-                if isinstance(to_patch_from, (staticmethod, classmethod)):
-                    to_patch_from = to_patch_from.__func__
-                if isinstance(to_patch_to, property) and isinstance(
-                    to_patch_from, property
-                ):
-                    for attr in ("fget", "fset", "fdel"):
-                        if (
-                            getattr(to_patch_to, attr) is None
-                            or getattr(to_patch_from, attr) is None
-                        ):
-                            self.try_patch_attr(to_patch_to, to_patch_from, attr)
-                        else:
-                            self.patch_function(
-                                getattr(to_patch_to, attr),
-                                getattr(to_patch_from, attr),
-                                is_method,
-                            )
-                elif not isinstance(to_patch_to, property) and not isinstance(
-                    to_patch_from, property
-                ):
-                    self.patch_function(to_patch_to, to_patch_from, is_method)
-                else:
-                    raise ValueError(
-                        "adding or removing property decorations not supported"
+                # Compile with correct filename to preserve in traceback
+                filename = (
+                    getattr(to_patch_to, "__code__", None)
+                    and to_patch_to.__code__.co_filename
+                    or "<string>"
+                )
+                func_asts = [ast.parse(func_code)]
+                if len(cast(ast.FunctionDef, func_asts[0].body[0]).decorator_list) > 0:
+                    without_decorator_list = pickle.loads(pickle.dumps(func_asts[0]))
+                    cast(
+                        ast.FunctionDef, without_decorator_list.body[0]
+                    ).decorator_list = []
+                    func_asts.insert(0, without_decorator_list)
+                for func_ast in func_asts:
+                    compiled_code = compile(
+                        func_ast, filename, mode="exec", dont_inherit=True
                     )
+                    exec(compiled_code, global_env, local_env)  # type: ignore[arg-type]
+                    # local_env contains the function exec'd from  new version of function
+                    if is_method:
+                        to_patch_from = getattr(local_env["__autoreload_class__"], name)
+                    else:
+                        to_patch_from = local_env[name]
+                    if isinstance(to_patch_from, (staticmethod, classmethod)):
+                        to_patch_from = to_patch_from.__func__
+                    if isinstance(to_patch_to, property) and isinstance(
+                        to_patch_from, property
+                    ):
+                        for attr in ("fget", "fset", "fdel"):
+                            if (
+                                getattr(to_patch_to, attr) is None
+                                or getattr(to_patch_from, attr) is None
+                            ):
+                                self.try_patch_attr(to_patch_to, to_patch_from, attr)
+                            else:
+                                self.patch_function(
+                                    getattr(to_patch_to, attr),
+                                    getattr(to_patch_from, attr),
+                                    is_method,
+                                )
+                    elif not isinstance(to_patch_to, property) and not isinstance(
+                        to_patch_from, property
+                    ):
+                        self.patch_function(to_patch_to, to_patch_from, is_method)
+                    else:
+                        raise ValueError(
+                            "adding or removing property decorations not supported"
+                        )
             else:
                 exec(
                     ast.unparse(new_ast_def),