a couple of more stray XDG / .config references

IPython/core/usage.py

@@ -1,571 +1,570 b''
 # -*- coding: utf-8 -*-
 """Usage information for the main IPython applications.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #  Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 import sys
 from IPython.core import release
 
 cl_usage = """\
 =========
  IPython
 =========
 
 Tools for Interactive Computing in Python
 =========================================
 
     A Python shell with automatic history (input and output), dynamic object
     introspection, easier configuration, command completion, access to the
     system shell and more.  IPython can also be embedded in running programs.
 
 
 Usage
 
     ipython [subcommand] [options] [-c cmd | -m mod | file] [--] [arg] ...
 
     If invoked with no options, it executes the file and exits, passing the
     remaining arguments to the script, just as if you had specified the same
     command with python. You may need to specify `--` before args to be passed
     to the script, to prevent IPython from attempting to parse them. If you
     specify the option `-i` before the filename, it will enter an interactive
     IPython session after running the script, rather than exiting. Files ending
     in .py will be treated as normal Python, but files ending in .ipy can
     contain special IPython syntax (magic commands, shell expansions, etc.).
 
     Almost all configuration in IPython is available via the command-line. Do
     `ipython --help-all` to see all available options.  For persistent
     configuration, look into your `ipython_config.py` configuration file for
     details.
 
     This file is typically installed in the `IPYTHONDIR` directory, and there
     is a separate configuration directory for each profile. The default profile
