Deprecate and undocument install_ext

It seem to me that Python packaging has come up to a point where
actually telling peoples they can install python extensions not using
package manager is unreasonable.

Recent extension even recommend using `install_ext` as **the way** to
install things, which is unsecure, confusing, and there is no update
mechanisme, nor version conflict resolution.

IPython/core/magics/extension.py

@@ -1,93 +1,96 b''
 """Implementation of magic functions for the extension machinery.
 """
 from __future__ import print_function
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012 The IPython Development Team.
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib
 import os
 
 # Our own packages
 from IPython.core.error import UsageError
 from IPython.core.magic import Magics, magics_class, line_magic
+from  warnings import warn
 
 #-----------------------------------------------------------------------------
 # Magic implementation classes
 #-----------------------------------------------------------------------------
 
 @magics_class
 class ExtensionMagics(Magics):
     """Magics to manage the IPython extensions system."""
 
     @line_magic
     def install_ext(self, parameter_s=''):
         """Download and install an extension from a URL, e.g.::
 
             %install_ext https://bitbucket.org/birkenfeld/ipython-physics/raw/d1310a2ab15d/physics.py
 
         The URL should point to an importable Python module - either a .py file
         or a .zip file.
 
         Parameters:
 
           -n filename : Specify a name for the file, rather than taking it from
                         the URL.
         """
+        warn("%install_ext` is deprecated, please distribute your extension(s)"
+             "as a python packages.", UserWarning)
         opts, args = self.parse_options(parameter_s, 'n:')
         try:
             filename = self.shell.extension_manager.install_extension(args,
                                                                  opts.get('n'))
         except ValueError as e:
             print(e)
             return
 
         filename = os.path.basename(filename)
         print("Installed %s. To use it, type:" % filename)
         print("  %%load_ext %s" % os.path.splitext(filename)[0])
 
 
     @line_magic
     def load_ext(self, module_str):
         """Load an IPython extension by its module name."""
         if not module_str:
             raise UsageError('Missing module name.')
         res = self.shell.extension_manager.load_extension(module_str)
         
         if res == 'already loaded':
             print("The %s extension is already loaded. To reload it, use:" % module_str)
             print("  %reload_ext", module_str)
         elif res == 'no load function':
             print("The %s module is not an IPython extension." % module_str)
 
     @line_magic
     def unload_ext(self, module_str):
         """Unload an IPython extension by its module name.
         
         Not all extensions can be unloaded, only those which define an
         ``unload_ipython_extension`` function.
         """
         if not module_str:
             raise UsageError('Missing module name.')
         
         res = self.shell.extension_manager.unload_extension(module_str)
         
         if res == 'no unload function':
             print("The %s extension doesn't define how to unload it." % module_str)
         elif res == "not loaded":
             print("The %s extension is not loaded." % module_str)
 
     @line_magic
     def reload_ext(self, module_str):
         """Reload an IPython extension by its module name."""
         if not module_str:
             raise UsageError('Missing module name.')
         self.shell.extension_manager.reload_extension(module_str)

docs/source/config/extensions/index.rst

@@ -1,103 +1,100 b''
 .. _extensions_overview:
 
 ==================
 IPython extensions
 ==================
 
 A level above configuration are IPython extensions, Python modules which modify
 the behaviour of the shell. They are referred to by an importable module name,
 and can be placed anywhere you'd normally import from, or in
 ``.ipython/extensions/``.
 
 Getting extensions
 ==================
 
 A few important extensions are :ref:`bundled with IPython <bundled_extensions>`.
 Others can be found on the `extensions index
 <https://github.com/ipython/ipython/wiki/Extensions-Index>`_ on the wiki, and
 the `Framework :: IPython tag <https://pypi.python.org/pypi?:action=browse&c=586>`_
 on PyPI.
 
 Extensions on PyPI can be installed using ``pip``, like any other Python package.
-Other simple extensions can be installed with the ``%install_ext`` magic. The
-latter does no validation, so be careful using it on untrusted networks like
-public wifi.
 
 Using extensions
 ================
 
 To load an extension while IPython is running, use the ``%load_ext`` magic:
 
 .. sourcecode:: ipython
 
     In [1]: %load_ext myextension
 
 To load it each time IPython starts, list it in your configuration file::
 
     c.InteractiveShellApp.extensions = [
         'myextension'
     ]
 
 Writing extensions
 ==================
 
 An IPython extension is an importable Python module that has a couple of special
 functions to load and unload it. Here is a template::
 
     # myextension.py
 
     def load_ipython_extension(ipython):
         # The `ipython` argument is the currently active `InteractiveShell`
         # instance, which can be used in any way. This allows you to register
         # new magics or aliases, for example.
 
     def unload_ipython_extension(ipython):
         # If you want your extension to be unloadable, put that logic here.
 
 This :func:`load_ipython_extension` function is called after your extension is
 imported, and the currently active :class:`~IPython.core.interactiveshell.InteractiveShell`
 instance is passed as the only argument. You can do anything you want with
 IPython at that point.
 
 :func:`load_ipython_extension` will be called again if you load or reload
 the extension again. It is up to the extension author to add code to manage
 that.
 
 Useful :class:`InteractiveShell` methods include :meth:`~IPython.core.interactiveshell.InteractiveShell.register_magic_function`, 
 :meth:`~IPython.core.interactiveshell.InteractiveShell.push` (to add variables to the user namespace) and 
 :meth:`~IPython.core.interactiveshell.InteractiveShell.drop_by_id` (to remove variables on unloading).
 
 .. seealso::
 
    :ref:`defining_magics`
 
 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 :file:`extensions/`
 within the :ref:`IPython directory <ipythondir>`. This directory is
 added to :data:`sys.path` automatically.
 
 When your extension is ready for general use, please add it to the `extensions
 index <https://github.com/ipython/ipython/wiki/Extensions-Index>`_. We also
 encourage you to upload it to PyPI and use the ``Framework :: IPython``
 classifier, so that users can install it with standard packaging tools.
 
 .. _bundled_extensions:
 
 Extensions bundled with IPython
 ===============================
 
 .. toctree::
    :maxdepth: 1
 
    autoreload
    storemagic
    sympyprinting
 
 * ``octavemagic`` used to be bundled, but is now part of `oct2py <http://blink1073.github.io/oct2py/docs/>`_.
   Use ``%load_ext oct2py.ipython`` to load it.
 * ``rmagic`` is now part of `rpy2 <http://rpy.sourceforge.net/>`_. Use
   ``%load_ext rpy2.ipython`` to load it, and see :mod:`rpy2.ipython.rmagic` for
   details of how to use it.
 * ``cythonmagic`` used to be bundled, but is now part of `cython <https://github.com/cython/cython/>`_
   Use ``%load_ext Cython`` to load it.