ipython 9.1.0__tar.gz → 9.3.0__tar.gz

{ipython-9.1.0 → ipython-9.3.0}/IPython/__init__.py

@@ -80,6 +80,11 @@ def embed_kernel(module=None, local_ns=None, **kwargs):
     and/or you want to load full IPython configuration,
     you probably want `IPython.start_kernel()` instead.
 
+    This is a deprecated alias for `ipykernel.embed.embed_kernel()`,
+    to be removed in the future.
+    You should import directly from `ipykernel.embed`; this wrapper
+    fails anyway if you don't have `ipykernel` package installed.
+
     Parameters
     ----------
     module : types.ModuleType, optional

{ipython-9.1.0 → ipython-9.3.0}/IPython/core/completer.py

@@ -203,15 +203,11 @@ from types import SimpleNamespace
 from typing import (
     Iterable,
     Iterator,
-    List,
-    Tuple,
     Union,
     Any,
     Sequence,
-    Dict,
     Optional,
     TYPE_CHECKING,
-    Set,
     Sized,
     TypeVar,
     Literal,
@@ -236,10 +232,12 @@ from traitlets import (
     List as ListTrait,
     Unicode,
     Dict as DictTrait,
+    DottedObjectName,
     Union as UnionTrait,
     observe,
 )
 from traitlets.config.configurable import Configurable
+from traitlets.utils.importstring import import_item
 
 import __main__
 
@@ -987,7 +985,7 @@ class Completer(Configurable):
 
         - ``forbidden``: no evaluation of code is permitted,
         - ``minimal``: evaluation of literals and access to built-in namespace;
-          no item/attribute evaluationm no access to locals/globals,
+          no item/attribute evaluation, no access to locals/globals,
           no evaluation of any operations or comparisons.
         - ``limited``: access to all namespaces, evaluation of hard-coded methods
           (for example: :any:`dict.keys`, :any:`object.__getattr__`,
@@ -995,7 +993,9 @@ class Completer(Configurable):
           :any:`dict`, :any:`list`, :any:`tuple`, ``pandas.Series``),
         - ``unsafe``: evaluation of all methods and function calls but not of
           syntax with side-effects like `del x`,
-        - ``dangerous``: completely arbitrary evaluation.
+        - ``dangerous``: completely arbitrary evaluation; does not support auto-import.
+
+        To override specific elements of the policy, you can use ``policy_overrides`` trait.
         """,
     ).tag(config=True)
 
@@ -1031,6 +1031,35 @@ class Completer(Configurable):
         """,
     ).tag(config=True)
 
