add whatsnew and uppercase C in load_ext

Use uppercase as this is what is in cython docs.

docs/source/whatsnew/pr/remove_cythonmagic.rst

@@ -0,0 +1,1 b''
+* The ``%cython`` magic, is now part of the Cython module. Use `%load_ext Cython` with a version of Cython >= 0.21 to have acces to the magic now. 

IPython/extensions/cythonmagic.py

@@ -1,41 +1,41 b''
 # -*- coding: utf-8 -*-
 """
 The cython magic has been integrated into Cython itself, 
 which is now released in version 0.21.
 
 cf github `cython` organisation, `cython` repo, under the 
 file `Cython/Build/IpythonMagic.py`
 """
 #-----------------------------------------------------------------------------
 # Copyright (C) 2010-2011, 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.
 #-----------------------------------------------------------------------------
 
 from __future__ import print_function
 
 try:
     import Cython
 except:
     Cython = None
 
 try:
     from Cython.Build.IpythonMagic import CythonMagics
 except :
     pass
 
 
 ## still load the magic in IPython 3.x, remove completely in future versions.
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
     
     print("""The Cython magic has been move to the Cython package, hence """)
-    print("""`%load_ext cythonmagic` is deprecated; Please use `%load_ext cython` instead.""")
+    print("""`%load_ext cythonmagic` is deprecated; Please use `%load_ext Cython` instead.""")
     
     if Cython is None or tuple(map(int,Cython.__version__.split('.'))) < (0,21) : 
         print("You need Cython version >=0.21 to use the Cython magic")
         return 
     print("""\nThough, because I am nice, I'll still try to load it for you this time.""")
     Cython.load_ipython_extension(ip)

docs/source/config/extensions/index.rst

@@ -1,104 +1,104 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
    cythonmagic
    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.
+  Use ``%load_ext Cython`` to load it.

docs/source/config/intro.rst

@@ -1,156 +1,156 b''
 =====================================
 Introduction to IPython configuration
 =====================================
 
 .. _setting_config:
 
 Setting configurable options
 ============================
 
 Many of IPython's classes have configurable attributes (see
 :doc:`options/index` for the list). These can be
 configured in several ways.
 
 Python config files
 -------------------
 
 To create the blank config files, run::
 
     ipython profile create [profilename]
 
 If you leave out the profile name, the files will be created for the
 ``default`` profile (see :ref:`profiles`). These will typically be
 located in :file:`~/.ipython/profile_default/`, and will be named
 :file:`ipython_config.py`, :file:`ipython_notebook_config.py`, etc.
 The settings in :file:`ipython_config.py` apply to all IPython commands.
 
 The files typically start by getting the root config object::
 
     c = get_config()
 
 You can then configure class attributes like this::
 
     c.InteractiveShell.automagic = False
 
 Be careful with spelling--incorrect names will simply be ignored, with
 no error.
 
 To add to a collection which may have already been defined elsewhere,
 you can use methods like those found on lists, dicts and sets: append,
 extend, :meth:`~IPython.config.loader.LazyConfigValue.prepend` (like
 extend, but at the front), add and update (which works both for dicts
 and sets)::
 
-    c.InteractiveShellApp.extensions.append('cython')
+    c.InteractiveShellApp.extensions.append('Cython')
 
 .. versionadded:: 2.0
    list, dict and set methods for config values
 
 Example config file
 ```````````````````
 
 ::
 
     # sample ipython_config.py
     c = get_config()
 
     c.TerminalIPythonApp.display_banner = True
     c.InteractiveShellApp.log_level = 20
     c.InteractiveShellApp.extensions = [
         'myextension'
     ]
     c.InteractiveShellApp.exec_lines = [
         'import numpy',
         'import scipy'
     ]
     c.InteractiveShellApp.exec_files = [
         'mycode.py',
         'fancy.ipy'
     ]
     c.InteractiveShell.autoindent = True
     c.InteractiveShell.colors = 'LightBG'
     c.InteractiveShell.confirm_exit = False
     c.InteractiveShell.deep_reload = True
     c.InteractiveShell.editor = 'nano'
     c.InteractiveShell.xmode = 'Context'
 
     c.PromptManager.in_template  = 'In [\#]: '
     c.PromptManager.in2_template = '   .\D.: '
     c.PromptManager.out_template = 'Out[\#]: '
     c.PromptManager.justify = True
 
     c.PrefilterManager.multi_line_specials = True
 
     c.AliasManager.user_aliases = [
      ('la', 'ls -al')
     ]
 
 
 Command line arguments
 ----------------------
 
 Every configurable value can be set from the command line, using this
 syntax::
 
     ipython --ClassName.attribute=value
 
 Many frequently used options have short aliases and flags, such as
 ``--matplotlib`` (to integrate with a matplotlib GUI event loop) or
 ``--pdb`` (automatic post-mortem debugging of exceptions).
 
 To see all of these abbreviated options, run::
 
     ipython --help
     ipython notebook --help
     # etc.
 
 Options specified at the command line, in either format, override
 options set in a configuration file.
 
 The config magic
 ----------------
 
 You can also modify config from inside IPython, using a magic command::
 
     %config IPCompleter.greedy = True
 
 At present, this only affects the current session - changes you make to
 config are not saved anywhere. Also, some options are only read when
 IPython starts, so they can't be changed like this.
 
 .. _profiles:
 
 Profiles
 ========
 
 IPython can use multiple profiles, with separate configuration and
 history. By default, if you don't specify a profile, IPython always runs
 in the ``default`` profile. To use a new profile::
 
     ipython profile create foo   # create the profile foo
     ipython --profile=foo        # start IPython using the new profile
 
 Profiles are typically stored in :ref:`ipythondir`, but you can also keep
 a profile in the current working directory, for example to distribute it
 with a project. To find a profile directory on the filesystem::
 
     ipython locate profile foo
 
 .. _ipythondir:
 
 The IPython directory
 =====================
 
 IPython stores its files---config, command history and extensions---in
 the directory :file:`~/.ipython/` by default.
 
 .. envvar:: IPYTHONDIR
 
    If set, this environment variable should be the path to a directory,
    which IPython will use for user data. IPython will create it if it
    does not exist.
 
 .. option:: --ipython-dir=<path>
 
    This command line option can also be used to override the default
    IPython directory.