Merge pull request #13194 from meysam81/meysam/remove-deprecated-stuff

feat: remove deprecated code & files ⚰️

docs/source/whatsnew/pr/remove-deprecated-stuff.rst

@@ -0,0 +1,8 b''
+Remove Deprecated Stuff
+================================
+
+We no longer need to add `extensions` to the PYTHONPATH because that is being
+handled by `load_extension`.
+
+We are also removing Cythonmagic, sympyprinting and rmagic as they are now in
+other packages and no longer need to be inside IPython.

IPython/__init__.py

@@ -1,149 +1,144 b''
 # encoding: utf-8
 """
 IPython: tools for interactive and parallel computing in Python.
 
 https://ipython.org
 """
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2008-2011, IPython Development Team.
 #  Copyright (c) 2001-2007, Fernando Perez <[e-mail]>
 #  Copyright (c) 2001, Janko Hauser <[e-mail]>
 #  Copyright (c) 2001, Nathaniel Gray <[e-mail]>
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import sys
 
 #-----------------------------------------------------------------------------
 # Setup everything
 #-----------------------------------------------------------------------------
 
 # Don't forget to also update setup.py when this changes!
 if sys.version_info < (3, 6):
     raise ImportError(
 """
 IPython 7.10+ supports Python 3.6 and above.
 When using Python 2.7, please install IPython 5.x LTS Long Term Support version.
 Python 3.3 and 3.4 were supported up to IPython 6.x.
 Python 3.5 was supported with IPython 7.0 to 7.9.
 
 See IPython `README.rst` file for more information:
 
     https://github.com/ipython/ipython/blob/master/README.rst
 
 """)
 
-# Make it easy to import extensions - they are always directly on pythonpath.
-# Therefore, non-IPython modules can be added to extensions directory.
-# This should probably be in ipapp.py.
-sys.path.append(os.path.join(os.path.dirname(__file__), "extensions"))
-
 #-----------------------------------------------------------------------------
 # Setup the top level names
 #-----------------------------------------------------------------------------
 
 from .core.getipython import get_ipython
 from .core import release
 from .core.application import Application
 from .terminal.embed import embed
 
 from .core.interactiveshell import InteractiveShell
 from .testing import test
 from .utils.sysinfo import sys_info
 from .utils.frame import extract_module_locals
 
 # Release data
 __author__ = '%s <%s>' % (release.author, release.author_email)
 __license__  = release.license
 __version__  = release.version
 version_info = release.version_info
 
 def embed_kernel(module=None, local_ns=None, **kwargs):
     """Embed and start an IPython kernel in a given scope.
 
     If you don't want the kernel to initialize the namespace
     from the scope of the surrounding function,
     and/or you want to load full IPython configuration,
     you probably want `IPython.start_kernel()` instead.
 
     Parameters
     ----------
     module : types.ModuleType, optional
         The module to load into IPython globals (default: caller)
     local_ns : dict, optional
         The namespace to load into IPython user namespace (default: caller)
     **kwargs : various, optional
         Further keyword args are relayed to the IPKernelApp constructor,
         allowing configuration of the Kernel.  Will only have an effect
         on the first embed_kernel call for a given process.
     """
     
     (caller_module, caller_locals) = extract_module_locals(1)
     if module is None:
         module = caller_module
     if local_ns is None:
         local_ns = 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)
 
 def start_ipython(argv=None, **kwargs):
     """Launch a normal IPython instance (as opposed to embedded)
 
     `IPython.embed()` puts a shell in a particular calling scope,
     such as a function or method for debugging purposes,
     which is often not desirable.
 
     `start_ipython()` does full, regular IPython initialization,
     including loading startup files, configuration, etc.
     much of which is skipped by `embed()`.
 
     This is a public API method, and will survive implementation changes.
 
     Parameters
     ----------
     argv : list or None, optional
         If unspecified or None, IPython will parse command-line options from sys.argv.
         To prevent any command-line parsing, pass an empty list: `argv=[]`.
     user_ns : dict, optional
         specify this dictionary to initialize the IPython user namespace with particular values.
     **kwargs : various, optional
         Any other kwargs will be passed to the Application constructor,
         such as `config`.
     """
     from IPython.terminal.ipapp import launch_new_instance
     return launch_new_instance(argv=argv, **kwargs)
 
 def start_kernel(argv=None, **kwargs):
     """Launch a normal IPython kernel instance (as opposed to embedded)
 
     `IPython.embed_kernel()` puts a shell in a particular calling scope,
     such as a function or method for debugging purposes,
     which is often not desirable.
 
     `start_kernel()` does full, regular IPython initialization,
     including loading startup files, configuration, etc.
     much of which is skipped by `embed()`.
 
     Parameters
     ----------
     argv : list or None, optional
         If unspecified or None, IPython will parse command-line options from sys.argv.
         To prevent any command-line parsing, pass an empty list: `argv=[]`.
     user_ns : dict, optional
         specify this dictionary to initialize the IPython user namespace with particular values.
     **kwargs : various, optional
         Any other kwargs will be passed to the Application constructor,
         such as `config`.
     """
     from IPython.kernel.zmq.kernelapp import launch_new_instance
     return launch_new_instance(argv=argv, **kwargs)

IPython/core/extensions.py