+    policy_overrides = DictTrait(
+        default_value={},
+        key_trait=Unicode(),
+        help="""Overrides for policy evaluation.
+
+        For example, to enable auto-import on completion specify:
+
+        .. code-block::
+
+            ipython --Completer.policy_overrides='{"allow_auto_import": True}' --Completer.use_jedi=False
+
+        """,
+    ).tag(config=True)
+
+    auto_import_method = DottedObjectName(
+        default_value="importlib.import_module",
+        allow_none=True,
+        help="""\
+        Provisional:
+              This is a provisional API in IPython 9.3, it may change without warnings.
+
+        A fully qualified path to an auto-import method for use by completer.
+        The function should take a single string and return `ModuleType` and
+        can raise `ImportError` exception if module is not found.
+
+        The default auto-import implementation does not populate the user namespace with the imported module.
+        """,
+    ).tag(config=True)
+
     def __init__(self, namespace=None, global_namespace=None, **kwargs):
         """Create a new completer for the command line.
 
@@ -1134,6 +1163,48 @@ class Completer(Configurable):
     # we simple attribute matching with normal identifiers.
     _ATTR_MATCH_RE = re.compile(r"(.+)\.(\w*)$")
 
+    def _strip_code_before_operator(self, code: str) -> str:
+        o_parens = {"(", "[", "{"}
+        c_parens = {")", "]", "}"}
+
+        # Dry-run tokenize to catch errors
+        try:
+            _ = list(tokenize.generate_tokens(iter(code.splitlines()).__next__))
+        except tokenize.TokenError:
+            # Try trimming the expression and retrying
+            trimmed_code = self._trim_expr(code)
+            try:
+                _ = list(
+                    tokenize.generate_tokens(iter(trimmed_code.splitlines()).__next__)
+                )
+                code = trimmed_code
+            except tokenize.TokenError:
+                return code
+
+        tokens = _parse_tokens(code)
+        encountered_operator = False
+        after_operator = []
+        nesting_level = 0
+
+        for t in tokens:
+            if t.type == tokenize.OP:
+                if t.string in o_parens:
+                    nesting_level += 1
+                elif t.string in c_parens:
+                    nesting_level -= 1
+                elif t.string != "." and nesting_level == 0:
+                    encountered_operator = True
+                    after_operator = []
+                    continue
+
+            if encountered_operator:
+                after_operator.append(t.string)
+
+        if encountered_operator:
+            return "".join(after_operator)
+        else:
+            return code
+
     def _attr_matches(
         self, text: str, include_prefix: bool = True
     ) -> tuple[Sequence[str], str]:
@@ -1141,9 +1212,12 @@ class Completer(Configurable):
         if not m2:
             return [], ""
         expr, attr = m2.group(1, 2)
+        try:
+            expr = self._strip_code_before_operator(expr)
+        except tokenize.TokenError:
+            pass
 
         obj = self._evaluate_expr(expr)
-
         if obj is not_found:
             return [], ""
 
@@ -1234,6 +1308,8 @@ class Completer(Configurable):
                         globals=self.global_namespace,
                         locals=self.namespace,
                         evaluation=self.evaluation,
+                        auto_import=self._auto_import,
+                        policy_overrides=self.policy_overrides,
                     ),
                 )
                 done = True
@@ -1247,6 +1323,14 @@ class Completer(Configurable):
                 expr = self._trim_expr(expr)
         return obj
 
+    @property
+    def _auto_import(self):
+        if self.auto_import_method is None:
+            return None
+        if not hasattr(self, "_auto_import_func"):
+            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:
@@ -2787,6 +2871,8 @@ class IPCompleter(Completer):
                 locals=self.namespace,
                 evaluation=self.evaluation,  # type: ignore
                 in_subscript=True,
+                auto_import=self._auto_import,
+                policy_overrides=self.policy_overrides,
             ),
         )
 

{ipython-9.1.0 → ipython-9.3.0}/IPython/core/guarded_eval.py

@@ -1,19 +1,15 @@
+from copy import copy
 from inspect import isclass, signature, Signature
-from pygments.formatters.terminal256 import Terminal256Formatter
 from typing import (
     Annotated,
     AnyStr,
     Callable,
-    Dict,
     Literal,
     NamedTuple,
     NewType,
     Optional,
     Protocol,
-    Set,
     Sequence,
-    Tuple,
-    Type,
     TypeGuard,
     Union,
     get_args,
@@ -97,6 +93,7 @@ class EvaluationPolicy:
     allow_builtins_access: bool = False
     allow_all_operations: bool = False
     allow_any_calls: bool = False
+    allow_auto_import: bool = False
     allowed_calls: set[Callable] = field(default_factory=set)
 
     def can_get_item(self, value, item):
@@ -330,6 +327,10 @@ class EvaluationContext(NamedTuple):
     #: Whether the evaluation of code takes place inside of a subscript.
     #: Useful for evaluating ``:-1, 'col'`` in ``df[:-1, 'col']``.
     in_subscript: bool = False
+    #: Auto import method
+    auto_import: Callable[list[str], ModuleType] | None = None
+    #: Overrides for evaluation policy
+    policy_overrides: dict = {}
 
 
 class _IdentitySubscript:
@@ -463,6 +464,17 @@ def _find_dunder(node_op, dunders) -> Union[tuple[str, ...], None]:
     return dunder
 
 
+def get_policy(context: EvaluationContext) -> EvaluationPolicy:
+    policy = copy(EVALUATION_POLICIES[context.evaluation])
+
+    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 eval_node(node: Union[ast.AST, None], context: EvaluationContext):
     """Evaluate AST node in provided context.
 
