##// END OF EJS Templates
Updating the Release.py. Also fixed a typo in the docs.
Brian Granger -
Show More
@@ -1,97 +1,121 b''
1 1 # -*- coding: utf-8 -*-
2 2 """Release data for the IPython project."""
3 3
4 4 #*****************************************************************************
5 5 # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
6 6 #
7 7 # Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray
8 8 # <n8gray@caltech.edu>
9 9 #
10 10 # Distributed under the terms of the BSD License. The full license is in
11 11 # the file COPYING, distributed as part of this software.
12 12 #*****************************************************************************
13 13
14 14 # Name of the package for release purposes. This is the name which labels
15 15 # the tarballs and RPMs made by distutils, so it's best to lowercase it.
16 16 name = 'ipython'
17 17
18 18 # For versions with substrings (like 0.6.16.svn), use an extra . to separate
19 19 # the new substring. We have to avoid using either dashes or underscores,
20 20 # because bdist_rpm does not accept dashes (an RPM) convention, and
21 21 # bdist_deb does not accept underscores (a Debian convention).
22 22
23 23 development = False # change this to False to do a release
24 24 version_base = '0.9.1'
25 25 branch = 'ipython'
26 26 revision = '1143'
27 27
28 28 if development:
29 29 if branch == 'ipython':
30 30 version = '%s.bzr.r%s' % (version_base, revision)
31 31 else:
32 32 version = '%s.bzr.r%s.%s' % (version_base, revision, branch)
33 33 else:
34 34 version = version_base
35 35
36 36
37 description = "Tools for interactive development in Python."
37 description = "An interactive computing environment for Python"
38 38
39 39 long_description = \
40 40 """
41 IPython provides a replacement for the interactive Python interpreter with
42 extra functionality.
41 The goal of IPython is to create a comprehensive environment for
42 interactive and exploratory computing. To support this goal, IPython
43 has two main components:
43 44
44 Main features:
45 * An enhanced interactive Python shell.
46
47 * An architecture for interactive parallel computing.
48
49 The enhanced interactive Python shell has the following main features:
45 50
46 51 * Comprehensive object introspection.
47 52
48 53 * Input history, persistent across sessions.
49 54
50 55 * Caching of output results during a session with automatically generated
51 56 references.
52 57
53 58 * Readline based name completion.
54 59
55 60 * Extensible system of 'magic' commands for controlling the environment and
56 61 performing many tasks related either to IPython or the operating system.
57 62
58 63 * Configuration system with easy switching between different setups (simpler
59 64 than changing $PYTHONSTARTUP environment variables every time).
60 65
61 66 * Session logging and reloading.
62 67
63 68 * Extensible syntax processing for special purpose situations.
64 69
65 70 * Access to the system shell with user-extensible alias system.
66 71
67 * Easily embeddable in other Python programs.
72 * Easily embeddable in other Python programs and wxPython GUIs.
68 73
69 74 * Integrated access to the pdb debugger and the Python profiler.
70 75
71 The latest development version is always available at the IPython subversion
72 repository_.
76 The parallel computing architecture has the following main features:
77
78 * Quickly parallelize Python code from an interactive Python/IPython session.
79
80 * A flexible and dynamic process model that be deployed on anything from
81 multicore workstations to supercomputers.
82
83 * An architecture that supports many different styles of parallelism, from
84 message passing to task farming.
85
86 * Both blocking and fully asynchronous interfaces.
87
88 * High level APIs that enable many things to be parallelized in a few lines
89 of code.
90
91 * Share live parallel jobs with other users securely.
92
93 * Dynamically load balanced task farming system.
94
95 * Robust error handling in parallel code.
73 96
74 .. _repository: http://ipython.scipy.org/svn/ipython/ipython/trunk#egg=ipython-dev
97 The latest development version is always available from IPython's `Launchpad
98 site <http://launchpad.net/ipython>`_.
75 99 """
76 100
77 101 license = 'BSD'
78 102
79 103 authors = {'Fernando' : ('Fernando Perez','fperez@colorado.edu'),
80 104 'Janko' : ('Janko Hauser','jhauser@zscout.de'),
81 105 'Nathan' : ('Nathaniel Gray','n8gray@caltech.edu'),
82 106 'Ville' : ('Ville Vainio','vivainio@gmail.com'),
83 107 'Brian' : ('Brian E Granger', 'ellisonbg@gmail.com'),
84 108 'Min' : ('Min Ragan-Kelley', 'benjaminrk@gmail.com')
85 109 }
86 110
87 111 author = 'The IPython Development Team'
88 112
89 113 author_email = 'ipython-dev@scipy.org'
90 114
91 115 url = 'http://ipython.scipy.org'
92 116
93 117 download_url = 'http://ipython.scipy.org/dist'
94 118
95 119 platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME']
96 120
97 121 keywords = ['Interactive','Interpreter','Shell','Parallel','Distributed']
@@ -1,233 +1,233 b''
1 1 .. _overview:
2 2
3 3 ============
4 4 Introduction
5 5 ============
6 6
7 7 Overview
8 8 ========
9 9
10 10 One of Python's most useful features is its interactive interpreter.
11 11 This system allows very fast testing of ideas without the overhead of
12 12 creating test files as is typical in most programming languages.
13 13 However, the interpreter supplied with the standard Python distribution
14 14 is somewhat limited for extended interactive use.
15 15
16 16 The goal of IPython is to create a comprehensive environment for
17 interactive and exploratory computing. To support, this goal, IPython
17 interactive and exploratory computing. To support this goal, IPython
18 18 has two main components:
19 19
20 20 * An enhanced interactive Python shell.
21 21 * An architecture for interactive parallel computing.
22 22
23 23 All of IPython is open source (released under the revised BSD license).
24 24
25 25 Enhanced interactive Python shell
26 26 =================================
27 27
28 28 IPython's interactive shell (:command:`ipython`), has the following goals,
29 29 amongst others:
30 30
31 31 1. Provide an interactive shell superior to Python's default. IPython
32 32 has many features for object introspection, system shell access,
33 33 and its own special command system for adding functionality when
34 34 working interactively. It tries to be a very efficient environment
35 35 both for Python code development and for exploration of problems
36 36 using Python objects (in situations like data analysis).
37 37
38 38 2. Serve as an embeddable, ready to use interpreter for your own
39 39 programs. IPython can be started with a single call from inside
40 40 another program, providing access to the current namespace. This
41 41 can be very useful both for debugging purposes and for situations
42 42 where a blend of batch-processing and interactive exploration are
43 43 needed. New in the 0.9 version of IPython is a reusable wxPython
44 44 based IPython widget.
45 45
46 46 3. Offer a flexible framework which can be used as the base
47 47 environment for other systems with Python as the underlying
48 48 language. Specifically scientific environments like Mathematica,
49 49 IDL and Matlab inspired its design, but similar ideas can be
50 50 useful in many fields.
51 51
52 52 4. Allow interactive testing of threaded graphical toolkits. IPython
53 53 has support for interactive, non-blocking control of GTK, Qt and
54 54 WX applications via special threading flags. The normal Python
55 55 shell can only do this for Tkinter applications.
56 56
57 57 Main features of the interactive shell
58 58 --------------------------------------
59 59
60 60 * Dynamic object introspection. One can access docstrings, function
61 61 definition prototypes, source code, source files and other details
62 62 of any object accessible to the interpreter with a single
63 63 keystroke (:samp:`?`, and using :samp:`??` provides additional detail).
64 64
65 65 * Searching through modules and namespaces with :samp:`*` wildcards, both
66 66 when using the :samp:`?` system and via the :samp:`%psearch` command.
67 67
68 68 * Completion in the local namespace, by typing :kbd:`TAB` at the prompt.
69 69 This works for keywords, modules, methods, variables and files in the
70 70 current directory. This is supported via the readline library, and
71 71 full access to configuring readline's behavior is provided.
72 72 Custom completers can be implemented easily for different purposes
73 73 (system commands, magic arguments etc.)
74 74
75 75 * Numbered input/output prompts with command history (persistent
76 76 across sessions and tied to each profile), full searching in this
77 77 history and caching of all input and output.
78 78
79 79 * User-extensible 'magic' commands. A set of commands prefixed with
80 80 :samp:`%` is available for controlling IPython itself and provides
81 81 directory control, namespace information and many aliases to
82 82 common system shell commands.
83 83
84 84 * Alias facility for defining your own system aliases.
85 85
86 86 * Complete system shell access. Lines starting with :samp:`!` are passed
87 87 directly to the system shell, and using :samp:`!!` or :samp:`var = !cmd`
88 88 captures shell output into python variables for further use.
89 89
90 90 * Background execution of Python commands in a separate thread.
91 91 IPython has an internal job manager called jobs, and a
92 92 convenience backgrounding magic function called :samp:`%bg`.
93 93
94 94 * The ability to expand python variables when calling the system
95 95 shell. In a shell command, any python variable prefixed with :samp:`$` is
96 96 expanded. A double :samp:`$$` allows passing a literal :samp:`$` to the shell (for
97 97 access to shell and environment variables like :envvar:`PATH`).
98 98
99 99 * Filesystem navigation, via a magic :samp:`%cd` command, along with a
100 100 persistent bookmark system (using :samp:`%bookmark`) for fast access to
101 101 frequently visited directories.
102 102
103 103 * A lightweight persistence framework via the :samp:`%store` command, which
104 104 allows you to save arbitrary Python variables. These get restored
105 105 automatically when your session restarts.
106 106
107 107 * Automatic indentation (optional) of code as you type (through the
108 108 readline library).
109 109
110 110 * Macro system for quickly re-executing multiple lines of previous
111 111 input with a single name. Macros can be stored persistently via
112 112 :samp:`%store` and edited via :samp:`%edit`.
113 113
114 114 * Session logging (you can then later use these logs as code in your
115 115 programs). Logs can optionally timestamp all input, and also store
116 116 session output (marked as comments, so the log remains valid
117 117 Python source code).
118 118
119 119 * Session restoring: logs can be replayed to restore a previous
120 120 session to the state where you left it.
121 121
122 122 * Verbose and colored exception traceback printouts. Easier to parse
123 123 visually, and in verbose mode they produce a lot of useful
124 124 debugging information (basically a terminal version of the cgitb
125 125 module).
126 126
127 127 * Auto-parentheses: callable objects can be executed without
128 128 parentheses: :samp:`sin 3` is automatically converted to :samp:`sin(3)`.
129 129
130 130 * Auto-quoting: using :samp:`,`, or :samp:`;` as the first character forces
131 131 auto-quoting of the rest of the line: :samp:`,my_function a b` becomes
132 132 automatically :samp:`my_function("a","b")`, while :samp:`;my_function a b`
133 133 becomes :samp:`my_function("a b")`.
134 134
135 135 * Extensible input syntax. You can define filters that pre-process
136 136 user input to simplify input in special situations. This allows
137 137 for example pasting multi-line code fragments which start with
138 138 :samp:`>>>` or :samp:`...` such as those from other python sessions or the
139 139 standard Python documentation.
140 140
141 141 * Flexible configuration system. It uses a configuration file which
142 142 allows permanent setting of all command-line options, module
143 143 loading, code and file execution. The system allows recursive file
144 144 inclusion, so you can have a base file with defaults and layers
145 145 which load other customizations for particular projects.
146 146
147 147 * Embeddable. You can call IPython as a python shell inside your own
148 148 python programs. This can be used both for debugging code or for
149 149 providing interactive abilities to your programs with knowledge
150 150 about the local namespaces (very useful in debugging and data
151 151 analysis situations).
152 152
153 153 * Easy debugger access. You can set IPython to call up an enhanced
154 154 version of the Python debugger (pdb) every time there is an
155 155 uncaught exception. This drops you inside the code which triggered
156 156 the exception with all the data live and it is possible to
157 157 navigate the stack to rapidly isolate the source of a bug. The
158 158 :samp:`%run` magic command (with the :samp:`-d` option) can run any script under
159 159 pdb's control, automatically setting initial breakpoints for you.
160 160 This version of pdb has IPython-specific improvements, including
161 161 tab-completion and traceback coloring support. For even easier
162 162 debugger access, try :samp:`%debug` after seeing an exception. winpdb is
163 163 also supported, see ipy_winpdb extension.
164 164
165 165 * Profiler support. You can run single statements (similar to
166 166 :samp:`profile.run()`) or complete programs under the profiler's control.
167 167 While this is possible with standard cProfile or profile modules,
168 168 IPython wraps this functionality with magic commands (see :samp:`%prun`
169 169 and :samp:`%run -p`) convenient for rapid interactive work.
170 170
171 171 * Doctest support. The special :samp:`%doctest_mode` command toggles a mode
172 172 that allows you to paste existing doctests (with leading :samp:`>>>`
173 173 prompts and whitespace) and uses doctest-compatible prompts and
174 174 output, so you can use IPython sessions as doctest code.
175 175
176 176 Interactive parallel computing
177 177 ==============================
178 178
179 179 Increasingly, parallel computer hardware, such as multicore CPUs, clusters and supercomputers, is becoming ubiquitous. Over the last 3 years, we have developed an
180 180 architecture within IPython that allows such hardware to be used quickly and easily
181 181 from Python. Moreover, this architecture is designed to support interactive and
182 182 collaborative parallel computing.
183 183
184 184 The main features of this system are:
185 185
186 186 * Quickly parallelize Python code from an interactive Python/IPython session.
187 187
188 188 * A flexible and dynamic process model that be deployed on anything from
189 189 multicore workstations to supercomputers.
190 190
191 191 * An architecture that supports many different styles of parallelism, from
192 192 message passing to task farming. And all of these styles can be handled
193 193 interactively.
194 194
195 195 * Both blocking and fully asynchronous interfaces.
196 196
197 197 * High level APIs that enable many things to be parallelized in a few lines
198 198 of code.
199 199
200 200 * Write parallel code that will run unchanged on everything from multicore
201 201 workstations to supercomputers.
202 202
203 203 * Full integration with Message Passing libraries (MPI).
204 204
205 205 * Capabilities based security model with full encryption of network connections.
206 206
207 207 * Share live parallel jobs with other users securely. We call this collaborative
208 208 parallel computing.
209 209
210 210 * Dynamically load balanced task farming system.
211 211
212 212 * Robust error handling. Python exceptions raised in parallel execution are
213 213 gathered and presented to the top-level code.
214 214
215 215 For more information, see our :ref:`overview <parallel_index>` of using IPython for
216 216 parallel computing.
217 217
218 218 Portability and Python requirements
219 219 -----------------------------------
220 220
221 221 As of the 0.9 release, IPython requires Python 2.4 or greater. We have
222 222 not begun to test IPython on Python 2.6 or 3.0, but we expect it will
223 223 work with some minor changes.
224 224
225 225 IPython is known to work on the following operating systems:
226 226
227 227 * Linux
228 228 * AIX
229 229 * Most other Unix-like OSs (Solaris, BSD, etc.)
230 230 * Mac OS X
231 231 * Windows (CygWin, XP, Vista, etc.)
232 232
233 233 See :ref:`here <install_index>` for instructions on how to install IPython. No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now