ipython · Carreau · Jun 1, 2026 · Jun 1, 2026 · Jun 1, 2026 · Jun 1, 2026
diff --git a/IPython/__init__.py b/IPython/__init__.py
@@ -109,7 +109,7 @@ def embed_kernel(module=None, local_ns=None, **kwargs):
         module = caller_module
     if local_ns is None:
         local_ns = dict(**caller_locals)
-    
+
     # Only import .zmq when we really need it
     from ipykernel.embed import embed_kernel as real_embed_kernel
     real_embed_kernel(module=module, local_ns=local_ns, **kwargs)

diff --git a/IPython/core/alias.py b/IPython/core/alias.py
@@ -7,6 +7,7 @@
 * Fernando Perez
 * Brian Granger
 """
+from __future__ import annotations
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
@@ -30,8 +31,6 @@
 from traitlets import List, Instance
 from logging import error
 
-import typing as t
-
 
 #-----------------------------------------------------------------------------
 # Utilities
@@ -40,7 +39,7 @@
 # This is used as the pattern for calls to split_user_input.
 shell_line_split = re.compile(r'^(\s*)()(\S+)(.*$)')
 
-def default_aliases() -> t.List[t.Tuple[str, str]]:
+def default_aliases() -> list[tuple[str, str]]:
     """Return list of shell aliases to auto-define.
     """
     # Note: the aliases defined here should be safe to use on a kernel
@@ -156,7 +155,7 @@ def validate(self):
                                     "got: %r" % self.cmd)
 
         nargs = self.cmd.count('%s') - self.cmd.count('%%s')
-  
+
         if (nargs > 0) and (self.cmd.find('%l') >= 0):
             raise InvalidAliasError('The %s and %l specifiers are mutually '
                                     'exclusive in alias definitions.')
@@ -173,7 +172,7 @@ def __call__(self, rest=''):
         if cmd.find('%l') >= 0:
             cmd = cmd.replace('%l', rest)
             rest = ''
-        
+
         if nargs==0:
             if cmd.find('%%s') >= 1:
                 cmd = cmd.replace('%%s', '%s')

diff --git a/IPython/core/application.py b/IPython/core/application.py
@@ -131,7 +131,7 @@ class BaseIPythonApplication(Application):
     aliases = base_aliases
     flags = base_flags
     classes = List([ProfileDir])
-    
+
     # enable `load_subconfig('cfg.py', profile='name')`
     python_config_loader_class = ProfileAwareConfigLoader
 
@@ -152,15 +152,15 @@ def _config_file_name_changed(self, change):
     builtin_profile_dir = Unicode(
         os.path.join(get_ipython_package_dir(), u'config', u'profile', u'default')
     )
-    
+
     config_file_paths = List(Unicode())
     @default('config_file_paths')
     def _config_file_paths_default(self):
         return []
 
     extra_config_file = Unicode(
     help="""Path to an extra config file to load.
-    
+
     If specified, load this config file in addition to any other IPython config.
     """).tag(config=True)
     @observe('extra_config_file')
@@ -177,7 +177,7 @@ def _extra_config_file_changed(self, change):
     profile = Unicode(u'default',
         help="""The IPython profile to use."""
     ).tag(config=True)
-    
+
     @observe('profile')
     def _profile_changed(self, change):
         self.builtin_profile_dir = os.path.join(
@@ -212,7 +212,7 @@ def _ipython_dir_default(self):
             'new': d,
         })
         return d
-    
+
     _in_init_profile_dir = False
 
     profile_dir = Instance(ProfileDir, allow_none=True)
@@ -246,7 +246,7 @@ def _config_files_default(self):
         profile, then they will be staged into the new directory.  Otherwise,
         default config files will be automatically generated.
         """).tag(config=True)