-    directory will be located in $IPYTHONDIR/profile_default. For Linux users,
-    IPYTHONDIR defaults to `$HOME/.config/ipython`, and for other Unix systems
-    to `$HOME/.ipython`.  For Windows users, $HOME resolves to C:\\Documents
-    and Settings\\YourUserName in most instances.
+    directory will be located in $IPYTHONDIR/profile_default. IPYTHONDIR
+    defaults to to `$HOME/.ipython`.  For Windows users, $HOME resolves to
+    C:\\Documents and Settings\\YourUserName in most instances.
 
     To initialize a profile with the default configuration file, do::
 
       $> ipython profile create
 
     and start editing `IPYTHONDIR/profile_default/ipython_config.py`
 
     In IPython's documentation, we will refer to this directory as
     `IPYTHONDIR`, you can change its default location by creating an
     environment variable with this name and setting it to the desired path.
 
     For more information, see the manual available in HTML and PDF in your
     installation, or online at http://ipython.org/documentation.html.
 """
 
 interactive_usage = """
 IPython -- An enhanced Interactive Python
 =========================================
 
 IPython offers a combination of convenient shell features, special commands
 and a history mechanism for both input (command history) and output (results
 caching, similar to Mathematica). It is intended to be a fully compatible
 replacement for the standard Python interpreter, while offering vastly
 improved functionality and flexibility.
 
 At your system command line, type 'ipython -h' to see the command line
 options available. This document only describes interactive features.
 
 MAIN FEATURES
 -------------
 
 * Access to the standard Python help. As of Python 2.1, a help system is
   available with access to object docstrings and the Python manuals. Simply
   type 'help' (no quotes) to access it.
 
 * Magic commands: type %magic for information on the magic subsystem.
 
 * System command aliases, via the %alias command or the configuration file(s).
 
 * Dynamic object information:
 
   Typing ?word or word? prints detailed information about an object.  If
   certain strings in the object are too long (docstrings, code, etc.) they get
   snipped in the center for brevity.
 
   Typing ??word or word?? gives access to the full information without
   snipping long strings. Long strings are sent to the screen through the less
   pager if longer than the screen, printed otherwise.
 
   The ?/?? system gives access to the full source code for any object (if
   available), shows function prototypes and other useful information.
 
   If you just want to see an object's docstring, type '%pdoc object' (without
   quotes, and without % if you have automagic on).
 
   Both %pdoc and ?/?? give you access to documentation even on things which are
   not explicitely defined. Try for example typing {}.get? or after import os,
   type os.path.abspath??. The magic functions %pdef, %source and %file operate
   similarly.
 
 * Completion in the local namespace, by typing TAB at the prompt.
 
   At any time, hitting tab will complete any available python commands or
   variable names, and show you a list of the possible completions if there's
   no unambiguous one. It will also complete filenames in the current directory.
 
   This feature requires the readline and rlcomplete modules, so it won't work
   if your Python lacks readline support (such as under Windows).
 
 * Search previous command history in two ways (also requires readline):
 
   - Start typing, and then use Ctrl-p (previous,up) and Ctrl-n (next,down) to
     search through only the history items that match what you've typed so
     far. If you use Ctrl-p/Ctrl-n at a blank prompt, they just behave like
     normal arrow keys.
 
   - Hit Ctrl-r: opens a search prompt. Begin typing and the system searches
     your history for lines that match what you've typed so far, completing as
     much as it can.
 
   - %hist: search history by index (this does *not* require readline).
 
 * Persistent command history across sessions.
 
 * Logging of input with the ability to save and restore a working session.
 
 * System escape with !. Typing !ls will run 'ls' in the current directory.
 
 * The reload command does a 'deep' reload of a module: changes made to the
   module since you imported will actually be available without having to exit.
 
 * Verbose and colored exception traceback printouts. See the magic xmode and
   xcolor functions for details (just type %magic).
 
 * Input caching system:
 
   IPython offers numbered prompts (In/Out) with input and output caching. All
   input is saved and can be retrieved as variables (besides the usual arrow
   key recall).
 
   The following GLOBAL variables always exist (so don't overwrite them!):
   _i: stores previous input.
   _ii: next previous.
   _iii: next-next previous.
   _ih : a list of all input _ih[n] is the input from line n.
 
   Additionally, global variables named _i<n> are dynamically created (<n>
   being the prompt counter), such that _i<n> == _ih[<n>]
 
   For example, what you typed at prompt 14 is available as _i14 and _ih[14].
 
   You can create macros which contain multiple input lines from this history,
   for later re-execution, with the %macro function.
 
   The history function %hist allows you to see any part of your input history
   by printing a range of the _i variables. Note that inputs which contain
   magic functions (%) appear in the history with a prepended comment. This is
   because they aren't really valid Python code, so you can't exec them.
 
 * Output caching system:
 
   For output that is returned from actions, a system similar to the input
   cache exists but using _ instead of _i. Only actions that produce a result
   (NOT assignments, for example) are cached. If you are familiar with
   Mathematica, IPython's _ variables behave exactly like Mathematica's %
   variables.
 
   The following GLOBAL variables always exist (so don't overwrite them!):
   _ (one underscore): previous output.
   __ (two underscores): next previous.
   ___ (three underscores): next-next previous.
 
   Global variables named _<n> are dynamically created (<n> being the prompt
   counter), such that the result of output <n> is always available as _<n>.
 
   Finally, a global dictionary named _oh exists with entries for all lines
   which generated output.
 
 * Directory history:
 
   Your history of visited directories is kept in the global list _dh, and the
   magic %cd command can be used to go to any entry in that list.
 
 * Auto-parentheses and auto-quotes (adapted from Nathan Gray's LazyPython)
 
   1. Auto-parentheses
         
      Callable objects (i.e. functions, methods, etc) can be invoked like
      this (notice the commas between the arguments)::
        
          In [1]: callable_ob arg1, arg2, arg3
        
      and the input will be translated to this::
        
          callable_ob(arg1, arg2, arg3)
        
      This feature is off by default (in rare cases it can produce
      undesirable side-effects), but you can activate it at the command-line
      by starting IPython with `--autocall 1`, set it permanently in your
      configuration file, or turn on at runtime with `%autocall 1`.
 
      You can force auto-parentheses by using '/' as the first character
      of a line.  For example::
        
           In [1]: /globals             # becomes 'globals()'
        
      Note that the '/' MUST be the first character on the line!  This
      won't work::
        
           In [2]: print /globals    # syntax error
 
      In most cases the automatic algorithm should work, so you should
      rarely need to explicitly invoke /. One notable exception is if you
      are trying to call a function with a list of tuples as arguments (the
      parenthesis will confuse IPython)::
        
           In [1]: zip (1,2,3),(4,5,6)  # won't work
        
      but this will work::
        
           In [2]: /zip (1,2,3),(4,5,6)
           ------> zip ((1,2,3),(4,5,6))
           Out[2]= [(1, 4), (2, 5), (3, 6)]
 
      IPython tells you that it has altered your command line by
      displaying the new command line preceded by -->.  e.g.::
        
           In [18]: callable list
           -------> callable (list)
 
   2. Auto-Quoting
     
      You can force auto-quoting of a function's arguments by using ',' as
      the first character of a line.  For example::
        
           In [1]: ,my_function /home/me   # becomes my_function("/home/me")
 
      If you use ';' instead, the whole argument is quoted as a single
      string (while ',' splits on whitespace)::
        
           In [2]: ,my_function a b c   # becomes my_function("a","b","c")
           In [3]: ;my_function a b c   # becomes my_function("a b c")
 
      Note that the ',' MUST be the first character on the line!  This
      won't work::
        
           In [4]: x = ,my_function /home/me    # syntax error
 """
 
 interactive_usage_min =  """\
 An enhanced console for Python.
 Some of its features are:
 - Readline support if the readline library is present.
 - Tab completion in the local namespace.
 - Logging of input, see command-line options.
 - System shell escape via ! , eg !ls.
 - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
 - Keeps track of locally defined variables via %who, %whos.
 - Show object information with a ? eg ?x or x? (use ?? for more info).
 """
 
 quick_reference = r"""
 IPython -- An enhanced Interactive Python - Quick Reference Card
 ================================================================
 
 obj?, obj??      : Get help, or more help for object (also works as
                    ?obj, ??obj).
 ?foo.*abc*       : List names in 'foo' containing 'abc' in them.
 %magic           : Information about IPython's 'magic' % functions.
 
 Magic functions are prefixed by % or %%, and typically take their arguments
 without parentheses, quotes or even commas for convenience.  Line magics take a
 single % and cell magics are prefixed with two %%.
 
 Example magic function calls:
 
 %alias d ls -F   : 'd' is now an alias for 'ls -F'
 alias d ls -F    : Works if 'alias' not a python name
 alist = %alias   : Get list of aliases to 'alist'
 cd /usr/share    : Obvious. cd -<tab> to choose from visited dirs.
 %cd??            : See help AND source for magic %cd
 %timeit x=10     : time the 'x=10' statement with high precision.
 %%timeit x=2**100
 x**100           : time 'x*100' with a setup of 'x=2**100'; setup code is not
                    counted.  This is an example of a cell magic.
 
 System commands:
 
 !cp a.txt b/     : System command escape, calls os.system()
 cp a.txt b/      : after %rehashx, most system commands work without !
 cp ${f}.txt $bar : Variable expansion in magics and system commands
 files = !ls /usr : Capture sytem command output
 files.s, files.l, files.n: "a b c", ['a','b','c'], 'a\nb\nc'
 
 History:
 
 _i, _ii, _iii    : Previous, next previous, next next previous input
 _i4, _ih[2:5]    : Input history line 4, lines 2-4
 exec _i81        : Execute input history line #81 again
 %rep 81          : Edit input history line #81
 _, __, ___       : previous, next previous, next next previous output
 _dh              : Directory history
 _oh              : Output history
 %hist            : Command history. '%hist -g foo' search history for 'foo'
 
 Autocall:
 
 f 1,2            : f(1,2)  # Off by default, enable with %autocall magic.
 /f 1,2           : f(1,2) (forced autoparen)
 ,f 1 2           : f("1","2")
 ;f 1 2           : f("1 2")
 
 Remember: TAB completion works in many contexts, not just file names
 or python names.
 
 The following magic functions are currently available:
 
 """
 
 gui_reference = """\
 ===============================
  The graphical IPython console
 ===============================
 
 This console is designed to emulate the look, feel and workflow of a terminal
 environment, while adding a number of enhancements that are simply not possible
 in a real terminal, such as inline syntax highlighting, true multiline editing,
 inline graphics and much more.
 
 This quick reference document contains the basic information you'll need to
 know to make the most efficient use of it.  For the various command line
 options available at startup, type ``ipython qtconsole --help`` at the command line.
 
 
 Multiline editing
 =================
 
 The graphical console is capable of true multiline editing, but it also tries
 to behave intuitively like a terminal when possible.  If you are used to
 IPython's old terminal behavior, you should find the transition painless, and
 once you learn a few basic keybindings it will be a much more efficient
 environment.
 
 For single expressions or indented blocks, the console behaves almost like the
 terminal IPython: single expressions are immediately evaluated, and indented
 blocks are evaluated once a single blank line is entered::
 
     In [1]: print "Hello IPython!"  # Enter was pressed at the end of the line
     Hello IPython!
 
     In [2]: for i in range(10):
        ...: 	print i,
        ...:
     0 1 2 3 4 5 6 7 8 9
 
 If you want to enter more than one expression in a single input block
 (something not possible in the terminal), you can use ``Control-Enter`` at the
 end of your first line instead of ``Enter``.  At that point the console goes
 into 'cell mode' and even if your inputs are not indented, it will continue
 accepting arbitrarily many lines until either you enter an extra blank line or
 you hit ``Shift-Enter`` (the key binding that forces execution).  When a
 multiline cell is entered, IPython analyzes it and executes its code producing
 an ``Out[n]`` prompt only for the last expression in it, while the rest of the
 cell is executed as if it was a script.  An example should clarify this::
 
     In [3]: x=1  # Hit C-Enter here
        ...: y=2  # from now on, regular Enter is sufficient
        ...: z=3
        ...: x**2  # This does *not* produce an Out[] value
        ...: x+y+z  # Only the last expression does
        ...:
     Out[3]: 6
 
 The behavior where an extra blank line forces execution is only active if you
 are actually typing at the keyboard each line, and is meant to make it mimic
 the IPython terminal behavior.  If you paste a long chunk of input (for example
 a long script copied form an editor or web browser), it can contain arbitrarily
 many intermediate blank lines and they won't cause any problems.  As always,
 you can then make it execute by appending a blank line *at the end* or hitting
 ``Shift-Enter`` anywhere within the cell.
 
 With the up arrow key, you can retrieve previous blocks of input that contain
 multiple lines.  You can move inside of a multiline cell like you would in any
 text editor.  When you want it executed, the simplest thing to do is to hit the
 force execution key, ``Shift-Enter`` (though you can also navigate to the end
 and append a blank line by using ``Enter`` twice).
 
 If you've edited a multiline cell and accidentally navigate out of it with the
 up or down arrow keys, IPython will clear the cell and replace it with the
 contents of the one above or below that you navigated to.  If this was an
 accident and you want to retrieve the cell you were editing, use the Undo
 keybinding, ``Control-z``.
 
 
 Key bindings
 ============
 
 The IPython console supports most of the basic Emacs line-oriented keybindings,
 in addition to some of its own.
 
 The keybinding prefixes mean:
 
 - ``C``: Control
 - ``S``: Shift
 - ``M``: Meta (typically the Alt key)
 
 The keybindings themselves are:
 
 - ``Enter``: insert new line (may cause execution, see above).
 - ``C-Enter``: *force* new line, *never* causes execution.
 - ``S-Enter``: *force* execution regardless of where cursor is, no newline added.
 - ``Up``: step backwards through the history.
 - ``Down``: step forwards through the history.
 - ``S-Up``: search backwards through the history (like ``C-r`` in bash).
 - ``S-Down``: search forwards through the history.
 - ``C-c``: copy highlighted text to clipboard (prompts are automatically stripped).
 - ``C-S-c``: copy highlighted text to clipboard (prompts are not stripped).
 - ``C-v``: paste text from clipboard.
 - ``C-z``: undo (retrieves lost text if you move out of a cell with the arrows).
 - ``C-S-z``: redo.
 - ``C-o``: move to 'other' area, between pager and terminal.
 - ``C-l``: clear terminal.
 - ``C-a``: go to beginning of line.
 - ``C-e``: go to end of line.
 - ``C-u``: kill from cursor to the begining of the line.
 - ``C-k``: kill from cursor to the end of the line.
 - ``C-y``: yank (paste)
 - ``C-p``: previous line (like up arrow)
 - ``C-n``: next line (like down arrow)
 - ``C-f``: forward (like right arrow)
 - ``C-b``: back (like left arrow)
 - ``C-d``: delete next character, or exits if input is empty
 - ``M-<``: move to the beginning of the input region.
 - ``M->``: move to the end of the input region.
 - ``M-d``: delete next word.
 - ``M-Backspace``: delete previous word.
 - ``C-.``: force a kernel restart (a confirmation dialog appears).
 - ``C-+``: increase font size.
 - ``C--``: decrease font size.
 - ``C-M-Space``: toggle full screen. (Command-Control-Space on Mac OS X)
 
 The IPython pager
 =================
 
 IPython will show long blocks of text from many sources using a builtin pager.
 You can control where this pager appears with the ``--paging`` command-line
 flag:
 
 - ``inside`` [default]: the pager is overlaid on top of the main terminal. You
   must quit the pager to get back to the terminal (similar to how a pager such
   as ``less`` or ``more`` works).
 
 - ``vsplit``: the console is made double-tall, and the pager appears on the
   bottom area when needed.  You can view its contents while using the terminal.
 
 - ``hsplit``: the console is made double-wide, and the pager appears on the
   right area when needed.  You can view its contents while using the terminal.
 
 - ``none``: the console never pages output.
 
 If you use the vertical or horizontal paging modes, you can navigate between
 terminal and pager as follows:
 
 - Tab key: goes from pager to terminal (but not the other way around).
 - Control-o: goes from one to another always.
 - Mouse: click on either.
 
 In all cases, the ``q`` or ``Escape`` keys quit the pager (when used with the
 focus on the pager area).
 
 Running subprocesses
 ====================
 
 The graphical IPython console uses the ``pexpect`` module to run subprocesses
 when you type ``!command``.  This has a number of advantages (true asynchronous
 output from subprocesses as well as very robust termination of rogue
 subprocesses with ``Control-C``), as well as some limitations.  The main
 limitation is that you can *not* interact back with the subprocess, so anything
 that invokes a pager or expects you to type input into it will block and hang
 (you can kill it with ``Control-C``).
 
 We have provided as magics ``%less`` to page files (aliased to ``%more``),
 ``%clear`` to clear the terminal, and ``%man`` on Linux/OSX.  These cover the
 most common commands you'd want to call in your subshell and that would cause
 problems if invoked via ``!cmd``, but you need to be aware of this limitation.
 
 Display
 =======
 
 The IPython console can now display objects in a variety of formats, including
 HTML, PNG and SVG. This is accomplished using the display functions in
 ``IPython.core.display``::
 
     In [4]: from IPython.core.display import display, display_html
 
     In [5]: from IPython.core.display import display_png, display_svg
 
 Python objects can simply be passed to these functions and the appropriate
 representations will be displayed in the console as long as the objects know
 how to compute those representations. The easiest way of teaching objects how
 to format themselves in various representations is to define special methods
 such as: ``_repr_html_``, ``_repr_svg_`` and ``_repr_png_``. IPython's display formatters
 can also be given custom formatter functions for various types::
 
     In [6]: ip = get_ipython()
 
     In [7]: html_formatter = ip.display_formatter.formatters['text/html']
 
     In [8]: html_formatter.for_type(Foo, foo_to_html)
 
 For further details, see ``IPython.core.formatters``.
 
 Inline matplotlib graphics
 ==========================
 
 The IPython console is capable of displaying matplotlib figures inline, in SVG
 or PNG format.  If started with the ``matplotlib=inline``, then all figures are
 rendered inline automatically (PNG by default).  If started with ``--matplotlib``
 or ``matplotlib=<your backend>``, then a GUI backend will be used, but IPython's
 ``display()`` and ``getfigs()`` functions can be used to view plots inline::
 
     In [9]: display(*getfigs())    # display all figures inline
 
     In[10]: display(*getfigs(1,2)) # display figures 1 and 2 inline
 """
 
 
 quick_guide = """\
 ?         -> Introduction and overview of IPython's features.
 %quickref -> Quick reference.
 help      -> Python's own help system.
 object?   -> Details about 'object', use 'object??' for extra details.
 """
 
 gui_note = """\
 %guiref   -> A brief reference about the graphical user interface.
 """
 
 default_banner_parts = [
     'Python %s\n' % (sys.version.split('\n')[0],),
     'Type "copyright", "credits" or "license" for more information.\n\n',
     'IPython {version} -- An enhanced Interactive Python.\n'.format(
         version=release.version,
         ),
     quick_guide
 ]
 
 default_gui_banner_parts = default_banner_parts + [gui_note]
 
 default_banner = ''.join(default_banner_parts)
 
 default_gui_banner = ''.join(default_gui_banner_parts)
 
 # page GUI Reference, for use as a magic:
 
 def page_guiref(arg_s=None):
     """Show a basic reference about the GUI Console."""
     from IPython.core import page
     page.page(gui_reference, auto_html=True)
 

docs/source/config/old.rst

@@ -1,231 +1,230 b''
 .. _initial config:
 
 =============================================================
 Outdated configuration information that might still be useful
 =============================================================
 
 .. warning::
 
     All of the information in this file is outdated. Until the new
     configuration system is better documented, this material is being kept.
 
 This section will help you set various things in your environment for
 your IPython sessions to be as efficient as possible. All of IPython's
 configuration information, along with several example files, is stored
-in a directory named by default $HOME/.config/ipython if $HOME/.config 
-exists (Linux), or $HOME/.ipython as a secondary default. You can change this by
+in a directory named by default $HOME/.ipython. You can change this by
 defining the environment variable IPYTHONDIR, or at runtime with the
 command line option -ipythondir.
 
 If all goes well, the first time you run IPython it should automatically create
 a user copy of the config directory for you, based on its builtin defaults. You
 can look at the files it creates to learn more about configuring the
 system. The main file you will modify to configure IPython's behavior is called
 ipythonrc (with a .ini extension under Windows), included for reference
 :ref:`here <ipythonrc>`. This file is very commented and has many variables you
 can change to suit your taste, you can find more details :ref:`here
 <customization>`. Here we discuss the basic things you will want to make sure
 things are working properly from the beginning.
 
 Color
 =====
 
 The default IPython configuration has most bells and whistles turned on
 (they're pretty safe). But there's one that may cause problems on some
 systems: the use of color on screen for displaying information. This is
 very useful, since IPython can show prompts and exception tracebacks
 with various colors, display syntax-highlighted source code, and in
 general make it easier to visually parse information.
 
 The following terminals seem to handle the color sequences fine:
 
     * Linux main text console, KDE Konsole, Gnome Terminal, E-term,
       rxvt, xterm.
     * CDE terminal (tested under Solaris). This one boldfaces light colors.
     * (X)Emacs buffers. See the emacs_ section for more details on
       using IPython with (X)Emacs.
     * A Windows (XP/2k) command prompt with pyreadline_.
     * A Windows (XP/2k) CygWin shell. Although some users have reported
       problems; it is not clear whether there is an issue for everyone
       or only under specific configurations. If you have full color
       support under cygwin, please post to the IPython mailing list so
       this issue can be resolved for all users.
 
 .. _pyreadline: https://code.launchpad.net/pyreadline
       
 These have shown problems:
 
     * Windows command prompt in WinXP/2k logged into a Linux machine via
       telnet or ssh.
     * Windows native command prompt in WinXP/2k, without Gary Bishop's
       extensions. Once Gary's readline library is installed, the normal
       WinXP/2k command prompt works perfectly.
 
 Currently the following color schemes are available:
 
     * NoColor: uses no color escapes at all (all escapes are empty '' ''
       strings). This 'scheme' is thus fully safe to use in any terminal.
     * Linux: works well in Linux console type environments: dark
       background with light fonts. It uses bright colors for
       information, so it is difficult to read if you have a light
       colored background.
     * LightBG: the basic colors are similar to those in the Linux scheme
       but darker. It is easy to read in terminals with light backgrounds.
 
 IPython uses colors for two main groups of things: prompts and
 tracebacks which are directly printed to the terminal, and the object
 introspection system which passes large sets of data through a pager.
 
 Input/Output prompts and exception tracebacks
 =============================================
 
 You can test whether the colored prompts and tracebacks work on your
 system interactively by typing '%colors Linux' at the prompt (use
 '%colors LightBG' if your terminal has a light background). If the input
 prompt shows garbage like::
 
     [0;32mIn [[1;32m1[0;32m]: [0;00m
 
 instead of (in color) something like::
 
     In [1]:
 
 this means that your terminal doesn't properly handle color escape
 sequences. You can go to a 'no color' mode by typing '%colors NoColor'.
 
 You can try using a different terminal emulator program (Emacs users,
 see below). To permanently set your color preferences, edit the file
 $IPYTHONDIR/ipythonrc and set the colors option to the desired value.
 
 
 Object details (types, docstrings, source code, etc.)
 =====================================================
 
 IPython has a set of special functions for studying the objects you are working
 with, discussed in detail :ref:`here <dynamic_object_info>`. But this system
 relies on passing information which is longer than your screen through a data
 pager, such as the common Unix less and more programs. In order to be able to
 see this information in color, your pager needs to be properly configured. I
 strongly recommend using less instead of more, as it seems that more simply can
 not understand colored text correctly.
 
 In order to configure less as your default pager, do the following:
 
    1. Set the environment PAGER variable to less.
    2. Set the environment LESS variable to -r (plus any other options
       you always want to pass to less by default). This tells less to
       properly interpret control sequences, which is how color
       information is given to your terminal.
 
 For the bash shell, add to your ~/.bashrc file the lines::
 
     export PAGER=less
     export LESS=-r
 
 For the csh or tcsh shells, add to your ~/.cshrc file the lines::
 
     setenv PAGER less
     setenv LESS -r
     
 There is similar syntax for other Unix shells, look at your system
 documentation for details.
 
 If you are on a system which lacks proper data pagers (such as Windows),
 IPython will use a very limited builtin pager.
 
 .. _Prompts:
 
 Fine-tuning your prompt
 =======================
 
 IPython's prompts can be customized using a syntax similar to that of
 the bash shell. Many of bash's escapes are supported, as well as a few
 additional ones. We list them below::
 
     \#
         the prompt/history count number. This escape is automatically
         wrapped in the coloring codes for the currently active color scheme. 
     \N
         the 'naked' prompt/history count number: this is just the number
         itself, without any coloring applied to it. This lets you produce
         numbered prompts with your own colors. 
     \D
         the prompt/history count, with the actual digits replaced by dots.
         Used mainly in continuation prompts (prompt_in2) 
     \w
         the current working directory 
     \W
         the basename of current working directory 
     \Xn
         where $n=0\ldots5.$ The current working directory, with $HOME
         replaced by ~, and filtered out to contain only $n$ path elements 
     \Yn
         Similar to \Xn, but with the $n+1$ element included if it is ~ (this
         is similar to the behavior of the %cn escapes in tcsh) 
     \u
         the username of the current user 
     \$
         if the effective UID is 0, a #, otherwise a $ 
     \h
         the hostname up to the first '.' 
     \H
         the hostname 
     \n
         a newline 
     \r
         a carriage return 
     \v
         IPython version string 
 
 In addition to these, ANSI color escapes can be insterted into the
 prompts, as \C_ColorName. The list of valid color names is: Black, Blue,
 Brown, Cyan, DarkGray, Green, LightBlue, LightCyan, LightGray,
 LightGreen, LightPurple, LightRed, NoColor, Normal, Purple, Red, White,
 Yellow.
 
 Finally, IPython supports the evaluation of arbitrary expressions in
 your prompt string. The prompt strings are evaluated through the syntax
 of PEP 215, but basically you can use $x.y to expand the value of x.y,
 and for more complicated expressions you can use braces: ${foo()+x} will
 call function foo and add to it the value of x, before putting the
 result into your prompt. For example, using
 prompt_in1 '${commands.getoutput("uptime")}\nIn [\#]: ' 
 will print the result of the uptime command on each prompt (assuming the
 commands module has been imported in your ipythonrc file).
 
 
       Prompt examples
 
 The following options in an ipythonrc file will give you IPython's
 default prompts::
 
     prompt_in1 'In [\#]:' 
     prompt_in2 '   .\D.:' 
     prompt_out 'Out[\#]:'
 
 which look like this::
 
     In [1]: 1+2 
     Out[1]: 3
 
     In [2]: for i in (1,2,3): 
        ...:    print i, 
        ...: 
     1 2 3
 
 These will give you a very colorful prompt with path information::
 
     #prompt_in1 '\C_Red\u\C_Blue[\C_Cyan\Y1\C_Blue]\C_LightGreen\#>' 
     prompt_in2 ' ..\D>' 
     prompt_out '<\#>'
 
 which look like this::
 
     fperez[~/ipython]1> 1+2 
                     <1> 3 
     fperez[~/ipython]2> for i in (1,2,3): 
                    ...>     print i, 
                    ...> 
     1 2 3