@@ -490,7 +502,8 @@ def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
     The purpose of this function is to guard against unwanted side-effects;
     it does not give guarantees on protection from malicious code execution.
     """
-    policy = EVALUATION_POLICIES[context.evaluation]
+    policy = get_policy(context)
+
     if node is None:
         return None
     if isinstance(node, ast.Expression):
@@ -711,7 +724,7 @@ def _resolve_annotation(
 
 
 def _eval_node_name(node_id: str, context: EvaluationContext):
-    policy = EVALUATION_POLICIES[context.evaluation]
+    policy = get_policy(context)
     if policy.allow_locals_access and node_id in context.locals:
         return context.locals[node_id]
     if policy.allow_globals_access and node_id in context.globals:
@@ -719,6 +732,8 @@ def _eval_node_name(node_id: str, context: EvaluationContext):
     if policy.allow_builtins_access and hasattr(builtins, node_id):
         # note: do not use __builtins__, it is implementation detail of cPython
         return getattr(builtins, node_id)
+    if policy.allow_auto_import and context.auto_import:
+        return context.auto_import(node_id)
     if not policy.allow_globals_access and not policy.allow_locals_access:
         raise GuardRejection(
             f"Namespace access not allowed in {context.evaluation} mode"
@@ -728,7 +743,7 @@ def _eval_node_name(node_id: str, context: EvaluationContext):
 
 
 def _eval_or_create_duck(duck_type, node: ast.Call, context: EvaluationContext):
-    policy = EVALUATION_POLICIES[context.evaluation]
+    policy = get_policy(context)
     # if allow-listed builtin is on type annotation, instantiate it
     if policy.can_call(duck_type) and not node.keywords:
         args = [eval_node(arg, context) for arg in node.args]

{ipython-9.1.0 → ipython-9.3.0}/IPython/core/interactiveshell.py

@@ -290,7 +290,7 @@ class ExecutionResult:
     """
 
     execution_count: Optional[int] = None
-    error_before_exec: Optional[bool] = None
+    error_before_exec: Optional[BaseException] = None
     error_in_exec: Optional[BaseException] = None
     info = None
     result = None
@@ -314,6 +314,7 @@ class ExecutionResult:
         return '<%s object at %x, execution_count=%s error_before_exec=%s error_in_exec=%s info=%s result=%s>' %\
                 (name, id(self), self.execution_count, self.error_before_exec, self.error_in_exec, repr(self.info), repr(self.result))
 
+
 @functools.wraps(io_open)
 def _modified_open(file, *args, **kwargs):
     if file in {0, 1, 2}:
@@ -331,7 +332,7 @@ class InteractiveShell(SingletonConfigurable):
 
     _instance = None
     _user_ns: dict
-    _sys_modules_keys: set[str, AnyType]
+    _sys_modules_keys: set[str]
 
     inspector: oinspect.Inspector
 
@@ -1572,7 +1573,7 @@ class InteractiveShell(SingletonConfigurable):
             if isinstance(variables, str):
                 vlist = variables.split()
             else:
-                vlist = variables
+                vlist = list(variables)
             vdict = {}
             cf = sys._getframe(1)
             for name in vlist:
@@ -1887,11 +1888,12 @@ class InteractiveShell(SingletonConfigurable):
         with self.builtin_trap:
             info = self._object_find(oname)
             if info.found:
-                docformat = (
-                    sphinxify(self.object_inspect(oname))
-                    if self.sphinxify_docstring
-                    else None
-                )
+                if self.sphinxify_docstring:
+                    if sphinxify is None:
+                        raise ImportError("Module ``docrepr`` required but missing")
+                    docformat = sphinxify(self.object_inspect(oname))
+                else:
+                    docformat = None
                 return self.inspector._get_info(
                     info.obj,
                     oname,
@@ -2196,7 +2198,7 @@ class InteractiveShell(SingletonConfigurable):
         except KeyboardInterrupt:
             print('\n' + self.get_exception_only(), file=sys.stderr)
 
-    def _showtraceback(self, etype, evalue, stb: str):
+    def _showtraceback(self, etype, evalue, stb: list[str]):
         """Actually show a traceback.
 
         Subclasses may override this method to put the traceback on a different
@@ -3152,14 +3154,17 @@ class InteractiveShell(SingletonConfigurable):
         try:
             result = runner(coro)
         except BaseException as e:
-            info = ExecutionInfo(
-                raw_cell, store_history, silent, shell_futures, cell_id
-            )
-            result = ExecutionResult(info)
-            result.error_in_exec = e
-            self.showtraceback(running_compiled_code=True)
-        finally:
-            return result
+            try:
+                info = ExecutionInfo(
+                    raw_cell, store_history, silent, shell_futures, cell_id
+                )
+                result = ExecutionResult(info)
+                result.error_in_exec = e
+                self.showtraceback(running_compiled_code=True)
+            except:
+                pass
+
+        return result
 
     def should_run_async(
         self, raw_cell: str, *, transformed_cell=None, preprocessing_exc_tuple=None
@@ -3596,7 +3601,7 @@ class InteractiveShell(SingletonConfigurable):
                 if mode == "exec":
                     mod = Module([node], [])
                 elif mode == "single":
-                    mod = ast.Interactive([node])  # type: ignore
+                    mod = ast.Interactive([node])
                 with compiler.extra_flags(
                     getattr(ast, "PyCF_ALLOW_TOP_LEVEL_AWAIT", 0x0)
                     if self.autoawait

{ipython-9.1.0 → ipython-9.3.0}/IPython/core/magics/execution.py

@@ -160,10 +160,11 @@ class TimeitTemplateFiller(ast.NodeTransformer):
 
 class Timer(timeit.Timer):
     """Timer class that explicitly uses self.inner
-    
+
     which is an undocumented implementation detail of CPython,
     not shared by PyPy.
     """
+
     # Timer.timeit copied from CPython 3.4.2
     def timeit(self, number=timeit.default_number):
         """Time 'number' executions of the main statement.
@@ -201,7 +202,6 @@ class ExecutionMagics(Magics):
     @no_var_expand
     @line_cell_magic
     def prun(self, parameter_s='', cell=None):
-
         """Run a statement through the python code profiler.
 
         **Usage, in line mode**::
@@ -1000,7 +1000,7 @@ class ExecutionMagics(Magics):
                     # Stop iteration is raised on quit command
                     pass
 
-        except:
+        except Exception:
             etype, value, tb = sys.exc_info()
             # Skip three frames in the traceback: the %run one,
             # one inside bdb.py, and the command-line typed by the
@@ -1142,7 +1142,7 @@ class ExecutionMagics(Magics):
         )
         if stmt == "" and cell is None:
             return
-        
+
         timefunc = timeit.default_timer
         number = int(getattr(opts, "n", 0))
         default_repeat = 7 if timeit.default_repeat < 7 else timeit.default_repeat
@@ -1262,7 +1262,7 @@ class ExecutionMagics(Magics):
     @needs_local_scope
     @line_cell_magic
     @output_can_be_silenced
-    def time(self,line='', cell=None, local_ns=None):
+    def time(self, line="", cell=None, local_ns=None):
         """Time execution of a Python statement or expression.
 
         The CPU and wall clock times are printed, and the value of the
@@ -1277,13 +1277,19 @@ class ExecutionMagics(Magics):
         - In cell mode, you can time the cell body (a directly
           following statement raises an error).
 
-        This function provides very basic timing functionality.  Use the timeit
+        This function provides very basic timing functionality. Use the timeit
         magic for more control over the measurement.
 
         .. versionchanged:: 7.3
             User variables are no longer expanded,
             the magic line is always left unmodified.
 
+        .. versionchanged:: 8.3
+            The time magic now correctly propagates system-exiting exceptions
+            (such as ``KeyboardInterrupt`` invoked when interrupting execution)
+            rather than just printing out the exception traceback.
+            The non-system-exception will still be caught as before.
+
         Examples
         --------
         ::
@@ -1324,10 +1330,10 @@ class ExecutionMagics(Magics):
                 Compiler : 0.78 s
         """
         # fail immediately if the given expression can't be compiled
-        
+
         if line and cell:
             raise UsageError("Can't use statement directly after '%%time'!")
-        
+
         if cell:
             expr = self.shell.transform_cell(cell)
         else:
@@ -1338,7 +1344,7 @@ class ExecutionMagics(Magics):
 
         t0 = clock()
         expr_ast = self.shell.compile.ast_parse(expr)
-        tp = clock()-t0
+        tp = clock() - t0
 
         # Apply AST transformations
         expr_ast = self.shell.transform_ast(expr_ast)
@@ -1346,8 +1352,8 @@ class ExecutionMagics(Magics):
         # Minimum time above which compilation time will be reported
         tc_min = 0.1
 
-        expr_val=None
-        if len(expr_ast.body)==1 and isinstance(expr_ast.body[0], ast.Expr):
+        expr_val = None
+        if len(expr_ast.body) == 1 and isinstance(expr_ast.body[0], ast.Expr):
             mode = 'eval'
             source = '<timed eval>'
             expr_ast = ast.Expression(expr_ast.body[0].value)
@@ -1356,25 +1362,25 @@ class ExecutionMagics(Magics):
             source = '<timed exec>'
             # multi-line %%time case
             if len(expr_ast.body) > 1 and isinstance(expr_ast.body[-1], ast.Expr):
-                expr_val= expr_ast.body[-1]
+                expr_val = expr_ast.body[-1]
                 expr_ast = expr_ast.body[:-1]
                 expr_ast = Module(expr_ast, [])
                 expr_val = ast.Expression(expr_val.value)
 
         t0 = clock()
         code = self.shell.compile(expr_ast, source, mode)
-        tc = clock()-t0
+        tc = clock() - t0
 
         # skew measurement as little as possible
         glob = self.shell.user_ns
         wtime = time.time
         # time execution
         wall_st = wtime()
-        if mode=='eval':
+        if mode == "eval":
             st = clock2()
             try:
                 out = eval(code, glob, local_ns)
-            except:
+            except Exception:
                 self.shell.showtraceback()
                 return
             end = clock2()
@@ -1382,12 +1388,12 @@ class ExecutionMagics(Magics):
             st = clock2()
             try:
                 exec(code, glob, local_ns)
-                out=None
+                out = None
                 # multi-line %%time case
                 if expr_val is not None:
                     code_2 = self.shell.compile(expr_val, source, 'eval')
                     out = eval(code_2, glob, local_ns)
-            except:
+            except Exception:
                 self.shell.showtraceback()
                 return
             end = clock2()
@@ -1630,14 +1636,15 @@ def parse_breakpoint(text, current_file):
         return current_file, int(text)
     else:
         return text[:colon], int(text[colon+1:])
-    
+
+
 def _format_time(timespan, precision=3):
     """Formats the timespan in a human readable form"""
 
     if timespan >= 60.0:
         # we have more than a minute, format that in a human readable form
         # Idea from http://snipplr.com/view/5713/
-        parts = [("d", 60*60*24),("h", 60*60),("min", 60), ("s", 1)]
+        parts = [("d", 60 * 60 * 24), ("h", 60 * 60), ("min", 60), ("s", 1)]
         time = []
         leftover = timespan
         for suffix, length in parts:
@@ -1649,7 +1656,6 @@ def _format_time(timespan, precision=3):
                 break
         return " ".join(time)
 
-
     # Unfortunately characters outside of range(128) can cause problems in
     # certain terminals.
     # See bug: https://bugs.launchpad.net/ipython/+bug/348466
@@ -1663,7 +1669,7 @@ def _format_time(timespan, precision=3):
         except:
             pass
     scaling = [1, 1e3, 1e6, 1e9]
-        
+
     if timespan > 0.0:
         order = min(-int(math.floor(math.log10(timespan)) // 3), 3)
     else:

{ipython-9.1.0 → ipython-9.3.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 = 1
+_version_minor = 3
 _version_patch = 0
 _version_extra = ".dev"
 # _version_extra = "b2"

{ipython-9.1.0 → ipython-9.3.0}/IPython/terminal/interactiveshell.py

@@ -475,7 +475,7 @@ class TerminalInteractiveShell(InteractiveShell):
         allow_none=True,
         help="""\
         Provisional:
-            This is a provisinal API in IPython 8.32, before stabilisation
+            This is a provisional API in IPython 8.32, before stabilisation
             in 9.0, it may change without warnings.
 
         class to use for the `NavigableAutoSuggestFromHistory` to request
@@ -507,13 +507,16 @@ class TerminalInteractiveShell(InteractiveShell):
         elif provider == "NavigableAutoSuggestFromHistory":
             # LLM stuff are all Provisional in 8.32
             if self._llm_provider_class:
-                llm_provider_constructor = import_item(self._llm_provider_class)
-                llm_provider = llm_provider_constructor(**self.llm_constructor_kwargs)
+
+                def init_llm_provider():
+                    llm_provider_constructor = import_item(self._llm_provider_class)
+                    return llm_provider_constructor(**self.llm_constructor_kwargs)
+
             else:
-                llm_provider = None
+                init_llm_provider = None
             self.auto_suggest = NavigableAutoSuggestFromHistory()
             # Provisinal in 8.32
-            self.auto_suggest._llm_provider = llm_provider
+            self.auto_suggest._init_llm_provider = init_llm_provider
 
             name = self.llm_prefix_from_history