@@ -1,150 +1,167 b''
 # encoding: utf-8
 """A class for managing IPython extensions."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 import os.path
 import sys
 from importlib import import_module, reload
 
 from traitlets.config.configurable import Configurable
 from IPython.utils.path import ensure_dir_exists, compress_user
 from IPython.utils.decorators import undoc
 from traitlets import Instance
 
 
 #-----------------------------------------------------------------------------
 # Main class
 #-----------------------------------------------------------------------------
 
+BUILTINS_EXTS = {"storemagic": False, "autoreload": False}
+
+
 class ExtensionManager(Configurable):
     """A class to manage IPython extensions.
 
     An IPython extension is an importable Python module that has
     a function with the signature::
 
         def load_ipython_extension(ipython):
             # Do things with ipython
 
     This function is called after your extension is imported and the
     currently active :class:`InteractiveShell` instance is passed as
     the only argument.  You can do anything you want with IPython at
     that point, including defining new magic and aliases, adding new
     components, etc.
     
     You can also optionally define an :func:`unload_ipython_extension(ipython)`
     function, which will be called if the user unloads or reloads the extension.
     The extension manager will only call :func:`load_ipython_extension` again
     if the extension is reloaded.
 
     You can put your extension modules anywhere you want, as long as
     they can be imported by Python's standard import mechanism.  However,
     to make it easy to write extensions, you can also put your extensions
     in ``os.path.join(self.ipython_dir, 'extensions')``.  This directory
     is added to ``sys.path`` automatically.
     """
 
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
 
     def __init__(self, shell=None, **kwargs):
         super(ExtensionManager, self).__init__(shell=shell, **kwargs)
         self.shell.observe(
             self._on_ipython_dir_changed, names=('ipython_dir',)
         )
         self.loaded = set()
 
     @property
     def ipython_extension_dir(self):
         return os.path.join(self.shell.ipython_dir, u'extensions')
 
     def _on_ipython_dir_changed(self, change):
         ensure_dir_exists(self.ipython_extension_dir)
 
-    def load_extension(self, module_str):
+    def load_extension(self, module_str: str):
         """Load an IPython extension by its module name.
 
         Returns the string "already loaded" if the extension is already loaded,
         "no load function" if the module doesn't have a load_ipython_extension
         function, or None if it succeeded.
         """
+        try:
+            return self._load_extension(module_str)
+        except ModuleNotFoundError:
+            if module_str in BUILTINS_EXTS:
+                BUILTINS_EXTS[module_str] = True
+                return self._load_extension("IPython.extensions." + module_str)
+            raise
+
+    def _load_extension(self, module_str: str):
         if module_str in self.loaded:
             return "already loaded"
 
         from IPython.utils.syspathcontext import prepended_to_syspath
 
         with self.shell.builtin_trap:
             if module_str not in sys.modules:
                 with prepended_to_syspath(self.ipython_extension_dir):
                     mod = import_module(module_str)
                     if mod.__file__.startswith(self.ipython_extension_dir):
                         print(("Loading extensions from {dir} is deprecated. "
                                "We recommend managing extensions like any "
                                "other Python packages, in site-packages.").format(
                               dir=compress_user(self.ipython_extension_dir)))
             mod = sys.modules[module_str]
             if self._call_load_ipython_extension(mod):
                 self.loaded.add(module_str)
             else:
                 return "no load function"
 
-    def unload_extension(self, module_str):
+    def unload_extension(self, module_str: str):
         """Unload an IPython extension by its module name.
 
         This function looks up the extension's name in ``sys.modules`` and
         simply calls ``mod.unload_ipython_extension(self)``.
 
         Returns the string "no unload function" if the extension doesn't define
         a function to unload itself, "not loaded" if the extension isn't loaded,
         otherwise None.
         """
+        if BUILTINS_EXTS.get(module_str, False) is True:
+            module_str = "IPython.extensions." + module_str
         if module_str not in self.loaded:
             return "not loaded"
         
         if module_str in sys.modules:
             mod = sys.modules[module_str]
             if self._call_unload_ipython_extension(mod):
                 self.loaded.discard(module_str)
             else:
                 return "no unload function"
 
-    def reload_extension(self, module_str):
+    def reload_extension(self, module_str: str):
         """Reload an IPython extension by calling reload.
 
         If the module has not been loaded before,
         :meth:`InteractiveShell.load_extension` is called. Otherwise
         :func:`reload` is called and then the :func:`load_ipython_extension`
         function of the module, if it exists is called.
         """
         from IPython.utils.syspathcontext import prepended_to_syspath
 
+        if BUILTINS_EXTS.get(module_str, False) is True:
+            module_str = "IPython.extensions." + module_str
+
         if (module_str in self.loaded) and (module_str in sys.modules):
             self.unload_extension(module_str)
             mod = sys.modules[module_str]
             with prepended_to_syspath(self.ipython_extension_dir):
                 reload(mod)
             if self._call_load_ipython_extension(mod):
                 self.loaded.add(module_str)
         else:
             self.load_extension(module_str)
 
     def _call_load_ipython_extension(self, mod):
         if hasattr(mod, 'load_ipython_extension'):
             mod.load_ipython_extension(self.shell)
             return True
 
     def _call_unload_ipython_extension(self, mod):
         if hasattr(mod, 'unload_ipython_extension'):
             mod.unload_ipython_extension(self.shell)
             return True
 
     @undoc
     def install_extension(self, url, filename=None):
         """
         Deprecated.
         """
         # Ensure the extension directory exists
         raise DeprecationWarning(
             '`install_extension` and the `install_ext` magic have been deprecated since IPython 4.0'
             'Use pip or other package managers to manage ipython extensions.')