-    
+
     verbose_crash = Bool(False,
         help="""Create a massive crash report when IPython encounters what may be an
         internal error.  The default is to append a short message to the
@@ -261,30 +261,30 @@ def __init__(self, **kwargs):
         # ensure current working directory exists
         try:
             os.getcwd()
-        except:
+        except OSError:
             # exit if cwd doesn't exist
             self.log.error("Current working directory doesn't exist.")
             self.exit(1)
 
     #-------------------------------------------------------------------------
     # Various stages of Application creation
     #-------------------------------------------------------------------------
-    
+
     def init_crash_handler(self):
         """Create a crash handler, typically setting sys.excepthook to it."""
         self.crash_handler = self.crash_handler_class(self)
         sys.excepthook = self.excepthook
         def unset_crashhandler():
             sys.excepthook = sys.__excepthook__
         atexit.register(unset_crashhandler)
-    
+
     def excepthook(self, etype, evalue, tb):
         """this is sys.excepthook after init_crashhandler
 
         set self.verbose_crash=True to use our full crashhandler, instead of
         a regular traceback with a short message (crash_handler_lite)
         """
-        
+
         if self.verbose_crash:
             return self.crash_handler(etype, evalue, tb)
         else:
@@ -355,7 +355,7 @@ def load_config_file(self, suppress_errors=IPYTHON_SUPPRESS_CONFIG_ERRORS):
             pass
         if suppress_errors is not None:
             Application.raise_config_file_errors = old_value
-        
+
         for config_file_name in self.config_files:
             if not config_file_name or config_file_name == base_config:
                 continue

diff --git a/IPython/core/async_helpers.py b/IPython/core/async_helpers.py
@@ -9,6 +9,7 @@
 explicitly to actually raise a SyntaxError and stay as close as possible to
 Python semantics.
 """
+from __future__ import annotations
 
 import ast
 import asyncio

diff --git a/IPython/core/autocall.py b/IPython/core/autocall.py
@@ -30,15 +30,15 @@
 
 class IPyAutocall:
     """ Instances of this class are always autocalled
-    
+
     This happens regardless of 'autocall' variable state. Use this to
     develop macro-like mechanisms.
     """
     _ip = None
     rewrite = True
     def __init__(self, ip=None):
         self._ip = ip
-    
+
     def set_ip(self, ip):
         """Will be used to set _ip point to current ipython instance b/f call
 
@@ -52,13 +52,13 @@ class ExitAutocall(IPyAutocall):
     """An autocallable object which will be added to the user namespace so that
     exit, exit(), quit or quit() are all valid ways to close the shell."""
     rewrite = False
-    
+
     def __call__(self):
         self._ip.ask_exit()
-        
+
 class ZMQExitAutocall(ExitAutocall):
     """Exit IPython. Autocallable, so it needn't be explicitly called.
-    
+
     Parameters
     ----------
     keep_kernel : bool

diff --git a/IPython/core/builtin_trap.py b/IPython/core/builtin_trap.py
@@ -3,12 +3,18 @@
 """
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
+from __future__ import annotations
+
 import builtins as builtin_mod
+from typing import Any, TYPE_CHECKING
 
 from traitlets.config.configurable import Configurable
 
 from traitlets import Instance
 
+if TYPE_CHECKING:
+    from types import TracebackType
+
 
 class __BuiltinUndefined:
     pass
@@ -29,35 +35,36 @@ class BuiltinTrap(Configurable):
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
                      allow_none=True)
 
-    def __init__(self, shell=None):
+    def __init__(self, shell: Any = None) -> None:
         super(BuiltinTrap, self).__init__(shell=shell, config=None)
-        self._orig_builtins = {}
+        self._orig_builtins: dict[str, Any] = {}
         # We define this to track if a single BuiltinTrap is nested.
         # Only turn off the trap when the outermost call to __exit__ is made.
         self._nested_level = 0
         self.shell = shell
         # builtins we always add - if set to HideBuiltin, they will just
         # be removed instead of being replaced by something else
-        self.auto_builtins = {'exit': HideBuiltin,
-                              'quit': HideBuiltin,
-                              'get_ipython': self.shell.get_ipython,
-                              }
+        self.auto_builtins: dict[str, Any] = {
+            'exit': HideBuiltin,
+            'quit': HideBuiltin,
+            'get_ipython': self.shell.get_ipython,
+        }
 
-    def __enter__(self):
+    def __enter__(self) -> BuiltinTrap:
         if self._nested_level == 0:
             self.activate()
         self._nested_level += 1
         # I return self, so callers can use add_builtin in a with clause.
         return self
 
-    def __exit__(self, type, value, traceback):
+    def __exit__(self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None) -> bool:
         if self._nested_level == 1:
             self.deactivate()
         self._nested_level -= 1
         # Returning False will cause exceptions to propagate
         return False
 
-    def add_builtin(self, key, value):
+    def add_builtin(self, key: str, value: Any) -> None:
         """Add a builtin and save the original."""
         bdict = builtin_mod.__dict__
         orig = bdict.get(key, BuiltinUndefined)
@@ -69,25 +76,24 @@ def add_builtin(self, key, value):
             self._orig_builtins[key] = orig
             bdict[key] = value
 
-    def remove_builtin(self, key, orig):
+    def remove_builtin(self, key: str, orig: Any) -> None:
         """Remove an added builtin and re-set the original."""
         if orig is BuiltinUndefined:
             del builtin_mod.__dict__[key]
         else:
             builtin_mod.__dict__[key] = orig
 
-    def activate(self):
+    def activate(self) -> None:
         """Store ipython references in the __builtin__ namespace."""
 
         add_builtin = self.add_builtin
         for name, func in self.auto_builtins.items():
             add_builtin(name, func)
 
-    def deactivate(self):
+    def deactivate(self) -> None:
         """Remove any builtins which might have been added by add_builtins, or
         restore overwritten ones to their previous values."""
         remove_builtin = self.remove_builtin
         for key, val in self._orig_builtins.items():
             remove_builtin(key, val)
         self._orig_builtins.clear()
-        self._builtins_added = False
diff --git a/IPython/core/compilerop.py b/IPython/core/compilerop.py
@@ -26,6 +26,10 @@
 # Imports
 #-----------------------------------------------------------------------------
 
+from __future__ import annotations
+
+import ast
+
 # Stdlib imports
 import __future__
 from ast import PyCF_ONLY_AST
@@ -34,8 +38,8 @@
 import hashlib
 import linecache
 import operator
-import time
 from contextlib import contextmanager
+from typing import Generator
 
 #-----------------------------------------------------------------------------
 # Constants
@@ -51,7 +55,7 @@
 # Local utilities
 #-----------------------------------------------------------------------------
 
-def code_name(code, number=0) -> str:
+def code_name(code: str, number: int = 0) -> str:
     """ Compute a (probably) unique name for code for caching.
 
     This now expects code to be unicode.
@@ -78,26 +82,26 @@ def __init__(self):
         # argument used for the builtins.compile function.
         self._filename_map = {}
 
-    def ast_parse(self, source, filename='<unknown>', symbol='exec'):
+    def ast_parse(self, source: str, filename: str = '<unknown>', symbol: str = 'exec') -> ast.AST:
         """Parse code to an AST with the current compiler flags active.
 
         Arguments are exactly the same as ast.parse (in the standard library),
         and are passed to the built-in compile function."""
         return compile(source, filename, symbol, self.flags | PyCF_ONLY_AST, 1)
 
-    def reset_compiler_flags(self):
+    def reset_compiler_flags(self) -> None:
         """Reset compiler flags to default state."""
         # This value is copied from codeop.Compile.__init__, so if that ever
         # changes, it will need to be updated.
         self.flags = codeop.PyCF_DONT_IMPLY_DEDENT
 
     @property
-    def compiler_flags(self):
+    def compiler_flags(self) -> int:
         """Flags currently active in the compilation process.
         """
         return self.flags
 
-    def get_code_name(self, raw_code, transformed_code, number):
+    def get_code_name(self, raw_code: str, transformed_code: str, number: int) -> str:
         """Compute filename given the code, and the cell number.
 
         Parameters
@@ -116,7 +120,7 @@ def get_code_name(self, raw_code, transformed_code, number):
         """
         return code_name(transformed_code, number)
 
-    def format_code_name(self, name) -> str:
+    def format_code_name(self, name: str) -> tuple[str, str] | None:
         """Return a user-friendly label and name for a code block.
 
         Parameters
@@ -131,7 +135,7 @@ def format_code_name(self, name) -> str:
         if name in self._filename_map:
             return "Cell", "In[%s]" % self._filename_map[name]
 
-    def cache(self, transformed_code, number=0, raw_code=None):
+    def cache(self, transformed_code: str, number: int = 0, raw_code: str | None = None) -> str:
         """Make a name for a block of code, and cache the code.
 
         Parameters
@@ -178,7 +182,7 @@ def cache(self, transformed_code, number=0, raw_code=None):
         return name
 
     @contextmanager
-    def extra_flags(self, flags):
+    def extra_flags(self, flags: int) -> Generator[None, None, None]:
         ## bits that we'll set to 1
         turn_on_bits = ~self.flags & flags