Show More
@@ -0,0 +1,240 b'' | |||||
|
1 | .. _paralleltask: | |||
|
2 | ||||
|
3 | ========================== | |||
|
4 | The IPython task interface | |||
|
5 | ========================== | |||
|
6 | ||||
|
7 | .. contents:: | |||
|
8 | ||||
|
9 | The ``Task`` interface to the controller presents the engines as a fault tolerant, dynamic load-balanced system or workers. Unlike the ``MultiEngine`` interface, in the ``Task`` interface, the user have no direct access to individual engines. In some ways, this interface is simpler, but in other ways it is more powerful. Best of all the user can use both of these interfaces at the same time to take advantage or both of their strengths. When the user can break up the user's work into segments that do not depend on previous execution, the ``Task`` interface is ideal. But it also has more power and flexibility, allowing the user to guide the distribution of jobs, without having to assign Tasks to engines explicitly. | |||
|
10 | ||||
|
11 | Starting the IPython controller and engines | |||
|
12 | =========================================== | |||
|
13 | ||||
|
14 | To follow along with this tutorial, the user will need to start the IPython | |||
|
15 | controller and four IPython engines. The simplest way of doing this is to | |||
|
16 | use the ``ipcluster`` command:: | |||
|
17 | ||||
|
18 | $ ipcluster -n 4 | |||
|
19 | ||||
|
20 | For more detailed information about starting the controller and engines, see our :ref:`introduction <ip1par>` to using IPython for parallel computing. | |||
|
21 | ||||
|
22 | The magic here is that this single controller and set of engines is running both the MultiEngine and ``Task`` interfaces simultaneously. | |||
|
23 | ||||
|
24 | QuickStart Task Farming | |||
|
25 | ======================= | |||
|
26 | ||||
|
27 | First, a quick example of how to start running the most basic Tasks. | |||
|
28 | The first step is to import the IPython ``client`` module and then create a ``TaskClient`` instance:: | |||
|
29 | ||||
|
30 | In [1]: from IPython.kernel import client | |||
|
31 | ||||
|
32 | In [2]: tc = client.TaskClient() | |||
|
33 | ||||
|
34 | Then the user wrap the commands the user want to run in Tasks:: | |||
|
35 | ||||
|
36 | In [3]: tasklist = [] | |||
|
37 | In [4]: for n in range(1000): | |||
|
38 | ... tasklist.append(client.Task("a = %i"%n, pull="a")) | |||
|
39 | ||||
|
40 | The first argument of the ``Task`` constructor is a string, the command to be executed. The most important optional keyword argument is ``pull``, which can be a string or list of strings, and it specifies the variable names to be saved as results of the ``Task``. | |||
|
41 | ||||
|
42 | Next, the user need to submit the Tasks to the ``TaskController`` with the ``TaskClient``:: | |||
|
43 | ||||
|
44 | In [5]: taskids = [ tc.run(t) for t in tasklist ] | |||
|
45 | ||||
|
46 | This will give the user a list of the TaskIDs used by the controller to keep track of the Tasks and their results. Now at some point the user are going to want to get those results back. The ``barrier`` method allows the user to wait for the Tasks to finish running:: | |||
|
47 | ||||
|
48 | In [6]: tc.barrier(taskids) | |||
|
49 | ||||
|
50 | This command will block until all the Tasks in ``taskids`` have finished. Now, the user probably want to look at the user's results:: | |||
|
51 | ||||
|
52 | In [7]: task_results = [ tc.get_task_result(taskid) for taskid in taskids ] | |||
|
53 | ||||
|
54 | Now the user have a list of ``TaskResult`` objects, which have the actual result as a dictionary, but also keep track of some useful metadata about the ``Task``:: | |||
|
55 | ||||
|
56 | In [8]: tr = ``Task``_results[73] | |||
|
57 | ||||
|
58 | In [9]: tr | |||
|
59 | Out[9]: ``TaskResult``[ID:73]:{'a':73} | |||
|
60 | ||||
|
61 | In [10]: tr.engineid | |||
|
62 | Out[10]: 1 | |||
|
63 | ||||
|
64 | In [11]: tr.submitted, tr.completed, tr.duration | |||
|
65 | Out[11]: ("2008/03/08 03:41:42", "2008/03/08 03:41:44", 2.12345) | |||
|
66 | ||||
|
67 | The actual results are stored in a dictionary, ``tr.results``, and a namespace object ``tr.ns`` which accesses the result keys by attribute:: | |||
|
68 | ||||
|
69 | In [12]: tr.results['a'] | |||
|
70 | Out[12]: 73 | |||
|
71 | ||||
|
72 | In [13]: tr.ns.a | |||
|
73 | Out[13]: 73 | |||
|
74 | ||||
|
75 | That should cover the basics of running simple Tasks. There are several more powerful things the user can do with Tasks covered later. The most useful probably being using a ``MutiEngineClient`` interface to initialize all the engines with the import dependencies necessary to run the user's Tasks. | |||
|
76 | ||||
|
77 | There are many options for running and managing Tasks. The best way to learn further about the ``Task`` interface is to study the examples in ``docs/examples``. If the user do so and learn a lots about this interface, we encourage the user to expand this documentation about the ``Task`` system. | |||
|
78 | ||||
|
79 | Overview of the Task System | |||
|
80 | =========================== | |||
|
81 | ||||
|
82 | The user's view of the ``Task`` system has three basic objects: The ``TaskClient``, the ``Task``, and the ``TaskResult``. The names of these three objects well indicate their role. | |||
|
83 | ||||
|
84 | The ``TaskClient`` is the user's ``Task`` farming connection to the IPython cluster. Unlike the ``MultiEngineClient``, the ``TaskControler`` handles all the scheduling and distribution of work, so the ``TaskClient`` has no notion of engines, it just submits Tasks and requests their results. The Tasks are described as ``Task`` objects, and their results are wrapped in ``TaskResult`` objects. Thus, there are very few necessary methods for the user to manage. | |||
|
85 | ||||
|
86 | Inside the task system is a Scheduler object, which assigns tasks to workers. The default scheduler is a simple FIFO queue. Subclassing the Scheduler should be easy, just implementing your own priority system. | |||
|
87 | ||||
|
88 | The TaskClient | |||
|
89 | ============== | |||
|
90 | ||||
|
91 | The ``TaskClient`` is the object the user use to connect to the ``Controller`` that is managing the user's Tasks. It is the analog of the ``MultiEngineClient`` for the standard IPython multiplexing interface. As with all client interfaces, the first step is to import the IPython Client Module:: | |||
|
92 | ||||
|
93 | In [1]: from IPython.kernel import client | |||
|
94 | ||||
|
95 | Just as with the ``MultiEngineClient``, the user create the ``TaskClient`` with a tuple, containing the ip-address and port of the ``Controller``. the ``client`` module conveniently has the default address of the ``Task`` interface of the controller. Creating a default ``TaskClient`` object would be done with this:: | |||
|
96 | ||||
|
97 | In [2]: tc = client.TaskClient(client.default_task_address) | |||
|
98 | ||||
|
99 | or, if the user want to specify a non default location of the ``Controller``, the user can specify explicitly:: | |||
|
100 | ||||
|
101 | In [3]: tc = client.TaskClient(("192.168.1.1", 10113)) | |||
|
102 | ||||
|
103 | As discussed earlier, the ``TaskClient`` only has a few basic methods. | |||
|
104 | ||||
|
105 | * ``tc.run(task)`` | |||
|
106 | ``run`` is the method by which the user submits Tasks. It takes exactly one argument, a ``Task`` object. All the advanced control of ``Task`` behavior is handled by properties of the ``Task`` object, rather than the submission command, so they will be discussed later in the `Task`_ section. ``run`` returns an integer, the ``Task``ID by which the ``Task`` and its results can be tracked and retrieved:: | |||
|
107 | ||||
|
108 | In [4]: ``Task``ID = tc.run(``Task``) | |||
|
109 | ||||
|
110 | * ``tc.get_task_result(taskid, block=``False``)`` | |||
|
111 | ``get_task_result`` is the method by which results are retrieved. It takes a single integer argument, the ``Task``ID`` of the result the user wish to retrieve. ``get_task_result`` also takes a keyword argument ``block``. ``block`` specifies whether the user actually want to wait for the result. If ``block`` is false, as it is by default, ``get_task_result`` will return immediately. If the ``Task`` has completed, it will return the ``TaskResult`` object for that ``Task``. But if the ``Task`` has not completed, it will return ``None``. If the user specify ``block=``True``, then ``get_task_result`` will wait for the ``Task`` to complete, and always return the ``TaskResult`` for the requested ``Task``. | |||
|
112 | * ``tc.barrier(taskid(s))`` | |||
|
113 | ``barrier`` is a synchronization method. It takes exactly one argument, a ``Task``ID or list of taskIDs. ``barrier`` will block until all the specified Tasks have completed. In practice, a barrier is often called between the ``Task`` submission section of the code and the result gathering section:: | |||
|
114 | ||||
|
115 | In [5]: taskIDs = [ tc.run(``Task``) for ``Task`` in myTasks ] | |||
|
116 | ||||
|
117 | In [6]: tc.get_task_result(taskIDs[-1]) is None | |||
|
118 | Out[6]: ``True`` | |||
|
119 | ||||
|
120 | In [7]: tc.barrier(``Task``ID) | |||
|
121 | ||||
|
122 | In [8]: results = [ tc.get_task_result(tid) for tid in taskIDs ] | |||
|
123 | ||||
|
124 | * ``tc.queue_status(verbose=``False``)`` | |||
|
125 | ``queue_status`` is a method for querying the state of the ``TaskControler``. ``queue_status`` returns a dict of the form:: | |||
|
126 | ||||
|
127 | {'scheduled': Tasks that have been submitted but yet run | |||
|
128 | 'pending' : Tasks that are currently running | |||
|
129 | 'succeeded': Tasks that have completed successfully | |||
|
130 | 'failed' : Tasks that have finished with a failure | |||
|
131 | } | |||
|
132 | ||||
|
133 | if @verbose is not specified (or is ``False``), then the values of the dict are integers - the number of Tasks in each state. if @verbose is ``True``, then each element in the dict is a list of the taskIDs in that state:: | |||
|
134 | ||||
|
135 | In [8]: tc.queue_status() | |||
|
136 | Out[8]: {'scheduled': 4, | |||
|
137 | 'pending' : 2, | |||
|
138 | 'succeeded': 5, | |||
|
139 | 'failed' : 1 | |||
|
140 | } | |||
|
141 | ||||
|
142 | In [9]: tc.queue_status(verbose=True) | |||
|
143 | Out[9]: {'scheduled': [8,9,10,11], | |||
|
144 | 'pending' : [6,7], | |||
|
145 | 'succeeded': [0,1,2,4,5], | |||
|
146 | 'failed' : [3] | |||
|
147 | } | |||
|
148 | ||||
|
149 | * ``tc.abort(taskid)`` | |||
|
150 | ``abort`` allows the user to abort Tasks that have already been submitted. ``abort`` will always return immediately. If the ``Task`` has completed, ``abort`` will raise an ``IndexError ``Task`` Already Completed``. An obvious case for ``abort`` would be where the user submits a long-running ``Task`` with a number of retries (see ``Task``_ section for how to specify retries) in an interactive session, but realizes there has been a typo. The user can then abort the ``Task``, preventing certain failures from cluttering up the queue. It can also be used for parallel search-type problems, where only one ``Task`` will give the solution, so once the user find the solution, the user would want to abort all remaining Tasks to prevent wasted work. | |||
|
151 | * ``tc.spin()`` | |||
|
152 | ``spin`` simply triggers the scheduler in the ``TaskControler``. Under most normal circumstances, this will do nothing. The primary known usage case involves the ``Task`` dependency (see `Dependencies`_). The dependency is a function of an Engine's ``properties``, but changing the ``properties`` via the ``MutliEngineClient`` does not trigger a reschedule event. The main example case for this requires the following event sequence: | |||
|
153 | * ``engine`` is available, ``Task`` is submitted, but ``engine`` does not have ``Task``'s dependencies. | |||
|
154 | * ``engine`` gets necessary dependencies while no new Tasks are submitted or completed. | |||
|
155 | * now ``engine`` can run ``Task``, but a ``Task`` event is required for the ``TaskControler`` to try scheduling ``Task`` again. | |||
|
156 | ||||
|
157 | ``spin`` is just an empty ping method to ensure that the Controller has scheduled all available Tasks, and should not be needed under most normal circumstances. | |||
|
158 | ||||
|
159 | That covers the ``TaskClient``, a simple interface to the cluster. With this, the user can submit jobs (and abort if necessary), request their results, synchronize on arbitrary subsets of jobs. | |||
|
160 | ||||
|
161 | .. _task: The Task Object | |||
|
162 | ||||
|
163 | The Task Object | |||
|
164 | =============== | |||
|
165 | ||||
|
166 | The ``Task`` is the basic object for describing a job. It can be used in a very simple manner, where the user just specifies a command string to be executed as the ``Task``. The usage of this first argument is exactly the same as the ``execute`` method of the ``MultiEngine`` (in fact, ``execute`` is called to run the code):: | |||
|
167 | ||||
|
168 | In [1]: t = client.Task("a = str(id)") | |||
|
169 | ||||
|
170 | This ``Task`` would run, and store the string representation of the ``id`` element in ``a`` in each worker's namespace, but it is fairly useless because the user does not know anything about the state of the ``worker`` on which it ran at the time of retrieving results. It is important that each ``Task`` not expect the state of the ``worker`` to persist after the ``Task`` is completed. | |||
|
171 | There are many different situations for using ``Task`` Farming, and the ``Task`` object has many attributes for use in customizing the ``Task`` behavior. All of a ``Task``'s attributes may be specified in the constructor, through keyword arguments, or after ``Task`` construction through attribute assignment. | |||
|
172 | ||||
|
173 | Data Attributes | |||
|
174 | *************** | |||
|
175 | It is likely that the user may want to move data around before or after executing the ``Task``. We provide methods of sending data to initialize the worker's namespace, and specifying what data to bring back as the ``Task``'s results. | |||
|
176 | ||||
|
177 | * pull = [] | |||
|
178 | The obvious case is as above, where ``t`` would execute and store the result of ``myfunc`` in ``a``, it is likely that the user would want to bring ``a`` back to their namespace. This is done through the ``pull`` attribute. ``pull`` can be a string or list of strings, and it specifies the names of variables to be retrieved. The ``TaskResult`` object retrieved by ``get_task_result`` will have a dictionary of keys and values, and the ``Task``'s ``pull`` attribute determines what goes into it:: | |||
|
179 | ||||
|
180 | In [2]: t = client.Task("a = str(id)", pull = "a") | |||
|
181 | ||||
|
182 | In [3]: t = client.Task("a = str(id)", pull = ["a", "id"]) | |||
|
183 | ||||
|
184 | * push = {} | |||
|
185 | A user might also want to initialize some data into the namespace before the code part of the ``Task`` is run. Enter ``push``. ``push`` is a dictionary of key/value pairs to be loaded from the user's namespace into the worker's immediately before execution:: | |||
|
186 | ||||
|
187 | In [4]: t = client.Task("a = f(submitted)", push=dict(submitted=time.time()), pull="a") | |||
|
188 | ||||
|
189 | push and pull result directly in calling an ``engine``'s ``push`` and ``pull`` methods before and after ``Task`` execution respectively, and thus their api is the same. | |||
|
190 | ||||
|
191 | Namespace Cleaning | |||
|
192 | ****************** | |||
|
193 | When a user is running a large number of Tasks, it is likely that the namespace of the worker's could become cluttered. Some Tasks might be sensitive to clutter, while others might be known to cause namespace pollution. For these reasons, Tasks have two boolean attributes for cleaning up the namespace. | |||
|
194 | ||||
|
195 | * ``clear_after`` | |||
|
196 | if clear_after is specified ``True``, the worker on which the ``Task`` was run will be reset (via ``engine.reset``) upon completion of the ``Task``. This can be useful for both Tasks that produce clutter or Tasks whose intermediate data one might wish to be kept private:: | |||
|
197 | ||||
|
198 | In [5]: t = client.Task("a = range(1e10)", pull = "a",clear_after=True) | |||
|
199 | ||||
|
200 | ||||
|
201 | * ``clear_before`` | |||
|
202 | as one might guess, clear_before is identical to ``clear_after``, but it takes place before the ``Task`` is run. This ensures that the ``Task`` runs on a fresh worker:: | |||
|
203 | ||||
|
204 | In [6]: t = client.Task("a = globals()", pull = "a",clear_before=True) | |||
|
205 | ||||
|
206 | Of course, a user can both at the same time, ensuring that all workers are clear except when they are currently running a job. Both of these default to ``False``. | |||
|
207 | ||||
|
208 | Fault Tolerance | |||
|
209 | *************** | |||
|
210 | It is possible that Tasks might fail, and there are a variety of reasons this could happen. One might be that the worker it was running on disconnected, and there was nothing wrong with the ``Task`` itself. With the fault tolerance attributes of the ``Task``, the user can specify how many times to resubmit the ``Task``, and what to do if it never succeeds. | |||
|
211 | ||||
|
212 | * ``retries`` | |||
|
213 | ``retries`` is an integer, specifying the number of times a ``Task`` is to be retried. It defaults to zero. It is often a good idea for this number to be 1 or 2, to protect the ``Task`` from disconnecting engines, but not a large number. If a ``Task`` is failing 100 times, there is probably something wrong with the ``Task``. The canonical bad example: | |||
|
214 | ||||
|
215 | In [7]: t = client.Task("os.kill(os.getpid(), 9)", retries=99) | |||
|
216 | ||||
|
217 | This would actually take down 100 workers. | |||
|
218 | ||||
|
219 | * ``recovery_task`` | |||
|
220 | ``recovery_task`` is another ``Task`` object, to be run in the event of the original ``Task`` still failing after running out of retries. Since ``recovery_task`` is another ``Task`` object, it can have its own ``recovery_task``. The chain of Tasks is limitless, except loops are not allowed (that would be bad!). | |||
|
221 | ||||
|
222 | Dependencies | |||
|
223 | ************ | |||
|
224 | Dependencies are the most powerful part of the ``Task`` farming system, because it allows the user to do some classification of the workers, and guide the ``Task`` distribution without meddling with the controller directly. It makes use of two objects - the ``Task``'s ``depend`` attribute, and the engine's ``properties``. See the `MultiEngine`_ reference for how to use engine properties. The engine properties api exists for extending IPython, allowing conditional execution and new controllers that make decisions based on properties of its engines. Currently the ``Task`` dependency is the only internal use of the properties api. | |||
|
225 | ||||
|
226 | .. _MultiEngine: ./parallel_multiengine | |||
|
227 | ||||
|
228 | The ``depend`` attribute of a ``Task`` must be a function of exactly one argument, the worker's properties dictionary, and it should return ``True`` if the ``Task`` should be allowed to run on the worker and ``False`` if not. The usage in the controller is fault tolerant, so exceptions raised by ``Task.depend`` will be ignored and functionally equivalent to always returning ``False``. Tasks`` with invalid ``depend`` functions will never be assigned to a worker:: | |||
|
229 | ||||
|
230 | In [8]: def dep(properties): | |||
|
231 | ... return properties["RAM"] > 2**32 # have at least 4GB | |||
|
232 | In [9]: t = client.Task("a = bigfunc()", depend=dep) | |||
|
233 | ||||
|
234 | It is important to note that assignment of values to the properties dict is done entirely by the user, either locally (in the engine) using the EngineAPI, or remotely, through the ``MultiEngineClient``'s get/set_properties methods. | |||
|
235 | ||||
|
236 | ||||
|
237 | ||||
|
238 | ||||
|
239 | ||||
|
240 |
@@ -0,0 +1,191 b'' | |||||
|
1 | Overview | |||
|
2 | ======== | |||
|
3 | ||||
|
4 | This document describes the steps required to install IPython. IPython is organized into a number of subpackages, each of which has its own dependencies. All of the subpackages come with IPython, so you don't need to download and install them separately. However, to use a given subpackage, you will need to install all of its dependencies. | |||
|
5 | ||||
|
6 | ||||
|
7 | Please let us know if you have problems installing IPython or any of its | |||
|
8 | dependencies. IPython requires Python version 2.4 or greater. We have not tested | |||
|
9 | IPython with the upcoming 2.6 or 3.0 versions. | |||
|
10 | ||||
|
11 | .. warning:: | |||
|
12 | ||||
|
13 | IPython will not work with Python 2.3 or below. | |||
|
14 | ||||
|
15 | Some of the installation approaches use the :mod:`setuptools` package and its :command:`easy_install` command line program. In many scenarios, this provides the most simple method of installing IPython and its dependencies. It is not required though. More information about :mod:`setuptools` can be found on its website. | |||
|
16 | ||||
|
17 | More general information about installing Python packages can be found in Python's documentation at http://www.python.org/doc/. | |||
|
18 | ||||
|
19 | Installing IPython itself | |||
|
20 | ========================= | |||
|
21 | ||||
|
22 | Given a properly built Python, the basic interactive IPython shell will work with no external dependencies. However, some Python distributions (particularly on Windows and OS X), don't come with a working :mod:`readline` module. The IPython shell will work without :mod:`readline`, but will lack many features that users depend on, such as tab completion and command line editing. See below for details of how to make sure you have a working :mod:`readline`. | |||
|
23 | ||||
|
24 | Installation using easy_install | |||
|
25 | ------------------------------- | |||
|
26 | ||||
|
27 | If you have :mod:`setuptools` installed, the easiest way of getting IPython is to simple use :command:`easy_install`:: | |||
|
28 | ||||
|
29 | $ easy_install IPython | |||
|
30 | ||||
|
31 | That's it. | |||
|
32 | ||||
|
33 | Installation from source | |||
|
34 | ------------------------ | |||
|
35 | ||||
|
36 | If you don't want to use :command:`easy_install`, or don't have it installed, just grab the latest stable build of IPython from `here <http://ipython.scipy.org/dist/>`_. Then do the following:: | |||
|
37 | ||||
|
38 | $ tar -xzf ipython.tar.gz | |||
|
39 | $ cd ipython | |||
|
40 | $ python setup.py install | |||
|
41 | ||||
|
42 | If you are installing to a location (like ``/usr/local``) that requires higher permissions, you may need to run the last command with :command:`sudo`. | |||
|
43 | ||||
|
44 | Windows | |||
|
45 | ------- | |||
|
46 | ||||
|
47 | There are a few caveats for Windows users. The main issue is that a basic ``python setup.py install`` approach won't create ``.bat`` file or Start Menu shortcuts, which most users want. To get an installation with these, there are two choices: | |||
|
48 | ||||
|
49 | 1. Install using :command:`easy_install`. | |||
|
50 | ||||
|
51 | 2. Install using our binary ``.exe`` Windows installer, which can be found at `here <http://ipython.scipy.org/dist/>`_ | |||
|
52 | ||||
|
53 | 3. Install from source, but using :mod:`setuptools` (``python setupegg.py install``). | |||
|
54 | ||||
|
55 | Installing the development version | |||
|
56 | ---------------------------------- | |||
|
57 | ||||
|
58 | It is also possible to install the development version of IPython from our `Bazaar <http://bazaar-vcs.org/>`_ source code | |||
|
59 | repository. To do this you will need to have Bazaar installed on your system. Then just do:: | |||
|
60 | ||||
|
61 | $ bzr branch lp:ipython | |||
|
62 | $ cd ipython | |||
|
63 | $ python setup.py install | |||
|
64 | ||||
|
65 | Again, this last step on Windows won't create ``.bat`` files or Start Menu shortcuts, so you will have to use one of the other approaches listed above. | |||
|
66 | ||||
|
67 | Some users want to be able to follow the development branch as it changes. If you have :mod:`setuptools` installed, this is easy. Simply replace the last step by:: | |||
|
68 | ||||
|
69 | $ python setupegg.py develop | |||
|
70 | ||||
|
71 | This creates links in the right places and installs the command line script to the appropriate places. Then, if you want to update your IPython at any time, just do:: | |||
|
72 | ||||
|
73 | $ bzr pull | |||
|
74 | ||||
|
75 | Basic optional dependencies | |||
|
76 | =========================== | |||
|
77 | ||||
|
78 | There are a number of basic optional dependencies that most users will want to get. These are: | |||
|
79 | ||||
|
80 | * readline (for command line editing, tab completion, etc.) | |||
|
81 | * nose (to run the IPython test suite) | |||
|
82 | * pexpect (to use things like irunner) | |||
|
83 | ||||
|
84 | If you are comfortable installing these things yourself, have at it, otherwise read on for more details. | |||
|
85 | ||||
|
86 | readline | |||
|
87 | -------- | |||
|
88 | ||||
|
89 | In principle, all Python distributions should come with a working :mod:`readline` module. But, reality is not quite that simple. There are two common situations where you won't have a working :mod:`readline` module: | |||
|
90 | ||||
|
91 | * If you are using the built-in Python on Mac OS X. | |||
|
92 | ||||
|
93 | * If you are running Windows, which doesn't have a :mod:`readline` module. | |||
|
94 | ||||
|
95 | On OS X, the built-in Python doesn't not have :mod:`readline` because of license issues. Starting with OS X 10.5 (Leopard), Apple's built-in Python has a BSD-licensed not-quite-compatible readline replacement. As of IPython 0.9, many of the issues related to the differences between readline and libedit have been resolved. For many users, libedit may be sufficient. | |||
|
96 | ||||
|
97 | Most users on OS X will want to get the full :mod:`readline` module. To get a working :mod:`readline` module, just do (with :mod:`setuptools` installed):: | |||
|
98 | ||||
|
99 | $ easy_install readline | |||
|
100 | ||||
|
101 | .. note: | |||
|
102 | ||||
|
103 | Other Python distributions on OS X (such as fink, MacPorts and the | |||
|
104 | official python.org binaries) already have readline installed so | |||
|
105 | you don't have to do this step. | |||
|
106 | ||||
|
107 | If needed, the readline egg can be build and installed from source (see the wiki page at http://ipython.scipy.org/moin/InstallationOSXLeopard). | |||
|
108 | ||||
|
109 | On Windows, you will need the PyReadline module. PyReadline is a separate, Windows only implementation of readline that uses native Windows calls through :mod:`ctypes`. The easiest way of installing PyReadline is you use the binary installer available `here <http://ipython.scipy.org/dist/>`_. The :mod:`ctypes` module, which comes with Python 2.5 and greater, is required by PyReadline. It is available for Python 2.4 at http://python.net/crew/theller/ctypes. | |||
|
110 | ||||
|
111 | nose | |||
|
112 | ---- | |||
|
113 | ||||
|
114 | To run the IPython test suite you will need the :mod:`nose` package. Nose provides a great way of sniffing out and running all of the IPython tests. The simplest way of getting nose, is to use :command:`easy_install`:: | |||
|
115 | ||||
|
116 | $ easy_install nose | |||
|
117 | ||||
|
118 | Another way of getting this is to do:: | |||
|
119 | ||||
|
120 | $ easy_install IPython[test] | |||
|
121 | ||||
|
122 | For more installation options, see the `nose website <http://somethingaboutorange.com/mrl/projects/nose/>`_. Once you have nose installed, you can run IPython's test suite using the iptest command:: | |||
|
123 | ||||
|
124 | $ iptest | |||
|
125 | ||||
|
126 | ||||
|
127 | pexpect | |||
|
128 | ------- | |||
|
129 | ||||
|
130 | The `pexpect <http://www.noah.org/wiki/Pexpect>`_ package is used in IPython's :command:`irunner` script. On Unix platforms (including OS X), just do:: | |||
|
131 | ||||
|
132 | $ easy_install pexpect | |||
|
133 | ||||
|
134 | Windows users are out of luck as pexpect does not run there. | |||
|
135 | ||||
|
136 | Dependencies for IPython.kernel (parallel computing) | |||
|
137 | ==================================================== | |||
|
138 | ||||
|
139 | The IPython kernel provides a nice architecture for parallel computing. The main focus of this architecture is on interactive parallel computing. These features require a number of additional packages: | |||
|
140 | ||||
|
141 | * zope.interface (yep, we use interfaces) | |||
|
142 | * Twisted (asynchronous networking framework) | |||
|
143 | * Foolscap (a nice, secure network protocol) | |||
|
144 | * pyOpenSSL (security for network connections) | |||
|
145 | ||||
|
146 | On a Unix style platform (including OS X), if you want to use :mod:`setuptools`, you can just do:: | |||
|
147 | ||||
|
148 | $ easy_install IPython[kernel] # the first three | |||
|
149 | $ easy_install IPython[security] # pyOpenSSL | |||
|
150 | ||||
|
151 | zope.interface and Twisted | |||
|
152 | -------------------------- | |||
|
153 | ||||
|
154 | On Unix style platforms (including OS X), the simplest way of getting the these is to use :command:`easy_install`:: | |||
|
155 | ||||
|
156 | $ easy_install zope.interface | |||
|
157 | $ easy_install Twisted | |||
|
158 | ||||
|
159 | Of course, you can also download the source tarballs from the `Twisted website <twistedmatrix.org>`_ and the `zope.interface page at PyPI <http://pypi.python.org/pypi/zope.interface>`_ and do the usual ``python setup.py install`` if you prefer. | |||
|
160 | ||||
|
161 | Windows is a bit different. For zope.interface and Twisted, simply get the latest binary ``.exe`` installer from the Twisted website. This installer includes both zope.interface and Twisted and should just work. | |||
|
162 | ||||
|
163 | Foolscap | |||
|
164 | -------- | |||
|
165 | ||||
|
166 | Foolscap uses Twisted to provide a very nice secure RPC protocol that we use to implement our parallel computing features. | |||
|
167 | ||||
|
168 | On all platforms a simple:: | |||
|
169 | ||||
|
170 | $ easy_install foolscap | |||
|
171 | ||||
|
172 | should work. You can also download the source tarballs from the `Foolscap website <http://foolscap.lothar.com/trac>`_ and do ``python setup.py install`` if you prefer. | |||
|
173 | ||||
|
174 | pyOpenSSL | |||
|
175 | --------- | |||
|
176 | ||||
|
177 | IPython requires an older version of pyOpenSSL (0.6 rather than the current 0.7). There are a couple of options for getting this: | |||
|
178 | ||||
|
179 | 1. Most Linux distributions have packages for pyOpenSSL. | |||
|
180 | 2. The built-in Python 2.5 on OS X 10.5 already has it installed. | |||
|
181 | 3. There are source tarballs on the pyOpenSSL website. On Unix-like | |||
|
182 | platforms, these can be built using ``python seutp.py install``. | |||
|
183 | 4. There is also a binary ``.exe`` Windows installer on the `pyOpenSSL website <http://pyopenssl.sourceforge.net/>`_. | |||
|
184 | ||||
|
185 | Dependencies for IPython.frontend (the IPython GUI) | |||
|
186 | =================================================== | |||
|
187 | ||||
|
188 | wxPython | |||
|
189 | -------- | |||
|
190 | ||||
|
191 | Starting with IPython 0.9, IPython has a new IPython.frontend package that has a nice wxPython based IPython GUI. As you would expect, this GUI requires wxPython. Most Linux distributions have wxPython packages available and the built-in Python on OS X comes with wxPython preinstalled. For Windows, a binary installer is available on the `wxPython website <http://www.wxpython.org/>`_. No newline at end of file |
@@ -0,0 +1,423 b'' | |||||
|
1 | """ | |||
|
2 | Defines a docutils directive for inserting inheritance diagrams. | |||
|
3 | ||||
|
4 | Provide the directive with one or more classes or modules (separated | |||
|
5 | by whitespace). For modules, all of the classes in that module will | |||
|
6 | be used. | |||
|
7 | ||||
|
8 | Example:: | |||
|
9 | ||||
|
10 | Given the following classes: | |||
|
11 | ||||
|
12 | class A: pass | |||
|
13 | class B(A): pass | |||
|
14 | class C(A): pass | |||
|
15 | class D(B, C): pass | |||
|
16 | class E(B): pass | |||
|
17 | ||||
|
18 | .. inheritance-diagram: D E | |||
|
19 | ||||
|
20 | Produces a graph like the following: | |||
|
21 | ||||
|
22 | A | |||
|
23 | / \ | |||
|
24 | B C | |||
|
25 | / \ / | |||
|
26 | E D | |||
|
27 | ||||
|
28 | The graph is inserted as a PNG+image map into HTML and a PDF in | |||
|
29 | LaTeX. | |||
|
30 | """ | |||
|
31 | ||||
|
32 | import inspect | |||
|
33 | import os | |||
|
34 | import re | |||
|
35 | import subprocess | |||
|
36 | try: | |||
|
37 | from hashlib import md5 | |||
|
38 | except ImportError: | |||
|
39 | from md5 import md5 | |||
|
40 | ||||
|
41 | from docutils.nodes import Body, Element | |||
|
42 | from docutils.writers.html4css1 import HTMLTranslator | |||
|
43 | from sphinx.latexwriter import LaTeXTranslator | |||
|
44 | from docutils.parsers.rst import directives | |||
|
45 | from sphinx.roles import xfileref_role | |||
|
46 | ||||
|
47 | class DotException(Exception): | |||
|
48 | pass | |||
|
49 | ||||
|
50 | class InheritanceGraph(object): | |||
|
51 | """ | |||
|
52 | Given a list of classes, determines the set of classes that | |||
|
53 | they inherit from all the way to the root "object", and then | |||
|
54 | is able to generate a graphviz dot graph from them. | |||
|
55 | """ | |||
|
56 | def __init__(self, class_names, show_builtins=False): | |||
|
57 | """ | |||
|
58 | *class_names* is a list of child classes to show bases from. | |||
|
59 | ||||
|
60 | If *show_builtins* is True, then Python builtins will be shown | |||
|
61 | in the graph. | |||
|
62 | """ | |||
|
63 | self.class_names = class_names | |||
|
64 | self.classes = self._import_classes(class_names) | |||
|
65 | self.all_classes = self._all_classes(self.classes) | |||
|
66 | if len(self.all_classes) == 0: | |||
|
67 | raise ValueError("No classes found for inheritance diagram") | |||
|
68 | self.show_builtins = show_builtins | |||
|
69 | ||||
|
70 | py_sig_re = re.compile(r'''^([\w.]*\.)? # class names | |||
|
71 | (\w+) \s* $ # optionally arguments | |||
|
72 | ''', re.VERBOSE) | |||
|
73 | ||||
|
74 | def _import_class_or_module(self, name): | |||
|
75 | """ | |||
|
76 | Import a class using its fully-qualified *name*. | |||
|
77 | """ | |||
|
78 | try: | |||
|
79 | path, base = self.py_sig_re.match(name).groups() | |||
|
80 | except: | |||
|
81 | raise ValueError( | |||
|
82 | "Invalid class or module '%s' specified for inheritance diagram" % name) | |||
|
83 | fullname = (path or '') + base | |||
|
84 | path = (path and path.rstrip('.')) | |||
|
85 | if not path: | |||
|
86 | path = base | |||
|
87 | if not path: | |||
|
88 | raise ValueError( | |||
|
89 | "Invalid class or module '%s' specified for inheritance diagram" % name) | |||
|
90 | try: | |||
|
91 | module = __import__(path, None, None, []) | |||
|
92 | except ImportError: | |||
|
93 | raise ValueError( | |||
|
94 | "Could not import class or module '%s' specified for inheritance diagram" % name) | |||
|
95 | ||||
|
96 | try: | |||
|
97 | todoc = module | |||
|
98 | for comp in fullname.split('.')[1:]: | |||
|
99 | todoc = getattr(todoc, comp) | |||
|
100 | except AttributeError: | |||
|
101 | raise ValueError( | |||
|
102 | "Could not find class or module '%s' specified for inheritance diagram" % name) | |||
|
103 | ||||
|
104 | # If a class, just return it | |||
|
105 | if inspect.isclass(todoc): | |||
|
106 | return [todoc] | |||
|
107 | elif inspect.ismodule(todoc): | |||
|
108 | classes = [] | |||
|
109 | for cls in todoc.__dict__.values(): | |||
|
110 | if inspect.isclass(cls) and cls.__module__ == todoc.__name__: | |||
|
111 | classes.append(cls) | |||
|
112 | return classes | |||
|
113 | raise ValueError( | |||
|
114 | "'%s' does not resolve to a class or module" % name) | |||
|
115 | ||||
|
116 | def _import_classes(self, class_names): | |||
|
117 | """ | |||
|
118 | Import a list of classes. | |||
|
119 | """ | |||
|
120 | classes = [] | |||
|
121 | for name in class_names: | |||
|
122 | classes.extend(self._import_class_or_module(name)) | |||
|
123 | return classes | |||
|
124 | ||||
|
125 | def _all_classes(self, classes): | |||
|
126 | """ | |||
|
127 | Return a list of all classes that are ancestors of *classes*. | |||
|
128 | """ | |||
|
129 | all_classes = {} | |||
|
130 | ||||
|
131 | def recurse(cls): | |||
|
132 | all_classes[cls] = None | |||
|
133 | for c in cls.__bases__: | |||
|
134 | if c not in all_classes: | |||
|
135 | recurse(c) | |||
|
136 | ||||
|
137 | for cls in classes: | |||
|
138 | recurse(cls) | |||
|
139 | ||||
|
140 | return all_classes.keys() | |||
|
141 | ||||
|
142 | def class_name(self, cls, parts=0): | |||
|
143 | """ | |||
|
144 | Given a class object, return a fully-qualified name. This | |||
|
145 | works for things I've tested in matplotlib so far, but may not | |||
|
146 | be completely general. | |||
|
147 | """ | |||
|
148 | module = cls.__module__ | |||
|
149 | if module == '__builtin__': | |||
|
150 | fullname = cls.__name__ | |||
|
151 | else: | |||
|
152 | fullname = "%s.%s" % (module, cls.__name__) | |||
|
153 | if parts == 0: | |||
|
154 | return fullname | |||
|
155 | name_parts = fullname.split('.') | |||
|
156 | return '.'.join(name_parts[-parts:]) | |||
|
157 | ||||
|
158 | def get_all_class_names(self): | |||
|
159 | """ | |||
|
160 | Get all of the class names involved in the graph. | |||
|
161 | """ | |||
|
162 | return [self.class_name(x) for x in self.all_classes] | |||
|
163 | ||||
|
164 | # These are the default options for graphviz | |||
|
165 | default_graph_options = { | |||
|
166 | "rankdir": "LR", | |||
|
167 | "size": '"8.0, 12.0"' | |||
|
168 | } | |||
|
169 | default_node_options = { | |||
|
170 | "shape": "box", | |||
|
171 | "fontsize": 10, | |||
|
172 | "height": 0.25, | |||
|
173 | "fontname": "Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans", | |||
|
174 | "style": '"setlinewidth(0.5)"' | |||
|
175 | } | |||
|
176 | default_edge_options = { | |||
|
177 | "arrowsize": 0.5, | |||
|
178 | "style": '"setlinewidth(0.5)"' | |||
|
179 | } | |||
|
180 | ||||
|
181 | def _format_node_options(self, options): | |||
|
182 | return ','.join(["%s=%s" % x for x in options.items()]) | |||
|
183 | def _format_graph_options(self, options): | |||
|
184 | return ''.join(["%s=%s;\n" % x for x in options.items()]) | |||
|
185 | ||||
|
186 | def generate_dot(self, fd, name, parts=0, urls={}, | |||
|
187 | graph_options={}, node_options={}, | |||
|
188 | edge_options={}): | |||
|
189 | """ | |||
|
190 | Generate a graphviz dot graph from the classes that | |||
|
191 | were passed in to __init__. | |||
|
192 | ||||
|
193 | *fd* is a Python file-like object to write to. | |||
|
194 | ||||
|
195 | *name* is the name of the graph | |||
|
196 | ||||
|
197 | *urls* is a dictionary mapping class names to http urls | |||
|
198 | ||||
|
199 | *graph_options*, *node_options*, *edge_options* are | |||
|
200 | dictionaries containing key/value pairs to pass on as graphviz | |||
|
201 | properties. | |||
|
202 | """ | |||
|
203 | g_options = self.default_graph_options.copy() | |||
|
204 | g_options.update(graph_options) | |||
|
205 | n_options = self.default_node_options.copy() | |||
|
206 | n_options.update(node_options) | |||
|
207 | e_options = self.default_edge_options.copy() | |||
|
208 | e_options.update(edge_options) | |||
|
209 | ||||
|
210 | fd.write('digraph %s {\n' % name) | |||
|
211 | fd.write(self._format_graph_options(g_options)) | |||
|
212 | ||||
|
213 | for cls in self.all_classes: | |||
|
214 | if not self.show_builtins and cls in __builtins__.values(): | |||
|
215 | continue | |||
|
216 | ||||
|
217 | name = self.class_name(cls, parts) | |||
|
218 | ||||
|
219 | # Write the node | |||
|
220 | this_node_options = n_options.copy() | |||
|
221 | url = urls.get(self.class_name(cls)) | |||
|
222 | if url is not None: | |||
|
223 | this_node_options['URL'] = '"%s"' % url | |||
|
224 | fd.write(' "%s" [%s];\n' % | |||
|
225 | (name, self._format_node_options(this_node_options))) | |||
|
226 | ||||
|
227 | # Write the edges | |||
|
228 | for base in cls.__bases__: | |||
|
229 | if not self.show_builtins and base in __builtins__.values(): | |||
|
230 | continue | |||
|
231 | ||||
|
232 | base_name = self.class_name(base, parts) | |||
|
233 | fd.write(' "%s" -> "%s" [%s];\n' % | |||
|
234 | (base_name, name, | |||
|
235 | self._format_node_options(e_options))) | |||
|
236 | fd.write('}\n') | |||
|
237 | ||||
|
238 | def run_dot(self, args, name, parts=0, urls={}, | |||
|
239 | graph_options={}, node_options={}, edge_options={}): | |||
|
240 | """ | |||
|
241 | Run graphviz 'dot' over this graph, returning whatever 'dot' | |||
|
242 | writes to stdout. | |||
|
243 | ||||
|
244 | *args* will be passed along as commandline arguments. | |||
|
245 | ||||
|
246 | *name* is the name of the graph | |||
|
247 | ||||
|
248 | *urls* is a dictionary mapping class names to http urls | |||
|
249 | ||||
|
250 | Raises DotException for any of the many os and | |||
|
251 | installation-related errors that may occur. | |||
|
252 | """ | |||
|
253 | try: | |||
|
254 | dot = subprocess.Popen(['dot'] + list(args), | |||
|
255 | stdin=subprocess.PIPE, stdout=subprocess.PIPE, | |||
|
256 | close_fds=True) | |||
|
257 | except OSError: | |||
|
258 | raise DotException("Could not execute 'dot'. Are you sure you have 'graphviz' installed?") | |||
|
259 | except ValueError: | |||
|
260 | raise DotException("'dot' called with invalid arguments") | |||
|
261 | except: | |||
|
262 | raise DotException("Unexpected error calling 'dot'") | |||
|
263 | ||||
|
264 | self.generate_dot(dot.stdin, name, parts, urls, graph_options, | |||
|
265 | node_options, edge_options) | |||
|
266 | dot.stdin.close() | |||
|
267 | result = dot.stdout.read() | |||
|
268 | returncode = dot.wait() | |||
|
269 | if returncode != 0: | |||
|
270 | raise DotException("'dot' returned the errorcode %d" % returncode) | |||
|
271 | return result | |||
|
272 | ||||
|
273 | class inheritance_diagram(Body, Element): | |||
|
274 | """ | |||
|
275 | A docutils node to use as a placeholder for the inheritance | |||
|
276 | diagram. | |||
|
277 | """ | |||
|
278 | pass | |||
|
279 | ||||
|
280 | def inheritance_diagram_directive_run(class_names, options, state): | |||
|
281 | """ | |||
|
282 | Run when the inheritance_diagram directive is first encountered. | |||
|
283 | """ | |||
|
284 | node = inheritance_diagram() | |||
|
285 | ||||
|
286 | # Create a graph starting with the list of classes | |||
|
287 | graph = InheritanceGraph(class_names) | |||
|
288 | ||||
|
289 | # Create xref nodes for each target of the graph's image map and | |||
|
290 | # add them to the doc tree so that Sphinx can resolve the | |||
|
291 | # references to real URLs later. These nodes will eventually be | |||
|
292 | # removed from the doctree after we're done with them. | |||
|
293 | for name in graph.get_all_class_names(): | |||
|
294 | refnodes, x = xfileref_role( | |||
|
295 | 'class', ':class:`%s`' % name, name, 0, state) | |||
|
296 | node.extend(refnodes) | |||
|
297 | # Store the graph object so we can use it to generate the | |||
|
298 | # dot file later | |||
|
299 | node['graph'] = graph | |||
|
300 | # Store the original content for use as a hash | |||
|
301 | node['parts'] = options.get('parts', 0) | |||
|
302 | node['content'] = " ".join(class_names) | |||
|
303 | return [node] | |||
|
304 | ||||
|
305 | def get_graph_hash(node): | |||
|
306 | return md5(node['content'] + str(node['parts'])).hexdigest()[-10:] | |||
|
307 | ||||
|
308 | def html_output_graph(self, node): | |||
|
309 | """ | |||
|
310 | Output the graph for HTML. This will insert a PNG with clickable | |||
|
311 | image map. | |||
|
312 | """ | |||
|
313 | graph = node['graph'] | |||
|
314 | parts = node['parts'] | |||
|
315 | ||||
|
316 | graph_hash = get_graph_hash(node) | |||
|
317 | name = "inheritance%s" % graph_hash | |||
|
318 | png_path = os.path.join('_static', name + ".png") | |||
|
319 | ||||
|
320 | path = '_static' | |||
|
321 | source = self.document.attributes['source'] | |||
|
322 | count = source.split('/doc/')[-1].count('/') | |||
|
323 | for i in range(count): | |||
|
324 | if os.path.exists(path): break | |||
|
325 | path = '../'+path | |||
|
326 | path = '../'+path #specifically added for matplotlib | |||
|
327 | ||||
|
328 | # Create a mapping from fully-qualified class names to URLs. | |||
|
329 | urls = {} | |||
|
330 | for child in node: | |||
|
331 | if child.get('refuri') is not None: | |||
|
332 | urls[child['reftitle']] = child.get('refuri') | |||
|
333 | elif child.get('refid') is not None: | |||
|
334 | urls[child['reftitle']] = '#' + child.get('refid') | |||
|
335 | ||||
|
336 | # These arguments to dot will save a PNG file to disk and write | |||
|
337 | # an HTML image map to stdout. | |||
|
338 | image_map = graph.run_dot(['-Tpng', '-o%s' % png_path, '-Tcmapx'], | |||
|
339 | name, parts, urls) | |||
|
340 | return ('<img src="%s/%s.png" usemap="#%s" class="inheritance"/>%s' % | |||
|
341 | (path, name, name, image_map)) | |||
|
342 | ||||
|
343 | def latex_output_graph(self, node): | |||
|
344 | """ | |||
|
345 | Output the graph for LaTeX. This will insert a PDF. | |||
|
346 | """ | |||
|
347 | graph = node['graph'] | |||
|
348 | parts = node['parts'] | |||
|
349 | ||||
|
350 | graph_hash = get_graph_hash(node) | |||
|
351 | name = "inheritance%s" % graph_hash | |||
|
352 | pdf_path = os.path.join('_static', name + ".pdf") | |||
|
353 | ||||
|
354 | graph.run_dot(['-Tpdf', '-o%s' % pdf_path], | |||
|
355 | name, parts, graph_options={'size': '"6.0,6.0"'}) | |||
|
356 | return '\\includegraphics{../../%s}' % pdf_path | |||
|
357 | ||||
|
358 | def visit_inheritance_diagram(inner_func): | |||
|
359 | """ | |||
|
360 | This is just a wrapper around html/latex_output_graph to make it | |||
|
361 | easier to handle errors and insert warnings. | |||
|
362 | """ | |||
|
363 | def visitor(self, node): | |||
|
364 | try: | |||
|
365 | content = inner_func(self, node) | |||
|
366 | except DotException, e: | |||
|
367 | # Insert the exception as a warning in the document | |||
|
368 | warning = self.document.reporter.warning(str(e), line=node.line) | |||
|
369 | warning.parent = node | |||
|
370 | node.children = [warning] | |||
|
371 | else: | |||
|
372 | source = self.document.attributes['source'] | |||
|
373 | self.body.append(content) | |||
|
374 | node.children = [] | |||
|
375 | return visitor | |||
|
376 | ||||
|
377 | def do_nothing(self, node): | |||
|
378 | pass | |||
|
379 | ||||
|
380 | options_spec = { | |||
|
381 | 'parts': directives.nonnegative_int | |||
|
382 | } | |||
|
383 | ||||
|
384 | # Deal with the old and new way of registering directives | |||
|
385 | try: | |||
|
386 | from docutils.parsers.rst import Directive | |||
|
387 | except ImportError: | |||
|
388 | from docutils.parsers.rst.directives import _directives | |||
|
389 | def inheritance_diagram_directive(name, arguments, options, content, lineno, | |||
|
390 | content_offset, block_text, state, | |||
|
391 | state_machine): | |||
|
392 | return inheritance_diagram_directive_run(arguments, options, state) | |||
|
393 | inheritance_diagram_directive.__doc__ = __doc__ | |||
|
394 | inheritance_diagram_directive.arguments = (1, 100, 0) | |||
|
395 | inheritance_diagram_directive.options = options_spec | |||
|
396 | inheritance_diagram_directive.content = 0 | |||
|
397 | _directives['inheritance-diagram'] = inheritance_diagram_directive | |||
|
398 | else: | |||
|
399 | class inheritance_diagram_directive(Directive): | |||
|
400 | has_content = False | |||
|
401 | required_arguments = 1 | |||
|
402 | optional_arguments = 100 | |||
|
403 | final_argument_whitespace = False | |||
|
404 | option_spec = options_spec | |||
|
405 | ||||
|
406 | def run(self): | |||
|
407 | return inheritance_diagram_directive_run( | |||
|
408 | self.arguments, self.options, self.state) | |||
|
409 | inheritance_diagram_directive.__doc__ = __doc__ | |||
|
410 | ||||
|
411 | directives.register_directive('inheritance-diagram', | |||
|
412 | inheritance_diagram_directive) | |||
|
413 | ||||
|
414 | def setup(app): | |||
|
415 | app.add_node(inheritance_diagram) | |||
|
416 | ||||
|
417 | HTMLTranslator.visit_inheritance_diagram = \ | |||
|
418 | visit_inheritance_diagram(html_output_graph) | |||
|
419 | HTMLTranslator.depart_inheritance_diagram = do_nothing | |||
|
420 | ||||
|
421 | LaTeXTranslator.visit_inheritance_diagram = \ | |||
|
422 | visit_inheritance_diagram(latex_output_graph) | |||
|
423 | LaTeXTranslator.depart_inheritance_diagram = do_nothing |
@@ -0,0 +1,75 b'' | |||||
|
1 | from pygments.lexer import Lexer, do_insertions | |||
|
2 | from pygments.lexers.agile import PythonConsoleLexer, PythonLexer, \ | |||
|
3 | PythonTracebackLexer | |||
|
4 | from pygments.token import Comment, Generic | |||
|
5 | from sphinx import highlighting | |||
|
6 | import re | |||
|
7 | ||||
|
8 | line_re = re.compile('.*?\n') | |||
|
9 | ||||
|
10 | class IPythonConsoleLexer(Lexer): | |||
|
11 | """ | |||
|
12 | For IPython console output or doctests, such as: | |||
|
13 | ||||
|
14 | Tracebacks are not currently supported. | |||
|
15 | ||||
|
16 | .. sourcecode:: ipython | |||
|
17 | ||||
|
18 | In [1]: a = 'foo' | |||
|
19 | ||||
|
20 | In [2]: a | |||
|
21 | Out[2]: 'foo' | |||
|
22 | ||||
|
23 | In [3]: print a | |||
|
24 | foo | |||
|
25 | ||||
|
26 | In [4]: 1 / 0 | |||
|
27 | """ | |||
|
28 | name = 'IPython console session' | |||
|
29 | aliases = ['ipython'] | |||
|
30 | mimetypes = ['text/x-ipython-console'] | |||
|
31 | input_prompt = re.compile("(In \[[0-9]+\]: )|( \.\.\.+:)") | |||
|
32 | output_prompt = re.compile("(Out\[[0-9]+\]: )|( \.\.\.+:)") | |||
|
33 | continue_prompt = re.compile(" \.\.\.+:") | |||
|
34 | tb_start = re.compile("\-+") | |||
|
35 | ||||
|
36 | def get_tokens_unprocessed(self, text): | |||
|
37 | pylexer = PythonLexer(**self.options) | |||
|
38 | tblexer = PythonTracebackLexer(**self.options) | |||
|
39 | ||||
|
40 | curcode = '' | |||
|
41 | insertions = [] | |||
|
42 | for match in line_re.finditer(text): | |||
|
43 | line = match.group() | |||
|
44 | input_prompt = self.input_prompt.match(line) | |||
|
45 | continue_prompt = self.continue_prompt.match(line.rstrip()) | |||
|
46 | output_prompt = self.output_prompt.match(line) | |||
|
47 | if line.startswith("#"): | |||
|
48 | insertions.append((len(curcode), | |||
|
49 | [(0, Comment, line)])) | |||
|
50 | elif input_prompt is not None: | |||
|
51 | insertions.append((len(curcode), | |||
|
52 | [(0, Generic.Prompt, input_prompt.group())])) | |||
|
53 | curcode += line[input_prompt.end():] | |||
|
54 | elif continue_prompt is not None: | |||
|
55 | insertions.append((len(curcode), | |||
|
56 | [(0, Generic.Prompt, continue_prompt.group())])) | |||
|
57 | curcode += line[continue_prompt.end():] | |||
|
58 | elif output_prompt is not None: | |||
|
59 | insertions.append((len(curcode), | |||
|
60 | [(0, Generic.Output, output_prompt.group())])) | |||
|
61 | curcode += line[output_prompt.end():] | |||
|
62 | else: | |||
|
63 | if curcode: | |||
|
64 | for item in do_insertions(insertions, | |||
|
65 | pylexer.get_tokens_unprocessed(curcode)): | |||
|
66 | yield item | |||
|
67 | curcode = '' | |||
|
68 | insertions = [] | |||
|
69 | yield match.start(), Generic.Output, line | |||
|
70 | if curcode: | |||
|
71 | for item in do_insertions(insertions, | |||
|
72 | pylexer.get_tokens_unprocessed(curcode)): | |||
|
73 | yield item | |||
|
74 | ||||
|
75 | highlighting.lexers['ipython'] = IPythonConsoleLexer() |
@@ -0,0 +1,87 b'' | |||||
|
1 | # | |||
|
2 | # A pair of directives for inserting content that will only appear in | |||
|
3 | # either html or latex. | |||
|
4 | # | |||
|
5 | ||||
|
6 | from docutils.nodes import Body, Element | |||
|
7 | from docutils.writers.html4css1 import HTMLTranslator | |||
|
8 | from sphinx.latexwriter import LaTeXTranslator | |||
|
9 | from docutils.parsers.rst import directives | |||
|
10 | ||||
|
11 | class html_only(Body, Element): | |||
|
12 | pass | |||
|
13 | ||||
|
14 | class latex_only(Body, Element): | |||
|
15 | pass | |||
|
16 | ||||
|
17 | def run(content, node_class, state, content_offset): | |||
|
18 | text = '\n'.join(content) | |||
|
19 | node = node_class(text) | |||
|
20 | state.nested_parse(content, content_offset, node) | |||
|
21 | return [node] | |||
|
22 | ||||
|
23 | try: | |||
|
24 | from docutils.parsers.rst import Directive | |||
|
25 | except ImportError: | |||
|
26 | from docutils.parsers.rst.directives import _directives | |||
|
27 | ||||
|
28 | def html_only_directive(name, arguments, options, content, lineno, | |||
|
29 | content_offset, block_text, state, state_machine): | |||
|
30 | return run(content, html_only, state, content_offset) | |||
|
31 | ||||
|
32 | def latex_only_directive(name, arguments, options, content, lineno, | |||
|
33 | content_offset, block_text, state, state_machine): | |||
|
34 | return run(content, latex_only, state, content_offset) | |||
|
35 | ||||
|
36 | for func in (html_only_directive, latex_only_directive): | |||
|
37 | func.content = 1 | |||
|
38 | func.options = {} | |||
|
39 | func.arguments = None | |||
|
40 | ||||
|
41 | _directives['htmlonly'] = html_only_directive | |||
|
42 | _directives['latexonly'] = latex_only_directive | |||
|
43 | else: | |||
|
44 | class OnlyDirective(Directive): | |||
|
45 | has_content = True | |||
|
46 | required_arguments = 0 | |||
|
47 | optional_arguments = 0 | |||
|
48 | final_argument_whitespace = True | |||
|
49 | option_spec = {} | |||
|
50 | ||||
|
51 | def run(self): | |||
|
52 | self.assert_has_content() | |||
|
53 | return run(self.content, self.node_class, | |||
|
54 | self.state, self.content_offset) | |||
|
55 | ||||
|
56 | class HtmlOnlyDirective(OnlyDirective): | |||
|
57 | node_class = html_only | |||
|
58 | ||||
|
59 | class LatexOnlyDirective(OnlyDirective): | |||
|
60 | node_class = latex_only | |||
|
61 | ||||
|
62 | directives.register_directive('htmlonly', HtmlOnlyDirective) | |||
|
63 | directives.register_directive('latexonly', LatexOnlyDirective) | |||
|
64 | ||||
|
65 | def setup(app): | |||
|
66 | app.add_node(html_only) | |||
|
67 | app.add_node(latex_only) | |||
|
68 | ||||
|
69 | # Add visit/depart methods to HTML-Translator: | |||
|
70 | def visit_perform(self, node): | |||
|
71 | pass | |||
|
72 | def depart_perform(self, node): | |||
|
73 | pass | |||
|
74 | def visit_ignore(self, node): | |||
|
75 | node.children = [] | |||
|
76 | def depart_ignore(self, node): | |||
|
77 | node.children = [] | |||
|
78 | ||||
|
79 | HTMLTranslator.visit_html_only = visit_perform | |||
|
80 | HTMLTranslator.depart_html_only = depart_perform | |||
|
81 | HTMLTranslator.visit_latex_only = visit_ignore | |||
|
82 | HTMLTranslator.depart_latex_only = depart_ignore | |||
|
83 | ||||
|
84 | LaTeXTranslator.visit_html_only = visit_ignore | |||
|
85 | LaTeXTranslator.depart_html_only = depart_ignore | |||
|
86 | LaTeXTranslator.visit_latex_only = visit_perform | |||
|
87 | LaTeXTranslator.depart_latex_only = depart_perform |
@@ -0,0 +1,155 b'' | |||||
|
1 | """A special directive for including a matplotlib plot. | |||
|
2 | ||||
|
3 | Given a path to a .py file, it includes the source code inline, then: | |||
|
4 | ||||
|
5 | - On HTML, will include a .png with a link to a high-res .png. | |||
|
6 | ||||
|
7 | - On LaTeX, will include a .pdf | |||
|
8 | ||||
|
9 | This directive supports all of the options of the `image` directive, | |||
|
10 | except for `target` (since plot will add its own target). | |||
|
11 | ||||
|
12 | Additionally, if the :include-source: option is provided, the literal | |||
|
13 | source will be included inline, as well as a link to the source. | |||
|
14 | """ | |||
|
15 | ||||
|
16 | import sys, os, glob, shutil | |||
|
17 | from docutils.parsers.rst import directives | |||
|
18 | ||||
|
19 | try: | |||
|
20 | # docutils 0.4 | |||
|
21 | from docutils.parsers.rst.directives.images import align | |||
|
22 | except ImportError: | |||
|
23 | # docutils 0.5 | |||
|
24 | from docutils.parsers.rst.directives.images import Image | |||
|
25 | align = Image.align | |||
|
26 | ||||
|
27 | ||||
|
28 | import matplotlib | |||
|
29 | import IPython.Shell | |||
|
30 | matplotlib.use('Agg') | |||
|
31 | import matplotlib.pyplot as plt | |||
|
32 | ||||
|
33 | mplshell = IPython.Shell.MatplotlibShell('mpl') | |||
|
34 | ||||
|
35 | options = {'alt': directives.unchanged, | |||
|
36 | 'height': directives.length_or_unitless, | |||
|
37 | 'width': directives.length_or_percentage_or_unitless, | |||
|
38 | 'scale': directives.nonnegative_int, | |||
|
39 | 'align': align, | |||
|
40 | 'class': directives.class_option, | |||
|
41 | 'include-source': directives.flag } | |||
|
42 | ||||
|
43 | template = """ | |||
|
44 | .. htmlonly:: | |||
|
45 | ||||
|
46 | [`source code <../%(srcdir)s/%(basename)s.py>`__, | |||
|
47 | `png <../%(srcdir)s/%(basename)s.hires.png>`__, | |||
|
48 | `pdf <../%(srcdir)s/%(basename)s.pdf>`__] | |||
|
49 | ||||
|
50 | .. image:: ../%(srcdir)s/%(basename)s.png | |||
|
51 | %(options)s | |||
|
52 | ||||
|
53 | .. latexonly:: | |||
|
54 | .. image:: ../%(srcdir)s/%(basename)s.pdf | |||
|
55 | %(options)s | |||
|
56 | ||||
|
57 | """ | |||
|
58 | ||||
|
59 | def makefig(fullpath, outdir): | |||
|
60 | """ | |||
|
61 | run a pyplot script and save the low and high res PNGs and a PDF in _static | |||
|
62 | """ | |||
|
63 | ||||
|
64 | fullpath = str(fullpath) # todo, why is unicode breaking this | |||
|
65 | formats = [('png', 100), | |||
|
66 | ('hires.png', 200), | |||
|
67 | ('pdf', 72), | |||
|
68 | ] | |||
|
69 | ||||
|
70 | basedir, fname = os.path.split(fullpath) | |||
|
71 | basename, ext = os.path.splitext(fname) | |||
|
72 | all_exists = True | |||
|
73 | ||||
|
74 | if basedir != outdir: | |||
|
75 | shutil.copyfile(fullpath, os.path.join(outdir, fname)) | |||
|
76 | ||||
|
77 | for format, dpi in formats: | |||
|
78 | outname = os.path.join(outdir, '%s.%s' % (basename, format)) | |||
|
79 | if not os.path.exists(outname): | |||
|
80 | all_exists = False | |||
|
81 | break | |||
|
82 | ||||
|
83 | if all_exists: | |||
|
84 | print ' already have %s'%fullpath | |||
|
85 | return | |||
|
86 | ||||
|
87 | print ' building %s'%fullpath | |||
|
88 | plt.close('all') # we need to clear between runs | |||
|
89 | matplotlib.rcdefaults() | |||
|
90 | ||||
|
91 | mplshell.magic_run(fullpath) | |||
|
92 | for format, dpi in formats: | |||
|
93 | outname = os.path.join(outdir, '%s.%s' % (basename, format)) | |||
|
94 | if os.path.exists(outname): continue | |||
|
95 | plt.savefig(outname, dpi=dpi) | |||
|
96 | ||||
|
97 | def run(arguments, options, state_machine, lineno): | |||
|
98 | reference = directives.uri(arguments[0]) | |||
|
99 | basedir, fname = os.path.split(reference) | |||
|
100 | basename, ext = os.path.splitext(fname) | |||
|
101 | ||||
|
102 | # todo - should we be using the _static dir for the outdir, I am | |||
|
103 | # not sure we want to corrupt that dir with autogenerated files | |||
|
104 | # since it also has permanent files in it which makes it difficult | |||
|
105 | # to clean (save an rm -rf followed by and svn up) | |||
|
106 | srcdir = 'pyplots' | |||
|
107 | ||||
|
108 | makefig(os.path.join(srcdir, reference), srcdir) | |||
|
109 | ||||
|
110 | # todo: it is not great design to assume the makefile is putting | |||
|
111 | # the figs into the right place, so we may want to do that here instead. | |||
|
112 | ||||
|
113 | if options.has_key('include-source'): | |||
|
114 | lines = ['.. literalinclude:: ../pyplots/%(reference)s' % locals()] | |||
|
115 | del options['include-source'] | |||
|
116 | else: | |||
|
117 | lines = [] | |||
|
118 | ||||
|
119 | options = [' :%s: %s' % (key, val) for key, val in | |||
|
120 | options.items()] | |||
|
121 | options = "\n".join(options) | |||
|
122 | ||||
|
123 | lines.extend((template % locals()).split('\n')) | |||
|
124 | ||||
|
125 | state_machine.insert_input( | |||
|
126 | lines, state_machine.input_lines.source(0)) | |||
|
127 | return [] | |||
|
128 | ||||
|
129 | ||||
|
130 | try: | |||
|
131 | from docutils.parsers.rst import Directive | |||
|
132 | except ImportError: | |||
|
133 | from docutils.parsers.rst.directives import _directives | |||
|
134 | ||||
|
135 | def plot_directive(name, arguments, options, content, lineno, | |||
|
136 | content_offset, block_text, state, state_machine): | |||
|
137 | return run(arguments, options, state_machine, lineno) | |||
|
138 | plot_directive.__doc__ = __doc__ | |||
|
139 | plot_directive.arguments = (1, 0, 1) | |||
|
140 | plot_directive.options = options | |||
|
141 | ||||
|
142 | _directives['plot'] = plot_directive | |||
|
143 | else: | |||
|
144 | class plot_directive(Directive): | |||
|
145 | required_arguments = 1 | |||
|
146 | optional_arguments = 0 | |||
|
147 | final_argument_whitespace = True | |||
|
148 | option_spec = options | |||
|
149 | def run(self): | |||
|
150 | return run(self.arguments, self.options, | |||
|
151 | self.state_machine, self.lineno) | |||
|
152 | plot_directive.__doc__ = __doc__ | |||
|
153 | ||||
|
154 | directives.register_directive('plot', plot_directive) | |||
|
155 |
@@ -1,99 +1,97 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 | """Release data for the IPython project. |
|
2 | """Release data for the IPython project.""" | |
3 |
|
||||
4 | $Id: Release.py 3002 2008-02-01 07:17:00Z fperez $""" |
|
|||
5 |
|
3 | |||
6 | #***************************************************************************** |
|
4 | #***************************************************************************** | |
7 | # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu> |
|
5 | # Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu> | |
8 | # |
|
6 | # | |
9 | # Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray |
|
7 | # Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray | |
10 | # <n8gray@caltech.edu> |
|
8 | # <n8gray@caltech.edu> | |
11 | # |
|
9 | # | |
12 | # Distributed under the terms of the BSD License. The full license is in |
|
10 | # Distributed under the terms of the BSD License. The full license is in | |
13 | # the file COPYING, distributed as part of this software. |
|
11 | # the file COPYING, distributed as part of this software. | |
14 | #***************************************************************************** |
|
12 | #***************************************************************************** | |
15 |
|
13 | |||
16 | # Name of the package for release purposes. This is the name which labels |
|
14 | # Name of the package for release purposes. This is the name which labels | |
17 | # the tarballs and RPMs made by distutils, so it's best to lowercase it. |
|
15 | # the tarballs and RPMs made by distutils, so it's best to lowercase it. | |
18 | name = 'ipython' |
|
16 | name = 'ipython' | |
19 |
|
17 | |||
20 | # For versions with substrings (like 0.6.16.svn), use an extra . to separate |
|
18 | # For versions with substrings (like 0.6.16.svn), use an extra . to separate | |
21 | # the new substring. We have to avoid using either dashes or underscores, |
|
19 | # the new substring. We have to avoid using either dashes or underscores, | |
22 | # because bdist_rpm does not accept dashes (an RPM) convention, and |
|
20 | # because bdist_rpm does not accept dashes (an RPM) convention, and | |
23 | # bdist_deb does not accept underscores (a Debian convention). |
|
21 | # bdist_deb does not accept underscores (a Debian convention). | |
24 |
|
22 | |||
25 | development = False # change this to False to do a release |
|
23 | development = False # change this to False to do a release | |
26 |
version_base = '0.9. |
|
24 | version_base = '0.9.1' | |
27 | branch = 'ipython' |
|
25 | branch = 'ipython' | |
28 |
revision = '11 |
|
26 | revision = '1143' | |
29 |
|
27 | |||
30 | if development: |
|
28 | if development: | |
31 | if branch == 'ipython': |
|
29 | if branch == 'ipython': | |
32 | version = '%s.bzr.r%s' % (version_base, revision) |
|
30 | version = '%s.bzr.r%s' % (version_base, revision) | |
33 | else: |
|
31 | else: | |
34 | version = '%s.bzr.r%s.%s' % (version_base, revision, branch) |
|
32 | version = '%s.bzr.r%s.%s' % (version_base, revision, branch) | |
35 | else: |
|
33 | else: | |
36 | version = version_base |
|
34 | version = version_base | |
37 |
|
35 | |||
38 |
|
36 | |||
39 | description = "Tools for interactive development in Python." |
|
37 | description = "Tools for interactive development in Python." | |
40 |
|
38 | |||
41 | long_description = \ |
|
39 | long_description = \ | |
42 | """ |
|
40 | """ | |
43 | IPython provides a replacement for the interactive Python interpreter with |
|
41 | IPython provides a replacement for the interactive Python interpreter with | |
44 | extra functionality. |
|
42 | extra functionality. | |
45 |
|
43 | |||
46 | Main features: |
|
44 | Main features: | |
47 |
|
45 | |||
48 | * Comprehensive object introspection. |
|
46 | * Comprehensive object introspection. | |
49 |
|
47 | |||
50 | * Input history, persistent across sessions. |
|
48 | * Input history, persistent across sessions. | |
51 |
|
49 | |||
52 | * Caching of output results during a session with automatically generated |
|
50 | * Caching of output results during a session with automatically generated | |
53 | references. |
|
51 | references. | |
54 |
|
52 | |||
55 | * Readline based name completion. |
|
53 | * Readline based name completion. | |
56 |
|
54 | |||
57 | * Extensible system of 'magic' commands for controlling the environment and |
|
55 | * Extensible system of 'magic' commands for controlling the environment and | |
58 | performing many tasks related either to IPython or the operating system. |
|
56 | performing many tasks related either to IPython or the operating system. | |
59 |
|
57 | |||
60 | * Configuration system with easy switching between different setups (simpler |
|
58 | * Configuration system with easy switching between different setups (simpler | |
61 | than changing $PYTHONSTARTUP environment variables every time). |
|
59 | than changing $PYTHONSTARTUP environment variables every time). | |
62 |
|
60 | |||
63 | * Session logging and reloading. |
|
61 | * Session logging and reloading. | |
64 |
|
62 | |||
65 | * Extensible syntax processing for special purpose situations. |
|
63 | * Extensible syntax processing for special purpose situations. | |
66 |
|
64 | |||
67 | * Access to the system shell with user-extensible alias system. |
|
65 | * Access to the system shell with user-extensible alias system. | |
68 |
|
66 | |||
69 | * Easily embeddable in other Python programs. |
|
67 | * Easily embeddable in other Python programs. | |
70 |
|
68 | |||
71 | * Integrated access to the pdb debugger and the Python profiler. |
|
69 | * Integrated access to the pdb debugger and the Python profiler. | |
72 |
|
70 | |||
73 | The latest development version is always available at the IPython subversion |
|
71 | The latest development version is always available at the IPython subversion | |
74 | repository_. |
|
72 | repository_. | |
75 |
|
73 | |||
76 | .. _repository: http://ipython.scipy.org/svn/ipython/ipython/trunk#egg=ipython-dev |
|
74 | .. _repository: http://ipython.scipy.org/svn/ipython/ipython/trunk#egg=ipython-dev | |
77 | """ |
|
75 | """ | |
78 |
|
76 | |||
79 | license = 'BSD' |
|
77 | license = 'BSD' | |
80 |
|
78 | |||
81 | authors = {'Fernando' : ('Fernando Perez','fperez@colorado.edu'), |
|
79 | authors = {'Fernando' : ('Fernando Perez','fperez@colorado.edu'), | |
82 | 'Janko' : ('Janko Hauser','jhauser@zscout.de'), |
|
80 | 'Janko' : ('Janko Hauser','jhauser@zscout.de'), | |
83 | 'Nathan' : ('Nathaniel Gray','n8gray@caltech.edu'), |
|
81 | 'Nathan' : ('Nathaniel Gray','n8gray@caltech.edu'), | |
84 | 'Ville' : ('Ville Vainio','vivainio@gmail.com'), |
|
82 | 'Ville' : ('Ville Vainio','vivainio@gmail.com'), | |
85 | 'Brian' : ('Brian E Granger', 'ellisonbg@gmail.com'), |
|
83 | 'Brian' : ('Brian E Granger', 'ellisonbg@gmail.com'), | |
86 | 'Min' : ('Min Ragan-Kelley', 'benjaminrk@gmail.com') |
|
84 | 'Min' : ('Min Ragan-Kelley', 'benjaminrk@gmail.com') | |
87 | } |
|
85 | } | |
88 |
|
86 | |||
89 | author = 'The IPython Development Team' |
|
87 | author = 'The IPython Development Team' | |
90 |
|
88 | |||
91 | author_email = 'ipython-dev@scipy.org' |
|
89 | author_email = 'ipython-dev@scipy.org' | |
92 |
|
90 | |||
93 | url = 'http://ipython.scipy.org' |
|
91 | url = 'http://ipython.scipy.org' | |
94 |
|
92 | |||
95 | download_url = 'http://ipython.scipy.org/dist' |
|
93 | download_url = 'http://ipython.scipy.org/dist' | |
96 |
|
94 | |||
97 | platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME'] |
|
95 | platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME'] | |
98 |
|
96 | |||
99 | keywords = ['Interactive','Interpreter','Shell','Parallel','Distributed'] |
|
97 | keywords = ['Interactive','Interpreter','Shell','Parallel','Distributed'] |
@@ -1,360 +1,429 b'' | |||||
1 | # encoding: utf-8 |
|
1 | # encoding: utf-8 | |
2 | # -*- test-case-name: IPython.frontend.tests.test_frontendbase -*- |
|
2 | # -*- test-case-name: IPython.frontend.tests.test_frontendbase -*- | |
3 | """ |
|
3 | """ | |
4 | frontendbase provides an interface and base class for GUI frontends for |
|
4 | frontendbase provides an interface and base class for GUI frontends for | |
5 | IPython.kernel/IPython.kernel.core. |
|
5 | IPython.kernel/IPython.kernel.core. | |
6 |
|
6 | |||
7 | Frontend implementations will likely want to subclass FrontEndBase. |
|
7 | Frontend implementations will likely want to subclass FrontEndBase. | |
8 |
|
8 | |||
9 | Author: Barry Wark |
|
9 | Author: Barry Wark | |
10 | """ |
|
10 | """ | |
11 | __docformat__ = "restructuredtext en" |
|
11 | __docformat__ = "restructuredtext en" | |
12 |
|
12 | |||
13 | #------------------------------------------------------------------------------- |
|
13 | #------------------------------------------------------------------------------- | |
14 | # Copyright (C) 2008 The IPython Development Team |
|
14 | # Copyright (C) 2008 The IPython Development Team | |
15 | # |
|
15 | # | |
16 | # Distributed under the terms of the BSD License. The full license is in |
|
16 | # Distributed under the terms of the BSD License. The full license is in | |
17 | # the file COPYING, distributed as part of this software. |
|
17 | # the file COPYING, distributed as part of this software. | |
18 | #------------------------------------------------------------------------------- |
|
18 | #------------------------------------------------------------------------------- | |
19 |
|
19 | |||
20 | #------------------------------------------------------------------------------- |
|
20 | #------------------------------------------------------------------------------- | |
21 | # Imports |
|
21 | # Imports | |
22 | #------------------------------------------------------------------------------- |
|
22 | #------------------------------------------------------------------------------- | |
23 | import string |
|
23 | import string | |
24 | import uuid |
|
24 | ||
25 | import _ast |
|
25 | try: | |
|
26 | import _ast | |||
|
27 | except ImportError: | |||
|
28 | # Python 2.4 hackish workaround. | |||
|
29 | class bunch: pass | |||
|
30 | _ast = bunch() | |||
|
31 | _ast.PyCF_ONLY_AST = 1024 | |||
|
32 | ||||
|
33 | ||||
|
34 | ||||
|
35 | try: | |||
|
36 | import uuid | |||
|
37 | except ImportError: | |||
|
38 | # Python 2.4 hackish workaround. | |||
|
39 | class UUID: | |||
|
40 | def __init__(self,bytes): | |||
|
41 | version = 4 | |||
|
42 | int = long(('%02x'*16) % tuple(map(ord, bytes)), 16) | |||
|
43 | # Set the variant to RFC 4122. | |||
|
44 | int &= ~(0xc000 << 48L) | |||
|
45 | int |= 0x8000 << 48L | |||
|
46 | # Set the version number. | |||
|
47 | int &= ~(0xf000 << 64L) | |||
|
48 | int |= version << 76L | |||
|
49 | self.__dict__['int'] = int | |||
|
50 | ||||
|
51 | def __cmp__(self, other): | |||
|
52 | if isinstance(other, UUID): | |||
|
53 | return cmp(self.int, other.int) | |||
|
54 | return NotImplemented | |||
|
55 | ||||
|
56 | def __hash__(self): | |||
|
57 | return hash(self.int) | |||
|
58 | ||||
|
59 | def __int__(self): | |||
|
60 | return self.int | |||
|
61 | ||||
|
62 | def __repr__(self): | |||
|
63 | return 'UUID(%r)' % str(self) | |||
|
64 | ||||
|
65 | def __setattr__(self, name, value): | |||
|
66 | raise TypeError('UUID objects are immutable') | |||
|
67 | ||||
|
68 | def __str__(self): | |||
|
69 | hex = '%032x' % self.int | |||
|
70 | return '%s-%s-%s-%s-%s' % ( | |||
|
71 | hex[:8], hex[8:12], hex[12:16], hex[16:20], hex[20:]) | |||
|
72 | ||||
|
73 | def get_bytes(self): | |||
|
74 | bytes = '' | |||
|
75 | for shift in range(0, 128, 8): | |||
|
76 | bytes = chr((self.int >> shift) & 0xff) + bytes | |||
|
77 | return bytes | |||
|
78 | ||||
|
79 | bytes = property(get_bytes) | |||
|
80 | ||||
|
81 | ||||
|
82 | def _u4(): | |||
|
83 | "Fake random uuid" | |||
|
84 | ||||
|
85 | import random | |||
|
86 | bytes = [chr(random.randrange(256)) for i in range(16)] | |||
|
87 | return UUID(bytes) | |||
|
88 | ||||
|
89 | class bunch: pass | |||
|
90 | uuid = bunch() | |||
|
91 | uuid.uuid4 = _u4 | |||
|
92 | del _u4 | |||
|
93 | ||||
|
94 | ||||
26 |
|
95 | |||
27 | from IPython.frontend.zopeinterface import ( |
|
96 | from IPython.frontend.zopeinterface import ( | |
28 | Interface, |
|
97 | Interface, | |
29 | Attribute, |
|
98 | Attribute, | |
30 | ) |
|
99 | ) | |
31 | from IPython.kernel.core.history import FrontEndHistory |
|
100 | from IPython.kernel.core.history import FrontEndHistory | |
32 | from IPython.kernel.core.util import Bunch |
|
101 | from IPython.kernel.core.util import Bunch | |
33 |
|
102 | |||
34 | ############################################################################## |
|
103 | ############################################################################## | |
35 | # TEMPORARY!!! fake configuration, while we decide whether to use tconfig or |
|
104 | # TEMPORARY!!! fake configuration, while we decide whether to use tconfig or | |
36 | # not |
|
105 | # not | |
37 |
|
106 | |||
38 | rc = Bunch() |
|
107 | rc = Bunch() | |
39 | rc.prompt_in1 = r'In [$number]: ' |
|
108 | rc.prompt_in1 = r'In [$number]: ' | |
40 | rc.prompt_in2 = r'...' |
|
109 | rc.prompt_in2 = r'...' | |
41 | rc.prompt_out = r'Out [$number]: ' |
|
110 | rc.prompt_out = r'Out [$number]: ' | |
42 |
|
111 | |||
43 | ############################################################################## |
|
112 | ############################################################################## | |
44 | # Interface definitions |
|
113 | # Interface definitions | |
45 | ############################################################################## |
|
114 | ############################################################################## | |
46 |
|
115 | |||
47 | class IFrontEndFactory(Interface): |
|
116 | class IFrontEndFactory(Interface): | |
48 | """Factory interface for frontends.""" |
|
117 | """Factory interface for frontends.""" | |
49 |
|
118 | |||
50 | def __call__(engine=None, history=None): |
|
119 | def __call__(engine=None, history=None): | |
51 | """ |
|
120 | """ | |
52 | Parameters: |
|
121 | Parameters: | |
53 | interpreter : IPython.kernel.engineservice.IEngineCore |
|
122 | interpreter : IPython.kernel.engineservice.IEngineCore | |
54 | """ |
|
123 | """ | |
55 |
|
124 | |||
56 | pass |
|
125 | pass | |
57 |
|
126 | |||
58 |
|
127 | |||
59 | class IFrontEnd(Interface): |
|
128 | class IFrontEnd(Interface): | |
60 | """Interface for frontends. All methods return t.i.d.Deferred""" |
|
129 | """Interface for frontends. All methods return t.i.d.Deferred""" | |
61 |
|
130 | |||
62 | Attribute("input_prompt_template", "string.Template instance\ |
|
131 | Attribute("input_prompt_template", "string.Template instance\ | |
63 | substituteable with execute result.") |
|
132 | substituteable with execute result.") | |
64 | Attribute("output_prompt_template", "string.Template instance\ |
|
133 | Attribute("output_prompt_template", "string.Template instance\ | |
65 | substituteable with execute result.") |
|
134 | substituteable with execute result.") | |
66 | Attribute("continuation_prompt_template", "string.Template instance\ |
|
135 | Attribute("continuation_prompt_template", "string.Template instance\ | |
67 | substituteable with execute result.") |
|
136 | substituteable with execute result.") | |
68 |
|
137 | |||
69 | def update_cell_prompt(result, blockID=None): |
|
138 | def update_cell_prompt(result, blockID=None): | |
70 | """Subclass may override to update the input prompt for a block. |
|
139 | """Subclass may override to update the input prompt for a block. | |
71 |
|
140 | |||
72 | In asynchronous frontends, this method will be called as a |
|
141 | In asynchronous frontends, this method will be called as a | |
73 | twisted.internet.defer.Deferred's callback/errback. |
|
142 | twisted.internet.defer.Deferred's callback/errback. | |
74 | Implementations should thus return result when finished. |
|
143 | Implementations should thus return result when finished. | |
75 |
|
144 | |||
76 | Result is a result dict in case of success, and a |
|
145 | Result is a result dict in case of success, and a | |
77 | twisted.python.util.failure.Failure in case of an error |
|
146 | twisted.python.util.failure.Failure in case of an error | |
78 | """ |
|
147 | """ | |
79 |
|
148 | |||
80 | pass |
|
149 | pass | |
81 |
|
150 | |||
82 | def render_result(result): |
|
151 | def render_result(result): | |
83 | """Render the result of an execute call. Implementors may choose the |
|
152 | """Render the result of an execute call. Implementors may choose the | |
84 | method of rendering. |
|
153 | method of rendering. | |
85 | For example, a notebook-style frontend might render a Chaco plot |
|
154 | For example, a notebook-style frontend might render a Chaco plot | |
86 | inline. |
|
155 | inline. | |
87 |
|
156 | |||
88 | Parameters: |
|
157 | Parameters: | |
89 | result : dict (result of IEngineBase.execute ) |
|
158 | result : dict (result of IEngineBase.execute ) | |
90 | blockID = result['blockID'] |
|
159 | blockID = result['blockID'] | |
91 |
|
160 | |||
92 | Result: |
|
161 | Result: | |
93 | Output of frontend rendering |
|
162 | Output of frontend rendering | |
94 | """ |
|
163 | """ | |
95 |
|
164 | |||
96 | pass |
|
165 | pass | |
97 |
|
166 | |||
98 | def render_error(failure): |
|
167 | def render_error(failure): | |
99 | """Subclasses must override to render the failure. |
|
168 | """Subclasses must override to render the failure. | |
100 |
|
169 | |||
101 | In asynchronous frontend, since this method will be called as a |
|
170 | In asynchronous frontend, since this method will be called as a | |
102 | twisted.internet.defer.Deferred's callback. Implementations |
|
171 | twisted.internet.defer.Deferred's callback. Implementations | |
103 | should thus return result when finished. |
|
172 | should thus return result when finished. | |
104 |
|
173 | |||
105 | blockID = failure.blockID |
|
174 | blockID = failure.blockID | |
106 | """ |
|
175 | """ | |
107 |
|
176 | |||
108 | pass |
|
177 | pass | |
109 |
|
178 | |||
110 | def input_prompt(number=''): |
|
179 | def input_prompt(number=''): | |
111 | """Returns the input prompt by subsituting into |
|
180 | """Returns the input prompt by subsituting into | |
112 | self.input_prompt_template |
|
181 | self.input_prompt_template | |
113 | """ |
|
182 | """ | |
114 | pass |
|
183 | pass | |
115 |
|
184 | |||
116 | def output_prompt(number=''): |
|
185 | def output_prompt(number=''): | |
117 | """Returns the output prompt by subsituting into |
|
186 | """Returns the output prompt by subsituting into | |
118 | self.output_prompt_template |
|
187 | self.output_prompt_template | |
119 | """ |
|
188 | """ | |
120 |
|
189 | |||
121 | pass |
|
190 | pass | |
122 |
|
191 | |||
123 | def continuation_prompt(): |
|
192 | def continuation_prompt(): | |
124 | """Returns the continuation prompt by subsituting into |
|
193 | """Returns the continuation prompt by subsituting into | |
125 | self.continuation_prompt_template |
|
194 | self.continuation_prompt_template | |
126 | """ |
|
195 | """ | |
127 |
|
196 | |||
128 | pass |
|
197 | pass | |
129 |
|
198 | |||
130 | def is_complete(block): |
|
199 | def is_complete(block): | |
131 | """Returns True if block is complete, False otherwise.""" |
|
200 | """Returns True if block is complete, False otherwise.""" | |
132 |
|
201 | |||
133 | pass |
|
202 | pass | |
134 |
|
203 | |||
135 | def compile_ast(block): |
|
204 | def compile_ast(block): | |
136 | """Compiles block to an _ast.AST""" |
|
205 | """Compiles block to an _ast.AST""" | |
137 |
|
206 | |||
138 | pass |
|
207 | pass | |
139 |
|
208 | |||
140 | def get_history_previous(current_block): |
|
209 | def get_history_previous(current_block): | |
141 | """Returns the block previous in the history. Saves currentBlock if |
|
210 | """Returns the block previous in the history. Saves currentBlock if | |
142 | the history_cursor is currently at the end of the input history""" |
|
211 | the history_cursor is currently at the end of the input history""" | |
143 | pass |
|
212 | pass | |
144 |
|
213 | |||
145 | def get_history_next(): |
|
214 | def get_history_next(): | |
146 | """Returns the next block in the history.""" |
|
215 | """Returns the next block in the history.""" | |
147 |
|
216 | |||
148 | pass |
|
217 | pass | |
149 |
|
218 | |||
150 | def complete(self, line): |
|
219 | def complete(self, line): | |
151 | """Returns the list of possible completions, and the completed |
|
220 | """Returns the list of possible completions, and the completed | |
152 | line. |
|
221 | line. | |
153 |
|
222 | |||
154 | The input argument is the full line to be completed. This method |
|
223 | The input argument is the full line to be completed. This method | |
155 | returns both the line completed as much as possible, and the list |
|
224 | returns both the line completed as much as possible, and the list | |
156 | of further possible completions (full words). |
|
225 | of further possible completions (full words). | |
157 | """ |
|
226 | """ | |
158 | pass |
|
227 | pass | |
159 |
|
228 | |||
160 |
|
229 | |||
161 | ############################################################################## |
|
230 | ############################################################################## | |
162 | # Base class for all the frontends. |
|
231 | # Base class for all the frontends. | |
163 | ############################################################################## |
|
232 | ############################################################################## | |
164 |
|
233 | |||
165 | class FrontEndBase(object): |
|
234 | class FrontEndBase(object): | |
166 | """ |
|
235 | """ | |
167 | FrontEndBase manages the state tasks for a CLI frontend: |
|
236 | FrontEndBase manages the state tasks for a CLI frontend: | |
168 | - Input and output history management |
|
237 | - Input and output history management | |
169 | - Input/continuation and output prompt generation |
|
238 | - Input/continuation and output prompt generation | |
170 |
|
239 | |||
171 | Some issues (due to possibly unavailable engine): |
|
240 | Some issues (due to possibly unavailable engine): | |
172 | - How do we get the current cell number for the engine? |
|
241 | - How do we get the current cell number for the engine? | |
173 | - How do we handle completions? |
|
242 | - How do we handle completions? | |
174 | """ |
|
243 | """ | |
175 |
|
244 | |||
176 | history_cursor = 0 |
|
245 | history_cursor = 0 | |
177 |
|
246 | |||
178 | input_prompt_template = string.Template(rc.prompt_in1) |
|
247 | input_prompt_template = string.Template(rc.prompt_in1) | |
179 | output_prompt_template = string.Template(rc.prompt_out) |
|
248 | output_prompt_template = string.Template(rc.prompt_out) | |
180 | continuation_prompt_template = string.Template(rc.prompt_in2) |
|
249 | continuation_prompt_template = string.Template(rc.prompt_in2) | |
181 |
|
250 | |||
182 | def __init__(self, shell=None, history=None): |
|
251 | def __init__(self, shell=None, history=None): | |
183 | self.shell = shell |
|
252 | self.shell = shell | |
184 | if history is None: |
|
253 | if history is None: | |
185 | self.history = FrontEndHistory(input_cache=['']) |
|
254 | self.history = FrontEndHistory(input_cache=['']) | |
186 | else: |
|
255 | else: | |
187 | self.history = history |
|
256 | self.history = history | |
188 |
|
257 | |||
189 |
|
258 | |||
190 | def input_prompt(self, number=''): |
|
259 | def input_prompt(self, number=''): | |
191 | """Returns the current input prompt |
|
260 | """Returns the current input prompt | |
192 |
|
261 | |||
193 | It would be great to use ipython1.core.prompts.Prompt1 here |
|
262 | It would be great to use ipython1.core.prompts.Prompt1 here | |
194 | """ |
|
263 | """ | |
195 | return self.input_prompt_template.safe_substitute({'number':number}) |
|
264 | return self.input_prompt_template.safe_substitute({'number':number}) | |
196 |
|
265 | |||
197 |
|
266 | |||
198 | def continuation_prompt(self): |
|
267 | def continuation_prompt(self): | |
199 | """Returns the current continuation prompt""" |
|
268 | """Returns the current continuation prompt""" | |
200 |
|
269 | |||
201 | return self.continuation_prompt_template.safe_substitute() |
|
270 | return self.continuation_prompt_template.safe_substitute() | |
202 |
|
271 | |||
203 | def output_prompt(self, number=''): |
|
272 | def output_prompt(self, number=''): | |
204 | """Returns the output prompt for result""" |
|
273 | """Returns the output prompt for result""" | |
205 |
|
274 | |||
206 | return self.output_prompt_template.safe_substitute({'number':number}) |
|
275 | return self.output_prompt_template.safe_substitute({'number':number}) | |
207 |
|
276 | |||
208 |
|
277 | |||
209 | def is_complete(self, block): |
|
278 | def is_complete(self, block): | |
210 | """Determine if block is complete. |
|
279 | """Determine if block is complete. | |
211 |
|
280 | |||
212 | Parameters |
|
281 | Parameters | |
213 | block : string |
|
282 | block : string | |
214 |
|
283 | |||
215 | Result |
|
284 | Result | |
216 | True if block can be sent to the engine without compile errors. |
|
285 | True if block can be sent to the engine without compile errors. | |
217 | False otherwise. |
|
286 | False otherwise. | |
218 | """ |
|
287 | """ | |
219 |
|
288 | |||
220 | try: |
|
289 | try: | |
221 | ast = self.compile_ast(block) |
|
290 | ast = self.compile_ast(block) | |
222 | except: |
|
291 | except: | |
223 | return False |
|
292 | return False | |
224 |
|
293 | |||
225 | lines = block.split('\n') |
|
294 | lines = block.split('\n') | |
226 | return (len(lines)==1 or str(lines[-1])=='') |
|
295 | return (len(lines)==1 or str(lines[-1])=='') | |
227 |
|
296 | |||
228 |
|
297 | |||
229 | def compile_ast(self, block): |
|
298 | def compile_ast(self, block): | |
230 | """Compile block to an AST |
|
299 | """Compile block to an AST | |
231 |
|
300 | |||
232 | Parameters: |
|
301 | Parameters: | |
233 | block : str |
|
302 | block : str | |
234 |
|
303 | |||
235 | Result: |
|
304 | Result: | |
236 | AST |
|
305 | AST | |
237 |
|
306 | |||
238 | Throws: |
|
307 | Throws: | |
239 | Exception if block cannot be compiled |
|
308 | Exception if block cannot be compiled | |
240 | """ |
|
309 | """ | |
241 |
|
310 | |||
242 | return compile(block, "<string>", "exec", _ast.PyCF_ONLY_AST) |
|
311 | return compile(block, "<string>", "exec", _ast.PyCF_ONLY_AST) | |
243 |
|
312 | |||
244 |
|
313 | |||
245 | def execute(self, block, blockID=None): |
|
314 | def execute(self, block, blockID=None): | |
246 | """Execute the block and return the result. |
|
315 | """Execute the block and return the result. | |
247 |
|
316 | |||
248 | Parameters: |
|
317 | Parameters: | |
249 | block : {str, AST} |
|
318 | block : {str, AST} | |
250 | blockID : any |
|
319 | blockID : any | |
251 | Caller may provide an ID to identify this block. |
|
320 | Caller may provide an ID to identify this block. | |
252 | result['blockID'] := blockID |
|
321 | result['blockID'] := blockID | |
253 |
|
322 | |||
254 | Result: |
|
323 | Result: | |
255 | Deferred result of self.interpreter.execute |
|
324 | Deferred result of self.interpreter.execute | |
256 | """ |
|
325 | """ | |
257 |
|
326 | |||
258 | if(not self.is_complete(block)): |
|
327 | if(not self.is_complete(block)): | |
259 | raise Exception("Block is not compilable") |
|
328 | raise Exception("Block is not compilable") | |
260 |
|
329 | |||
261 | if(blockID == None): |
|
330 | if(blockID == None): | |
262 | blockID = uuid.uuid4() #random UUID |
|
331 | blockID = uuid.uuid4() #random UUID | |
263 |
|
332 | |||
264 | try: |
|
333 | try: | |
265 | result = self.shell.execute(block) |
|
334 | result = self.shell.execute(block) | |
266 | except Exception,e: |
|
335 | except Exception,e: | |
267 | e = self._add_block_id_for_failure(e, blockID=blockID) |
|
336 | e = self._add_block_id_for_failure(e, blockID=blockID) | |
268 | e = self.update_cell_prompt(e, blockID=blockID) |
|
337 | e = self.update_cell_prompt(e, blockID=blockID) | |
269 | e = self.render_error(e) |
|
338 | e = self.render_error(e) | |
270 | else: |
|
339 | else: | |
271 | result = self._add_block_id_for_result(result, blockID=blockID) |
|
340 | result = self._add_block_id_for_result(result, blockID=blockID) | |
272 | result = self.update_cell_prompt(result, blockID=blockID) |
|
341 | result = self.update_cell_prompt(result, blockID=blockID) | |
273 | result = self.render_result(result) |
|
342 | result = self.render_result(result) | |
274 |
|
343 | |||
275 | return result |
|
344 | return result | |
276 |
|
345 | |||
277 |
|
346 | |||
278 | def _add_block_id_for_result(self, result, blockID): |
|
347 | def _add_block_id_for_result(self, result, blockID): | |
279 | """Add the blockID to result or failure. Unfortunatley, we have to |
|
348 | """Add the blockID to result or failure. Unfortunatley, we have to | |
280 | treat failures differently than result dicts. |
|
349 | treat failures differently than result dicts. | |
281 | """ |
|
350 | """ | |
282 |
|
351 | |||
283 | result['blockID'] = blockID |
|
352 | result['blockID'] = blockID | |
284 |
|
353 | |||
285 | return result |
|
354 | return result | |
286 |
|
355 | |||
287 | def _add_block_id_for_failure(self, failure, blockID): |
|
356 | def _add_block_id_for_failure(self, failure, blockID): | |
288 | """_add_block_id_for_failure""" |
|
357 | """_add_block_id_for_failure""" | |
289 | failure.blockID = blockID |
|
358 | failure.blockID = blockID | |
290 | return failure |
|
359 | return failure | |
291 |
|
360 | |||
292 |
|
361 | |||
293 | def _add_history(self, result, block=None): |
|
362 | def _add_history(self, result, block=None): | |
294 | """Add block to the history""" |
|
363 | """Add block to the history""" | |
295 |
|
364 | |||
296 | assert(block != None) |
|
365 | assert(block != None) | |
297 | self.history.add_items([block]) |
|
366 | self.history.add_items([block]) | |
298 | self.history_cursor += 1 |
|
367 | self.history_cursor += 1 | |
299 |
|
368 | |||
300 | return result |
|
369 | return result | |
301 |
|
370 | |||
302 |
|
371 | |||
303 | def get_history_previous(self, current_block): |
|
372 | def get_history_previous(self, current_block): | |
304 | """ Returns previous history string and decrement history cursor. |
|
373 | """ Returns previous history string and decrement history cursor. | |
305 | """ |
|
374 | """ | |
306 | command = self.history.get_history_item(self.history_cursor - 1) |
|
375 | command = self.history.get_history_item(self.history_cursor - 1) | |
307 |
|
376 | |||
308 | if command is not None: |
|
377 | if command is not None: | |
309 | if(self.history_cursor+1 == len(self.history.input_cache)): |
|
378 | if(self.history_cursor+1 == len(self.history.input_cache)): | |
310 | self.history.input_cache[self.history_cursor] = current_block |
|
379 | self.history.input_cache[self.history_cursor] = current_block | |
311 | self.history_cursor -= 1 |
|
380 | self.history_cursor -= 1 | |
312 | return command |
|
381 | return command | |
313 |
|
382 | |||
314 |
|
383 | |||
315 | def get_history_next(self): |
|
384 | def get_history_next(self): | |
316 | """ Returns next history string and increment history cursor. |
|
385 | """ Returns next history string and increment history cursor. | |
317 | """ |
|
386 | """ | |
318 | command = self.history.get_history_item(self.history_cursor+1) |
|
387 | command = self.history.get_history_item(self.history_cursor+1) | |
319 |
|
388 | |||
320 | if command is not None: |
|
389 | if command is not None: | |
321 | self.history_cursor += 1 |
|
390 | self.history_cursor += 1 | |
322 | return command |
|
391 | return command | |
323 |
|
392 | |||
324 | ### |
|
393 | ### | |
325 | # Subclasses probably want to override these methods... |
|
394 | # Subclasses probably want to override these methods... | |
326 | ### |
|
395 | ### | |
327 |
|
396 | |||
328 | def update_cell_prompt(self, result, blockID=None): |
|
397 | def update_cell_prompt(self, result, blockID=None): | |
329 | """Subclass may override to update the input prompt for a block. |
|
398 | """Subclass may override to update the input prompt for a block. | |
330 |
|
399 | |||
331 | This method only really makes sens in asyncrhonous frontend. |
|
400 | This method only really makes sens in asyncrhonous frontend. | |
332 | Since this method will be called as a |
|
401 | Since this method will be called as a | |
333 | twisted.internet.defer.Deferred's callback, implementations should |
|
402 | twisted.internet.defer.Deferred's callback, implementations should | |
334 | return result when finished. |
|
403 | return result when finished. | |
335 | """ |
|
404 | """ | |
336 |
|
405 | |||
337 | raise NotImplementedError |
|
406 | raise NotImplementedError | |
338 |
|
407 | |||
339 |
|
408 | |||
340 | def render_result(self, result): |
|
409 | def render_result(self, result): | |
341 | """Subclasses must override to render result. |
|
410 | """Subclasses must override to render result. | |
342 |
|
411 | |||
343 | In asynchronous frontends, this method will be called as a |
|
412 | In asynchronous frontends, this method will be called as a | |
344 | twisted.internet.defer.Deferred's callback. Implementations |
|
413 | twisted.internet.defer.Deferred's callback. Implementations | |
345 | should thus return result when finished. |
|
414 | should thus return result when finished. | |
346 | """ |
|
415 | """ | |
347 |
|
416 | |||
348 | raise NotImplementedError |
|
417 | raise NotImplementedError | |
349 |
|
418 | |||
350 |
|
419 | |||
351 | def render_error(self, failure): |
|
420 | def render_error(self, failure): | |
352 | """Subclasses must override to render the failure. |
|
421 | """Subclasses must override to render the failure. | |
353 |
|
422 | |||
354 | In asynchronous frontends, this method will be called as a |
|
423 | In asynchronous frontends, this method will be called as a | |
355 | twisted.internet.defer.Deferred's callback. Implementations |
|
424 | twisted.internet.defer.Deferred's callback. Implementations | |
356 | should thus return result when finished. |
|
425 | should thus return result when finished. | |
357 | """ |
|
426 | """ | |
358 |
|
427 | |||
359 | raise NotImplementedError |
|
428 | raise NotImplementedError | |
360 |
|
429 |
@@ -1,320 +1,333 b'' | |||||
1 | """ |
|
1 | """ | |
2 | Base front end class for all line-oriented frontends, rather than |
|
2 | Base front end class for all line-oriented frontends, rather than | |
3 | block-oriented. |
|
3 | block-oriented. | |
4 |
|
4 | |||
5 | Currently this focuses on synchronous frontends. |
|
5 | Currently this focuses on synchronous frontends. | |
6 | """ |
|
6 | """ | |
7 | __docformat__ = "restructuredtext en" |
|
7 | __docformat__ = "restructuredtext en" | |
8 |
|
8 | |||
9 | #------------------------------------------------------------------------------- |
|
9 | #------------------------------------------------------------------------------- | |
10 | # Copyright (C) 2008 The IPython Development Team |
|
10 | # Copyright (C) 2008 The IPython Development Team | |
11 | # |
|
11 | # | |
12 | # Distributed under the terms of the BSD License. The full license is in |
|
12 | # Distributed under the terms of the BSD License. The full license is in | |
13 | # the file COPYING, distributed as part of this software. |
|
13 | # the file COPYING, distributed as part of this software. | |
14 | #------------------------------------------------------------------------------- |
|
14 | #------------------------------------------------------------------------------- | |
15 |
|
15 | |||
16 | #------------------------------------------------------------------------------- |
|
16 | #------------------------------------------------------------------------------- | |
17 | # Imports |
|
17 | # Imports | |
18 | #------------------------------------------------------------------------------- |
|
18 | #------------------------------------------------------------------------------- | |
19 | import re |
|
19 | import re | |
20 |
|
20 | |||
21 | import IPython |
|
21 | import IPython | |
22 | import sys |
|
22 | import sys | |
23 | import codeop |
|
23 | import codeop | |
24 | import traceback |
|
24 | import traceback | |
25 |
|
25 | |||
26 | from frontendbase import FrontEndBase |
|
26 | from frontendbase import FrontEndBase | |
27 | from IPython.kernel.core.interpreter import Interpreter |
|
27 | from IPython.kernel.core.interpreter import Interpreter | |
28 |
|
28 | |||
29 | def common_prefix(strings): |
|
29 | def common_prefix(strings): | |
30 | """ Given a list of strings, return the common prefix between all |
|
30 | """ Given a list of strings, return the common prefix between all | |
31 | these strings. |
|
31 | these strings. | |
32 | """ |
|
32 | """ | |
33 | ref = strings[0] |
|
33 | ref = strings[0] | |
34 | prefix = '' |
|
34 | prefix = '' | |
35 | for size in range(len(ref)): |
|
35 | for size in range(len(ref)): | |
36 | test_prefix = ref[:size+1] |
|
36 | test_prefix = ref[:size+1] | |
37 | for string in strings[1:]: |
|
37 | for string in strings[1:]: | |
38 | if not string.startswith(test_prefix): |
|
38 | if not string.startswith(test_prefix): | |
39 | return prefix |
|
39 | return prefix | |
40 | prefix = test_prefix |
|
40 | prefix = test_prefix | |
41 |
|
41 | |||
42 | return prefix |
|
42 | return prefix | |
43 |
|
43 | |||
44 | #------------------------------------------------------------------------------- |
|
44 | #------------------------------------------------------------------------------- | |
45 | # Base class for the line-oriented front ends |
|
45 | # Base class for the line-oriented front ends | |
46 | #------------------------------------------------------------------------------- |
|
46 | #------------------------------------------------------------------------------- | |
47 | class LineFrontEndBase(FrontEndBase): |
|
47 | class LineFrontEndBase(FrontEndBase): | |
48 | """ Concrete implementation of the FrontEndBase class. This is meant |
|
48 | """ Concrete implementation of the FrontEndBase class. This is meant | |
49 | to be the base class behind all the frontend that are line-oriented, |
|
49 | to be the base class behind all the frontend that are line-oriented, | |
50 | rather than block-oriented. |
|
50 | rather than block-oriented. | |
51 | """ |
|
51 | """ | |
52 |
|
52 | |||
53 | # We need to keep the prompt number, to be able to increment |
|
53 | # We need to keep the prompt number, to be able to increment | |
54 | # it when there is an exception. |
|
54 | # it when there is an exception. | |
55 | prompt_number = 1 |
|
55 | prompt_number = 1 | |
56 |
|
56 | |||
57 | # We keep a reference to the last result: it helps testing and |
|
57 | # We keep a reference to the last result: it helps testing and | |
58 | # programatic control of the frontend. |
|
58 | # programatic control of the frontend. | |
59 | last_result = dict(number=0) |
|
59 | last_result = dict(number=0) | |
60 |
|
60 | |||
61 | # The input buffer being edited |
|
61 | # The input buffer being edited | |
62 | input_buffer = '' |
|
62 | input_buffer = '' | |
63 |
|
63 | |||
64 | # Set to true for debug output |
|
64 | # Set to true for debug output | |
65 | debug = False |
|
65 | debug = False | |
66 |
|
66 | |||
67 | # A banner to print at startup |
|
67 | # A banner to print at startup | |
68 | banner = None |
|
68 | banner = None | |
69 |
|
69 | |||
70 | #-------------------------------------------------------------------------- |
|
70 | #-------------------------------------------------------------------------- | |
71 | # FrontEndBase interface |
|
71 | # FrontEndBase interface | |
72 | #-------------------------------------------------------------------------- |
|
72 | #-------------------------------------------------------------------------- | |
73 |
|
73 | |||
74 | def __init__(self, shell=None, history=None, banner=None, *args, **kwargs): |
|
74 | def __init__(self, shell=None, history=None, banner=None, *args, **kwargs): | |
75 | if shell is None: |
|
75 | if shell is None: | |
76 | shell = Interpreter() |
|
76 | shell = Interpreter() | |
77 | FrontEndBase.__init__(self, shell=shell, history=history) |
|
77 | FrontEndBase.__init__(self, shell=shell, history=history) | |
78 |
|
78 | |||
79 | if banner is not None: |
|
79 | if banner is not None: | |
80 | self.banner = banner |
|
80 | self.banner = banner | |
81 |
|
81 | |||
82 | def start(self): |
|
82 | def start(self): | |
83 | """ Put the frontend in a state where it is ready for user |
|
83 | """ Put the frontend in a state where it is ready for user | |
84 | interaction. |
|
84 | interaction. | |
85 | """ |
|
85 | """ | |
86 | if self.banner is not None: |
|
86 | if self.banner is not None: | |
87 | self.write(self.banner, refresh=False) |
|
87 | self.write(self.banner, refresh=False) | |
88 |
|
88 | |||
89 | self.new_prompt(self.input_prompt_template.substitute(number=1)) |
|
89 | self.new_prompt(self.input_prompt_template.substitute(number=1)) | |
90 |
|
90 | |||
91 |
|
91 | |||
92 | def complete(self, line): |
|
92 | def complete(self, line): | |
93 | """Complete line in engine's user_ns |
|
93 | """Complete line in engine's user_ns | |
94 |
|
94 | |||
95 | Parameters |
|
95 | Parameters | |
96 | ---------- |
|
96 | ---------- | |
97 | line : string |
|
97 | line : string | |
98 |
|
98 | |||
99 | Result |
|
99 | Result | |
100 | ------ |
|
100 | ------ | |
101 | The replacement for the line and the list of possible completions. |
|
101 | The replacement for the line and the list of possible completions. | |
102 | """ |
|
102 | """ | |
103 | completions = self.shell.complete(line) |
|
103 | completions = self.shell.complete(line) | |
104 | complete_sep = re.compile('[\s\{\}\[\]\(\)\=]') |
|
104 | complete_sep = re.compile('[\s\{\}\[\]\(\)\=]') | |
105 | if completions: |
|
105 | if completions: | |
106 | prefix = common_prefix(completions) |
|
106 | prefix = common_prefix(completions) | |
107 | residual = complete_sep.split(line)[:-1] |
|
107 | residual = complete_sep.split(line)[:-1] | |
108 | line = line[:-len(residual)] + prefix |
|
108 | line = line[:-len(residual)] + prefix | |
109 | return line, completions |
|
109 | return line, completions | |
110 |
|
110 | |||
111 |
|
111 | |||
112 | def render_result(self, result): |
|
112 | def render_result(self, result): | |
113 | """ Frontend-specific rendering of the result of a calculation |
|
113 | """ Frontend-specific rendering of the result of a calculation | |
114 | that has been sent to an engine. |
|
114 | that has been sent to an engine. | |
115 | """ |
|
115 | """ | |
116 | if 'stdout' in result and result['stdout']: |
|
116 | if 'stdout' in result and result['stdout']: | |
117 | self.write('\n' + result['stdout']) |
|
117 | self.write('\n' + result['stdout']) | |
118 | if 'display' in result and result['display']: |
|
118 | if 'display' in result and result['display']: | |
119 | self.write("%s%s\n" % ( |
|
119 | self.write("%s%s\n" % ( | |
120 | self.output_prompt_template.substitute( |
|
120 | self.output_prompt_template.substitute( | |
121 | number=result['number']), |
|
121 | number=result['number']), | |
122 | result['display']['pprint'] |
|
122 | result['display']['pprint'] | |
123 | ) ) |
|
123 | ) ) | |
124 |
|
124 | |||
125 |
|
125 | |||
126 | def render_error(self, failure): |
|
126 | def render_error(self, failure): | |
127 | """ Frontend-specific rendering of error. |
|
127 | """ Frontend-specific rendering of error. | |
128 | """ |
|
128 | """ | |
129 | self.write('\n\n'+str(failure)+'\n\n') |
|
129 | self.write('\n\n'+str(failure)+'\n\n') | |
130 | return failure |
|
130 | return failure | |
131 |
|
131 | |||
132 |
|
132 | |||
133 | def is_complete(self, string): |
|
133 | def is_complete(self, string): | |
134 | """ Check if a string forms a complete, executable set of |
|
134 | """ Check if a string forms a complete, executable set of | |
135 | commands. |
|
135 | commands. | |
136 |
|
136 | |||
137 | For the line-oriented frontend, multi-line code is not executed |
|
137 | For the line-oriented frontend, multi-line code is not executed | |
138 | as soon as it is complete: the users has to enter two line |
|
138 | as soon as it is complete: the users has to enter two line | |
139 | returns. |
|
139 | returns. | |
140 | """ |
|
140 | """ | |
141 | if string in ('', '\n'): |
|
141 | if string in ('', '\n'): | |
142 | # Prefiltering, eg through ipython0, may return an empty |
|
142 | # Prefiltering, eg through ipython0, may return an empty | |
143 | # string although some operations have been accomplished. We |
|
143 | # string although some operations have been accomplished. We | |
144 | # thus want to consider an empty string as a complete |
|
144 | # thus want to consider an empty string as a complete | |
145 | # statement. |
|
145 | # statement. | |
146 | return True |
|
146 | return True | |
147 | elif ( len(self.input_buffer.split('\n'))>2 |
|
147 | elif ( len(self.input_buffer.split('\n'))>2 | |
148 | and not re.findall(r"\n[\t ]*\n[\t ]*$", string)): |
|
148 | and not re.findall(r"\n[\t ]*\n[\t ]*$", string)): | |
149 | return False |
|
149 | return False | |
150 | else: |
|
150 | else: | |
151 | self.capture_output() |
|
151 | self.capture_output() | |
152 | try: |
|
152 | try: | |
153 | # Add line returns here, to make sure that the statement is |
|
153 | # Add line returns here, to make sure that the statement is | |
154 | # complete. |
|
154 | # complete. | |
155 | is_complete = codeop.compile_command(string.rstrip() + '\n\n', |
|
155 | is_complete = codeop.compile_command(string.rstrip() + '\n\n', | |
156 | "<string>", "exec") |
|
156 | "<string>", "exec") | |
157 | self.release_output() |
|
157 | self.release_output() | |
158 | except Exception, e: |
|
158 | except Exception, e: | |
159 | # XXX: Hack: return True so that the |
|
159 | # XXX: Hack: return True so that the | |
160 | # code gets executed and the error captured. |
|
160 | # code gets executed and the error captured. | |
161 | is_complete = True |
|
161 | is_complete = True | |
162 | return is_complete |
|
162 | return is_complete | |
163 |
|
163 | |||
164 |
|
164 | |||
165 | def write(self, string, refresh=True): |
|
165 | def write(self, string, refresh=True): | |
166 | """ Write some characters to the display. |
|
166 | """ Write some characters to the display. | |
167 |
|
167 | |||
168 | Subclass should overide this method. |
|
168 | Subclass should overide this method. | |
169 |
|
169 | |||
170 | The refresh keyword argument is used in frontends with an |
|
170 | The refresh keyword argument is used in frontends with an | |
171 | event loop, to choose whether the write should trigget an UI |
|
171 | event loop, to choose whether the write should trigget an UI | |
172 | refresh, and thus be syncrhonous, or not. |
|
172 | refresh, and thus be syncrhonous, or not. | |
173 | """ |
|
173 | """ | |
174 | print >>sys.__stderr__, string |
|
174 | print >>sys.__stderr__, string | |
175 |
|
175 | |||
176 |
|
176 | |||
177 | def execute(self, python_string, raw_string=None): |
|
177 | def execute(self, python_string, raw_string=None): | |
178 | """ Stores the raw_string in the history, and sends the |
|
178 | """ Stores the raw_string in the history, and sends the | |
179 | python string to the interpreter. |
|
179 | python string to the interpreter. | |
180 | """ |
|
180 | """ | |
181 | if raw_string is None: |
|
181 | if raw_string is None: | |
182 | raw_string = python_string |
|
182 | raw_string = python_string | |
183 | # Create a false result, in case there is an exception |
|
183 | # Create a false result, in case there is an exception | |
184 | self.last_result = dict(number=self.prompt_number) |
|
184 | self.last_result = dict(number=self.prompt_number) | |
|
185 | ||||
|
186 | ## try: | |||
|
187 | ## self.history.input_cache[-1] = raw_string.rstrip() | |||
|
188 | ## result = self.shell.execute(python_string) | |||
|
189 | ## self.last_result = result | |||
|
190 | ## self.render_result(result) | |||
|
191 | ## except: | |||
|
192 | ## self.show_traceback() | |||
|
193 | ## finally: | |||
|
194 | ## self.after_execute() | |||
|
195 | ||||
185 | try: |
|
196 | try: | |
186 | self.history.input_cache[-1] = raw_string.rstrip() |
|
197 | try: | |
187 | result = self.shell.execute(python_string) |
|
198 | self.history.input_cache[-1] = raw_string.rstrip() | |
188 | self.last_result = result |
|
199 | result = self.shell.execute(python_string) | |
189 |
self. |
|
200 | self.last_result = result | |
190 | except: |
|
201 | self.render_result(result) | |
191 | self.show_traceback() |
|
202 | except: | |
|
203 | self.show_traceback() | |||
192 | finally: |
|
204 | finally: | |
193 | self.after_execute() |
|
205 | self.after_execute() | |
194 |
|
206 | |||
|
207 | ||||
195 | #-------------------------------------------------------------------------- |
|
208 | #-------------------------------------------------------------------------- | |
196 | # LineFrontEndBase interface |
|
209 | # LineFrontEndBase interface | |
197 | #-------------------------------------------------------------------------- |
|
210 | #-------------------------------------------------------------------------- | |
198 |
|
211 | |||
199 | def prefilter_input(self, string): |
|
212 | def prefilter_input(self, string): | |
200 | """ Prefilter the input to turn it in valid python. |
|
213 | """ Prefilter the input to turn it in valid python. | |
201 | """ |
|
214 | """ | |
202 | string = string.replace('\r\n', '\n') |
|
215 | string = string.replace('\r\n', '\n') | |
203 | string = string.replace('\t', 4*' ') |
|
216 | string = string.replace('\t', 4*' ') | |
204 | # Clean the trailing whitespace |
|
217 | # Clean the trailing whitespace | |
205 | string = '\n'.join(l.rstrip() for l in string.split('\n')) |
|
218 | string = '\n'.join(l.rstrip() for l in string.split('\n')) | |
206 | return string |
|
219 | return string | |
207 |
|
220 | |||
208 |
|
221 | |||
209 | def after_execute(self): |
|
222 | def after_execute(self): | |
210 | """ All the operations required after an execution to put the |
|
223 | """ All the operations required after an execution to put the | |
211 | terminal back in a shape where it is usable. |
|
224 | terminal back in a shape where it is usable. | |
212 | """ |
|
225 | """ | |
213 | self.prompt_number += 1 |
|
226 | self.prompt_number += 1 | |
214 | self.new_prompt(self.input_prompt_template.substitute( |
|
227 | self.new_prompt(self.input_prompt_template.substitute( | |
215 | number=(self.last_result['number'] + 1))) |
|
228 | number=(self.last_result['number'] + 1))) | |
216 | # Start a new empty history entry |
|
229 | # Start a new empty history entry | |
217 | self._add_history(None, '') |
|
230 | self._add_history(None, '') | |
218 | self.history_cursor = len(self.history.input_cache) - 1 |
|
231 | self.history_cursor = len(self.history.input_cache) - 1 | |
219 |
|
232 | |||
220 |
|
233 | |||
221 | def complete_current_input(self): |
|
234 | def complete_current_input(self): | |
222 | """ Do code completion on current line. |
|
235 | """ Do code completion on current line. | |
223 | """ |
|
236 | """ | |
224 | if self.debug: |
|
237 | if self.debug: | |
225 | print >>sys.__stdout__, "complete_current_input", |
|
238 | print >>sys.__stdout__, "complete_current_input", | |
226 | line = self.input_buffer |
|
239 | line = self.input_buffer | |
227 | new_line, completions = self.complete(line) |
|
240 | new_line, completions = self.complete(line) | |
228 | if len(completions)>1: |
|
241 | if len(completions)>1: | |
229 | self.write_completion(completions, new_line=new_line) |
|
242 | self.write_completion(completions, new_line=new_line) | |
230 | elif not line == new_line: |
|
243 | elif not line == new_line: | |
231 | self.input_buffer = new_line |
|
244 | self.input_buffer = new_line | |
232 | if self.debug: |
|
245 | if self.debug: | |
233 | print >>sys.__stdout__, 'line', line |
|
246 | print >>sys.__stdout__, 'line', line | |
234 | print >>sys.__stdout__, 'new_line', new_line |
|
247 | print >>sys.__stdout__, 'new_line', new_line | |
235 | print >>sys.__stdout__, completions |
|
248 | print >>sys.__stdout__, completions | |
236 |
|
249 | |||
237 |
|
250 | |||
238 | def get_line_width(self): |
|
251 | def get_line_width(self): | |
239 | """ Return the width of the line in characters. |
|
252 | """ Return the width of the line in characters. | |
240 | """ |
|
253 | """ | |
241 | return 80 |
|
254 | return 80 | |
242 |
|
255 | |||
243 |
|
256 | |||
244 | def write_completion(self, possibilities, new_line=None): |
|
257 | def write_completion(self, possibilities, new_line=None): | |
245 | """ Write the list of possible completions. |
|
258 | """ Write the list of possible completions. | |
246 |
|
259 | |||
247 | new_line is the completed input line that should be displayed |
|
260 | new_line is the completed input line that should be displayed | |
248 | after the completion are writen. If None, the input_buffer |
|
261 | after the completion are writen. If None, the input_buffer | |
249 | before the completion is used. |
|
262 | before the completion is used. | |
250 | """ |
|
263 | """ | |
251 | if new_line is None: |
|
264 | if new_line is None: | |
252 | new_line = self.input_buffer |
|
265 | new_line = self.input_buffer | |
253 |
|
266 | |||
254 | self.write('\n') |
|
267 | self.write('\n') | |
255 | max_len = len(max(possibilities, key=len)) + 1 |
|
268 | max_len = len(max(possibilities, key=len)) + 1 | |
256 |
|
269 | |||
257 | # Now we check how much symbol we can put on a line... |
|
270 | # Now we check how much symbol we can put on a line... | |
258 | chars_per_line = self.get_line_width() |
|
271 | chars_per_line = self.get_line_width() | |
259 | symbols_per_line = max(1, chars_per_line/max_len) |
|
272 | symbols_per_line = max(1, chars_per_line/max_len) | |
260 |
|
273 | |||
261 | pos = 1 |
|
274 | pos = 1 | |
262 | buf = [] |
|
275 | buf = [] | |
263 | for symbol in possibilities: |
|
276 | for symbol in possibilities: | |
264 | if pos < symbols_per_line: |
|
277 | if pos < symbols_per_line: | |
265 | buf.append(symbol.ljust(max_len)) |
|
278 | buf.append(symbol.ljust(max_len)) | |
266 | pos += 1 |
|
279 | pos += 1 | |
267 | else: |
|
280 | else: | |
268 | buf.append(symbol.rstrip() + '\n') |
|
281 | buf.append(symbol.rstrip() + '\n') | |
269 | pos = 1 |
|
282 | pos = 1 | |
270 | self.write(''.join(buf)) |
|
283 | self.write(''.join(buf)) | |
271 | self.new_prompt(self.input_prompt_template.substitute( |
|
284 | self.new_prompt(self.input_prompt_template.substitute( | |
272 | number=self.last_result['number'] + 1)) |
|
285 | number=self.last_result['number'] + 1)) | |
273 | self.input_buffer = new_line |
|
286 | self.input_buffer = new_line | |
274 |
|
287 | |||
275 |
|
288 | |||
276 | def new_prompt(self, prompt): |
|
289 | def new_prompt(self, prompt): | |
277 | """ Prints a prompt and starts a new editing buffer. |
|
290 | """ Prints a prompt and starts a new editing buffer. | |
278 |
|
291 | |||
279 | Subclasses should use this method to make sure that the |
|
292 | Subclasses should use this method to make sure that the | |
280 | terminal is put in a state favorable for a new line |
|
293 | terminal is put in a state favorable for a new line | |
281 | input. |
|
294 | input. | |
282 | """ |
|
295 | """ | |
283 | self.input_buffer = '' |
|
296 | self.input_buffer = '' | |
284 | self.write(prompt) |
|
297 | self.write(prompt) | |
285 |
|
298 | |||
286 |
|
299 | |||
287 | #-------------------------------------------------------------------------- |
|
300 | #-------------------------------------------------------------------------- | |
288 | # Private API |
|
301 | # Private API | |
289 | #-------------------------------------------------------------------------- |
|
302 | #-------------------------------------------------------------------------- | |
290 |
|
303 | |||
291 | def _on_enter(self): |
|
304 | def _on_enter(self): | |
292 | """ Called when the return key is pressed in a line editing |
|
305 | """ Called when the return key is pressed in a line editing | |
293 | buffer. |
|
306 | buffer. | |
294 | """ |
|
307 | """ | |
295 | current_buffer = self.input_buffer |
|
308 | current_buffer = self.input_buffer | |
296 | cleaned_buffer = self.prefilter_input(current_buffer) |
|
309 | cleaned_buffer = self.prefilter_input(current_buffer) | |
297 | if self.is_complete(cleaned_buffer): |
|
310 | if self.is_complete(cleaned_buffer): | |
298 | self.execute(cleaned_buffer, raw_string=current_buffer) |
|
311 | self.execute(cleaned_buffer, raw_string=current_buffer) | |
299 | else: |
|
312 | else: | |
300 | self.input_buffer += self._get_indent_string( |
|
313 | self.input_buffer += self._get_indent_string( | |
301 | current_buffer[:-1]) |
|
314 | current_buffer[:-1]) | |
302 | if len(current_buffer.split('\n')) == 2: |
|
315 | if len(current_buffer.split('\n')) == 2: | |
303 | self.input_buffer += '\t\t' |
|
316 | self.input_buffer += '\t\t' | |
304 | if current_buffer[:-1].split('\n')[-1].rstrip().endswith(':'): |
|
317 | if current_buffer[:-1].split('\n')[-1].rstrip().endswith(':'): | |
305 | self.input_buffer += '\t' |
|
318 | self.input_buffer += '\t' | |
306 |
|
319 | |||
307 |
|
320 | |||
308 | def _get_indent_string(self, string): |
|
321 | def _get_indent_string(self, string): | |
309 | """ Return the string of whitespace that prefixes a line. Used to |
|
322 | """ Return the string of whitespace that prefixes a line. Used to | |
310 | add the right amount of indendation when creating a new line. |
|
323 | add the right amount of indendation when creating a new line. | |
311 | """ |
|
324 | """ | |
312 | string = string.replace('\t', ' '*4) |
|
325 | string = string.replace('\t', ' '*4) | |
313 | string = string.split('\n')[-1] |
|
326 | string = string.split('\n')[-1] | |
314 | indent_chars = len(string) - len(string.lstrip()) |
|
327 | indent_chars = len(string) - len(string.lstrip()) | |
315 | indent_string = '\t'*(indent_chars // 4) + \ |
|
328 | indent_string = '\t'*(indent_chars // 4) + \ | |
316 | ' '*(indent_chars % 4) |
|
329 | ' '*(indent_chars % 4) | |
317 |
|
330 | |||
318 | return indent_string |
|
331 | return indent_string | |
319 |
|
332 | |||
320 |
|
333 |
@@ -1,230 +1,246 b'' | |||||
1 | """ |
|
1 | """ | |
2 | Frontend class that uses IPython0 to prefilter the inputs. |
|
2 | Frontend class that uses IPython0 to prefilter the inputs. | |
3 |
|
3 | |||
4 | Using the IPython0 mechanism gives us access to the magics. |
|
4 | Using the IPython0 mechanism gives us access to the magics. | |
5 |
|
5 | |||
6 | This is a transitory class, used here to do the transition between |
|
6 | This is a transitory class, used here to do the transition between | |
7 | ipython0 and ipython1. This class is meant to be short-lived as more |
|
7 | ipython0 and ipython1. This class is meant to be short-lived as more | |
8 | functionnality is abstracted out of ipython0 in reusable functions and |
|
8 | functionnality is abstracted out of ipython0 in reusable functions and | |
9 | is added on the interpreter. This class can be a used to guide this |
|
9 | is added on the interpreter. This class can be a used to guide this | |
10 | refactoring. |
|
10 | refactoring. | |
11 | """ |
|
11 | """ | |
12 | __docformat__ = "restructuredtext en" |
|
12 | __docformat__ = "restructuredtext en" | |
13 |
|
13 | |||
14 | #------------------------------------------------------------------------------- |
|
14 | #------------------------------------------------------------------------------- | |
15 | # Copyright (C) 2008 The IPython Development Team |
|
15 | # Copyright (C) 2008 The IPython Development Team | |
16 | # |
|
16 | # | |
17 | # Distributed under the terms of the BSD License. The full license is in |
|
17 | # Distributed under the terms of the BSD License. The full license is in | |
18 | # the file COPYING, distributed as part of this software. |
|
18 | # the file COPYING, distributed as part of this software. | |
19 | #------------------------------------------------------------------------------- |
|
19 | #------------------------------------------------------------------------------- | |
20 |
|
20 | |||
21 | #------------------------------------------------------------------------------- |
|
21 | #------------------------------------------------------------------------------- | |
22 | # Imports |
|
22 | # Imports | |
23 | #------------------------------------------------------------------------------- |
|
23 | #------------------------------------------------------------------------------- | |
24 | import sys |
|
24 | import sys | |
25 |
|
25 | |||
26 | from linefrontendbase import LineFrontEndBase, common_prefix |
|
26 | from linefrontendbase import LineFrontEndBase, common_prefix | |
27 | from frontendbase import FrontEndBase |
|
27 | from frontendbase import FrontEndBase | |
28 |
|
28 | |||
29 | from IPython.ipmaker import make_IPython |
|
29 | from IPython.ipmaker import make_IPython | |
30 | from IPython.ipapi import IPApi |
|
30 | from IPython.ipapi import IPApi | |
31 | from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap |
|
31 | from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap | |
32 |
|
32 | |||
33 | from IPython.kernel.core.sync_traceback_trap import SyncTracebackTrap |
|
33 | from IPython.kernel.core.sync_traceback_trap import SyncTracebackTrap | |
34 |
|
34 | |||
35 | from IPython.genutils import Term |
|
35 | from IPython.genutils import Term | |
36 | import pydoc |
|
36 | import pydoc | |
37 | import os |
|
37 | import os | |
38 | import sys |
|
38 | import sys | |
39 |
|
39 | |||
40 |
|
40 | |||
41 | def mk_system_call(system_call_function, command): |
|
41 | def mk_system_call(system_call_function, command): | |
42 | """ given a os.system replacement, and a leading string command, |
|
42 | """ given a os.system replacement, and a leading string command, | |
43 | returns a function that will execute the command with the given |
|
43 | returns a function that will execute the command with the given | |
44 | argument string. |
|
44 | argument string. | |
45 | """ |
|
45 | """ | |
46 | def my_system_call(args): |
|
46 | def my_system_call(args): | |
47 | system_call_function("%s %s" % (command, args)) |
|
47 | system_call_function("%s %s" % (command, args)) | |
48 | return my_system_call |
|
48 | return my_system_call | |
49 |
|
49 | |||
50 | #------------------------------------------------------------------------------- |
|
50 | #------------------------------------------------------------------------------- | |
51 | # Frontend class using ipython0 to do the prefiltering. |
|
51 | # Frontend class using ipython0 to do the prefiltering. | |
52 | #------------------------------------------------------------------------------- |
|
52 | #------------------------------------------------------------------------------- | |
53 | class PrefilterFrontEnd(LineFrontEndBase): |
|
53 | class PrefilterFrontEnd(LineFrontEndBase): | |
54 | """ Class that uses ipython0 to do prefilter the input, do the |
|
54 | """ Class that uses ipython0 to do prefilter the input, do the | |
55 | completion and the magics. |
|
55 | completion and the magics. | |
56 |
|
56 | |||
57 | The core trick is to use an ipython0 instance to prefilter the |
|
57 | The core trick is to use an ipython0 instance to prefilter the | |
58 | input, and share the namespace between the interpreter instance used |
|
58 | input, and share the namespace between the interpreter instance used | |
59 | to execute the statements and the ipython0 used for code |
|
59 | to execute the statements and the ipython0 used for code | |
60 | completion... |
|
60 | completion... | |
61 | """ |
|
61 | """ | |
62 |
|
62 | |||
63 | debug = False |
|
63 | debug = False | |
64 |
|
64 | |||
65 | def __init__(self, ipython0=None, *args, **kwargs): |
|
65 | def __init__(self, ipython0=None, *args, **kwargs): | |
66 | """ Parameters: |
|
66 | """ Parameters: | |
67 | ----------- |
|
67 | ----------- | |
68 |
|
68 | |||
69 | ipython0: an optional ipython0 instance to use for command |
|
69 | ipython0: an optional ipython0 instance to use for command | |
70 | prefiltering and completion. |
|
70 | prefiltering and completion. | |
71 | """ |
|
71 | """ | |
72 | LineFrontEndBase.__init__(self, *args, **kwargs) |
|
72 | LineFrontEndBase.__init__(self, *args, **kwargs) | |
73 | self.shell.output_trap = RedirectorOutputTrap( |
|
73 | self.shell.output_trap = RedirectorOutputTrap( | |
74 | out_callback=self.write, |
|
74 | out_callback=self.write, | |
75 | err_callback=self.write, |
|
75 | err_callback=self.write, | |
76 | ) |
|
76 | ) | |
77 | self.shell.traceback_trap = SyncTracebackTrap( |
|
77 | self.shell.traceback_trap = SyncTracebackTrap( | |
78 | formatters=self.shell.traceback_trap.formatters, |
|
78 | formatters=self.shell.traceback_trap.formatters, | |
79 | ) |
|
79 | ) | |
80 |
|
80 | |||
81 | # Start the ipython0 instance: |
|
81 | # Start the ipython0 instance: | |
82 | self.save_output_hooks() |
|
82 | self.save_output_hooks() | |
83 | if ipython0 is None: |
|
83 | if ipython0 is None: | |
84 | # Instanciate an IPython0 interpreter to be able to use the |
|
84 | # Instanciate an IPython0 interpreter to be able to use the | |
85 | # prefiltering. |
|
85 | # prefiltering. | |
86 | # XXX: argv=[] is a bit bold. |
|
86 | # XXX: argv=[] is a bit bold. | |
87 | ipython0 = make_IPython(argv=[], |
|
87 | ipython0 = make_IPython(argv=[], | |
88 | user_ns=self.shell.user_ns, |
|
88 | user_ns=self.shell.user_ns, | |
89 | user_global_ns=self.shell.user_global_ns) |
|
89 | user_global_ns=self.shell.user_global_ns) | |
90 | self.ipython0 = ipython0 |
|
90 | self.ipython0 = ipython0 | |
91 | # Set the pager: |
|
91 | # Set the pager: | |
92 | self.ipython0.set_hook('show_in_pager', |
|
92 | self.ipython0.set_hook('show_in_pager', | |
93 | lambda s, string: self.write("\n" + string)) |
|
93 | lambda s, string: self.write("\n" + string)) | |
94 | self.ipython0.write = self.write |
|
94 | self.ipython0.write = self.write | |
95 | self._ip = _ip = IPApi(self.ipython0) |
|
95 | self._ip = _ip = IPApi(self.ipython0) | |
96 | # Make sure the raw system call doesn't get called, as we don't |
|
96 | # Make sure the raw system call doesn't get called, as we don't | |
97 | # have a stdin accessible. |
|
97 | # have a stdin accessible. | |
98 | self._ip.system = self.system_call |
|
98 | self._ip.system = self.system_call | |
99 | # XXX: Muck around with magics so that they work better |
|
99 | # XXX: Muck around with magics so that they work better | |
100 | # in our environment |
|
100 | # in our environment | |
101 | self.ipython0.magic_ls = mk_system_call(self.system_call, |
|
101 | self.ipython0.magic_ls = mk_system_call(self.system_call, | |
102 | 'ls -CF') |
|
102 | 'ls -CF') | |
103 | # And now clean up the mess created by ipython0 |
|
103 | # And now clean up the mess created by ipython0 | |
104 | self.release_output() |
|
104 | self.release_output() | |
105 |
|
105 | |||
106 |
|
106 | |||
107 | if not 'banner' in kwargs and self.banner is None: |
|
107 | if not 'banner' in kwargs and self.banner is None: | |
108 | self.banner = self.ipython0.BANNER + """ |
|
108 | self.banner = self.ipython0.BANNER + """ | |
109 | This is the wx frontend, by Gael Varoquaux. This is EXPERIMENTAL code.""" |
|
109 | This is the wx frontend, by Gael Varoquaux. This is EXPERIMENTAL code.""" | |
110 |
|
110 | |||
111 | self.start() |
|
111 | self.start() | |
112 |
|
112 | |||
113 | #-------------------------------------------------------------------------- |
|
113 | #-------------------------------------------------------------------------- | |
114 | # FrontEndBase interface |
|
114 | # FrontEndBase interface | |
115 | #-------------------------------------------------------------------------- |
|
115 | #-------------------------------------------------------------------------- | |
116 |
|
116 | |||
117 | def show_traceback(self): |
|
117 | def show_traceback(self): | |
118 | """ Use ipython0 to capture the last traceback and display it. |
|
118 | """ Use ipython0 to capture the last traceback and display it. | |
119 | """ |
|
119 | """ | |
120 | self.capture_output() |
|
120 | self.capture_output() | |
121 | self.ipython0.showtraceback(tb_offset=-1) |
|
121 | self.ipython0.showtraceback(tb_offset=-1) | |
122 | self.release_output() |
|
122 | self.release_output() | |
123 |
|
123 | |||
124 |
|
124 | |||
125 | def execute(self, python_string, raw_string=None): |
|
125 | def execute(self, python_string, raw_string=None): | |
126 | if self.debug: |
|
126 | if self.debug: | |
127 | print 'Executing Python code:', repr(python_string) |
|
127 | print 'Executing Python code:', repr(python_string) | |
128 | self.capture_output() |
|
128 | self.capture_output() | |
129 | LineFrontEndBase.execute(self, python_string, |
|
129 | LineFrontEndBase.execute(self, python_string, | |
130 | raw_string=raw_string) |
|
130 | raw_string=raw_string) | |
131 | self.release_output() |
|
131 | self.release_output() | |
132 |
|
132 | |||
133 |
|
133 | |||
134 | def save_output_hooks(self): |
|
134 | def save_output_hooks(self): | |
135 | """ Store all the output hooks we can think of, to be able to |
|
135 | """ Store all the output hooks we can think of, to be able to | |
136 | restore them. |
|
136 | restore them. | |
137 |
|
137 | |||
138 | We need to do this early, as starting the ipython0 instance will |
|
138 | We need to do this early, as starting the ipython0 instance will | |
139 | screw ouput hooks. |
|
139 | screw ouput hooks. | |
140 | """ |
|
140 | """ | |
141 | self.__old_cout_write = Term.cout.write |
|
141 | self.__old_cout_write = Term.cout.write | |
142 | self.__old_cerr_write = Term.cerr.write |
|
142 | self.__old_cerr_write = Term.cerr.write | |
143 | self.__old_stdout = sys.stdout |
|
143 | self.__old_stdout = sys.stdout | |
144 | self.__old_stderr= sys.stderr |
|
144 | self.__old_stderr= sys.stderr | |
145 | self.__old_help_output = pydoc.help.output |
|
145 | self.__old_help_output = pydoc.help.output | |
146 | self.__old_display_hook = sys.displayhook |
|
146 | self.__old_display_hook = sys.displayhook | |
147 |
|
147 | |||
148 |
|
148 | |||
149 | def capture_output(self): |
|
149 | def capture_output(self): | |
150 | """ Capture all the output mechanisms we can think of. |
|
150 | """ Capture all the output mechanisms we can think of. | |
151 | """ |
|
151 | """ | |
152 | self.save_output_hooks() |
|
152 | self.save_output_hooks() | |
153 | Term.cout.write = self.write |
|
153 | Term.cout.write = self.write | |
154 | Term.cerr.write = self.write |
|
154 | Term.cerr.write = self.write | |
155 | sys.stdout = Term.cout |
|
155 | sys.stdout = Term.cout | |
156 | sys.stderr = Term.cerr |
|
156 | sys.stderr = Term.cerr | |
157 | pydoc.help.output = self.shell.output_trap.out |
|
157 | pydoc.help.output = self.shell.output_trap.out | |
158 |
|
158 | |||
159 |
|
159 | |||
160 | def release_output(self): |
|
160 | def release_output(self): | |
161 | """ Release all the different captures we have made. |
|
161 | """ Release all the different captures we have made. | |
162 | """ |
|
162 | """ | |
163 | Term.cout.write = self.__old_cout_write |
|
163 | Term.cout.write = self.__old_cout_write | |
164 | Term.cerr.write = self.__old_cerr_write |
|
164 | Term.cerr.write = self.__old_cerr_write | |
165 | sys.stdout = self.__old_stdout |
|
165 | sys.stdout = self.__old_stdout | |
166 | sys.stderr = self.__old_stderr |
|
166 | sys.stderr = self.__old_stderr | |
167 | pydoc.help.output = self.__old_help_output |
|
167 | pydoc.help.output = self.__old_help_output | |
168 | sys.displayhook = self.__old_display_hook |
|
168 | sys.displayhook = self.__old_display_hook | |
169 |
|
169 | |||
170 |
|
170 | |||
171 | def complete(self, line): |
|
171 | def complete(self, line): | |
172 | # FIXME: This should be factored out in the linefrontendbase |
|
172 | # FIXME: This should be factored out in the linefrontendbase | |
173 | # method. |
|
173 | # method. | |
174 | word = line.split('\n')[-1].split(' ')[-1] |
|
174 | word = line.split('\n')[-1].split(' ')[-1] | |
175 | completions = self.ipython0.complete(word) |
|
175 | completions = self.ipython0.complete(word) | |
176 | # FIXME: The proper sort should be done in the complete method. |
|
176 | # FIXME: The proper sort should be done in the complete method. | |
177 | key = lambda x: x.replace('_', '') |
|
177 | key = lambda x: x.replace('_', '') | |
178 | completions.sort(key=key) |
|
178 | completions.sort(key=key) | |
179 | if completions: |
|
179 | if completions: | |
180 | prefix = common_prefix(completions) |
|
180 | prefix = common_prefix(completions) | |
181 | line = line[:-len(word)] + prefix |
|
181 | line = line[:-len(word)] + prefix | |
182 | return line, completions |
|
182 | return line, completions | |
183 |
|
183 | |||
184 |
|
184 | |||
185 | #-------------------------------------------------------------------------- |
|
185 | #-------------------------------------------------------------------------- | |
186 | # LineFrontEndBase interface |
|
186 | # LineFrontEndBase interface | |
187 | #-------------------------------------------------------------------------- |
|
187 | #-------------------------------------------------------------------------- | |
188 |
|
188 | |||
189 | def prefilter_input(self, input_string): |
|
189 | def prefilter_input(self, input_string): | |
190 | """ Using IPython0 to prefilter the commands to turn them |
|
190 | """ Using IPython0 to prefilter the commands to turn them | |
191 | in executable statements that are valid Python strings. |
|
191 | in executable statements that are valid Python strings. | |
192 | """ |
|
192 | """ | |
193 | input_string = LineFrontEndBase.prefilter_input(self, input_string) |
|
193 | input_string = LineFrontEndBase.prefilter_input(self, input_string) | |
194 | filtered_lines = [] |
|
194 | filtered_lines = [] | |
195 | # The IPython0 prefilters sometime produce output. We need to |
|
195 | # The IPython0 prefilters sometime produce output. We need to | |
196 | # capture it. |
|
196 | # capture it. | |
197 | self.capture_output() |
|
197 | self.capture_output() | |
198 | self.last_result = dict(number=self.prompt_number) |
|
198 | self.last_result = dict(number=self.prompt_number) | |
|
199 | ||||
|
200 | ## try: | |||
|
201 | ## for line in input_string.split('\n'): | |||
|
202 | ## filtered_lines.append( | |||
|
203 | ## self.ipython0.prefilter(line, False).rstrip()) | |||
|
204 | ## except: | |||
|
205 | ## # XXX: probably not the right thing to do. | |||
|
206 | ## self.ipython0.showsyntaxerror() | |||
|
207 | ## self.after_execute() | |||
|
208 | ## finally: | |||
|
209 | ## self.release_output() | |||
|
210 | ||||
|
211 | ||||
199 | try: |
|
212 | try: | |
200 | for line in input_string.split('\n'): |
|
213 | try: | |
201 | filtered_lines.append( |
|
214 | for line in input_string.split('\n'): | |
202 | self.ipython0.prefilter(line, False).rstrip()) |
|
215 | filtered_lines.append( | |
203 | except: |
|
216 | self.ipython0.prefilter(line, False).rstrip()) | |
204 | # XXX: probably not the right thing to do. |
|
217 | except: | |
205 | self.ipython0.showsyntaxerror() |
|
218 | # XXX: probably not the right thing to do. | |
206 | self.after_execute() |
|
219 | self.ipython0.showsyntaxerror() | |
|
220 | self.after_execute() | |||
207 | finally: |
|
221 | finally: | |
208 | self.release_output() |
|
222 | self.release_output() | |
209 |
|
223 | |||
|
224 | ||||
|
225 | ||||
210 | # Clean up the trailing whitespace, to avoid indentation errors |
|
226 | # Clean up the trailing whitespace, to avoid indentation errors | |
211 | filtered_string = '\n'.join(filtered_lines) |
|
227 | filtered_string = '\n'.join(filtered_lines) | |
212 | return filtered_string |
|
228 | return filtered_string | |
213 |
|
229 | |||
214 |
|
230 | |||
215 | #-------------------------------------------------------------------------- |
|
231 | #-------------------------------------------------------------------------- | |
216 | # PrefilterFrontEnd interface |
|
232 | # PrefilterFrontEnd interface | |
217 | #-------------------------------------------------------------------------- |
|
233 | #-------------------------------------------------------------------------- | |
218 |
|
234 | |||
219 | def system_call(self, command_string): |
|
235 | def system_call(self, command_string): | |
220 | """ Allows for frontend to define their own system call, to be |
|
236 | """ Allows for frontend to define their own system call, to be | |
221 | able capture output and redirect input. |
|
237 | able capture output and redirect input. | |
222 | """ |
|
238 | """ | |
223 | return os.system(command_string) |
|
239 | return os.system(command_string) | |
224 |
|
240 | |||
225 |
|
241 | |||
226 | def do_exit(self): |
|
242 | def do_exit(self): | |
227 | """ Exit the shell, cleanup and save the history. |
|
243 | """ Exit the shell, cleanup and save the history. | |
228 | """ |
|
244 | """ | |
229 | self.ipython0.atexit_operations() |
|
245 | self.ipython0.atexit_operations() | |
230 |
|
246 |
@@ -1,143 +1,141 b'' | |||||
1 | # encoding: utf-8 |
|
1 | # encoding: utf-8 | |
2 | # -*- test-case-name: IPython.kernel.test.test_contexts -*- |
|
2 | # -*- test-case-name: IPython.kernel.test.test_contexts -*- | |
3 | """Context managers for IPython. |
|
3 | """Context managers for IPython. | |
4 |
|
4 | |||
5 | Python 2.5 introduced the `with` statement, which is based on the context |
|
5 | Python 2.5 introduced the `with` statement, which is based on the context | |
6 | manager protocol. This module offers a few context managers for common cases, |
|
6 | manager protocol. This module offers a few context managers for common cases, | |
7 | which can also be useful as templates for writing new, application-specific |
|
7 | which can also be useful as templates for writing new, application-specific | |
8 | managers. |
|
8 | managers. | |
9 | """ |
|
9 | """ | |
10 |
|
10 | |||
11 | from __future__ import with_statement |
|
|||
12 |
|
||||
13 | __docformat__ = "restructuredtext en" |
|
11 | __docformat__ = "restructuredtext en" | |
14 |
|
12 | |||
15 | #------------------------------------------------------------------------------- |
|
13 | #------------------------------------------------------------------------------- | |
16 | # Copyright (C) 2008 The IPython Development Team |
|
14 | # Copyright (C) 2008 The IPython Development Team | |
17 | # |
|
15 | # | |
18 | # Distributed under the terms of the BSD License. The full license is in |
|
16 | # Distributed under the terms of the BSD License. The full license is in | |
19 | # the file COPYING, distributed as part of this software. |
|
17 | # the file COPYING, distributed as part of this software. | |
20 | #------------------------------------------------------------------------------- |
|
18 | #------------------------------------------------------------------------------- | |
21 |
|
19 | |||
22 | #------------------------------------------------------------------------------- |
|
20 | #------------------------------------------------------------------------------- | |
23 | # Imports |
|
21 | # Imports | |
24 | #------------------------------------------------------------------------------- |
|
22 | #------------------------------------------------------------------------------- | |
25 |
|
23 | |||
26 | import linecache |
|
24 | import linecache | |
27 | import sys |
|
25 | import sys | |
28 |
|
26 | |||
29 | from twisted.internet.error import ConnectionRefusedError |
|
27 | from twisted.internet.error import ConnectionRefusedError | |
30 |
|
28 | |||
31 | from IPython.ultraTB import _fixed_getinnerframes, findsource |
|
29 | from IPython.ultraTB import _fixed_getinnerframes, findsource | |
32 | from IPython import ipapi |
|
30 | from IPython import ipapi | |
33 |
|
31 | |||
34 | from IPython.kernel import error |
|
32 | from IPython.kernel import error | |
35 |
|
33 | |||
36 | #--------------------------------------------------------------------------- |
|
34 | #--------------------------------------------------------------------------- | |
37 | # Utility functions needed by all context managers. |
|
35 | # Utility functions needed by all context managers. | |
38 | #--------------------------------------------------------------------------- |
|
36 | #--------------------------------------------------------------------------- | |
39 |
|
37 | |||
40 | def remote(): |
|
38 | def remote(): | |
41 | """Raises a special exception meant to be caught by context managers. |
|
39 | """Raises a special exception meant to be caught by context managers. | |
42 | """ |
|
40 | """ | |
43 | m = 'Special exception to stop local execution of parallel code.' |
|
41 | m = 'Special exception to stop local execution of parallel code.' | |
44 | raise error.StopLocalExecution(m) |
|
42 | raise error.StopLocalExecution(m) | |
45 |
|
43 | |||
46 |
|
44 | |||
47 | def strip_whitespace(source,require_remote=True): |
|
45 | def strip_whitespace(source,require_remote=True): | |
48 | """strip leading whitespace from input source. |
|
46 | """strip leading whitespace from input source. | |
49 |
|
47 | |||
50 | :Parameters: |
|
48 | :Parameters: | |
51 |
|
49 | |||
52 | """ |
|
50 | """ | |
53 | remote_mark = 'remote()' |
|
51 | remote_mark = 'remote()' | |
54 | # Expand tabs to avoid any confusion. |
|
52 | # Expand tabs to avoid any confusion. | |
55 | wsource = [l.expandtabs(4) for l in source] |
|
53 | wsource = [l.expandtabs(4) for l in source] | |
56 | # Detect the indentation level |
|
54 | # Detect the indentation level | |
57 | done = False |
|
55 | done = False | |
58 | for line in wsource: |
|
56 | for line in wsource: | |
59 | if line.isspace(): |
|
57 | if line.isspace(): | |
60 | continue |
|
58 | continue | |
61 | for col,char in enumerate(line): |
|
59 | for col,char in enumerate(line): | |
62 | if char != ' ': |
|
60 | if char != ' ': | |
63 | done = True |
|
61 | done = True | |
64 | break |
|
62 | break | |
65 | if done: |
|
63 | if done: | |
66 | break |
|
64 | break | |
67 | # Now we know how much leading space there is in the code. Next, we |
|
65 | # Now we know how much leading space there is in the code. Next, we | |
68 | # extract up to the first line that has less indentation. |
|
66 | # extract up to the first line that has less indentation. | |
69 | # WARNINGS: we skip comments that may be misindented, but we do NOT yet |
|
67 | # WARNINGS: we skip comments that may be misindented, but we do NOT yet | |
70 | # detect triple quoted strings that may have flush left text. |
|
68 | # detect triple quoted strings that may have flush left text. | |
71 | for lno,line in enumerate(wsource): |
|
69 | for lno,line in enumerate(wsource): | |
72 | lead = line[:col] |
|
70 | lead = line[:col] | |
73 | if lead.isspace(): |
|
71 | if lead.isspace(): | |
74 | continue |
|
72 | continue | |
75 | else: |
|
73 | else: | |
76 | if not lead.lstrip().startswith('#'): |
|
74 | if not lead.lstrip().startswith('#'): | |
77 | break |
|
75 | break | |
78 | # The real 'with' source is up to lno |
|
76 | # The real 'with' source is up to lno | |
79 | src_lines = [l[col:] for l in wsource[:lno+1]] |
|
77 | src_lines = [l[col:] for l in wsource[:lno+1]] | |
80 |
|
78 | |||
81 | # Finally, check that the source's first non-comment line begins with the |
|
79 | # Finally, check that the source's first non-comment line begins with the | |
82 | # special call 'remote()' |
|
80 | # special call 'remote()' | |
83 | if require_remote: |
|
81 | if require_remote: | |
84 | for nline,line in enumerate(src_lines): |
|
82 | for nline,line in enumerate(src_lines): | |
85 | if line.isspace() or line.startswith('#'): |
|
83 | if line.isspace() or line.startswith('#'): | |
86 | continue |
|
84 | continue | |
87 | if line.startswith(remote_mark): |
|
85 | if line.startswith(remote_mark): | |
88 | break |
|
86 | break | |
89 | else: |
|
87 | else: | |
90 | raise ValueError('%s call missing at the start of code' % |
|
88 | raise ValueError('%s call missing at the start of code' % | |
91 | remote_mark) |
|
89 | remote_mark) | |
92 | out_lines = src_lines[nline+1:] |
|
90 | out_lines = src_lines[nline+1:] | |
93 | else: |
|
91 | else: | |
94 | # If the user specified that the remote() call wasn't mandatory |
|
92 | # If the user specified that the remote() call wasn't mandatory | |
95 | out_lines = src_lines |
|
93 | out_lines = src_lines | |
96 |
|
94 | |||
97 | # src = ''.join(out_lines) # dbg |
|
95 | # src = ''.join(out_lines) # dbg | |
98 | #print 'SRC:\n<<<<<<<>>>>>>>\n%s<<<<<>>>>>>' % src # dbg |
|
96 | #print 'SRC:\n<<<<<<<>>>>>>>\n%s<<<<<>>>>>>' % src # dbg | |
99 | return ''.join(out_lines) |
|
97 | return ''.join(out_lines) | |
100 |
|
98 | |||
101 | class RemoteContextBase(object): |
|
99 | class RemoteContextBase(object): | |
102 | def __init__(self): |
|
100 | def __init__(self): | |
103 | self.ip = ipapi.get() |
|
101 | self.ip = ipapi.get() | |
104 |
|
102 | |||
105 | def _findsource_file(self,f): |
|
103 | def _findsource_file(self,f): | |
106 | linecache.checkcache() |
|
104 | linecache.checkcache() | |
107 | s = findsource(f.f_code) |
|
105 | s = findsource(f.f_code) | |
108 | lnum = f.f_lineno |
|
106 | lnum = f.f_lineno | |
109 | wsource = s[0][f.f_lineno:] |
|
107 | wsource = s[0][f.f_lineno:] | |
110 | return strip_whitespace(wsource) |
|
108 | return strip_whitespace(wsource) | |
111 |
|
109 | |||
112 | def _findsource_ipython(self,f): |
|
110 | def _findsource_ipython(self,f): | |
113 | from IPython import ipapi |
|
111 | from IPython import ipapi | |
114 | self.ip = ipapi.get() |
|
112 | self.ip = ipapi.get() | |
115 | buf = self.ip.IP.input_hist_raw[-1].splitlines()[1:] |
|
113 | buf = self.ip.IP.input_hist_raw[-1].splitlines()[1:] | |
116 | wsource = [l+'\n' for l in buf ] |
|
114 | wsource = [l+'\n' for l in buf ] | |
117 |
|
115 | |||
118 | return strip_whitespace(wsource) |
|
116 | return strip_whitespace(wsource) | |
119 |
|
117 | |||
120 | def findsource(self,frame): |
|
118 | def findsource(self,frame): | |
121 | local_ns = frame.f_locals |
|
119 | local_ns = frame.f_locals | |
122 | global_ns = frame.f_globals |
|
120 | global_ns = frame.f_globals | |
123 | if frame.f_code.co_filename == '<ipython console>': |
|
121 | if frame.f_code.co_filename == '<ipython console>': | |
124 | src = self._findsource_ipython(frame) |
|
122 | src = self._findsource_ipython(frame) | |
125 | else: |
|
123 | else: | |
126 | src = self._findsource_file(frame) |
|
124 | src = self._findsource_file(frame) | |
127 | return src |
|
125 | return src | |
128 |
|
126 | |||
129 | def __enter__(self): |
|
127 | def __enter__(self): | |
130 | raise NotImplementedError |
|
128 | raise NotImplementedError | |
131 |
|
129 | |||
132 | def __exit__ (self, etype, value, tb): |
|
130 | def __exit__ (self, etype, value, tb): | |
133 | if issubclass(etype,error.StopLocalExecution): |
|
131 | if issubclass(etype,error.StopLocalExecution): | |
134 | return True |
|
132 | return True | |
135 |
|
133 | |||
136 | class RemoteMultiEngine(RemoteContextBase): |
|
134 | class RemoteMultiEngine(RemoteContextBase): | |
137 | def __init__(self,mec): |
|
135 | def __init__(self,mec): | |
138 | self.mec = mec |
|
136 | self.mec = mec | |
139 | RemoteContextBase.__init__(self) |
|
137 | RemoteContextBase.__init__(self) | |
140 |
|
138 | |||
141 | def __enter__(self): |
|
139 | def __enter__(self): | |
142 | src = self.findsource(sys._getframe(1)) |
|
140 | src = self.findsource(sys._getframe(1)) | |
143 | return self.mec.execute(src) |
|
141 | return self.mec.execute(src) |
@@ -1,41 +1,43 b'' | |||||
1 | from __future__ import with_statement |
|
1 | #from __future__ import with_statement | |
|
2 | ||||
|
3 | # XXX This file is currently disabled to preserve 2.4 compatibility. | |||
2 |
|
4 | |||
3 | #def test_simple(): |
|
5 | #def test_simple(): | |
4 | if 0: |
|
6 | if 0: | |
5 |
|
7 | |||
6 | # XXX - for now, we need a running cluster to be started separately. The |
|
8 | # XXX - for now, we need a running cluster to be started separately. The | |
7 | # daemon work is almost finished, and will make much of this unnecessary. |
|
9 | # daemon work is almost finished, and will make much of this unnecessary. | |
8 | from IPython.kernel import client |
|
10 | from IPython.kernel import client | |
9 | mec = client.MultiEngineClient(('127.0.0.1',10105)) |
|
11 | mec = client.MultiEngineClient(('127.0.0.1',10105)) | |
10 |
|
12 | |||
11 | try: |
|
13 | try: | |
12 | mec.get_ids() |
|
14 | mec.get_ids() | |
13 | except ConnectionRefusedError: |
|
15 | except ConnectionRefusedError: | |
14 | import os, time |
|
16 | import os, time | |
15 | os.system('ipcluster -n 2 &') |
|
17 | os.system('ipcluster -n 2 &') | |
16 | time.sleep(2) |
|
18 | time.sleep(2) | |
17 | mec = client.MultiEngineClient(('127.0.0.1',10105)) |
|
19 | mec = client.MultiEngineClient(('127.0.0.1',10105)) | |
18 |
|
20 | |||
19 | mec.block = False |
|
21 | mec.block = False | |
20 |
|
22 | |||
21 | import itertools |
|
23 | import itertools | |
22 | c = itertools.count() |
|
24 | c = itertools.count() | |
23 |
|
25 | |||
24 | parallel = RemoteMultiEngine(mec) |
|
26 | parallel = RemoteMultiEngine(mec) | |
25 |
|
27 | |||
26 | mec.pushAll() |
|
28 | mec.pushAll() | |
27 |
|
29 | |||
28 | with parallel as pr: |
|
30 | ## with parallel as pr: | |
29 | # A comment |
|
31 | ## # A comment | |
30 | remote() # this means the code below only runs remotely |
|
32 | ## remote() # this means the code below only runs remotely | |
31 | print 'Hello remote world' |
|
33 | ## print 'Hello remote world' | |
32 | x = range(10) |
|
34 | ## x = range(10) | |
33 | # Comments are OK |
|
35 | ## # Comments are OK | |
34 | # Even misindented. |
|
36 | ## # Even misindented. | |
35 | y = x+1 |
|
37 | ## y = x+1 | |
36 |
|
38 | |||
37 |
|
39 | |||
38 | with pfor('i',sequence) as pr: |
|
40 | ## with pfor('i',sequence) as pr: | |
39 | print x[i] |
|
41 | ## print x[i] | |
40 |
|
42 | |||
41 | print pr.x + pr.y |
|
43 | print pr.x + pr.y |
@@ -1,120 +1,123 b'' | |||||
1 | """Example showing how to merge multiple remote data streams. |
|
1 | """Example showing how to merge multiple remote data streams. | |
2 | """ |
|
2 | """ | |
3 | # Slightly modified version of: |
|
3 | # Slightly modified version of: | |
4 | # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/511509 |
|
4 | # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/511509 | |
5 |
|
5 | |||
6 | import heapq |
|
6 | import heapq | |
7 | from IPython.kernel.error import CompositeError |
|
7 | from IPython.kernel.error import CompositeError | |
8 |
|
8 | |||
9 | def mergesort(list_of_lists, key=None): |
|
9 | def mergesort(list_of_lists, key=None): | |
10 | """ Perform an N-way merge operation on sorted lists. |
|
10 | """ Perform an N-way merge operation on sorted lists. | |
11 |
|
11 | |||
12 | @param list_of_lists: (really iterable of iterable) of sorted elements |
|
12 | @param list_of_lists: (really iterable of iterable) of sorted elements | |
13 | (either by naturally or by C{key}) |
|
13 | (either by naturally or by C{key}) | |
14 | @param key: specify sort key function (like C{sort()}, C{sorted()}) |
|
14 | @param key: specify sort key function (like C{sort()}, C{sorted()}) | |
15 |
|
15 | |||
16 | Yields tuples of the form C{(item, iterator)}, where the iterator is the |
|
16 | Yields tuples of the form C{(item, iterator)}, where the iterator is the | |
17 | built-in list iterator or something you pass in, if you pre-generate the |
|
17 | built-in list iterator or something you pass in, if you pre-generate the | |
18 | iterators. |
|
18 | iterators. | |
19 |
|
19 | |||
20 | This is a stable merge; complexity O(N lg N) |
|
20 | This is a stable merge; complexity O(N lg N) | |
21 |
|
21 | |||
22 | Examples:: |
|
22 | Examples:: | |
23 |
|
23 | |||
24 | >>> print list(mergesort([[1,2,3,4], |
|
24 | >>> print list(mergesort([[1,2,3,4], | |
25 | ... [2,3.25,3.75,4.5,6,7], |
|
25 | ... [2,3.25,3.75,4.5,6,7], | |
26 | ... [2.625,3.625,6.625,9]])) |
|
26 | ... [2.625,3.625,6.625,9]])) | |
27 | [1, 2, 2, 2.625, 3, 3.25, 3.625, 3.75, 4, 4.5, 6, 6.625, 7, 9] |
|
27 | [1, 2, 2, 2.625, 3, 3.25, 3.625, 3.75, 4, 4.5, 6, 6.625, 7, 9] | |
28 |
|
28 | |||
29 | # note stability |
|
29 | # note stability | |
30 | >>> print list(mergesort([[1,2,3,4], |
|
30 | >>> print list(mergesort([[1,2,3,4], | |
31 | ... [2,3.25,3.75,4.5,6,7], |
|
31 | ... [2,3.25,3.75,4.5,6,7], | |
32 | ... [2.625,3.625,6.625,9]], |
|
32 | ... [2.625,3.625,6.625,9]], | |
33 | ... key=int)) |
|
33 | ... key=int)) | |
34 | [1, 2, 2, 2.625, 3, 3.25, 3.75, 3.625, 4, 4.5, 6, 6.625, 7, 9] |
|
34 | [1, 2, 2, 2.625, 3, 3.25, 3.75, 3.625, 4, 4.5, 6, 6.625, 7, 9] | |
35 |
|
35 | |||
36 |
|
36 | |||
37 | >>> print list(mergesort([[4, 3, 2, 1], |
|
37 | >>> print list(mergesort([[4, 3, 2, 1], | |
38 | ... [7, 6, 4.5, 3.75, 3.25, 2], |
|
38 | ... [7, 6, 4.5, 3.75, 3.25, 2], | |
39 | ... [9, 6.625, 3.625, 2.625]], |
|
39 | ... [9, 6.625, 3.625, 2.625]], | |
40 | ... key=lambda x: -x)) |
|
40 | ... key=lambda x: -x)) | |
41 | [9, 7, 6.625, 6, 4.5, 4, 3.75, 3.625, 3.25, 3, 2.625, 2, 2, 1] |
|
41 | [9, 7, 6.625, 6, 4.5, 4, 3.75, 3.625, 3.25, 3, 2.625, 2, 2, 1] | |
42 | """ |
|
42 | """ | |
43 |
|
43 | |||
44 | heap = [] |
|
44 | heap = [] | |
45 | for i, itr in enumerate(iter(pl) for pl in list_of_lists): |
|
45 | for i, itr in enumerate(iter(pl) for pl in list_of_lists): | |
46 | try: |
|
46 | try: | |
47 | item = itr.next() |
|
47 | item = itr.next() | |
48 | toadd = (key(item), i, item, itr) if key else (item, i, itr) |
|
48 | if key: | |
|
49 | toadd = (key(item), i, item, itr) | |||
|
50 | else: | |||
|
51 | toadd = (item, i, itr) | |||
49 | heap.append(toadd) |
|
52 | heap.append(toadd) | |
50 | except StopIteration: |
|
53 | except StopIteration: | |
51 | pass |
|
54 | pass | |
52 | heapq.heapify(heap) |
|
55 | heapq.heapify(heap) | |
53 |
|
56 | |||
54 | if key: |
|
57 | if key: | |
55 | while heap: |
|
58 | while heap: | |
56 | _, idx, item, itr = heap[0] |
|
59 | _, idx, item, itr = heap[0] | |
57 | yield item |
|
60 | yield item | |
58 | try: |
|
61 | try: | |
59 | item = itr.next() |
|
62 | item = itr.next() | |
60 | heapq.heapreplace(heap, (key(item), idx, item, itr) ) |
|
63 | heapq.heapreplace(heap, (key(item), idx, item, itr) ) | |
61 | except StopIteration: |
|
64 | except StopIteration: | |
62 | heapq.heappop(heap) |
|
65 | heapq.heappop(heap) | |
63 |
|
66 | |||
64 | else: |
|
67 | else: | |
65 | while heap: |
|
68 | while heap: | |
66 | item, idx, itr = heap[0] |
|
69 | item, idx, itr = heap[0] | |
67 | yield item |
|
70 | yield item | |
68 | try: |
|
71 | try: | |
69 | heapq.heapreplace(heap, (itr.next(), idx, itr)) |
|
72 | heapq.heapreplace(heap, (itr.next(), idx, itr)) | |
70 | except StopIteration: |
|
73 | except StopIteration: | |
71 | heapq.heappop(heap) |
|
74 | heapq.heappop(heap) | |
72 |
|
75 | |||
73 |
|
76 | |||
74 | def remote_iterator(rc,engine,name): |
|
77 | def remote_iterator(rc,engine,name): | |
75 | """Return an iterator on an object living on a remote engine. |
|
78 | """Return an iterator on an object living on a remote engine. | |
76 | """ |
|
79 | """ | |
77 | # Check that the object exists on the engine and pin a reference to it |
|
80 | # Check that the object exists on the engine and pin a reference to it | |
78 | iter_name = '_%s_rmt_iter_' % name |
|
81 | iter_name = '_%s_rmt_iter_' % name | |
79 | rc.execute('%s = iter(%s)' % (iter_name,name), targets=engine) |
|
82 | rc.execute('%s = iter(%s)' % (iter_name,name), targets=engine) | |
80 | tpl = '_tmp = %s.next()' % iter_name |
|
83 | tpl = '_tmp = %s.next()' % iter_name | |
81 | while True: |
|
84 | while True: | |
82 | try: |
|
85 | try: | |
83 | rc.execute(tpl, targets=engine) |
|
86 | rc.execute(tpl, targets=engine) | |
84 | result = rc.pull('_tmp', targets=engine)[0] |
|
87 | result = rc.pull('_tmp', targets=engine)[0] | |
85 | # This causes the StopIteration exception to be raised. |
|
88 | # This causes the StopIteration exception to be raised. | |
86 | except CompositeError, e: |
|
89 | except CompositeError, e: | |
87 | e.raise_exception() |
|
90 | e.raise_exception() | |
88 | else: |
|
91 | else: | |
89 | yield result |
|
92 | yield result | |
90 |
|
93 | |||
91 | # Main, interactive testing |
|
94 | # Main, interactive testing | |
92 | if __name__ == '__main__': |
|
95 | if __name__ == '__main__': | |
93 |
|
96 | |||
94 | from IPython.kernel import client |
|
97 | from IPython.kernel import client | |
95 | ipc = client.MultiEngineClient() |
|
98 | ipc = client.MultiEngineClient() | |
96 | print 'Engine IDs:',ipc.get_ids() |
|
99 | print 'Engine IDs:',ipc.get_ids() | |
97 |
|
100 | |||
98 | # Make a set of 'sorted datasets' |
|
101 | # Make a set of 'sorted datasets' | |
99 | a0 = range(5,20) |
|
102 | a0 = range(5,20) | |
100 | a1 = range(10) |
|
103 | a1 = range(10) | |
101 | a2 = range(15,25) |
|
104 | a2 = range(15,25) | |
102 |
|
105 | |||
103 | # Now, imagine these had been created in the remote engines by some long |
|
106 | # Now, imagine these had been created in the remote engines by some long | |
104 | # computation. In this simple example, we just send them over into the |
|
107 | # computation. In this simple example, we just send them over into the | |
105 | # remote engines. They will all be called 'a' in each engine. |
|
108 | # remote engines. They will all be called 'a' in each engine. | |
106 | ipc.push(dict(a=a0), targets=0) |
|
109 | ipc.push(dict(a=a0), targets=0) | |
107 | ipc.push(dict(a=a1), targets=1) |
|
110 | ipc.push(dict(a=a1), targets=1) | |
108 | ipc.push(dict(a=a2), targets=2) |
|
111 | ipc.push(dict(a=a2), targets=2) | |
109 |
|
112 | |||
110 | # And we now make a local object which represents the remote iterator |
|
113 | # And we now make a local object which represents the remote iterator | |
111 | aa0 = remote_iterator(ipc,0,'a') |
|
114 | aa0 = remote_iterator(ipc,0,'a') | |
112 | aa1 = remote_iterator(ipc,1,'a') |
|
115 | aa1 = remote_iterator(ipc,1,'a') | |
113 | aa2 = remote_iterator(ipc,2,'a') |
|
116 | aa2 = remote_iterator(ipc,2,'a') | |
114 |
|
117 | |||
115 | # Let's merge them, both locally and remotely: |
|
118 | # Let's merge them, both locally and remotely: | |
116 | print 'Merge the local datasets:' |
|
119 | print 'Merge the local datasets:' | |
117 | print list(mergesort([a0,a1,a2])) |
|
120 | print list(mergesort([a0,a1,a2])) | |
118 |
|
121 | |||
119 | print 'Locally merge the remote sets:' |
|
122 | print 'Locally merge the remote sets:' | |
120 | print list(mergesort([aa0,aa1,aa2])) |
|
123 | print list(mergesort([aa0,aa1,aa2])) |
@@ -1,252 +1,325 b'' | |||||
1 | .. _changes: |
|
1 | .. _changes: | |
2 |
|
2 | |||
3 | ========== |
|
3 | ========== | |
4 | What's new |
|
4 | What's new | |
5 | ========== |
|
5 | ========== | |
6 |
|
6 | |||
7 | .. contents:: |
|
7 | .. contents:: | |
8 | .. |
|
8 | .. | |
9 | 1 Release 0.9 |
|
9 | 1 Release 0.9 | |
10 | 1.1 New features |
|
10 | 1.1 New features | |
11 | 1.2 Bug fixes |
|
11 | 1.2 Bug fixes | |
12 | 1.3 Backwards incompatible changes |
|
12 | 1.3 Backwards incompatible changes | |
13 | 1.4 Changes merged in from IPython1 |
|
13 | 1.4 Changes merged in from IPython1 | |
14 | 1.4.1 New features |
|
14 | 1.4.1 New features | |
15 | 1.4.2 Bug fixes |
|
15 | 1.4.2 Bug fixes | |
16 | 1.4.3 Backwards incompatible changes |
|
16 | 1.4.3 Backwards incompatible changes | |
17 | 2 Release 0.8.4 |
|
17 | 2 Release 0.8.4 | |
18 |
3 Release 0.8. |
|
18 | 3 Release 0.8.3 | |
19 |
4 Release 0.8. |
|
19 | 4 Release 0.8.2 | |
20 | 5 Older releases |
|
20 | 5 Older releases | |
21 | .. |
|
21 | .. | |
22 |
|
22 | |||
23 |
|
23 | |||
24 | Release 0.9 |
|
24 | Release 0.9 | |
25 | =========== |
|
25 | =========== | |
26 |
|
26 | |||
27 | New features |
|
27 | New features | |
28 | ------------ |
|
28 | ------------ | |
29 |
|
29 | |||
|
30 | * All furl files and security certificates are now put in a read-only directory | |||
|
31 | named ~./ipython/security. | |||
|
32 | ||||
|
33 | * A single function :func:`get_ipython_dir`, in :mod:`IPython.genutils` that | |||
|
34 | determines the user's IPython directory in a robust manner. | |||
|
35 | ||||
30 | * Laurent's WX application has been given a top-level script called ipython-wx, |
|
36 | * Laurent's WX application has been given a top-level script called ipython-wx, | |
31 | and it has received numerous fixes. We expect this code to be |
|
37 | and it has received numerous fixes. We expect this code to be | |
32 | architecturally better integrated with Gael's WX 'ipython widget' over the |
|
38 | architecturally better integrated with Gael's WX 'ipython widget' over the | |
33 | next few releases. |
|
39 | next few releases. | |
34 |
|
40 | |||
35 | * The Editor synchronization work by Vivian De Smedt has been merged in. This |
|
41 | * The Editor synchronization work by Vivian De Smedt has been merged in. This | |
36 | code adds a number of new editor hooks to synchronize with editors under |
|
42 | code adds a number of new editor hooks to synchronize with editors under | |
37 | Windows. |
|
43 | Windows. | |
38 |
|
44 | |||
39 | * A new, still experimental but highly functional, WX shell by Gael Varoquaux. |
|
45 | * A new, still experimental but highly functional, WX shell by Gael Varoquaux. | |
40 | This work was sponsored by Enthought, and while it's still very new, it is |
|
46 | This work was sponsored by Enthought, and while it's still very new, it is | |
41 | based on a more cleanly organized arhictecture of the various IPython |
|
47 | based on a more cleanly organized arhictecture of the various IPython | |
42 | components. We will continue to develop this over the next few releases as a |
|
48 | components. We will continue to develop this over the next few releases as a | |
43 | model for GUI components that use IPython. |
|
49 | model for GUI components that use IPython. | |
44 |
|
50 | |||
45 | * Another GUI frontend, Cocoa based (Cocoa is the OSX native GUI framework), |
|
51 | * Another GUI frontend, Cocoa based (Cocoa is the OSX native GUI framework), | |
46 | authored by Barry Wark. Currently the WX and the Cocoa ones have slightly |
|
52 | authored by Barry Wark. Currently the WX and the Cocoa ones have slightly | |
47 | different internal organizations, but the whole team is working on finding |
|
53 | different internal organizations, but the whole team is working on finding | |
48 | what the right abstraction points are for a unified codebase. |
|
54 | what the right abstraction points are for a unified codebase. | |
49 |
|
55 | |||
50 | * As part of the frontend work, Barry Wark also implemented an experimental |
|
56 | * As part of the frontend work, Barry Wark also implemented an experimental | |
51 | event notification system that various ipython components can use. In the |
|
57 | event notification system that various ipython components can use. In the | |
52 | next release the implications and use patterns of this system regarding the |
|
58 | next release the implications and use patterns of this system regarding the | |
53 | various GUI options will be worked out. |
|
59 | various GUI options will be worked out. | |
54 |
|
60 | |||
55 | * IPython finally has a full test system, that can test docstrings with |
|
61 | * IPython finally has a full test system, that can test docstrings with | |
56 | IPython-specific functionality. There are still a few pieces missing for it |
|
62 | IPython-specific functionality. There are still a few pieces missing for it | |
57 | to be widely accessible to all users (so they can run the test suite at any |
|
63 | to be widely accessible to all users (so they can run the test suite at any | |
58 | time and report problems), but it now works for the developers. We are |
|
64 | time and report problems), but it now works for the developers. We are | |
59 | working hard on continuing to improve it, as this was probably IPython's |
|
65 | working hard on continuing to improve it, as this was probably IPython's | |
60 | major Achilles heel (the lack of proper test coverage made it effectively |
|
66 | major Achilles heel (the lack of proper test coverage made it effectively | |
61 | impossible to do large-scale refactoring). |
|
67 | impossible to do large-scale refactoring). The full test suite can now | |
62 |
|
68 | be run using the :command:`iptest` command line program. | ||
63 | * The notion of a task has been completely reworked. An `ITask` interface has |
|
69 | ||
64 | been created. This interface defines the methods that tasks need to implement. |
|
70 | * The notion of a task has been completely reworked. An `ITask` interface has | |
65 | These methods are now responsible for things like submitting tasks and processing |
|
71 | been created. This interface defines the methods that tasks need to | |
66 | results. There are two basic task types: :class:`IPython.kernel.task.StringTask` |
|
72 | implement. These methods are now responsible for things like submitting | |
67 | (this is the old `Task` object, but renamed) and the new |
|
73 | tasks and processing results. There are two basic task types: | |
68 |
|
|
74 | :class:`IPython.kernel.task.StringTask` (this is the old `Task` object, but | |
69 | * A new interface, :class:`IPython.kernel.mapper.IMapper` has been defined to |
|
75 | renamed) and the new :class:`IPython.kernel.task.MapTask`, which is based on | |
70 | standardize the idea of a `map` method. This interface has a single |
|
76 | a function. | |
71 | `map` method that has the same syntax as the built-in `map`. We have also defined |
|
77 | ||
72 | a `mapper` factory interface that creates objects that implement |
|
78 | * A new interface, :class:`IPython.kernel.mapper.IMapper` has been defined to | |
73 | :class:`IPython.kernel.mapper.IMapper` for different controllers. Both |
|
79 | standardize the idea of a `map` method. This interface has a single `map` | |
74 | the multiengine and task controller now have mapping capabilties. |
|
80 | method that has the same syntax as the built-in `map`. We have also defined | |
75 | * The parallel function capabilities have been reworks. The major changes are that |
|
81 | a `mapper` factory interface that creates objects that implement | |
76 | i) there is now an `@parallel` magic that creates parallel functions, ii) |
|
82 | :class:`IPython.kernel.mapper.IMapper` for different controllers. Both the | |
77 | the syntax for mulitple variable follows that of `map`, iii) both the |
|
83 | multiengine and task controller now have mapping capabilties. | |
78 | multiengine and task controller now have a parallel function implementation. |
|
84 | ||
79 | * All of the parallel computing capabilities from `ipython1-dev` have been merged into |
|
85 | * The parallel function capabilities have been reworks. The major changes are | |
80 | IPython proper. This resulted in the following new subpackages: |
|
86 | that i) there is now an `@parallel` magic that creates parallel functions, | |
81 | :mod:`IPython.kernel`, :mod:`IPython.kernel.core`, :mod:`IPython.config`, |
|
87 | ii) the syntax for mulitple variable follows that of `map`, iii) both the | |
82 | :mod:`IPython.tools` and :mod:`IPython.testing`. |
|
88 | multiengine and task controller now have a parallel function implementation. | |
83 | * As part of merging in the `ipython1-dev` stuff, the `setup.py` script and friends |
|
89 | ||
84 | have been completely refactored. Now we are checking for dependencies using |
|
90 | * All of the parallel computing capabilities from `ipython1-dev` have been | |
85 | the approach that matplotlib uses. |
|
91 | merged into IPython proper. This resulted in the following new subpackages: | |
86 | * The documentation has been completely reorganized to accept the documentation |
|
92 | :mod:`IPython.kernel`, :mod:`IPython.kernel.core`, :mod:`IPython.config`, | |
87 | from `ipython1-dev`. |
|
93 | :mod:`IPython.tools` and :mod:`IPython.testing`. | |
88 | * We have switched to using Foolscap for all of our network protocols in |
|
94 | ||
89 | :mod:`IPython.kernel`. This gives us secure connections that are both encrypted |
|
95 | * As part of merging in the `ipython1-dev` stuff, the `setup.py` script and | |
90 | and authenticated. |
|
96 | friends have been completely refactored. Now we are checking for | |
91 | * We have a brand new `COPYING.txt` files that describes the IPython license |
|
97 | dependencies using the approach that matplotlib uses. | |
92 | and copyright. The biggest change is that we are putting "The IPython |
|
98 | ||
93 | Development Team" as the copyright holder. We give more details about exactly |
|
99 | * The documentation has been completely reorganized to accept the documentation | |
94 | what this means in this file. All developer should read this and use the new |
|
100 | from `ipython1-dev`. | |
95 | banner in all IPython source code files. |
|
101 | ||
96 | * sh profile: ./foo runs foo as system command, no need to do !./foo anymore |
|
102 | * We have switched to using Foolscap for all of our network protocols in | |
97 | * String lists now support 'sort(field, nums = True)' method (to easily |
|
103 | :mod:`IPython.kernel`. This gives us secure connections that are both | |
98 | sort system command output). Try it with 'a = !ls -l ; a.sort(1, nums=1)' |
|
104 | encrypted and authenticated. | |
99 | * '%cpaste foo' now assigns the pasted block as string list, instead of string |
|
|||
100 | * The ipcluster script now run by default with no security. This is done because |
|
|||
101 | the main usage of the script is for starting things on localhost. Eventually |
|
|||
102 | when ipcluster is able to start things on other hosts, we will put security |
|
|||
103 | back. |
|
|||
104 | * 'cd --foo' searches directory history for string foo, and jumps to that dir. |
|
|||
105 | Last part of dir name is checked first. If no matches for that are found, |
|
|||
106 | look at the whole path. |
|
|||
107 |
|
105 | |||
|
106 | * We have a brand new `COPYING.txt` files that describes the IPython license | |||
|
107 | and copyright. The biggest change is that we are putting "The IPython | |||
|
108 | Development Team" as the copyright holder. We give more details about | |||
|
109 | exactly what this means in this file. All developer should read this and use | |||
|
110 | the new banner in all IPython source code files. | |||
|
111 | ||||
|
112 | * sh profile: ./foo runs foo as system command, no need to do !./foo anymore | |||
|
113 | ||||
|
114 | * String lists now support ``sort(field, nums = True)`` method (to easily sort | |||
|
115 | system command output). Try it with ``a = !ls -l ; a.sort(1, nums=1)``. | |||
|
116 | ||||
|
117 | * '%cpaste foo' now assigns the pasted block as string list, instead of string | |||
|
118 | ||||
|
119 | * The ipcluster script now run by default with no security. This is done | |||
|
120 | because the main usage of the script is for starting things on localhost. | |||
|
121 | Eventually when ipcluster is able to start things on other hosts, we will put | |||
|
122 | security back. | |||
|
123 | ||||
|
124 | * 'cd --foo' searches directory history for string foo, and jumps to that dir. | |||
|
125 | Last part of dir name is checked first. If no matches for that are found, | |||
|
126 | look at the whole path. | |||
|
127 | ||||
|
128 | ||||
108 | Bug fixes |
|
129 | Bug fixes | |
109 | --------- |
|
130 | --------- | |
110 |
|
131 | |||
111 | * The colors escapes in the multiengine client are now turned off on win32 as they |
|
132 | * The Windows installer has been fixed. Now all IPython scripts have ``.bat`` | |
112 | don't print correctly. |
|
133 | versions created. Also, the Start Menu shortcuts have been updated. | |
113 | * The :mod:`IPython.kernel.scripts.ipengine` script was exec'ing mpi_import_statement |
|
134 | ||
114 | incorrectly, which was leading the engine to crash when mpi was enabled. |
|
135 | * The colors escapes in the multiengine client are now turned off on win32 as | |
115 | * A few subpackages has missing `__init__.py` files. |
|
136 | they don't print correctly. | |
116 | * The documentation is only created is Sphinx is found. Previously, the `setup.py` |
|
137 | ||
117 | script would fail if it was missing. |
|
138 | * The :mod:`IPython.kernel.scripts.ipengine` script was exec'ing | |
118 | * Greedy 'cd' completion has been disabled again (it was enabled in 0.8.4) |
|
139 | mpi_import_statement incorrectly, which was leading the engine to crash when | |
|
140 | mpi was enabled. | |||
|
141 | ||||
|
142 | * A few subpackages had missing ``__init__.py`` files. | |||
|
143 | ||||
|
144 | * The documentation is only created if Sphinx is found. Previously, the | |||
|
145 | ``setup.py`` script would fail if it was missing. | |||
|
146 | ||||
|
147 | * Greedy ``cd`` completion has been disabled again (it was enabled in 0.8.4) as | |||
|
148 | it caused problems on certain platforms. | |||
119 |
|
149 | |||
120 |
|
150 | |||
121 | Backwards incompatible changes |
|
151 | Backwards incompatible changes | |
122 | ------------------------------ |
|
152 | ------------------------------ | |
123 |
|
153 | |||
|
154 | * The ``clusterfile`` options of the :command:`ipcluster` command has been | |||
|
155 | removed as it was not working and it will be replaced soon by something much | |||
|
156 | more robust. | |||
|
157 | ||||
|
158 | * The :mod:`IPython.kernel` configuration now properly find the user's | |||
|
159 | IPython directory. | |||
|
160 | ||||
124 | * In ipapi, the :func:`make_user_ns` function has been replaced with |
|
161 | * In ipapi, the :func:`make_user_ns` function has been replaced with | |
125 | :func:`make_user_namespaces`, to support dict subclasses in namespace |
|
162 | :func:`make_user_namespaces`, to support dict subclasses in namespace | |
126 | creation. |
|
163 | creation. | |
127 |
|
164 | |||
128 |
|
|
165 | * :class:`IPython.kernel.client.Task` has been renamed | |
129 |
|
|
166 | :class:`IPython.kernel.client.StringTask` to make way for new task types. | |
130 | * The keyword argument `style` has been renamed `dist` in `scatter`, `gather` |
|
167 | ||
131 | and `map`. |
|
168 | * The keyword argument `style` has been renamed `dist` in `scatter`, `gather` | |
132 | * Renamed the values that the rename `dist` keyword argument can have from |
|
169 | and `map`. | |
133 | `'basic'` to `'b'`. |
|
170 | ||
134 | * IPython has a larger set of dependencies if you want all of its capabilities. |
|
171 | * Renamed the values that the rename `dist` keyword argument can have from | |
135 | See the `setup.py` script for details. |
|
172 | `'basic'` to `'b'`. | |
136 | * The constructors for :class:`IPython.kernel.client.MultiEngineClient` and |
|
173 | ||
137 | :class:`IPython.kernel.client.TaskClient` no longer take the (ip,port) tuple. |
|
174 | * IPython has a larger set of dependencies if you want all of its capabilities. | |
138 | Instead they take the filename of a file that contains the FURL for that |
|
175 | See the `setup.py` script for details. | |
139 | client. If the FURL file is in your IPYTHONDIR, it will be found automatically |
|
176 | ||
140 | and the constructor can be left empty. |
|
177 | * The constructors for :class:`IPython.kernel.client.MultiEngineClient` and | |
141 | * The asynchronous clients in :mod:`IPython.kernel.asyncclient` are now created |
|
178 | :class:`IPython.kernel.client.TaskClient` no longer take the (ip,port) tuple. | |
142 | using the factory functions :func:`get_multiengine_client` and |
|
179 | Instead they take the filename of a file that contains the FURL for that | |
143 | :func:`get_task_client`. These return a `Deferred` to the actual client. |
|
180 | client. If the FURL file is in your IPYTHONDIR, it will be found automatically | |
144 | * The command line options to `ipcontroller` and `ipengine` have changed to |
|
181 | and the constructor can be left empty. | |
145 | reflect the new Foolscap network protocol and the FURL files. Please see the |
|
182 | ||
146 | help for these scripts for details. |
|
183 | * The asynchronous clients in :mod:`IPython.kernel.asyncclient` are now created | |
147 | * The configuration files for the kernel have changed because of the Foolscap stuff. |
|
184 | using the factory functions :func:`get_multiengine_client` and | |
148 | If you were using custom config files before, you should delete them and regenerate |
|
185 | :func:`get_task_client`. These return a `Deferred` to the actual client. | |
149 | new ones. |
|
186 | ||
|
187 | * The command line options to `ipcontroller` and `ipengine` have changed to | |||
|
188 | reflect the new Foolscap network protocol and the FURL files. Please see the | |||
|
189 | help for these scripts for details. | |||
|
190 | ||||
|
191 | * The configuration files for the kernel have changed because of the Foolscap | |||
|
192 | stuff. If you were using custom config files before, you should delete them | |||
|
193 | and regenerate new ones. | |||
150 |
|
194 | |||
151 | Changes merged in from IPython1 |
|
195 | Changes merged in from IPython1 | |
152 | ------------------------------- |
|
196 | ------------------------------- | |
153 |
|
197 | |||
154 | New features |
|
198 | New features | |
155 | ............ |
|
199 | ............ | |
156 |
|
200 | |||
157 |
|
|
201 | * Much improved ``setup.py`` and ``setupegg.py`` scripts. Because Twisted and | |
158 |
|
|
202 | zope.interface are now easy installable, we can declare them as dependencies | |
159 |
|
|
203 | in our setupegg.py script. | |
160 | * IPython is now compatible with Twisted 2.5.0 and 8.x. |
|
204 | ||
161 | * Added a new example of how to use :mod:`ipython1.kernel.asynclient`. |
|
205 | * IPython is now compatible with Twisted 2.5.0 and 8.x. | |
162 | * Initial draft of a process daemon in :mod:`ipython1.daemon`. This has not |
|
206 | ||
163 | been merged into IPython and is still in `ipython1-dev`. |
|
207 | * Added a new example of how to use :mod:`ipython1.kernel.asynclient`. | |
164 | * The ``TaskController`` now has methods for getting the queue status. |
|
208 | ||
165 | * The ``TaskResult`` objects not have information about how long the task |
|
209 | * Initial draft of a process daemon in :mod:`ipython1.daemon`. This has not | |
166 | took to run. |
|
210 | been merged into IPython and is still in `ipython1-dev`. | |
167 | * We are attaching additional attributes to exceptions ``(_ipython_*)`` that |
|
211 | ||
168 | we use to carry additional info around. |
|
212 | * The ``TaskController`` now has methods for getting the queue status. | |
169 | * New top-level module :mod:`asyncclient` that has asynchronous versions (that |
|
213 | ||
170 | return deferreds) of the client classes. This is designed to users who want |
|
214 | * The ``TaskResult`` objects not have information about how long the task | |
171 | to run their own Twisted reactor |
|
215 | took to run. | |
172 | * All the clients in :mod:`client` are now based on Twisted. This is done by |
|
216 | ||
173 | running the Twisted reactor in a separate thread and using the |
|
217 | * We are attaching additional attributes to exceptions ``(_ipython_*)`` that | |
174 | :func:`blockingCallFromThread` function that is in recent versions of Twisted. |
|
218 | we use to carry additional info around. | |
175 | * Functions can now be pushed/pulled to/from engines using |
|
219 | ||
176 | :meth:`MultiEngineClient.push_function` and :meth:`MultiEngineClient.pull_function`. |
|
220 | * New top-level module :mod:`asyncclient` that has asynchronous versions (that | |
177 | * Gather/scatter are now implemented in the client to reduce the work load |
|
221 | return deferreds) of the client classes. This is designed to users who want | |
178 | of the controller and improve performance. |
|
222 | to run their own Twisted reactor. | |
179 | * Complete rewrite of the IPython docuementation. All of the documentation |
|
223 | ||
180 | from the IPython website has been moved into docs/source as restructured |
|
224 | * All the clients in :mod:`client` are now based on Twisted. This is done by | |
181 | text documents. PDF and HTML documentation are being generated using |
|
225 | running the Twisted reactor in a separate thread and using the | |
182 | Sphinx. |
|
226 | :func:`blockingCallFromThread` function that is in recent versions of Twisted. | |
183 | * New developer oriented documentation: development guidelines and roadmap. |
|
227 | ||
184 | * Traditional ``ChangeLog`` has been changed to a more useful ``changes.txt`` file |
|
228 | * Functions can now be pushed/pulled to/from engines using | |
185 | that is organized by release and is meant to provide something more relevant |
|
229 | :meth:`MultiEngineClient.push_function` and | |
186 | for users. |
|
230 | :meth:`MultiEngineClient.pull_function`. | |
|
231 | ||||
|
232 | * Gather/scatter are now implemented in the client to reduce the work load | |||
|
233 | of the controller and improve performance. | |||
|
234 | ||||
|
235 | * Complete rewrite of the IPython docuementation. All of the documentation | |||
|
236 | from the IPython website has been moved into docs/source as restructured | |||
|
237 | text documents. PDF and HTML documentation are being generated using | |||
|
238 | Sphinx. | |||
|
239 | ||||
|
240 | * New developer oriented documentation: development guidelines and roadmap. | |||
|
241 | ||||
|
242 | * Traditional ``ChangeLog`` has been changed to a more useful ``changes.txt`` | |||
|
243 | file that is organized by release and is meant to provide something more | |||
|
244 | relevant for users. | |||
187 |
|
245 | |||
188 | Bug fixes |
|
246 | Bug fixes | |
189 | ......... |
|
247 | ......... | |
190 |
|
248 | |||
191 |
|
|
249 | * Created a proper ``MANIFEST.in`` file to create source distributions. | |
192 | * Fixed a bug in the ``MultiEngine`` interface. Previously, multi-engine |
|
250 | ||
193 | actions were being collected with a :class:`DeferredList` with |
|
251 | * Fixed a bug in the ``MultiEngine`` interface. Previously, multi-engine | |
194 | ``fireononeerrback=1``. This meant that methods were returning |
|
252 | actions were being collected with a :class:`DeferredList` with | |
195 | before all engines had given their results. This was causing extremely odd |
|
253 | ``fireononeerrback=1``. This meant that methods were returning | |
196 | bugs in certain cases. To fix this problem, we have 1) set |
|
254 | before all engines had given their results. This was causing extremely odd | |
197 | ``fireononeerrback=0`` to make sure all results (or exceptions) are in |
|
255 | bugs in certain cases. To fix this problem, we have 1) set | |
198 | before returning and 2) introduced a :exc:`CompositeError` exception |
|
256 | ``fireononeerrback=0`` to make sure all results (or exceptions) are in | |
199 | that wraps all of the engine exceptions. This is a huge change as it means |
|
257 | before returning and 2) introduced a :exc:`CompositeError` exception | |
200 | that users will have to catch :exc:`CompositeError` rather than the actual |
|
258 | that wraps all of the engine exceptions. This is a huge change as it means | |
201 | exception. |
|
259 | that users will have to catch :exc:`CompositeError` rather than the actual | |
|
260 | exception. | |||
202 |
|
261 | |||
203 | Backwards incompatible changes |
|
262 | Backwards incompatible changes | |
204 | .............................. |
|
263 | .............................. | |
205 |
|
264 | |||
206 |
|
|
265 | * All names have been renamed to conform to the lowercase_with_underscore | |
207 |
|
|
266 | convention. This will require users to change references to all names like | |
208 |
|
|
267 | ``queueStatus`` to ``queue_status``. | |
209 | * Previously, methods like :meth:`MultiEngineClient.push` and |
|
268 | ||
210 | :meth:`MultiEngineClient.push` used ``*args`` and ``**kwargs``. This was |
|
269 | * Previously, methods like :meth:`MultiEngineClient.push` and | |
211 | becoming a problem as we weren't able to introduce new keyword arguments into |
|
270 | :meth:`MultiEngineClient.push` used ``*args`` and ``**kwargs``. This was | |
212 | the API. Now these methods simple take a dict or sequence. This has also allowed |
|
271 | becoming a problem as we weren't able to introduce new keyword arguments into | |
213 | us to get rid of the ``*All`` methods like :meth:`pushAll` and :meth:`pullAll`. |
|
272 | the API. Now these methods simple take a dict or sequence. This has also | |
214 | These things are now handled with the ``targets`` keyword argument that defaults |
|
273 | allowed us to get rid of the ``*All`` methods like :meth:`pushAll` and | |
215 | to ``'all'``. |
|
274 | :meth:`pullAll`. These things are now handled with the ``targets`` keyword | |
216 | * The :attr:`MultiEngineClient.magicTargets` has been renamed to |
|
275 | argument that defaults to ``'all'``. | |
217 | :attr:`MultiEngineClient.targets`. |
|
276 | ||
218 | * All methods in the MultiEngine interface now accept the optional keyword argument |
|
277 | * The :attr:`MultiEngineClient.magicTargets` has been renamed to | |
219 | ``block``. |
|
278 | :attr:`MultiEngineClient.targets`. | |
220 | * Renamed :class:`RemoteController` to :class:`MultiEngineClient` and |
|
279 | ||
221 | :class:`TaskController` to :class:`TaskClient`. |
|
280 | * All methods in the MultiEngine interface now accept the optional keyword | |
222 | * Renamed the top-level module from :mod:`api` to :mod:`client`. |
|
281 | argument ``block``. | |
223 | * Most methods in the multiengine interface now raise a :exc:`CompositeError` exception |
|
282 | ||
224 | that wraps the user's exceptions, rather than just raising the raw user's exception. |
|
283 | * Renamed :class:`RemoteController` to :class:`MultiEngineClient` and | |
225 | * Changed the ``setupNS`` and ``resultNames`` in the ``Task`` class to ``push`` |
|
284 | :class:`TaskController` to :class:`TaskClient`. | |
226 | and ``pull``. |
|
285 | ||
|
286 | * Renamed the top-level module from :mod:`api` to :mod:`client`. | |||
|
287 | ||||
|
288 | * Most methods in the multiengine interface now raise a :exc:`CompositeError` | |||
|
289 | exception that wraps the user's exceptions, rather than just raising the raw | |||
|
290 | user's exception. | |||
|
291 | ||||
|
292 | * Changed the ``setupNS`` and ``resultNames`` in the ``Task`` class to ``push`` | |||
|
293 | and ``pull``. | |||
227 |
|
294 | |||
|
295 | ||||
228 | Release 0.8.4 |
|
296 | Release 0.8.4 | |
229 | ============= |
|
297 | ============= | |
230 |
|
298 | |||
231 | Someone needs to describe what went into 0.8.4. |
|
299 | This was a quick release to fix an unfortunate bug that slipped into the 0.8.3 | |
|
300 | release. The ``--twisted`` option was disabled, as it turned out to be broken | |||
|
301 | across several platforms. | |||
232 |
|
302 | |||
233 | Release 0.8.2 |
|
|||
234 | ============= |
|
|||
235 |
|
303 | |||
236 | * %pushd/%popd behave differently; now "pushd /foo" pushes CURRENT directory |
|
|||
237 | and jumps to /foo. The current behaviour is closer to the documented |
|
|||
238 | behaviour, and should not trip anyone. |
|
|||
239 |
|
||||
240 | Release 0.8.3 |
|
304 | Release 0.8.3 | |
241 | ============= |
|
305 | ============= | |
242 |
|
306 | |||
243 | * pydb is now disabled by default (due to %run -d problems). You can enable |
|
307 | * pydb is now disabled by default (due to %run -d problems). You can enable | |
244 | it by passing -pydb command line argument to IPython. Note that setting |
|
308 | it by passing -pydb command line argument to IPython. Note that setting | |
245 | it in config file won't work. |
|
309 | it in config file won't work. | |
246 |
|
310 | |||
|
311 | ||||
|
312 | Release 0.8.2 | |||
|
313 | ============= | |||
|
314 | ||||
|
315 | * %pushd/%popd behave differently; now "pushd /foo" pushes CURRENT directory | |||
|
316 | and jumps to /foo. The current behaviour is closer to the documented | |||
|
317 | behaviour, and should not trip anyone. | |||
|
318 | ||||
|
319 | ||||
247 | Older releases |
|
320 | Older releases | |
248 | ============== |
|
321 | ============== | |
249 |
|
322 | |||
250 |
Changes in earlier releases of IPython are described in the older file |
|
323 | Changes in earlier releases of IPython are described in the older file | |
251 | Please refer to this document for details. |
|
324 | ``ChangeLog``. Please refer to this document for details. | |
252 |
|
325 |
@@ -1,180 +1,187 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 | # |
|
2 | # | |
3 |
# IPython documentation build configuration file |
|
3 | # IPython documentation build configuration file. | |
4 | # sphinx-quickstart on Thu May 8 16:45:02 2008. |
|
|||
5 |
|
4 | |||
6 | # NOTE: This file has been edited manually from the auto-generated one from |
|
5 | # NOTE: This file has been edited manually from the auto-generated one from | |
7 | # sphinx. Do NOT delete and re-generate. If any changes from sphinx are |
|
6 | # sphinx. Do NOT delete and re-generate. If any changes from sphinx are | |
8 | # needed, generate a scratch one and merge by hand any new fields needed. |
|
7 | # needed, generate a scratch one and merge by hand any new fields needed. | |
9 |
|
8 | |||
10 | # |
|
9 | # | |
11 | # This file is execfile()d with the current directory set to its containing dir. |
|
10 | # This file is execfile()d with the current directory set to its containing dir. | |
12 | # |
|
11 | # | |
13 | # The contents of this file are pickled, so don't put values in the namespace |
|
12 | # The contents of this file are pickled, so don't put values in the namespace | |
14 | # that aren't pickleable (module imports are okay, they're removed automatically). |
|
13 | # that aren't pickleable (module imports are okay, they're removed automatically). | |
15 | # |
|
14 | # | |
16 | # All configuration values have a default value; values that are commented out |
|
15 | # All configuration values have a default value; values that are commented out | |
17 | # serve to show the default value. |
|
16 | # serve to show the default value. | |
18 |
|
17 | |||
19 | import sys, os |
|
18 | import sys, os | |
20 |
|
19 | |||
21 | # If your extensions are in another directory, add it here. If the directory |
|
20 | # If your extensions are in another directory, add it here. If the directory | |
22 | # is relative to the documentation root, use os.path.abspath to make it |
|
21 | # is relative to the documentation root, use os.path.abspath to make it | |
23 | # absolute, like shown here. |
|
22 | # absolute, like shown here. | |
24 |
|
|
23 | sys.path.append(os.path.abspath('../sphinxext')) | |
|
24 | ||||
|
25 | # Import support for ipython console session syntax highlighting (lives | |||
|
26 | # in the sphinxext directory defined above) | |||
|
27 | import ipython_console_highlighting | |||
25 |
|
28 | |||
26 | # We load the ipython release info into a dict by explicit execution |
|
29 | # We load the ipython release info into a dict by explicit execution | |
27 | iprelease = {} |
|
30 | iprelease = {} | |
28 | execfile('../../IPython/Release.py',iprelease) |
|
31 | execfile('../../IPython/Release.py',iprelease) | |
29 |
|
32 | |||
30 | # General configuration |
|
33 | # General configuration | |
31 | # --------------------- |
|
34 | # --------------------- | |
32 |
|
35 | |||
33 | # Add any Sphinx extension module names here, as strings. They can be extensions |
|
36 | # Add any Sphinx extension module names here, as strings. They can be extensions | |
34 | # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. |
|
37 | # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. | |
35 | #extensions = [] |
|
38 | extensions = ['sphinx.ext.autodoc', | |
|
39 | 'inheritance_diagram', 'only_directives', | |||
|
40 | 'ipython_console_highlighting', | |||
|
41 | # 'plot_directive', # disabled for now, needs matplotlib | |||
|
42 | ] | |||
36 |
|
43 | |||
37 | # Add any paths that contain templates here, relative to this directory. |
|
44 | # Add any paths that contain templates here, relative to this directory. | |
38 | templates_path = ['_templates'] |
|
45 | templates_path = ['_templates'] | |
39 |
|
46 | |||
40 | # The suffix of source filenames. |
|
47 | # The suffix of source filenames. | |
41 | source_suffix = '.txt' |
|
48 | source_suffix = '.txt' | |
42 |
|
49 | |||
43 | # The master toctree document. |
|
50 | # The master toctree document. | |
44 | master_doc = 'index' |
|
51 | master_doc = 'index' | |
45 |
|
52 | |||
46 | # General substitutions. |
|
53 | # General substitutions. | |
47 | project = 'IPython' |
|
54 | project = 'IPython' | |
48 | copyright = '2008, The IPython Development Team' |
|
55 | copyright = '2008, The IPython Development Team' | |
49 |
|
56 | |||
50 | # The default replacements for |version| and |release|, also used in various |
|
57 | # The default replacements for |version| and |release|, also used in various | |
51 | # other places throughout the built documents. |
|
58 | # other places throughout the built documents. | |
52 | # |
|
59 | # | |
53 | # The full version, including alpha/beta/rc tags. |
|
60 | # The full version, including alpha/beta/rc tags. | |
54 | release = iprelease['version'] |
|
61 | release = iprelease['version'] | |
55 | # The short X.Y version. |
|
62 | # The short X.Y version. | |
56 | version = '.'.join(release.split('.',2)[:2]) |
|
63 | version = '.'.join(release.split('.',2)[:2]) | |
57 |
|
64 | |||
58 |
|
65 | |||
59 | # There are two options for replacing |today|: either, you set today to some |
|
66 | # There are two options for replacing |today|: either, you set today to some | |
60 | # non-false value, then it is used: |
|
67 | # non-false value, then it is used: | |
61 | #today = '' |
|
68 | #today = '' | |
62 | # Else, today_fmt is used as the format for a strftime call. |
|
69 | # Else, today_fmt is used as the format for a strftime call. | |
63 | today_fmt = '%B %d, %Y' |
|
70 | today_fmt = '%B %d, %Y' | |
64 |
|
71 | |||
65 | # List of documents that shouldn't be included in the build. |
|
72 | # List of documents that shouldn't be included in the build. | |
66 | #unused_docs = [] |
|
73 | #unused_docs = [] | |
67 |
|
74 | |||
68 | # List of directories, relative to source directories, that shouldn't be searched |
|
75 | # List of directories, relative to source directories, that shouldn't be searched | |
69 | # for source files. |
|
76 | # for source files. | |
70 |
|
|
77 | exclude_dirs = ['attic'] | |
71 |
|
78 | |||
72 | # If true, '()' will be appended to :func: etc. cross-reference text. |
|
79 | # If true, '()' will be appended to :func: etc. cross-reference text. | |
73 | #add_function_parentheses = True |
|
80 | #add_function_parentheses = True | |
74 |
|
81 | |||
75 | # If true, the current module name will be prepended to all description |
|
82 | # If true, the current module name will be prepended to all description | |
76 | # unit titles (such as .. function::). |
|
83 | # unit titles (such as .. function::). | |
77 | #add_module_names = True |
|
84 | #add_module_names = True | |
78 |
|
85 | |||
79 | # If true, sectionauthor and moduleauthor directives will be shown in the |
|
86 | # If true, sectionauthor and moduleauthor directives will be shown in the | |
80 | # output. They are ignored by default. |
|
87 | # output. They are ignored by default. | |
81 | #show_authors = False |
|
88 | #show_authors = False | |
82 |
|
89 | |||
83 | # The name of the Pygments (syntax highlighting) style to use. |
|
90 | # The name of the Pygments (syntax highlighting) style to use. | |
84 | pygments_style = 'sphinx' |
|
91 | pygments_style = 'sphinx' | |
85 |
|
92 | |||
86 |
|
93 | |||
87 | # Options for HTML output |
|
94 | # Options for HTML output | |
88 | # ----------------------- |
|
95 | # ----------------------- | |
89 |
|
96 | |||
90 | # The style sheet to use for HTML and HTML Help pages. A file of that name |
|
97 | # The style sheet to use for HTML and HTML Help pages. A file of that name | |
91 | # must exist either in Sphinx' static/ path, or in one of the custom paths |
|
98 | # must exist either in Sphinx' static/ path, or in one of the custom paths | |
92 | # given in html_static_path. |
|
99 | # given in html_static_path. | |
93 | html_style = 'default.css' |
|
100 | html_style = 'default.css' | |
94 |
|
101 | |||
95 | # The name for this set of Sphinx documents. If None, it defaults to |
|
102 | # The name for this set of Sphinx documents. If None, it defaults to | |
96 | # "<project> v<release> documentation". |
|
103 | # "<project> v<release> documentation". | |
97 | #html_title = None |
|
104 | #html_title = None | |
98 |
|
105 | |||
99 | # The name of an image file (within the static path) to place at the top of |
|
106 | # The name of an image file (within the static path) to place at the top of | |
100 | # the sidebar. |
|
107 | # the sidebar. | |
101 | #html_logo = None |
|
108 | #html_logo = None | |
102 |
|
109 | |||
103 | # Add any paths that contain custom static files (such as style sheets) here, |
|
110 | # Add any paths that contain custom static files (such as style sheets) here, | |
104 | # relative to this directory. They are copied after the builtin static files, |
|
111 | # relative to this directory. They are copied after the builtin static files, | |
105 | # so a file named "default.css" will overwrite the builtin "default.css". |
|
112 | # so a file named "default.css" will overwrite the builtin "default.css". | |
106 | html_static_path = ['_static'] |
|
113 | html_static_path = ['_static'] | |
107 |
|
114 | |||
108 | # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, |
|
115 | # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, | |
109 | # using the given strftime format. |
|
116 | # using the given strftime format. | |
110 | html_last_updated_fmt = '%b %d, %Y' |
|
117 | html_last_updated_fmt = '%b %d, %Y' | |
111 |
|
118 | |||
112 | # If true, SmartyPants will be used to convert quotes and dashes to |
|
119 | # If true, SmartyPants will be used to convert quotes and dashes to | |
113 | # typographically correct entities. |
|
120 | # typographically correct entities. | |
114 | #html_use_smartypants = True |
|
121 | #html_use_smartypants = True | |
115 |
|
122 | |||
116 | # Custom sidebar templates, maps document names to template names. |
|
123 | # Custom sidebar templates, maps document names to template names. | |
117 | #html_sidebars = {} |
|
124 | #html_sidebars = {} | |
118 |
|
125 | |||
119 | # Additional templates that should be rendered to pages, maps page names to |
|
126 | # Additional templates that should be rendered to pages, maps page names to | |
120 | # template names. |
|
127 | # template names. | |
121 | #html_additional_pages = {} |
|
128 | #html_additional_pages = {} | |
122 |
|
129 | |||
123 | # If false, no module index is generated. |
|
130 | # If false, no module index is generated. | |
124 | #html_use_modindex = True |
|
131 | #html_use_modindex = True | |
125 |
|
132 | |||
126 | # If true, the reST sources are included in the HTML build as _sources/<name>. |
|
133 | # If true, the reST sources are included in the HTML build as _sources/<name>. | |
127 | #html_copy_source = True |
|
134 | #html_copy_source = True | |
128 |
|
135 | |||
129 | # If true, an OpenSearch description file will be output, and all pages will |
|
136 | # If true, an OpenSearch description file will be output, and all pages will | |
130 | # contain a <link> tag referring to it. The value of this option must be the |
|
137 | # contain a <link> tag referring to it. The value of this option must be the | |
131 | # base URL from which the finished HTML is served. |
|
138 | # base URL from which the finished HTML is served. | |
132 | #html_use_opensearch = '' |
|
139 | #html_use_opensearch = '' | |
133 |
|
140 | |||
134 | # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). |
|
141 | # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). | |
135 | #html_file_suffix = '' |
|
142 | #html_file_suffix = '' | |
136 |
|
143 | |||
137 | # Output file base name for HTML help builder. |
|
144 | # Output file base name for HTML help builder. | |
138 |
htmlhelp_basename = ' |
|
145 | htmlhelp_basename = 'ipythondoc' | |
139 |
|
146 | |||
140 |
|
147 | |||
141 | # Options for LaTeX output |
|
148 | # Options for LaTeX output | |
142 | # ------------------------ |
|
149 | # ------------------------ | |
143 |
|
150 | |||
144 | # The paper size ('letter' or 'a4'). |
|
151 | # The paper size ('letter' or 'a4'). | |
145 | latex_paper_size = 'letter' |
|
152 | latex_paper_size = 'letter' | |
146 |
|
153 | |||
147 | # The font size ('10pt', '11pt' or '12pt'). |
|
154 | # The font size ('10pt', '11pt' or '12pt'). | |
148 | latex_font_size = '11pt' |
|
155 | latex_font_size = '11pt' | |
149 |
|
156 | |||
150 | # Grouping the document tree into LaTeX files. List of tuples |
|
157 | # Grouping the document tree into LaTeX files. List of tuples | |
151 | # (source start file, target name, title, author, document class [howto/manual]). |
|
158 | # (source start file, target name, title, author, document class [howto/manual]). | |
152 |
|
159 | |||
153 | latex_documents = [ ('index', 'ipython.tex', 'IPython Documentation', |
|
160 | latex_documents = [ ('index', 'ipython.tex', 'IPython Documentation', | |
154 | ur"""Brian Granger, Fernando Pérez and Ville Vainio\\ |
|
161 | ur"""The IPython Development Team""", | |
155 | \ \\ |
|
|||
156 | With contributions from:\\ |
|
|||
157 | Benjamin Ragan-Kelley and Barry Wark.""", |
|
|||
158 | 'manual'), |
|
162 | 'manual'), | |
159 | ] |
|
163 | ] | |
160 |
|
164 | |||
161 | # The name of an image file (relative to this directory) to place at the top of |
|
165 | # The name of an image file (relative to this directory) to place at the top of | |
162 | # the title page. |
|
166 | # the title page. | |
163 | #latex_logo = None |
|
167 | #latex_logo = None | |
164 |
|
168 | |||
165 | # For "manual" documents, if this is true, then toplevel headings are parts, |
|
169 | # For "manual" documents, if this is true, then toplevel headings are parts, | |
166 | # not chapters. |
|
170 | # not chapters. | |
167 | #latex_use_parts = False |
|
171 | #latex_use_parts = False | |
168 |
|
172 | |||
169 | # Additional stuff for the LaTeX preamble. |
|
173 | # Additional stuff for the LaTeX preamble. | |
170 | #latex_preamble = '' |
|
174 | #latex_preamble = '' | |
171 |
|
175 | |||
172 | # Documents to append as an appendix to all manuals. |
|
176 | # Documents to append as an appendix to all manuals. | |
173 | #latex_appendices = [] |
|
177 | #latex_appendices = [] | |
174 |
|
178 | |||
175 | # If false, no module index is generated. |
|
179 | # If false, no module index is generated. | |
176 | #latex_use_modindex = True |
|
180 | #latex_use_modindex = True | |
177 |
|
181 | |||
178 |
|
182 | |||
179 | # Cleanup: delete release info to avoid pickling errors from sphinx |
|
183 | # Cleanup | |
|
184 | # ------- | |||
|
185 | # delete release info to avoid pickling errors from sphinx | |||
|
186 | ||||
180 | del iprelease |
|
187 | del iprelease |
@@ -1,284 +1,286 b'' | |||||
1 | .. _customization: |
|
1 | .. _customization: | |
2 |
|
2 | |||
3 | ======================== |
|
3 | ======================== | |
4 | Customization of IPython |
|
4 | Customization of IPython | |
5 | ======================== |
|
5 | ======================== | |
6 |
|
6 | |||
7 | There are 2 ways to configure IPython - the old way of using ipythonrc |
|
7 | There are 2 ways to configure IPython - the old way of using ipythonrc | |
8 | files (an INI-file like format), and the new way that involves editing |
|
8 | files (an INI-file like format), and the new way that involves editing | |
9 | your ipy_user_conf.py. Both configuration systems work at the same |
|
9 | your ipy_user_conf.py. Both configuration systems work at the same | |
10 | time, so you can set your options in both, but if you are hesitating |
|
10 | time, so you can set your options in both, but if you are hesitating | |
11 | about which alternative to choose, we recommend the ipy_user_conf.py |
|
11 | about which alternative to choose, we recommend the ipy_user_conf.py | |
12 | approach, as it will give you more power and control in the long |
|
12 | approach, as it will give you more power and control in the long | |
13 | run. However, there are few options such as pylab_import_all that can |
|
13 | run. However, there are few options such as pylab_import_all that can | |
14 | only be specified in ipythonrc file or command line - the reason for |
|
14 | only be specified in ipythonrc file or command line - the reason for | |
15 | this is that they are needed before IPython has been started up, and |
|
15 | this is that they are needed before IPython has been started up, and | |
16 | the IPApi object used in ipy_user_conf.py is not yet available at that |
|
16 | the IPApi object used in ipy_user_conf.py is not yet available at that | |
17 | time. A hybrid approach of specifying a few options in ipythonrc and |
|
17 | time. A hybrid approach of specifying a few options in ipythonrc and | |
18 | doing the more advanced configuration in ipy_user_conf.py is also |
|
18 | doing the more advanced configuration in ipy_user_conf.py is also | |
19 | possible. |
|
19 | possible. | |
20 |
|
20 | |||
|
21 | .. _ipythonrc: | |||
|
22 | ||||
21 | The ipythonrc approach |
|
23 | The ipythonrc approach | |
22 | ====================== |
|
24 | ====================== | |
23 |
|
25 | |||
24 | As we've already mentioned, IPython reads a configuration file which can |
|
26 | As we've already mentioned, IPython reads a configuration file which can | |
25 | be specified at the command line (-rcfile) or which by default is |
|
27 | be specified at the command line (-rcfile) or which by default is | |
26 | assumed to be called ipythonrc. Such a file is looked for in the current |
|
28 | assumed to be called ipythonrc. Such a file is looked for in the current | |
27 | directory where IPython is started and then in your IPYTHONDIR, which |
|
29 | directory where IPython is started and then in your IPYTHONDIR, which | |
28 | allows you to have local configuration files for specific projects. In |
|
30 | allows you to have local configuration files for specific projects. In | |
29 | this section we will call these types of configuration files simply |
|
31 | this section we will call these types of configuration files simply | |
30 | rcfiles (short for resource configuration file). |
|
32 | rcfiles (short for resource configuration file). | |
31 |
|
33 | |||
32 | The syntax of an rcfile is one of key-value pairs separated by |
|
34 | The syntax of an rcfile is one of key-value pairs separated by | |
33 | whitespace, one per line. Lines beginning with a # are ignored as |
|
35 | whitespace, one per line. Lines beginning with a # are ignored as | |
34 | comments, but comments can not be put on lines with data (the parser is |
|
36 | comments, but comments can not be put on lines with data (the parser is | |
35 | fairly primitive). Note that these are not python files, and this is |
|
37 | fairly primitive). Note that these are not python files, and this is | |
36 | deliberate, because it allows us to do some things which would be quite |
|
38 | deliberate, because it allows us to do some things which would be quite | |
37 | tricky to implement if they were normal python files. |
|
39 | tricky to implement if they were normal python files. | |
38 |
|
40 | |||
39 | First, an rcfile can contain permanent default values for almost all |
|
41 | First, an rcfile can contain permanent default values for almost all command | |
40 |
|
|
42 | line options (except things like -help or -Version). :ref:`This section | |
41 |
|
|
43 | <command_line_options>` contains a description of all command-line | |
42 | options. However, values you explicitly specify at the command line |
|
44 | options. However, values you explicitly specify at the command line override | |
43 |
|
|
45 | the values defined in the rcfile. | |
44 |
|
46 | |||
45 | Besides command line option values, the rcfile can specify values for |
|
47 | Besides command line option values, the rcfile can specify values for | |
46 | certain extra special options which are not available at the command |
|
48 | certain extra special options which are not available at the command | |
47 | line. These options are briefly described below. |
|
49 | line. These options are briefly described below. | |
48 |
|
50 | |||
49 | Each of these options may appear as many times as you need it in the file. |
|
51 | Each of these options may appear as many times as you need it in the file. | |
50 |
|
52 | |||
51 | * include <file1> <file2> ...: you can name other rcfiles you want |
|
53 | * include <file1> <file2> ...: you can name other rcfiles you want | |
52 | to recursively load up to 15 levels (don't use the <> brackets in |
|
54 | to recursively load up to 15 levels (don't use the <> brackets in | |
53 | your names!). This feature allows you to define a 'base' rcfile |
|
55 | your names!). This feature allows you to define a 'base' rcfile | |
54 | with general options and special-purpose files which can be loaded |
|
56 | with general options and special-purpose files which can be loaded | |
55 | only when needed with particular configuration options. To make |
|
57 | only when needed with particular configuration options. To make | |
56 | this more convenient, IPython accepts the -profile <name> option |
|
58 | this more convenient, IPython accepts the -profile <name> option | |
57 | (abbreviates to -p <name>) which tells it to look for an rcfile |
|
59 | (abbreviates to -p <name>) which tells it to look for an rcfile | |
58 | named ipythonrc-<name>. |
|
60 | named ipythonrc-<name>. | |
59 | * import_mod <mod1> <mod2> ...: import modules with 'import |
|
61 | * import_mod <mod1> <mod2> ...: import modules with 'import | |
60 | <mod1>,<mod2>,...' |
|
62 | <mod1>,<mod2>,...' | |
61 | * import_some <mod> <f1> <f2> ...: import functions with 'from |
|
63 | * import_some <mod> <f1> <f2> ...: import functions with 'from | |
62 | <mod> import <f1>,<f2>,...' |
|
64 | <mod> import <f1>,<f2>,...' | |
63 | * import_all <mod1> <mod2> ...: for each module listed import |
|
65 | * import_all <mod1> <mod2> ...: for each module listed import | |
64 | functions with ``from <mod> import *``. |
|
66 | functions with ``from <mod> import *``. | |
65 | * execute <python code>: give any single-line python code to be |
|
67 | * execute <python code>: give any single-line python code to be | |
66 | executed. |
|
68 | executed. | |
67 | * execfile <filename>: execute the python file given with an |
|
69 | * execfile <filename>: execute the python file given with an | |
68 | 'execfile(filename)' command. Username expansion is performed on |
|
70 | 'execfile(filename)' command. Username expansion is performed on | |
69 | the given names. So if you need any amount of extra fancy |
|
71 | the given names. So if you need any amount of extra fancy | |
70 | customization that won't fit in any of the above 'canned' options, |
|
72 | customization that won't fit in any of the above 'canned' options, | |
71 | you can just put it in a separate python file and execute it. |
|
73 | you can just put it in a separate python file and execute it. | |
72 | * alias <alias_def>: this is equivalent to calling |
|
74 | * alias <alias_def>: this is equivalent to calling | |
73 | '%alias <alias_def>' at the IPython command line. This way, from |
|
75 | '%alias <alias_def>' at the IPython command line. This way, from | |
74 | within IPython you can do common system tasks without having to |
|
76 | within IPython you can do common system tasks without having to | |
75 | exit it or use the ! escape. IPython isn't meant to be a shell |
|
77 | exit it or use the ! escape. IPython isn't meant to be a shell | |
76 | replacement, but it is often very useful to be able to do things |
|
78 | replacement, but it is often very useful to be able to do things | |
77 | with files while testing code. This gives you the flexibility to |
|
79 | with files while testing code. This gives you the flexibility to | |
78 | have within IPython any aliases you may be used to under your |
|
80 | have within IPython any aliases you may be used to under your | |
79 | normal system shell. |
|
81 | normal system shell. | |
80 |
|
82 | |||
81 | ipy_user_conf.py |
|
83 | ipy_user_conf.py | |
82 | ================ |
|
84 | ================ | |
83 |
|
85 | |||
84 | There should be a simple template ipy_user_conf.py file in your |
|
86 | There should be a simple template ipy_user_conf.py file in your | |
85 | ~/.ipython directory. It is a plain python module that is imported |
|
87 | ~/.ipython directory. It is a plain python module that is imported | |
86 | during IPython startup, so you can do pretty much what you want there |
|
88 | during IPython startup, so you can do pretty much what you want there | |
87 | - import modules, configure extensions, change options, define magic |
|
89 | - import modules, configure extensions, change options, define magic | |
88 | commands, put variables and functions in the IPython namespace, |
|
90 | commands, put variables and functions in the IPython namespace, | |
89 | etc. You use the IPython extension api object, acquired by |
|
91 | etc. You use the IPython extension api object, acquired by | |
90 | IPython.ipapi.get() and documented in the "IPython extension API" |
|
92 | IPython.ipapi.get() and documented in the "IPython extension API" | |
91 | chapter, to interact with IPython. A sample ipy_user_conf.py is listed |
|
93 | chapter, to interact with IPython. A sample ipy_user_conf.py is listed | |
92 | below for reference:: |
|
94 | below for reference:: | |
93 |
|
95 | |||
94 | # Most of your config files and extensions will probably start |
|
96 | # Most of your config files and extensions will probably start | |
95 | # with this import |
|
97 | # with this import | |
96 |
|
98 | |||
97 | import IPython.ipapi |
|
99 | import IPython.ipapi | |
98 | ip = IPython.ipapi.get() |
|
100 | ip = IPython.ipapi.get() | |
99 |
|
101 | |||
100 | # You probably want to uncomment this if you did %upgrade -nolegacy |
|
102 | # You probably want to uncomment this if you did %upgrade -nolegacy | |
101 | # import ipy_defaults |
|
103 | # import ipy_defaults | |
102 |
|
104 | |||
103 | import os |
|
105 | import os | |
104 |
|
106 | |||
105 | def main(): |
|
107 | def main(): | |
106 |
|
108 | |||
107 | #ip.dbg.debugmode = True |
|
109 | #ip.dbg.debugmode = True | |
108 | ip.dbg.debug_stack() |
|
110 | ip.dbg.debug_stack() | |
109 |
|
111 | |||
110 | # uncomment if you want to get ipython -p sh behaviour |
|
112 | # uncomment if you want to get ipython -p sh behaviour | |
111 | # without having to use command line switches |
|
113 | # without having to use command line switches | |
112 | import ipy_profile_sh |
|
114 | import ipy_profile_sh | |
113 | import jobctrl |
|
115 | import jobctrl | |
114 |
|
116 | |||
115 | # Configure your favourite editor? |
|
117 | # Configure your favourite editor? | |
116 | # Good idea e.g. for %edit os.path.isfile |
|
118 | # Good idea e.g. for %edit os.path.isfile | |
117 |
|
119 | |||
118 | #import ipy_editors |
|
120 | #import ipy_editors | |
119 |
|
121 | |||
120 | # Choose one of these: |
|
122 | # Choose one of these: | |
121 |
|
123 | |||
122 | #ipy_editors.scite() |
|
124 | #ipy_editors.scite() | |
123 | #ipy_editors.scite('c:/opt/scite/scite.exe') |
|
125 | #ipy_editors.scite('c:/opt/scite/scite.exe') | |
124 | #ipy_editors.komodo() |
|
126 | #ipy_editors.komodo() | |
125 | #ipy_editors.idle() |
|
127 | #ipy_editors.idle() | |
126 | # ... or many others, try 'ipy_editors??' after import to see them |
|
128 | # ... or many others, try 'ipy_editors??' after import to see them | |
127 |
|
129 | |||
128 | # Or roll your own: |
|
130 | # Or roll your own: | |
129 | #ipy_editors.install_editor("c:/opt/jed +$line $file") |
|
131 | #ipy_editors.install_editor("c:/opt/jed +$line $file") | |
130 |
|
132 | |||
131 |
|
133 | |||
132 | o = ip.options |
|
134 | o = ip.options | |
133 | # An example on how to set options |
|
135 | # An example on how to set options | |
134 | #o.autocall = 1 |
|
136 | #o.autocall = 1 | |
135 | o.system_verbose = 0 |
|
137 | o.system_verbose = 0 | |
136 |
|
138 | |||
137 | #import_all("os sys") |
|
139 | #import_all("os sys") | |
138 | #execf('~/_ipython/ns.py') |
|
140 | #execf('~/_ipython/ns.py') | |
139 |
|
141 | |||
140 |
|
142 | |||
141 | # -- prompt |
|
143 | # -- prompt | |
142 | # A different, more compact set of prompts from the default ones, that |
|
144 | # A different, more compact set of prompts from the default ones, that | |
143 | # always show your current location in the filesystem: |
|
145 | # always show your current location in the filesystem: | |
144 |
|
146 | |||
145 | #o.prompt_in1 = r'\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Normal\n\C_Green|\#>' |
|
147 | #o.prompt_in1 = r'\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Normal\n\C_Green|\#>' | |
146 | #o.prompt_in2 = r'.\D: ' |
|
148 | #o.prompt_in2 = r'.\D: ' | |
147 | #o.prompt_out = r'[\#] ' |
|
149 | #o.prompt_out = r'[\#] ' | |
148 |
|
150 | |||
149 | # Try one of these color settings if you can't read the text easily |
|
151 | # Try one of these color settings if you can't read the text easily | |
150 | # autoexec is a list of IPython commands to execute on startup |
|
152 | # autoexec is a list of IPython commands to execute on startup | |
151 | #o.autoexec.append('%colors LightBG') |
|
153 | #o.autoexec.append('%colors LightBG') | |
152 | #o.autoexec.append('%colors NoColor') |
|
154 | #o.autoexec.append('%colors NoColor') | |
153 | o.autoexec.append('%colors Linux') |
|
155 | o.autoexec.append('%colors Linux') | |
154 |
|
156 | |||
155 |
|
157 | |||
156 | # some config helper functions you can use |
|
158 | # some config helper functions you can use | |
157 | def import_all(modules): |
|
159 | def import_all(modules): | |
158 | """ Usage: import_all("os sys") """ |
|
160 | """ Usage: import_all("os sys") """ | |
159 | for m in modules.split(): |
|
161 | for m in modules.split(): | |
160 | ip.ex("from %s import *" % m) |
|
162 | ip.ex("from %s import *" % m) | |
161 |
|
163 | |||
162 | def execf(fname): |
|
164 | def execf(fname): | |
163 | """ Execute a file in user namespace """ |
|
165 | """ Execute a file in user namespace """ | |
164 | ip.ex('execfile("%s")' % os.path.expanduser(fname)) |
|
166 | ip.ex('execfile("%s")' % os.path.expanduser(fname)) | |
165 |
|
167 | |||
166 | main() |
|
168 | main() | |
167 |
|
169 | |||
168 | .. _Prompts: |
|
170 | .. _Prompts: | |
169 |
|
171 | |||
170 | Fine-tuning your prompt |
|
172 | Fine-tuning your prompt | |
171 | ======================= |
|
173 | ======================= | |
172 |
|
174 | |||
173 | IPython's prompts can be customized using a syntax similar to that of |
|
175 | IPython's prompts can be customized using a syntax similar to that of | |
174 | the bash shell. Many of bash's escapes are supported, as well as a few |
|
176 | the bash shell. Many of bash's escapes are supported, as well as a few | |
175 | additional ones. We list them below:: |
|
177 | additional ones. We list them below:: | |
176 |
|
178 | |||
177 | \# |
|
179 | \# | |
178 | the prompt/history count number. This escape is automatically |
|
180 | the prompt/history count number. This escape is automatically | |
179 | wrapped in the coloring codes for the currently active color scheme. |
|
181 | wrapped in the coloring codes for the currently active color scheme. | |
180 | \N |
|
182 | \N | |
181 | the 'naked' prompt/history count number: this is just the number |
|
183 | the 'naked' prompt/history count number: this is just the number | |
182 | itself, without any coloring applied to it. This lets you produce |
|
184 | itself, without any coloring applied to it. This lets you produce | |
183 | numbered prompts with your own colors. |
|
185 | numbered prompts with your own colors. | |
184 | \D |
|
186 | \D | |
185 | the prompt/history count, with the actual digits replaced by dots. |
|
187 | the prompt/history count, with the actual digits replaced by dots. | |
186 | Used mainly in continuation prompts (prompt_in2) |
|
188 | Used mainly in continuation prompts (prompt_in2) | |
187 | \w |
|
189 | \w | |
188 | the current working directory |
|
190 | the current working directory | |
189 | \W |
|
191 | \W | |
190 | the basename of current working directory |
|
192 | the basename of current working directory | |
191 | \Xn |
|
193 | \Xn | |
192 | where $n=0\ldots5.$ The current working directory, with $HOME |
|
194 | where $n=0\ldots5.$ The current working directory, with $HOME | |
193 | replaced by ~, and filtered out to contain only $n$ path elements |
|
195 | replaced by ~, and filtered out to contain only $n$ path elements | |
194 | \Yn |
|
196 | \Yn | |
195 | Similar to \Xn, but with the $n+1$ element included if it is ~ (this |
|
197 | Similar to \Xn, but with the $n+1$ element included if it is ~ (this | |
196 | is similar to the behavior of the %cn escapes in tcsh) |
|
198 | is similar to the behavior of the %cn escapes in tcsh) | |
197 | \u |
|
199 | \u | |
198 | the username of the current user |
|
200 | the username of the current user | |
199 | \$ |
|
201 | \$ | |
200 | if the effective UID is 0, a #, otherwise a $ |
|
202 | if the effective UID is 0, a #, otherwise a $ | |
201 | \h |
|
203 | \h | |
202 | the hostname up to the first '.' |
|
204 | the hostname up to the first '.' | |
203 | \H |
|
205 | \H | |
204 | the hostname |
|
206 | the hostname | |
205 | \n |
|
207 | \n | |
206 | a newline |
|
208 | a newline | |
207 | \r |
|
209 | \r | |
208 | a carriage return |
|
210 | a carriage return | |
209 | \v |
|
211 | \v | |
210 | IPython version string |
|
212 | IPython version string | |
211 |
|
213 | |||
212 | In addition to these, ANSI color escapes can be insterted into the |
|
214 | In addition to these, ANSI color escapes can be insterted into the | |
213 | prompts, as \C_ColorName. The list of valid color names is: Black, Blue, |
|
215 | prompts, as \C_ColorName. The list of valid color names is: Black, Blue, | |
214 | Brown, Cyan, DarkGray, Green, LightBlue, LightCyan, LightGray, |
|
216 | Brown, Cyan, DarkGray, Green, LightBlue, LightCyan, LightGray, | |
215 | LightGreen, LightPurple, LightRed, NoColor, Normal, Purple, Red, White, |
|
217 | LightGreen, LightPurple, LightRed, NoColor, Normal, Purple, Red, White, | |
216 | Yellow. |
|
218 | Yellow. | |
217 |
|
219 | |||
218 | Finally, IPython supports the evaluation of arbitrary expressions in |
|
220 | Finally, IPython supports the evaluation of arbitrary expressions in | |
219 | your prompt string. The prompt strings are evaluated through the syntax |
|
221 | your prompt string. The prompt strings are evaluated through the syntax | |
220 | of PEP 215, but basically you can use $x.y to expand the value of x.y, |
|
222 | of PEP 215, but basically you can use $x.y to expand the value of x.y, | |
221 | and for more complicated expressions you can use braces: ${foo()+x} will |
|
223 | and for more complicated expressions you can use braces: ${foo()+x} will | |
222 | call function foo and add to it the value of x, before putting the |
|
224 | call function foo and add to it the value of x, before putting the | |
223 | result into your prompt. For example, using |
|
225 | result into your prompt. For example, using | |
224 | prompt_in1 '${commands.getoutput("uptime")}\nIn [\#]: ' |
|
226 | prompt_in1 '${commands.getoutput("uptime")}\nIn [\#]: ' | |
225 | will print the result of the uptime command on each prompt (assuming the |
|
227 | will print the result of the uptime command on each prompt (assuming the | |
226 | commands module has been imported in your ipythonrc file). |
|
228 | commands module has been imported in your ipythonrc file). | |
227 |
|
229 | |||
228 |
|
230 | |||
229 | Prompt examples |
|
231 | Prompt examples | |
230 |
|
232 | |||
231 | The following options in an ipythonrc file will give you IPython's |
|
233 | The following options in an ipythonrc file will give you IPython's | |
232 | default prompts:: |
|
234 | default prompts:: | |
233 |
|
235 | |||
234 | prompt_in1 'In [\#]:' |
|
236 | prompt_in1 'In [\#]:' | |
235 | prompt_in2 ' .\D.:' |
|
237 | prompt_in2 ' .\D.:' | |
236 | prompt_out 'Out[\#]:' |
|
238 | prompt_out 'Out[\#]:' | |
237 |
|
239 | |||
238 | which look like this:: |
|
240 | which look like this:: | |
239 |
|
241 | |||
240 | In [1]: 1+2 |
|
242 | In [1]: 1+2 | |
241 | Out[1]: 3 |
|
243 | Out[1]: 3 | |
242 |
|
244 | |||
243 | In [2]: for i in (1,2,3): |
|
245 | In [2]: for i in (1,2,3): | |
244 | ...: print i, |
|
246 | ...: print i, | |
245 | ...: |
|
247 | ...: | |
246 | 1 2 3 |
|
248 | 1 2 3 | |
247 |
|
249 | |||
248 | These will give you a very colorful prompt with path information:: |
|
250 | These will give you a very colorful prompt with path information:: | |
249 |
|
251 | |||
250 | #prompt_in1 '\C_Red\u\C_Blue[\C_Cyan\Y1\C_Blue]\C_LightGreen\#>' |
|
252 | #prompt_in1 '\C_Red\u\C_Blue[\C_Cyan\Y1\C_Blue]\C_LightGreen\#>' | |
251 | prompt_in2 ' ..\D>' |
|
253 | prompt_in2 ' ..\D>' | |
252 | prompt_out '<\#>' |
|
254 | prompt_out '<\#>' | |
253 |
|
255 | |||
254 | which look like this:: |
|
256 | which look like this:: | |
255 |
|
257 | |||
256 | fperez[~/ipython]1> 1+2 |
|
258 | fperez[~/ipython]1> 1+2 | |
257 | <1> 3 |
|
259 | <1> 3 | |
258 | fperez[~/ipython]2> for i in (1,2,3): |
|
260 | fperez[~/ipython]2> for i in (1,2,3): | |
259 | ...> print i, |
|
261 | ...> print i, | |
260 | ...> |
|
262 | ...> | |
261 | 1 2 3 |
|
263 | 1 2 3 | |
262 |
|
264 | |||
263 |
|
265 | |||
264 | .. _Profiles: |
|
266 | .. _Profiles: | |
265 |
|
267 | |||
266 | IPython profiles |
|
268 | IPython profiles | |
267 | ================ |
|
269 | ================ | |
268 |
|
270 | |||
269 | As we already mentioned, IPython supports the -profile command-line |
|
271 | As we already mentioned, IPython supports the -profile command-line option (see | |
270 |
|
|
272 | :ref:`here <command_line_options>`). A profile is nothing more than a | |
271 |
|
|
273 | particular configuration file like your basic ipythonrc one, but with | |
272 |
|
|
274 | particular customizations for a specific purpose. When you start IPython with | |
273 |
|
|
275 | 'ipython -profile <name>', it assumes that in your IPYTHONDIR there is a file | |
274 | IPYTHONDIR there is a file called ipythonrc-<name> or |
|
276 | called ipythonrc-<name> or ipy_profile_<name>.py, and loads it instead of the | |
275 | ipy_profile_<name>.py, and loads it instead of the normal ipythonrc. |
|
277 | normal ipythonrc. | |
276 |
|
278 | |||
277 | This system allows you to maintain multiple configurations which load |
|
279 | This system allows you to maintain multiple configurations which load | |
278 | modules, set options, define functions, etc. suitable for different |
|
280 | modules, set options, define functions, etc. suitable for different | |
279 | tasks and activate them in a very simple manner. In order to avoid |
|
281 | tasks and activate them in a very simple manner. In order to avoid | |
280 | having to repeat all of your basic options (common things that don't |
|
282 | having to repeat all of your basic options (common things that don't | |
281 | change such as your color preferences, for example), any profile can |
|
283 | change such as your color preferences, for example), any profile can | |
282 | include another configuration file. The most common way to use profiles |
|
284 | include another configuration file. The most common way to use profiles | |
283 | is then to have each one include your basic ipythonrc file as a starting |
|
285 | is then to have each one include your basic ipythonrc file as a starting | |
284 | point, and then add further customizations. No newline at end of file |
|
286 | point, and then add further customizations. |
@@ -1,243 +1,244 b'' | |||||
1 | .. _initial config: |
|
1 | .. _initial config: | |
2 |
|
2 | |||
3 | ========================================= |
|
3 | ========================================= | |
4 | Initial configuration of your environment |
|
4 | Initial configuration of your environment | |
5 | ========================================= |
|
5 | ========================================= | |
6 |
|
6 | |||
7 | This section will help you set various things in your environment for |
|
7 | This section will help you set various things in your environment for | |
8 | your IPython sessions to be as efficient as possible. All of IPython's |
|
8 | your IPython sessions to be as efficient as possible. All of IPython's | |
9 | configuration information, along with several example files, is stored |
|
9 | configuration information, along with several example files, is stored | |
10 | in a directory named by default $HOME/.ipython. You can change this by |
|
10 | in a directory named by default $HOME/.ipython. You can change this by | |
11 | defining the environment variable IPYTHONDIR, or at runtime with the |
|
11 | defining the environment variable IPYTHONDIR, or at runtime with the | |
12 | command line option -ipythondir. |
|
12 | command line option -ipythondir. | |
13 |
|
13 | |||
14 | If all goes well, the first time you run IPython it should |
|
14 | If all goes well, the first time you run IPython it should automatically create | |
15 |
|
|
15 | a user copy of the config directory for you, based on its builtin defaults. You | |
16 | based on its builtin defaults. You can look at the files it creates to |
|
16 | can look at the files it creates to learn more about configuring the | |
17 | learn more about configuring the system. The main file you will modify |
|
17 | system. The main file you will modify to configure IPython's behavior is called | |
18 | to configure IPython's behavior is called ipythonrc (with a .ini |
|
18 | ipythonrc (with a .ini extension under Windows), included for reference | |
19 | extension under Windows), included for reference in `ipythonrc`_ |
|
19 | :ref:`here <ipythonrc>`. This file is very commented and has many variables you | |
20 | section. This file is very commented and has many variables you can |
|
20 | can change to suit your taste, you can find more details :ref:`here | |
21 | change to suit your taste, you can find more details in |
|
21 | <customization>`. Here we discuss the basic things you will want to make sure | |
22 | Sec. customization_. Here we discuss the basic things you will want to |
|
22 | things are working properly from the beginning. | |
23 | make sure things are working properly from the beginning. |
|
|||
24 |
|
23 | |||
25 |
|
24 | |||
26 |
.. _ |
|
25 | .. _accessing_help: | |
27 |
|
26 | |||
28 | Access to the Python help system |
|
27 | Access to the Python help system | |
29 | ================================ |
|
28 | ================================ | |
30 |
|
29 | |||
31 | This is true for Python in general (not just for IPython): you should |
|
30 | This is true for Python in general (not just for IPython): you should have an | |
32 |
|
|
31 | environment variable called PYTHONDOCS pointing to the directory where your | |
33 |
|
|
32 | HTML Python documentation lives. In my system it's | |
34 |
/usr/share/doc/python-doc |
|
33 | :file:`/usr/share/doc/python-doc/html`, check your local details or ask your | |
35 |
|
|
34 | systems administrator. | |
36 |
|
35 | |||
37 | This is the directory which holds the HTML version of the Python |
|
36 | This is the directory which holds the HTML version of the Python | |
38 | manuals. Unfortunately it seems that different Linux distributions |
|
37 | manuals. Unfortunately it seems that different Linux distributions | |
39 | package these files differently, so you may have to look around a bit. |
|
38 | package these files differently, so you may have to look around a bit. | |
40 | Below I show the contents of this directory on my system for reference:: |
|
39 | Below I show the contents of this directory on my system for reference:: | |
41 |
|
40 | |||
42 | [html]> ls |
|
41 | [html]> ls | |
43 | about.dat acks.html dist/ ext/ index.html lib/ modindex.html |
|
42 | about.html dist/ icons/ lib/ python2.5.devhelp.gz whatsnew/ | |
44 | stdabout.dat tut/ about.html api/ doc/ icons/ inst/ mac/ ref/ style.css |
|
43 | acks.html doc/ index.html mac/ ref/ | |
|
44 | api/ ext/ inst/ modindex.html tut/ | |||
45 |
|
45 | |||
46 | You should really make sure this variable is correctly set so that |
|
46 | You should really make sure this variable is correctly set so that | |
47 | Python's pydoc-based help system works. It is a powerful and convenient |
|
47 | Python's pydoc-based help system works. It is a powerful and convenient | |
48 | system with full access to the Python manuals and all modules accessible |
|
48 | system with full access to the Python manuals and all modules accessible | |
49 | to you. |
|
49 | to you. | |
50 |
|
50 | |||
51 | Under Windows it seems that pydoc finds the documentation automatically, |
|
51 | Under Windows it seems that pydoc finds the documentation automatically, | |
52 | so no extra setup appears necessary. |
|
52 | so no extra setup appears necessary. | |
53 |
|
53 | |||
54 |
|
54 | |||
55 | Editor |
|
55 | Editor | |
56 | ====== |
|
56 | ====== | |
57 |
|
57 | |||
58 | The %edit command (and its alias %ed) will invoke the editor set in your |
|
58 | The %edit command (and its alias %ed) will invoke the editor set in your | |
59 | environment as EDITOR. If this variable is not set, it will default to |
|
59 | environment as EDITOR. If this variable is not set, it will default to | |
60 | vi under Linux/Unix and to notepad under Windows. You may want to set |
|
60 | vi under Linux/Unix and to notepad under Windows. You may want to set | |
61 | this variable properly and to a lightweight editor which doesn't take |
|
61 | this variable properly and to a lightweight editor which doesn't take | |
62 | too long to start (that is, something other than a new instance of |
|
62 | too long to start (that is, something other than a new instance of | |
63 | Emacs). This way you can edit multi-line code quickly and with the power |
|
63 | Emacs). This way you can edit multi-line code quickly and with the power | |
64 | of a real editor right inside IPython. |
|
64 | of a real editor right inside IPython. | |
65 |
|
65 | |||
66 | If you are a dedicated Emacs user, you should set up the Emacs server so |
|
66 | If you are a dedicated Emacs user, you should set up the Emacs server so | |
67 | that new requests are handled by the original process. This means that |
|
67 | that new requests are handled by the original process. This means that | |
68 | almost no time is spent in handling the request (assuming an Emacs |
|
68 | almost no time is spent in handling the request (assuming an Emacs | |
69 | process is already running). For this to work, you need to set your |
|
69 | process is already running). For this to work, you need to set your | |
70 | EDITOR environment variable to 'emacsclient'. The code below, supplied |
|
70 | EDITOR environment variable to 'emacsclient'. The code below, supplied | |
71 | by Francois Pinard, can then be used in your .emacs file to enable the |
|
71 | by Francois Pinard, can then be used in your .emacs file to enable the | |
72 | server:: |
|
72 | server:: | |
73 |
|
73 | |||
74 | (defvar server-buffer-clients) |
|
74 | (defvar server-buffer-clients) | |
75 | (when (and (fboundp 'server-start) (string-equal (getenv "TERM") 'xterm)) |
|
75 | (when (and (fboundp 'server-start) (string-equal (getenv "TERM") 'xterm)) | |
76 | (server-start) |
|
76 | (server-start) | |
77 | (defun fp-kill-server-with-buffer-routine () |
|
77 | (defun fp-kill-server-with-buffer-routine () | |
78 | (and server-buffer-clients (server-done))) |
|
78 | (and server-buffer-clients (server-done))) | |
79 | (add-hook 'kill-buffer-hook 'fp-kill-server-with-buffer-routine)) |
|
79 | (add-hook 'kill-buffer-hook 'fp-kill-server-with-buffer-routine)) | |
80 |
|
80 | |||
81 | You can also set the value of this editor via the commmand-line option |
|
81 | You can also set the value of this editor via the commmand-line option | |
82 | '-editor' or in your ipythonrc file. This is useful if you wish to use |
|
82 | '-editor' or in your ipythonrc file. This is useful if you wish to use | |
83 | specifically for IPython an editor different from your typical default |
|
83 | specifically for IPython an editor different from your typical default | |
84 | (and for Windows users who tend to use fewer environment variables). |
|
84 | (and for Windows users who tend to use fewer environment variables). | |
85 |
|
85 | |||
86 |
|
86 | |||
87 | Color |
|
87 | Color | |
88 | ===== |
|
88 | ===== | |
89 |
|
89 | |||
90 | The default IPython configuration has most bells and whistles turned on |
|
90 | The default IPython configuration has most bells and whistles turned on | |
91 | (they're pretty safe). But there's one that may cause problems on some |
|
91 | (they're pretty safe). But there's one that may cause problems on some | |
92 | systems: the use of color on screen for displaying information. This is |
|
92 | systems: the use of color on screen for displaying information. This is | |
93 | very useful, since IPython can show prompts and exception tracebacks |
|
93 | very useful, since IPython can show prompts and exception tracebacks | |
94 | with various colors, display syntax-highlighted source code, and in |
|
94 | with various colors, display syntax-highlighted source code, and in | |
95 | general make it easier to visually parse information. |
|
95 | general make it easier to visually parse information. | |
96 |
|
96 | |||
97 | The following terminals seem to handle the color sequences fine: |
|
97 | The following terminals seem to handle the color sequences fine: | |
98 |
|
98 | |||
99 | * Linux main text console, KDE Konsole, Gnome Terminal, E-term, |
|
99 | * Linux main text console, KDE Konsole, Gnome Terminal, E-term, | |
100 | rxvt, xterm. |
|
100 | rxvt, xterm. | |
101 | * CDE terminal (tested under Solaris). This one boldfaces light colors. |
|
101 | * CDE terminal (tested under Solaris). This one boldfaces light colors. | |
102 | * (X)Emacs buffers. See the emacs_ section for more details on |
|
102 | * (X)Emacs buffers. See the emacs_ section for more details on | |
103 | using IPython with (X)Emacs. |
|
103 | using IPython with (X)Emacs. | |
104 | * A Windows (XP/2k) command prompt with pyreadline_. |
|
104 | * A Windows (XP/2k) command prompt with pyreadline_. | |
105 | * A Windows (XP/2k) CygWin shell. Although some users have reported |
|
105 | * A Windows (XP/2k) CygWin shell. Although some users have reported | |
106 | problems; it is not clear whether there is an issue for everyone |
|
106 | problems; it is not clear whether there is an issue for everyone | |
107 | or only under specific configurations. If you have full color |
|
107 | or only under specific configurations. If you have full color | |
108 | support under cygwin, please post to the IPython mailing list so |
|
108 | support under cygwin, please post to the IPython mailing list so | |
109 | this issue can be resolved for all users. |
|
109 | this issue can be resolved for all users. | |
110 |
|
110 | |||
|
111 | .. _pyreadline: https://code.launchpad.net/pyreadline | |||
|
112 | ||||
111 | These have shown problems: |
|
113 | These have shown problems: | |
112 |
|
114 | |||
113 | * Windows command prompt in WinXP/2k logged into a Linux machine via |
|
115 | * Windows command prompt in WinXP/2k logged into a Linux machine via | |
114 | telnet or ssh. |
|
116 | telnet or ssh. | |
115 | * Windows native command prompt in WinXP/2k, without Gary Bishop's |
|
117 | * Windows native command prompt in WinXP/2k, without Gary Bishop's | |
116 | extensions. Once Gary's readline library is installed, the normal |
|
118 | extensions. Once Gary's readline library is installed, the normal | |
117 | WinXP/2k command prompt works perfectly. |
|
119 | WinXP/2k command prompt works perfectly. | |
118 |
|
120 | |||
119 | Currently the following color schemes are available: |
|
121 | Currently the following color schemes are available: | |
120 |
|
122 | |||
121 | * NoColor: uses no color escapes at all (all escapes are empty '' '' |
|
123 | * NoColor: uses no color escapes at all (all escapes are empty '' '' | |
122 | strings). This 'scheme' is thus fully safe to use in any terminal. |
|
124 | strings). This 'scheme' is thus fully safe to use in any terminal. | |
123 | * Linux: works well in Linux console type environments: dark |
|
125 | * Linux: works well in Linux console type environments: dark | |
124 | background with light fonts. It uses bright colors for |
|
126 | background with light fonts. It uses bright colors for | |
125 | information, so it is difficult to read if you have a light |
|
127 | information, so it is difficult to read if you have a light | |
126 | colored background. |
|
128 | colored background. | |
127 | * LightBG: the basic colors are similar to those in the Linux scheme |
|
129 | * LightBG: the basic colors are similar to those in the Linux scheme | |
128 | but darker. It is easy to read in terminals with light backgrounds. |
|
130 | but darker. It is easy to read in terminals with light backgrounds. | |
129 |
|
131 | |||
130 | IPython uses colors for two main groups of things: prompts and |
|
132 | IPython uses colors for two main groups of things: prompts and | |
131 | tracebacks which are directly printed to the terminal, and the object |
|
133 | tracebacks which are directly printed to the terminal, and the object | |
132 | introspection system which passes large sets of data through a pager. |
|
134 | introspection system which passes large sets of data through a pager. | |
133 |
|
135 | |||
134 |
|
136 | |||
135 | Input/Output prompts and exception tracebacks |
|
137 | Input/Output prompts and exception tracebacks | |
136 | ============================================= |
|
138 | ============================================= | |
137 |
|
139 | |||
138 | You can test whether the colored prompts and tracebacks work on your |
|
140 | You can test whether the colored prompts and tracebacks work on your | |
139 | system interactively by typing '%colors Linux' at the prompt (use |
|
141 | system interactively by typing '%colors Linux' at the prompt (use | |
140 | '%colors LightBG' if your terminal has a light background). If the input |
|
142 | '%colors LightBG' if your terminal has a light background). If the input | |
141 | prompt shows garbage like:: |
|
143 | prompt shows garbage like:: | |
142 |
|
144 | |||
143 | [0;32mIn [[1;32m1[0;32m]: [0;00m |
|
145 | [0;32mIn [[1;32m1[0;32m]: [0;00m | |
144 |
|
146 | |||
145 | instead of (in color) something like:: |
|
147 | instead of (in color) something like:: | |
146 |
|
148 | |||
147 | In [1]: |
|
149 | In [1]: | |
148 |
|
150 | |||
149 | this means that your terminal doesn't properly handle color escape |
|
151 | this means that your terminal doesn't properly handle color escape | |
150 | sequences. You can go to a 'no color' mode by typing '%colors NoColor'. |
|
152 | sequences. You can go to a 'no color' mode by typing '%colors NoColor'. | |
151 |
|
153 | |||
152 | You can try using a different terminal emulator program (Emacs users, |
|
154 | You can try using a different terminal emulator program (Emacs users, | |
153 | see below). To permanently set your color preferences, edit the file |
|
155 | see below). To permanently set your color preferences, edit the file | |
154 | $HOME/.ipython/ipythonrc and set the colors option to the desired value. |
|
156 | $HOME/.ipython/ipythonrc and set the colors option to the desired value. | |
155 |
|
157 | |||
156 |
|
158 | |||
157 | Object details (types, docstrings, source code, etc.) |
|
159 | Object details (types, docstrings, source code, etc.) | |
158 | ===================================================== |
|
160 | ===================================================== | |
159 |
|
161 | |||
160 | IPython has a set of special functions for studying the objects you |
|
162 | IPython has a set of special functions for studying the objects you are working | |
161 | are working with, discussed in detail in Sec. `dynamic object |
|
163 | with, discussed in detail :ref:`here <dynamic_object_info>`. But this system | |
162 | information`_. But this system relies on passing information which is |
|
164 | relies on passing information which is longer than your screen through a data | |
163 | longer than your screen through a data pager, such as the common Unix |
|
165 | pager, such as the common Unix less and more programs. In order to be able to | |
164 | less and more programs. In order to be able to see this information in |
|
166 | see this information in color, your pager needs to be properly configured. I | |
165 | color, your pager needs to be properly configured. I strongly |
|
167 | strongly recommend using less instead of more, as it seems that more simply can | |
166 | recommend using less instead of more, as it seems that more simply can |
|
|||
167 | not understand colored text correctly. |
|
168 | not understand colored text correctly. | |
168 |
|
169 | |||
169 | In order to configure less as your default pager, do the following: |
|
170 | In order to configure less as your default pager, do the following: | |
170 |
|
171 | |||
171 | 1. Set the environment PAGER variable to less. |
|
172 | 1. Set the environment PAGER variable to less. | |
172 | 2. Set the environment LESS variable to -r (plus any other options |
|
173 | 2. Set the environment LESS variable to -r (plus any other options | |
173 | you always want to pass to less by default). This tells less to |
|
174 | you always want to pass to less by default). This tells less to | |
174 | properly interpret control sequences, which is how color |
|
175 | properly interpret control sequences, which is how color | |
175 | information is given to your terminal. |
|
176 | information is given to your terminal. | |
176 |
|
177 | |||
177 | For the csh or tcsh shells, add to your ~/.cshrc file the lines:: |
|
178 | For the csh or tcsh shells, add to your ~/.cshrc file the lines:: | |
178 |
|
179 | |||
179 | setenv PAGER less |
|
180 | setenv PAGER less | |
180 | setenv LESS -r |
|
181 | setenv LESS -r | |
181 |
|
182 | |||
182 | There is similar syntax for other Unix shells, look at your system |
|
183 | There is similar syntax for other Unix shells, look at your system | |
183 | documentation for details. |
|
184 | documentation for details. | |
184 |
|
185 | |||
185 | If you are on a system which lacks proper data pagers (such as Windows), |
|
186 | If you are on a system which lacks proper data pagers (such as Windows), | |
186 | IPython will use a very limited builtin pager. |
|
187 | IPython will use a very limited builtin pager. | |
187 |
|
188 | |||
188 | .. _emacs: |
|
189 | .. _emacs: | |
189 |
|
190 | |||
190 | (X)Emacs configuration |
|
191 | (X)Emacs configuration | |
191 | ====================== |
|
192 | ====================== | |
192 |
|
193 | |||
193 | Thanks to the work of Alexander Schmolck and Prabhu Ramachandran, |
|
194 | Thanks to the work of Alexander Schmolck and Prabhu Ramachandran, | |
194 | currently (X)Emacs and IPython get along very well. |
|
195 | currently (X)Emacs and IPython get along very well. | |
195 |
|
196 | |||
196 | Important note: You will need to use a recent enough version of |
|
197 | Important note: You will need to use a recent enough version of | |
197 | python-mode.el, along with the file ipython.el. You can check that the |
|
198 | python-mode.el, along with the file ipython.el. You can check that the | |
198 | version you have of python-mode.el is new enough by either looking at |
|
199 | version you have of python-mode.el is new enough by either looking at | |
199 | the revision number in the file itself, or asking for it in (X)Emacs via |
|
200 | the revision number in the file itself, or asking for it in (X)Emacs via | |
200 | M-x py-version. Versions 4.68 and newer contain the necessary fixes for |
|
201 | M-x py-version. Versions 4.68 and newer contain the necessary fixes for | |
201 | proper IPython support. |
|
202 | proper IPython support. | |
202 |
|
203 | |||
203 | The file ipython.el is included with the IPython distribution, in the |
|
204 | The file ipython.el is included with the IPython distribution, in the | |
204 | documentation directory (where this manual resides in PDF and HTML |
|
205 | documentation directory (where this manual resides in PDF and HTML | |
205 | formats). |
|
206 | formats). | |
206 |
|
207 | |||
207 | Once you put these files in your Emacs path, all you need in your .emacs |
|
208 | Once you put these files in your Emacs path, all you need in your .emacs | |
208 | file is:: |
|
209 | file is:: | |
209 |
|
210 | |||
210 | (require 'ipython) |
|
211 | (require 'ipython) | |
211 |
|
212 | |||
212 | This should give you full support for executing code snippets via |
|
213 | This should give you full support for executing code snippets via | |
213 | IPython, opening IPython as your Python shell via ``C-c !``, etc. |
|
214 | IPython, opening IPython as your Python shell via ``C-c !``, etc. | |
214 |
|
215 | |||
215 | You can customize the arguments passed to the IPython instance at startup by |
|
216 | You can customize the arguments passed to the IPython instance at startup by | |
216 | setting the ``py-python-command-args`` variable. For example, to start always |
|
217 | setting the ``py-python-command-args`` variable. For example, to start always | |
217 | in ``pylab`` mode with hardcoded light-background colors, you can use:: |
|
218 | in ``pylab`` mode with hardcoded light-background colors, you can use:: | |
218 |
|
219 | |||
219 | (setq py-python-command-args '("-pylab" "-colors" "LightBG")) |
|
220 | (setq py-python-command-args '("-pylab" "-colors" "LightBG")) | |
220 |
|
221 | |||
221 | If you happen to get garbage instead of colored prompts as described in |
|
222 | If you happen to get garbage instead of colored prompts as described in | |
222 | the previous section, you may need to set also in your .emacs file:: |
|
223 | the previous section, you may need to set also in your .emacs file:: | |
223 |
|
224 | |||
224 | (setq ansi-color-for-comint-mode t) |
|
225 | (setq ansi-color-for-comint-mode t) | |
225 |
|
226 | |||
226 | Notes: |
|
227 | Notes: | |
227 |
|
228 | |||
228 | * There is one caveat you should be aware of: you must start the |
|
229 | * There is one caveat you should be aware of: you must start the | |
229 | IPython shell before attempting to execute any code regions via |
|
230 | IPython shell before attempting to execute any code regions via | |
230 | ``C-c |``. Simply type C-c ! to start IPython before passing any code |
|
231 | ``C-c |``. Simply type C-c ! to start IPython before passing any code | |
231 | regions to the interpreter, and you shouldn't experience any |
|
232 | regions to the interpreter, and you shouldn't experience any | |
232 | problems. |
|
233 | problems. | |
233 | This is due to a bug in Python itself, which has been fixed for |
|
234 | This is due to a bug in Python itself, which has been fixed for | |
234 | Python 2.3, but exists as of Python 2.2.2 (reported as SF bug [ |
|
235 | Python 2.3, but exists as of Python 2.2.2 (reported as SF bug [ | |
235 | 737947 ]). |
|
236 | 737947 ]). | |
236 | * The (X)Emacs support is maintained by Alexander Schmolck, so all |
|
237 | * The (X)Emacs support is maintained by Alexander Schmolck, so all | |
237 | comments/requests should be directed to him through the IPython |
|
238 | comments/requests should be directed to him through the IPython | |
238 | mailing lists. |
|
239 | mailing lists. | |
239 | * This code is still somewhat experimental so it's a bit rough |
|
240 | * This code is still somewhat experimental so it's a bit rough | |
240 | around the edges (although in practice, it works quite well). |
|
241 | around the edges (although in practice, it works quite well). | |
241 | * Be aware that if you customize py-python-command previously, this |
|
242 | * Be aware that if you customize py-python-command previously, this | |
242 | value will override what ipython.el does (because loading the |
|
243 | value will override what ipython.el does (because loading the | |
243 | customization variables comes later). |
|
244 | customization variables comes later). |
@@ -1,139 +1,207 b'' | |||||
1 | .. _credits: |
|
1 | .. _credits: | |
2 |
|
2 | |||
3 | ======= |
|
3 | ======= | |
4 | Credits |
|
4 | Credits | |
5 | ======= |
|
5 | ======= | |
6 |
|
6 | |||
7 |
IPython is |
|
7 | IPython is led by Fernando Pérez. | |
8 | <Fernando.Perez@colorado.edu>, but the project was born from mixing in |
|
8 | ||
9 | Fernando's code with the IPP project by Janko Hauser |
|
9 | As of this writing, the following developers have joined the core team: | |
10 | <jhauser-AT-zscout.de> and LazyPython by Nathan Gray |
|
10 | ||
11 | <n8gray-AT-caltech.edu>. For all IPython-related requests, please |
|
11 | * [Robert Kern] <rkern-AT-enthought.com>: co-mentored the 2005 | |
12 | contact Fernando. |
|
12 | Google Summer of Code project to develop python interactive | |
13 |
|
13 | notebooks (XML documents) and graphical interface. This project | ||
14 | As of early 2006, the following developers have joined the core team: |
|
14 | was awarded to the students Tzanko Matev <tsanko-AT-gmail.com> and | |
15 |
|
15 | Toni Alatalo <antont-AT-an.org>. | ||
16 | * [Robert Kern] <rkern-AT-enthought.com>: co-mentored the 2005 |
|
16 | ||
17 | Google Summer of Code project to develop python interactive |
|
17 | * [Brian Granger] <ellisonbg-AT-gmail.com>: extending IPython to allow | |
18 | notebooks (XML documents) and graphical interface. This project |
|
18 | support for interactive parallel computing. | |
19 | was awarded to the students Tzanko Matev <tsanko-AT-gmail.com> and |
|
19 | ||
20 | Toni Alatalo <antont-AT-an.org> |
|
20 | * [Benjamin (Min) Ragan-Kelley]: key work on IPython's parallel | |
21 | * [Brian Granger] <bgranger-AT-scu.edu>: extending IPython to allow |
|
21 | computing infrastructure. | |
22 | support for interactive parallel computing. |
|
22 | ||
23 |
|
|
23 | * [Ville Vainio] <vivainio-AT-gmail.com>: Ville has made many improvements | |
24 | maintainer for the main trunk of IPython after version 0.7.1. |
|
24 | to the core of IPython and was the maintainer of the main IPython | |
|
25 | trunk from version 0.7.1 to 0.8.4. | |||
|
26 | ||||
|
27 | * [Gael Varoquaux] <gael.varoquaux-AT-normalesup.org>: work on the merged | |||
|
28 | architecture for the interpreter as of version 0.9, implementing a new WX GUI | |||
|
29 | based on this system. | |||
|
30 | ||||
|
31 | * [Barry Wark] <barrywark-AT-gmail.com>: implementing a new Cocoa GUI, as well | |||
|
32 | as work on the new interpreter architecture and Twisted support. | |||
|
33 | ||||
|
34 | * [Laurent Dufrechou] <laurent.dufrechou-AT-gmail.com>: development of the WX | |||
|
35 | GUI support. | |||
|
36 | ||||
|
37 | * [Jörgen Stenarson] <jorgen.stenarson-AT-bostream.nu>: maintainer of the | |||
|
38 | PyReadline project, necessary for IPython under windows. | |||
|
39 | ||||
25 |
|
40 | |||
26 | The IPython project is also very grateful to: |
|
41 | The IPython project is also very grateful to: | |
27 |
|
42 | |||
28 | Bill Bumgarner <bbum-AT-friday.com>: for providing the DPyGetOpt module |
|
43 | Bill Bumgarner <bbum-AT-friday.com>: for providing the DPyGetOpt module | |
29 | which gives very powerful and convenient handling of command-line |
|
44 | which gives very powerful and convenient handling of command-line | |
30 | options (light years ahead of what Python 2.1.1's getopt module does). |
|
45 | options (light years ahead of what Python 2.1.1's getopt module does). | |
31 |
|
46 | |||
32 | Ka-Ping Yee <ping-AT-lfw.org>: for providing the Itpl module for |
|
47 | Ka-Ping Yee <ping-AT-lfw.org>: for providing the Itpl module for | |
33 | convenient and powerful string interpolation with a much nicer syntax |
|
48 | convenient and powerful string interpolation with a much nicer syntax | |
34 | than formatting through the '%' operator. |
|
49 | than formatting through the '%' operator. | |
35 |
|
50 | |||
36 | Arnd Baecker <baecker-AT-physik.tu-dresden.de>: for his many very useful |
|
51 | Arnd Baecker <baecker-AT-physik.tu-dresden.de>: for his many very useful | |
37 | suggestions and comments, and lots of help with testing and |
|
52 | suggestions and comments, and lots of help with testing and | |
38 | documentation checking. Many of IPython's newer features are a result of |
|
53 | documentation checking. Many of IPython's newer features are a result of | |
39 | discussions with him (bugs are still my fault, not his). |
|
54 | discussions with him (bugs are still my fault, not his). | |
40 |
|
55 | |||
41 | Obviously Guido van Rossum and the whole Python development team, that |
|
56 | Obviously Guido van Rossum and the whole Python development team, that | |
42 | goes without saying. |
|
57 | goes without saying. | |
43 |
|
58 | |||
44 | IPython's website is generously hosted at http://ipython.scipy.orgby |
|
59 | IPython's website is generously hosted at http://ipython.scipy.orgby | |
45 | Enthought (http://www.enthought.com). I am very grateful to them and all |
|
60 | Enthought (http://www.enthought.com). I am very grateful to them and all | |
46 | of the SciPy team for their contribution. |
|
61 | of the SciPy team for their contribution. | |
47 |
|
62 | |||
48 | Fernando would also like to thank Stephen Figgins <fig-AT-monitor.net>, |
|
63 | Fernando would also like to thank Stephen Figgins <fig-AT-monitor.net>, | |
49 | an O'Reilly Python editor. His Oct/11/2001 article about IPP and |
|
64 | an O'Reilly Python editor. His Oct/11/2001 article about IPP and | |
50 | LazyPython, was what got this project started. You can read it at: |
|
65 | LazyPython, was what got this project started. You can read it at: | |
51 | http://www.onlamp.com/pub/a/python/2001/10/11/pythonnews.html. |
|
66 | http://www.onlamp.com/pub/a/python/2001/10/11/pythonnews.html. | |
52 |
|
67 | |||
53 | And last but not least, all the kind IPython users who have emailed new |
|
68 | And last but not least, all the kind IPython users who have emailed new code, | |
54 |
|
|
69 | bug reports, fixes, comments and ideas. A brief list follows, please let us | |
55 |
|
|
70 | know if we have ommitted your name by accident: | |
56 |
|
71 | |||
57 | * [Jack Moffit] <jack-AT-xiph.org> Bug fixes, including the infamous |
|
72 | * Dan Milstein <danmil-AT-comcast.net>. A bold refactoring of the | |
58 | color problem. This bug alone caused many lost hours and |
|
73 | core prefilter stuff in the IPython interpreter. | |
59 | frustration, many thanks to him for the fix. I've always been a |
|
74 | ||
60 | fan of Ogg & friends, now I have one more reason to like these folks. |
|
75 | * [Jack Moffit] <jack-AT-xiph.org> Bug fixes, including the infamous | |
61 | Jack is also contributing with Debian packaging and many other |
|
76 | color problem. This bug alone caused many lost hours and | |
62 | things. |
|
77 | frustration, many thanks to him for the fix. I've always been a | |
63 | * [Alexander Schmolck] <a.schmolck-AT-gmx.net> Emacs work, bug |
|
78 | fan of Ogg & friends, now I have one more reason to like these folks. | |
64 | reports, bug fixes, ideas, lots more. The ipython.el mode for |
|
79 | Jack is also contributing with Debian packaging and many other | |
65 | (X)Emacs is Alex's code, providing full support for IPython under |
|
80 | things. | |
66 | (X)Emacs. |
|
81 | ||
67 | * [Andrea Riciputi] <andrea.riciputi-AT-libero.it> Mac OSX |
|
82 | * [Alexander Schmolck] <a.schmolck-AT-gmx.net> Emacs work, bug | |
68 | information, Fink package management. |
|
83 | reports, bug fixes, ideas, lots more. The ipython.el mode for | |
69 | * [Gary Bishop] <gb-AT-cs.unc.edu> Bug reports, and patches to work |
|
84 | (X)Emacs is Alex's code, providing full support for IPython under | |
70 | around the exception handling idiosyncracies of WxPython. Readline |
|
85 | (X)Emacs. | |
71 | and color support for Windows. |
|
86 | ||
72 | * [Jeffrey Collins] <Jeff.Collins-AT-vexcel.com> Bug reports. Much |
|
87 | * [Andrea Riciputi] <andrea.riciputi-AT-libero.it> Mac OSX | |
73 | improved readline support, including fixes for Python 2.3. |
|
88 | information, Fink package management. | |
74 | * [Dryice Liu] <dryice-AT-liu.com.cn> FreeBSD port. |
|
89 | ||
75 | * [Mike Heeter] <korora-AT-SDF.LONESTAR.ORG> |
|
90 | * [Gary Bishop] <gb-AT-cs.unc.edu> Bug reports, and patches to work | |
76 | * [Christopher Hart] <hart-AT-caltech.edu> PDB integration. |
|
91 | around the exception handling idiosyncracies of WxPython. Readline | |
77 | * [Milan Zamazal] <pdm-AT-zamazal.org> Emacs info. |
|
92 | and color support for Windows. | |
78 | * [Philip Hisley] <compsys-AT-starpower.net> |
|
93 | ||
79 | * [Holger Krekel] <pyth-AT-devel.trillke.net> Tab completion, lots |
|
94 | * [Jeffrey Collins] <Jeff.Collins-AT-vexcel.com> Bug reports. Much | |
80 | more. |
|
95 | improved readline support, including fixes for Python 2.3. | |
81 | * [Robin Siebler] <robinsiebler-AT-starband.net> |
|
96 | ||
82 | * [Ralf Ahlbrink] <ralf_ahlbrink-AT-web.de> |
|
97 | * [Dryice Liu] <dryice-AT-liu.com.cn> FreeBSD port. | |
83 | * [Thorsten Kampe] <thorsten-AT-thorstenkampe.de> |
|
98 | ||
84 | * [Fredrik Kant] <fredrik.kant-AT-front.com> Windows setup. |
|
99 | * [Mike Heeter] <korora-AT-SDF.LONESTAR.ORG> | |
85 | * [Syver Enstad] <syver-en-AT-online.no> Windows setup. |
|
100 | ||
86 | * [Richard] <rxe-AT-renre-europe.com> Global embedding. |
|
101 | * [Christopher Hart] <hart-AT-caltech.edu> PDB integration. | |
87 | * [Hayden Callow] <h.callow-AT-elec.canterbury.ac.nz> Gnuplot.py 1.6 |
|
102 | ||
88 | compatibility. |
|
103 | * [Milan Zamazal] <pdm-AT-zamazal.org> Emacs info. | |
89 | * [Leonardo Santagada] <retype-AT-terra.com.br> Fixes for Windows |
|
104 | ||
90 | installation. |
|
105 | * [Philip Hisley] <compsys-AT-starpower.net> | |
91 | * [Christopher Armstrong] <radix-AT-twistedmatrix.com> Bugfixes. |
|
106 | ||
92 | * [Francois Pinard] <pinard-AT-iro.umontreal.ca> Code and |
|
107 | * [Holger Krekel] <pyth-AT-devel.trillke.net> Tab completion, lots | |
93 | documentation fixes. |
|
108 | more. | |
94 | * [Cory Dodt] <cdodt-AT-fcoe.k12.ca.us> Bug reports and Windows |
|
109 | ||
95 | ideas. Patches for Windows installer. |
|
110 | * [Robin Siebler] <robinsiebler-AT-starband.net> | |
96 | * [Olivier Aubert] <oaubert-AT-bat710.univ-lyon1.fr> New magics. |
|
111 | ||
97 | * [King C. Shu] <kingshu-AT-myrealbox.com> Autoindent patch. |
|
112 | * [Ralf Ahlbrink] <ralf_ahlbrink-AT-web.de> | |
98 | * [Chris Drexler] <chris-AT-ac-drexler.de> Readline packages for |
|
113 | ||
99 | Win32/CygWin. |
|
114 | * [Thorsten Kampe] <thorsten-AT-thorstenkampe.de> | |
100 | * [Gustavo Cordova Avila] <gcordova-AT-sismex.com> EvalDict code for |
|
115 | ||
101 | nice, lightweight string interpolation. |
|
116 | * [Fredrik Kant] <fredrik.kant-AT-front.com> Windows setup. | |
102 | * [Kasper Souren] <Kasper.Souren-AT-ircam.fr> Bug reports, ideas. |
|
117 | ||
103 | * [Gever Tulley] <gever-AT-helium.com> Code contributions. |
|
118 | * [Syver Enstad] <syver-en-AT-online.no> Windows setup. | |
104 | * [Ralf Schmitt] <ralf-AT-brainbot.com> Bug reports & fixes. |
|
119 | ||
105 | * [Oliver Sander] <osander-AT-gmx.de> Bug reports. |
|
120 | * [Richard] <rxe-AT-renre-europe.com> Global embedding. | |
106 | * [Rod Holland] <rhh-AT-structurelabs.com> Bug reports and fixes to |
|
121 | ||
107 | logging module. |
|
122 | * [Hayden Callow] <h.callow-AT-elec.canterbury.ac.nz> Gnuplot.py 1.6 | |
108 | * [Daniel 'Dang' Griffith] <pythondev-dang-AT-lazytwinacres.net> |
|
123 | compatibility. | |
109 | Fixes, enhancement suggestions for system shell use. |
|
124 | ||
110 | * [Viktor Ransmayr] <viktor.ransmayr-AT-t-online.de> Tests and |
|
125 | * [Leonardo Santagada] <retype-AT-terra.com.br> Fixes for Windows | |
111 | reports on Windows installation issues. Contributed a true Windows |
|
126 | installation. | |
112 | binary installer. |
|
127 | ||
113 | * [Mike Salib] <msalib-AT-mit.edu> Help fixing a subtle bug related |
|
128 | * [Christopher Armstrong] <radix-AT-twistedmatrix.com> Bugfixes. | |
114 | to traceback printing. |
|
129 | ||
115 | * [W.J. van der Laan] <gnufnork-AT-hetdigitalegat.nl> Bash-like |
|
130 | * [Francois Pinard] <pinard-AT-iro.umontreal.ca> Code and | |
116 | prompt specials. |
|
131 | documentation fixes. | |
117 | * [Antoon Pardon] <Antoon.Pardon-AT-rece.vub.ac.be> Critical fix for |
|
132 | ||
118 | the multithreaded IPython. |
|
133 | * [Cory Dodt] <cdodt-AT-fcoe.k12.ca.us> Bug reports and Windows | |
119 | * [John Hunter] <jdhunter-AT-nitace.bsd.uchicago.edu> Matplotlib |
|
134 | ideas. Patches for Windows installer. | |
120 | author, helped with all the development of support for matplotlib |
|
135 | ||
121 | in IPyhton, including making necessary changes to matplotlib itself. |
|
136 | * [Olivier Aubert] <oaubert-AT-bat710.univ-lyon1.fr> New magics. | |
122 | * [Matthew Arnison] <maffew-AT-cat.org.au> Bug reports, '%run -d' idea. |
|
137 | ||
123 | * [Prabhu Ramachandran] <prabhu_r-AT-users.sourceforge.net> Help |
|
138 | * [King C. Shu] <kingshu-AT-myrealbox.com> Autoindent patch. | |
124 | with (X)Emacs support, threading patches, ideas... |
|
139 | ||
125 | * [Norbert Tretkowski] <tretkowski-AT-inittab.de> help with Debian |
|
140 | * [Chris Drexler] <chris-AT-ac-drexler.de> Readline packages for | |
126 | packaging and distribution. |
|
141 | Win32/CygWin. | |
127 | * [George Sakkis] <gsakkis-AT-eden.rutgers.edu> New matcher for |
|
142 | ||
128 | tab-completing named arguments of user-defined functions. |
|
143 | * [Gustavo Cordova Avila] <gcordova-AT-sismex.com> EvalDict code for | |
129 | * [Jörgen Stenarson] <jorgen.stenarson-AT-bostream.nu> Wildcard |
|
144 | nice, lightweight string interpolation. | |
130 | support implementation for searching namespaces. |
|
145 | ||
131 | * [Vivian De Smedt] <vivian-AT-vdesmedt.com> Debugger enhancements, |
|
146 | * [Kasper Souren] <Kasper.Souren-AT-ircam.fr> Bug reports, ideas. | |
132 | so that when pdb is activated from within IPython, coloring, tab |
|
147 | ||
133 | completion and other features continue to work seamlessly. |
|
148 | * [Gever Tulley] <gever-AT-helium.com> Code contributions. | |
134 | * [Scott Tsai] <scottt958-AT-yahoo.com.tw> Support for automatic |
|
149 | ||
135 | editor invocation on syntax errors (see |
|
150 | * [Ralf Schmitt] <ralf-AT-brainbot.com> Bug reports & fixes. | |
136 | http://www.scipy.net/roundup/ipython/issue36). |
|
151 | ||
137 | * [Alexander Belchenko] <bialix-AT-ukr.net> Improvements for win32 |
|
152 | * [Oliver Sander] <osander-AT-gmx.de> Bug reports. | |
138 | paging system. |
|
153 | ||
139 | * [Will Maier] <willmaier-AT-ml1.net> Official OpenBSD port. No newline at end of file |
|
154 | * [Rod Holland] <rhh-AT-structurelabs.com> Bug reports and fixes to | |
|
155 | logging module. | |||
|
156 | ||||
|
157 | * [Daniel 'Dang' Griffith] <pythondev-dang-AT-lazytwinacres.net> | |||
|
158 | Fixes, enhancement suggestions for system shell use. | |||
|
159 | ||||
|
160 | * [Viktor Ransmayr] <viktor.ransmayr-AT-t-online.de> Tests and | |||
|
161 | reports on Windows installation issues. Contributed a true Windows | |||
|
162 | binary installer. | |||
|
163 | ||||
|
164 | * [Mike Salib] <msalib-AT-mit.edu> Help fixing a subtle bug related | |||
|
165 | to traceback printing. | |||
|
166 | ||||
|
167 | * [W.J. van der Laan] <gnufnork-AT-hetdigitalegat.nl> Bash-like | |||
|
168 | prompt specials. | |||
|
169 | ||||
|
170 | * [Antoon Pardon] <Antoon.Pardon-AT-rece.vub.ac.be> Critical fix for | |||
|
171 | the multithreaded IPython. | |||
|
172 | ||||
|
173 | * [John Hunter] <jdhunter-AT-nitace.bsd.uchicago.edu> Matplotlib | |||
|
174 | author, helped with all the development of support for matplotlib | |||
|
175 | in IPyhton, including making necessary changes to matplotlib itself. | |||
|
176 | ||||
|
177 | * [Matthew Arnison] <maffew-AT-cat.org.au> Bug reports, '%run -d' idea. | |||
|
178 | ||||
|
179 | * [Prabhu Ramachandran] <prabhu_r-AT-users.sourceforge.net> Help | |||
|
180 | with (X)Emacs support, threading patches, ideas... | |||
|
181 | ||||
|
182 | * [Norbert Tretkowski] <tretkowski-AT-inittab.de> help with Debian | |||
|
183 | packaging and distribution. | |||
|
184 | ||||
|
185 | * [George Sakkis] <gsakkis-AT-eden.rutgers.edu> New matcher for | |||
|
186 | tab-completing named arguments of user-defined functions. | |||
|
187 | ||||
|
188 | * [Jörgen Stenarson] <jorgen.stenarson-AT-bostream.nu> Wildcard | |||
|
189 | support implementation for searching namespaces. | |||
|
190 | ||||
|
191 | * [Vivian De Smedt] <vivian-AT-vdesmedt.com> Debugger enhancements, | |||
|
192 | so that when pdb is activated from within IPython, coloring, tab | |||
|
193 | completion and other features continue to work seamlessly. | |||
|
194 | ||||
|
195 | * [Scott Tsai] <scottt958-AT-yahoo.com.tw> Support for automatic | |||
|
196 | editor invocation on syntax errors (see | |||
|
197 | http://www.scipy.net/roundup/ipython/issue36). | |||
|
198 | ||||
|
199 | * [Alexander Belchenko] <bialix-AT-ukr.net> Improvements for win32 | |||
|
200 | paging system. | |||
|
201 | ||||
|
202 | * [Will Maier] <willmaier-AT-ml1.net> Official OpenBSD port. | |||
|
203 | ||||
|
204 | * [Ondrej Certik] <ondrej-AT-certik.cz>: set up the IPython docs to use the new | |||
|
205 | Sphinx system used by Python, Matplotlib and many more projects. | |||
|
206 | ||||
|
207 | * [Stefan van der Walt] <stefan-AT-sun.ac.za>: support for the new config system. |
@@ -1,397 +1,426 b'' | |||||
1 | .. _development: |
|
1 | .. _development: | |
2 |
|
2 | |||
3 | ================================== |
|
3 | ================================== | |
4 | IPython development guidelines |
|
4 | IPython development guidelines | |
5 | ================================== |
|
5 | ================================== | |
6 |
|
6 | |||
7 | .. contents:: |
|
7 | .. contents:: | |
8 |
|
8 | |||
9 |
|
9 | |||
10 | Overview |
|
10 | Overview | |
11 | ======== |
|
11 | ======== | |
12 |
|
12 | |||
13 | IPython is the next generation of IPython. It is named such for two reasons: |
|
13 | IPython is the next generation of IPython. It is named such for two reasons: | |
14 |
|
14 | |||
15 | - Eventually, IPython will become IPython version 1.0. |
|
15 | - Eventually, IPython will become IPython version 1.0. | |
16 | - This new code base needs to be able to co-exist with the existing IPython until |
|
16 | - This new code base needs to be able to co-exist with the existing IPython until | |
17 | it is a full replacement for it. Thus we needed a different name. We couldn't |
|
17 | it is a full replacement for it. Thus we needed a different name. We couldn't | |
18 | use ``ipython`` (lowercase) as some files systems are case insensitive. |
|
18 | use ``ipython`` (lowercase) as some files systems are case insensitive. | |
19 |
|
19 | |||
20 | There are two, no three, main goals of the IPython effort: |
|
20 | There are two, no three, main goals of the IPython effort: | |
21 |
|
21 | |||
22 | 1. Clean up the existing codebase and write lots of tests. |
|
22 | 1. Clean up the existing codebase and write lots of tests. | |
23 | 2. Separate the core functionality of IPython from the terminal to enable IPython |
|
23 | 2. Separate the core functionality of IPython from the terminal to enable IPython | |
24 | to be used from within a variety of GUI applications. |
|
24 | to be used from within a variety of GUI applications. | |
25 | 3. Implement a system for interactive parallel computing. |
|
25 | 3. Implement a system for interactive parallel computing. | |
26 |
|
26 | |||
27 |
While the third goal may seem a bit unrelated to the main focus of IPython, it |
|
27 | While the third goal may seem a bit unrelated to the main focus of IPython, it | |
28 |
out that the technologies required for this goal are nearly identical |
|
28 | turns out that the technologies required for this goal are nearly identical | |
29 |
required for goal two. This is the main reason the interactive |
|
29 | with those required for goal two. This is the main reason the interactive | |
30 |
capabilities are being put into IPython proper. Currently |
|
30 | parallel computing capabilities are being put into IPython proper. Currently | |
31 | furthest along. |
|
31 | the third of these goals is furthest along. | |
32 |
|
32 | |||
33 | This document describes IPython from the perspective of developers. |
|
33 | This document describes IPython from the perspective of developers. | |
34 |
|
34 | |||
35 |
|
35 | |||
36 | Project organization |
|
36 | Project organization | |
37 | ==================== |
|
37 | ==================== | |
38 |
|
38 | |||
39 | Subpackages |
|
39 | Subpackages | |
40 | ----------- |
|
40 | ----------- | |
41 |
|
41 | |||
42 |
IPython is organized into semi self-contained subpackages. Each of the |
|
42 | IPython is organized into semi self-contained subpackages. Each of the | |
|
43 | subpackages will have its own: | |||
43 |
|
44 | |||
44 | - **Dependencies**. One of the most important things to keep in mind in |
|
45 | - **Dependencies**. One of the most important things to keep in mind in | |
45 | partitioning code amongst subpackages, is that they should be used to cleanly |
|
46 | partitioning code amongst subpackages, is that they should be used to cleanly | |
46 |
encapsulate dependencies. |
|
47 | encapsulate dependencies. | |
|
48 | ||||
47 | - **Tests**. Each subpackage shoud have its own ``tests`` subdirectory that |
|
49 | - **Tests**. Each subpackage shoud have its own ``tests`` subdirectory that | |
48 |
contains all of the tests for that package. For information about writing |
|
50 | contains all of the tests for that package. For information about writing | |
49 | for IPython, see the `Testing System`_ section of this document. |
|
51 | tests for IPython, see the `Testing System`_ section of this document. | |
50 | - **Configuration**. Each subpackage should have its own ``config`` subdirectory |
|
52 | ||
51 | that contains the configuration information for the components of the |
|
53 | - **Configuration**. Each subpackage should have its own ``config`` | |
52 | subpackage. For information about how the IPython configuration system |
|
54 | subdirectory that contains the configuration information for the components | |
53 | works, see the `Configuration System`_ section of this document. |
|
55 | of the subpackage. For information about how the IPython configuration | |
54 | - **Scripts**. Each subpackage should have its own ``scripts`` subdirectory that |
|
56 | system works, see the `Configuration System`_ section of this document. | |
55 | contains all of the command line scripts associated with the subpackage. |
|
57 | ||
|
58 | - **Scripts**. Each subpackage should have its own ``scripts`` subdirectory | |||
|
59 | that contains all of the command line scripts associated with the subpackage. | |||
56 |
|
60 | |||
57 | Installation and dependencies |
|
61 | Installation and dependencies | |
58 | ----------------------------- |
|
62 | ----------------------------- | |
59 |
|
63 | |||
60 |
IPython will not use `setuptools`_ for installation. Instead, we will use |
|
64 | IPython will not use `setuptools`_ for installation. Instead, we will use | |
61 |
``setup.py`` scripts that use `distutils`_. While there are a number a |
|
65 | standard ``setup.py`` scripts that use `distutils`_. While there are a number a | |
62 |
features that `setuptools`_ has (like namespace packages), the |
|
66 | extremely nice features that `setuptools`_ has (like namespace packages), the | |
63 |
of `setuptools`_ has performance problems, particularly |
|
67 | current implementation of `setuptools`_ has performance problems, particularly | |
64 |
particular, when Python packages are installed on |
|
68 | on shared file systems. In particular, when Python packages are installed on | |
65 |
become much too long (up towards 10 seconds). |
|
69 | NSF file systems, import times become much too long (up towards 10 seconds). | |
66 |
|
70 | |||
67 | Because IPython is being used extensively in the context of high performance |
|
71 | Because IPython is being used extensively in the context of high performance | |
68 |
computing, where performance is critical but shared file systems are common, we |
|
72 | computing, where performance is critical but shared file systems are common, we | |
69 |
these performance hits are not acceptable. Thus, until the performance |
|
73 | feel these performance hits are not acceptable. Thus, until the performance | |
70 |
associated with `setuptools`_ are addressed, we will stick with plain |
|
74 | problems associated with `setuptools`_ are addressed, we will stick with plain | |
71 |
are hopeful that these problems will be addressed and that we |
|
75 | `distutils`_. We are hopeful that these problems will be addressed and that we | |
72 |
using `setuptools`_. Because of this, we are trying to |
|
76 | will eventually begin using `setuptools`_. Because of this, we are trying to | |
73 | will make the eventual transition to `setuptools`_ as painless as possible. |
|
77 | organize IPython in a way that will make the eventual transition to | |
74 |
|
78 | `setuptools`_ as painless as possible. | ||
75 | Because we will be using `distutils`_, there will be no method for automatically installing dependencies. Instead, we are following the approach of `Matplotlib`_ which can be summarized as follows: |
|
79 | ||
|
80 | Because we will be using `distutils`_, there will be no method for | |||
|
81 | automatically installing dependencies. Instead, we are following the approach | |||
|
82 | of `Matplotlib`_ which can be summarized as follows: | |||
76 |
|
83 | |||
77 | - Distinguish between required and optional dependencies. However, the required |
|
84 | - Distinguish between required and optional dependencies. However, the required | |
78 | dependencies for IPython should be only the Python standard library. |
|
85 | dependencies for IPython should be only the Python standard library. | |
79 | - Upon installation check to see which optional dependencies are present and tell |
|
86 | ||
80 | the user which parts of IPython need which optional dependencies. |
|
87 | - Upon installation check to see which optional dependencies are present and | |
|
88 | tell the user which parts of IPython need which optional dependencies. | |||
81 |
|
89 | |||
82 |
It is absolutely critical that each subpackage of IPython has a clearly |
|
90 | It is absolutely critical that each subpackage of IPython has a clearly | |
83 |
of dependencies and that dependencies are not carelessly |
|
91 | specified set of dependencies and that dependencies are not carelessly | |
84 |
subpackages. Furthermore, tests that have certain |
|
92 | inherited from other IPython subpackages. Furthermore, tests that have certain | |
85 | those dependencies are not present. Instead they should be skipped and print a |
|
93 | dependencies should not fail if those dependencies are not present. Instead | |
86 | message. |
|
94 | they should be skipped and print a message. | |
87 |
|
95 | |||
88 | .. _setuptools: http://peak.telecommunity.com/DevCenter/setuptools |
|
96 | .. _setuptools: http://peak.telecommunity.com/DevCenter/setuptools | |
89 | .. _distutils: http://docs.python.org/lib/module-distutils.html |
|
97 | .. _distutils: http://docs.python.org/lib/module-distutils.html | |
90 | .. _Matplotlib: http://matplotlib.sourceforge.net/ |
|
98 | .. _Matplotlib: http://matplotlib.sourceforge.net/ | |
91 |
|
99 | |||
92 | Specific subpackages |
|
100 | Specific subpackages | |
93 | -------------------- |
|
101 | -------------------- | |
94 |
|
102 | |||
95 | ``core`` |
|
103 | ``core`` | |
96 | This is the core functionality of IPython that is independent of the |
|
104 | This is the core functionality of IPython that is independent of the | |
97 | terminal, network and GUIs. Most of the code that is in the current |
|
105 | terminal, network and GUIs. Most of the code that is in the current | |
98 | IPython trunk will be refactored, cleaned up and moved here. |
|
106 | IPython trunk will be refactored, cleaned up and moved here. | |
99 |
|
107 | |||
100 | ``kernel`` |
|
108 | ``kernel`` | |
101 | The enables the IPython core to be expose to a the network. This is |
|
109 | The enables the IPython core to be expose to a the network. This is | |
102 | also where all of the parallel computing capabilities are to be found. |
|
110 | also where all of the parallel computing capabilities are to be found. | |
103 |
|
111 | |||
104 | ``config`` |
|
112 | ``config`` | |
105 | The configuration package used by IPython. |
|
113 | The configuration package used by IPython. | |
106 |
|
114 | |||
107 | ``frontends`` |
|
115 | ``frontends`` | |
108 | The various frontends for IPython. A frontend is the end-user application |
|
116 | The various frontends for IPython. A frontend is the end-user application | |
109 |
that exposes the capabilities of IPython to the user. The most basic |
|
117 | that exposes the capabilities of IPython to the user. The most basic | |
110 |
will simply be a terminal based application that looks just like |
|
118 | frontend will simply be a terminal based application that looks just like | |
111 |
IPython. Other frontends will likely be more powerful and based |
|
119 | today 's IPython. Other frontends will likely be more powerful and based | |
|
120 | on GUI toolkits. | |||
112 |
|
121 | |||
113 | ``notebook`` |
|
122 | ``notebook`` | |
114 | An application that allows users to work with IPython notebooks. |
|
123 | An application that allows users to work with IPython notebooks. | |
115 |
|
124 | |||
116 | ``tools`` |
|
125 | ``tools`` | |
117 | This is where general utilities go. |
|
126 | This is where general utilities go. | |
118 |
|
127 | |||
119 |
|
128 | |||
120 | Version control |
|
129 | Version control | |
121 | =============== |
|
130 | =============== | |
122 |
|
131 | |||
123 |
In the past, IPython development has been done using `Subversion`__. Recently, |
|
132 | In the past, IPython development has been done using `Subversion`__. Recently, | |
124 | to contribute code to IPython. Here is a sketch of how to use Bazaar for IPython |
|
133 | we made the transition to using `Bazaar`__ and `Launchpad`__. This makes it | |
125 | development. First, you should install Bazaar. After you have done that, make |
|
134 | much easier for people to contribute code to IPython. Here is a sketch of how | |
126 | sure that it is working by getting the latest main branch of IPython:: |
|
135 | to use Bazaar for IPython development. First, you should install Bazaar. | |
|
136 | After you have done that, make sure that it is working by getting the latest | |||
|
137 | main branch of IPython:: | |||
127 |
|
138 | |||
128 | $ bzr branch lp:ipython |
|
139 | $ bzr branch lp:ipython | |
129 |
|
140 | |||
130 | Now you can create a new branch for you to do your work in:: |
|
141 | Now you can create a new branch for you to do your work in:: | |
131 |
|
142 | |||
132 | $ bzr branch ipython ipython-mybranch |
|
143 | $ bzr branch ipython ipython-mybranch | |
133 |
|
144 | |||
134 |
The typical work cycle in this branch will be to make changes in |
|
145 | The typical work cycle in this branch will be to make changes in | |
135 | and then commit those changes using the commit command:: |
|
146 | ``ipython-mybranch`` and then commit those changes using the commit command:: | |
136 |
|
147 | |||
137 | $ ...do work in ipython-mybranch... |
|
148 | $ ...do work in ipython-mybranch... | |
138 | $ bzr ci -m "the commit message goes here" |
|
149 | $ bzr ci -m "the commit message goes here" | |
139 |
|
150 | |||
140 | Please note that since we now don't use an old-style linear ChangeLog |
|
151 | Please note that since we now don't use an old-style linear ChangeLog (that | |
141 |
|
|
152 | tends to cause problems with distributed version control systems), you should | |
142 |
|
|
153 | ensure that your log messages are reasonably detailed. Use a docstring-like | |
143 | detailed. Use a docstring-like approach in the commit messages |
|
154 | approach in the commit messages (including the second line being left | |
144 | (including the second line being left *blank*):: |
|
155 | *blank*):: | |
145 |
|
156 | |||
146 | Single line summary of changes being committed. |
|
157 | Single line summary of changes being committed. | |
147 |
|
158 | |||
148 | - more details when warranted ... |
|
159 | - more details when warranted ... | |
149 | - including crediting outside contributors if they sent the |
|
160 | - including crediting outside contributors if they sent the | |
150 | code/bug/idea! |
|
161 | code/bug/idea! | |
151 |
|
162 | |||
152 | If we couple this with a policy of making single commits for each |
|
163 | If we couple this with a policy of making single commits for each reasonably | |
153 |
|
|
164 | atomic change, the bzr log should give an excellent view of the project, and | |
154 |
|
|
165 | the `--short` log option becomes a nice summary. | |
155 |
|
166 | |||
156 |
While working with this branch, it is a good idea to merge in changes that have |
|
167 | While working with this branch, it is a good idea to merge in changes that have | |
157 | made upstream in the parent branch. This can be done by doing:: |
|
168 | been made upstream in the parent branch. This can be done by doing:: | |
158 |
|
169 | |||
159 | $ bzr pull |
|
170 | $ bzr pull | |
160 |
|
171 | |||
161 |
If this command shows that the branches have diverged, then you should do a |
|
172 | If this command shows that the branches have diverged, then you should do a | |
162 | instead:: |
|
173 | merge instead:: | |
163 |
|
174 | |||
164 | $ bzr merge lp:ipython |
|
175 | $ bzr merge lp:ipython | |
165 |
|
176 | |||
166 |
If you want others to be able to see your branch, you can create an account |
|
177 | If you want others to be able to see your branch, you can create an account | |
167 | launchpad and push the branch to your own workspace:: |
|
178 | with launchpad and push the branch to your own workspace:: | |
168 |
|
179 | |||
169 | $ bzr push bzr+ssh://<me>@bazaar.launchpad.net/~<me>/+junk/ipython-mybranch |
|
180 | $ bzr push bzr+ssh://<me>@bazaar.launchpad.net/~<me>/+junk/ipython-mybranch | |
170 |
|
181 | |||
171 |
Finally, once the work in your branch is done, you can merge your changes back |
|
182 | Finally, once the work in your branch is done, you can merge your changes back | |
172 | the `ipython` branch by using merge:: |
|
183 | into the `ipython` branch by using merge:: | |
173 |
|
184 | |||
174 | $ cd ipython |
|
185 | $ cd ipython | |
175 | $ merge ../ipython-mybranch |
|
186 | $ merge ../ipython-mybranch | |
176 | [resolve any conflicts] |
|
187 | [resolve any conflicts] | |
177 | $ bzr ci -m "Fixing that bug" |
|
188 | $ bzr ci -m "Fixing that bug" | |
178 | $ bzr push |
|
189 | $ bzr push | |
179 |
|
190 | |||
180 |
But this will require you to have write permissions to the `ipython` branch. |
|
191 | But this will require you to have write permissions to the `ipython` branch. | |
181 |
you can tell one of the IPython devs about your branch and they |
|
192 | It you don't you can tell one of the IPython devs about your branch and they | |
|
193 | can do the merge for you. | |||
182 |
|
194 | |||
183 | More information about Bazaar workflows can be found `here`__. |
|
195 | More information about Bazaar workflows can be found `here`__. | |
184 |
|
196 | |||
185 | .. __: http://subversion.tigris.org/ |
|
197 | .. __: http://subversion.tigris.org/ | |
186 | .. __: http://bazaar-vcs.org/ |
|
198 | .. __: http://bazaar-vcs.org/ | |
187 | .. __: http://www.launchpad.net/ipython |
|
199 | .. __: http://www.launchpad.net/ipython | |
188 | .. __: http://doc.bazaar-vcs.org/bzr.dev/en/user-guide/index.html |
|
200 | .. __: http://doc.bazaar-vcs.org/bzr.dev/en/user-guide/index.html | |
189 |
|
201 | |||
190 | Documentation |
|
202 | Documentation | |
191 | ============= |
|
203 | ============= | |
192 |
|
204 | |||
193 | Standalone documentation |
|
205 | Standalone documentation | |
194 | ------------------------ |
|
206 | ------------------------ | |
195 |
|
207 | |||
196 |
All standalone documentation should be written in plain text (``.txt``) files |
|
208 | All standalone documentation should be written in plain text (``.txt``) files | |
197 |
`reStructuredText`_ for markup and formatting. All such documentation |
|
209 | using `reStructuredText`_ for markup and formatting. All such documentation | |
198 |
in the top level directory ``docs`` of the IPython source |
|
210 | should be placed in the top level directory ``docs`` of the IPython source | |
199 |
a suitably named subdirectory should be used. The |
|
211 | tree. Or, when appropriate, a suitably named subdirectory should be used. The | |
200 | serve as the main source for IPython documentation and all existing documentation |
|
212 | documentation in this location will serve as the main source for IPython | |
201 | should be converted to this format. |
|
213 | documentation and all existing documentation should be converted to this | |
|
214 | format. | |||
202 |
|
215 | |||
203 |
In the future, the text files in the ``docs`` directory will be used to |
|
216 | In the future, the text files in the ``docs`` directory will be used to | |
204 |
forms of documentation for IPython. This include documentation on |
|
217 | generate all forms of documentation for IPython. This include documentation on | |
205 | as well as *pdf* documentation. |
|
218 | the IPython website as well as *pdf* documentation. | |
206 |
|
219 | |||
207 | .. _reStructuredText: http://docutils.sourceforge.net/rst.html |
|
220 | .. _reStructuredText: http://docutils.sourceforge.net/rst.html | |
208 |
|
221 | |||
209 | Docstring format |
|
222 | Docstring format | |
210 | ---------------- |
|
223 | ---------------- | |
211 |
|
224 | |||
212 |
Good docstrings are very important. All new code will use `Epydoc`_ for |
|
225 | Good docstrings are very important. All new code will use `Epydoc`_ for | |
213 |
docs, so we will follow the `Epydoc`_ conventions. More |
|
226 | generating API docs, so we will follow the `Epydoc`_ conventions. More | |
214 |
`reStructuredText`_ for markup and formatting, since |
|
227 | specifically, we will use `reStructuredText`_ for markup and formatting, since | |
215 |
variety of tools. This means that if in the future |
|
228 | it is understood by a wide variety of tools. This means that if in the future | |
216 |
`Epydoc`_ to something else, we'll have fewer |
|
229 | we have any reason to change from `Epydoc`_ to something else, we'll have fewer | |
|
230 | transition pains. | |||
217 |
|
231 | |||
218 | Details about using `reStructuredText`_ for docstrings can be found `here |
|
232 | Details about using `reStructuredText`_ for docstrings can be found `here | |
219 | <http://epydoc.sourceforge.net/manual-othermarkup.html>`_. |
|
233 | <http://epydoc.sourceforge.net/manual-othermarkup.html>`_. | |
220 |
|
234 | |||
221 | .. _Epydoc: http://epydoc.sourceforge.net/ |
|
235 | .. _Epydoc: http://epydoc.sourceforge.net/ | |
222 |
|
236 | |||
223 | Additional PEPs of interest regarding documentation of code: |
|
237 | Additional PEPs of interest regarding documentation of code: | |
224 |
|
238 | |||
225 | - `Docstring Conventions <http://www.python.org/peps/pep-0257.html>`_ |
|
239 | - `Docstring Conventions <http://www.python.org/peps/pep-0257.html>`_ | |
226 | - `Docstring Processing System Framework <http://www.python.org/peps/pep-0256.html>`_ |
|
240 | - `Docstring Processing System Framework <http://www.python.org/peps/pep-0256.html>`_ | |
227 | - `Docutils Design Specification <http://www.python.org/peps/pep-0258.html>`_ |
|
241 | - `Docutils Design Specification <http://www.python.org/peps/pep-0258.html>`_ | |
228 |
|
242 | |||
229 |
|
243 | |||
230 | Coding conventions |
|
244 | Coding conventions | |
231 | ================== |
|
245 | ================== | |
232 |
|
246 | |||
233 | General |
|
247 | General | |
234 | ------- |
|
248 | ------- | |
235 |
|
249 | |||
236 |
In general, we'll try to follow the standard Python style conventions as |
|
250 | In general, we'll try to follow the standard Python style conventions as | |
|
251 | described here: | |||
237 |
|
252 | |||
238 | - `Style Guide for Python Code <http://www.python.org/peps/pep-0008.html>`_ |
|
253 | - `Style Guide for Python Code <http://www.python.org/peps/pep-0008.html>`_ | |
239 |
|
254 | |||
240 |
|
255 | |||
241 | Other comments: |
|
256 | Other comments: | |
242 |
|
257 | |||
243 | - In a large file, top level classes and functions should be |
|
258 | - In a large file, top level classes and functions should be | |
244 | separated by 2-3 lines to make it easier to separate them visually. |
|
259 | separated by 2-3 lines to make it easier to separate them visually. | |
245 | - Use 4 spaces for indentation. |
|
260 | - Use 4 spaces for indentation. | |
246 | - Keep the ordering of methods the same in classes that have the same |
|
261 | - Keep the ordering of methods the same in classes that have the same | |
247 | methods. This is particularly true for classes that implement |
|
262 | methods. This is particularly true for classes that implement | |
248 | similar interfaces and for interfaces that are similar. |
|
263 | similar interfaces and for interfaces that are similar. | |
249 |
|
264 | |||
250 | Naming conventions |
|
265 | Naming conventions | |
251 | ------------------ |
|
266 | ------------------ | |
252 |
|
267 | |||
253 |
In terms of naming conventions, we'll follow the guidelines from the `Style |
|
268 | In terms of naming conventions, we'll follow the guidelines from the `Style | |
254 | Python Code`_. |
|
269 | Guide for Python Code`_. | |
255 |
|
270 | |||
256 | For all new IPython code (and much existing code is being refactored), we'll use: |
|
271 | For all new IPython code (and much existing code is being refactored), we'll use: | |
257 |
|
272 | |||
258 | - All ``lowercase`` module names. |
|
273 | - All ``lowercase`` module names. | |
259 |
|
274 | |||
260 | - ``CamelCase`` for class names. |
|
275 | - ``CamelCase`` for class names. | |
261 |
|
276 | |||
262 |
- ``lowercase_with_underscores`` for methods, functions, variables and |
|
277 | - ``lowercase_with_underscores`` for methods, functions, variables and | |
|
278 | attributes. | |||
263 |
|
279 | |||
264 | This may be confusing as most of the existing IPython codebase uses a different convention (``lowerCamelCase`` for methods and attributes). Slowly, we will move IPython over to the new |
|
280 | This may be confusing as most of the existing IPython codebase uses a different | |
265 | convention, providing shadow names for backward compatibility in public interfaces. |
|
281 | convention (``lowerCamelCase`` for methods and attributes). Slowly, we will | |
|
282 | move IPython over to the new convention, providing shadow names for backward | |||
|
283 | compatibility in public interfaces. | |||
266 |
|
284 | |||
267 |
There are, however, some important exceptions to these rules. In some cases, |
|
285 | There are, however, some important exceptions to these rules. In some cases, | |
268 | code will interface with packages (Twisted, Wx, Qt) that use other conventions. At some level this makes it impossible to adhere to our own standards at all times. In particular, when subclassing classes that use other naming conventions, you must follow their naming conventions. To deal with cases like this, we propose the following policy: |
|
286 | IPython code will interface with packages (Twisted, Wx, Qt) that use other | |
|
287 | conventions. At some level this makes it impossible to adhere to our own | |||
|
288 | standards at all times. In particular, when subclassing classes that use other | |||
|
289 | naming conventions, you must follow their naming conventions. To deal with | |||
|
290 | cases like this, we propose the following policy: | |||
269 |
|
291 | |||
270 | - If you are subclassing a class that uses different conventions, use its |
|
292 | - If you are subclassing a class that uses different conventions, use its | |
271 |
naming conventions throughout your subclass. Thus, if you are creating a |
|
293 | naming conventions throughout your subclass. Thus, if you are creating a | |
272 |
Twisted Protocol class, used Twisted's |
|
294 | Twisted Protocol class, used Twisted's | |
273 |
|
295 | ``namingSchemeForMethodsAndAttributes.`` | ||
274 | - All IPython's official interfaces should use our conventions. In some cases |
|
296 | ||
275 | this will mean that you need to provide shadow names (first implement ``fooBar`` |
|
297 | - All IPython's official interfaces should use our conventions. In some cases | |
276 | and then ``foo_bar = fooBar``). We want to avoid this at all costs, but it |
|
298 | this will mean that you need to provide shadow names (first implement | |
277 | will probably be necessary at times. But, please use this sparingly! |
|
299 | ``fooBar`` and then ``foo_bar = fooBar``). We want to avoid this at all | |
278 |
|
300 | costs, but it will probably be necessary at times. But, please use this | ||
279 | Implementation-specific *private* methods will use ``_single_underscore_prefix``. |
|
301 | sparingly! | |
280 | Names with a leading double underscore will *only* be used in special cases, as they |
|
302 | ||
281 | makes subclassing difficult (such names are not easily seen by child classes). |
|
303 | Implementation-specific *private* methods will use | |
282 |
|
304 | ``_single_underscore_prefix``. Names with a leading double underscore will | ||
283 | Occasionally some run-in lowercase names are used, but mostly for very short names or |
|
305 | *only* be used in special cases, as they makes subclassing difficult (such | |
284 | where we are implementing methods very similar to existing ones in a base class (like |
|
306 | names are not easily seen by child classes). | |
285 | ``runlines()`` where ``runsource()`` and ``runcode()`` had established precedent). |
|
307 | ||
|
308 | Occasionally some run-in lowercase names are used, but mostly for very short | |||
|
309 | names or where we are implementing methods very similar to existing ones in a | |||
|
310 | base class (like ``runlines()`` where ``runsource()`` and ``runcode()`` had | |||
|
311 | established precedent). | |||
286 |
|
312 | |||
287 | The old IPython codebase has a big mix of classes and modules prefixed with an |
|
313 | The old IPython codebase has a big mix of classes and modules prefixed with an | |
288 |
explicit ``IP``. In Python this is mostly unnecessary, redundant and frowned |
|
314 | explicit ``IP``. In Python this is mostly unnecessary, redundant and frowned | |
289 |
namespaces offer cleaner prefixing. The only case where this approach |
|
315 | upon, as namespaces offer cleaner prefixing. The only case where this approach | |
290 |
for classes which are expected to be imported into external |
|
316 | is justified is for classes which are expected to be imported into external | |
291 |
generic name (like Shell) is too likely to clash with |
|
317 | namespaces and a very generic name (like Shell) is too likely to clash with | |
292 | revisit this issue as we clean up and refactor the code, but in general we should |
|
318 | something else. We'll need to revisit this issue as we clean up and refactor | |
293 | remove as many unnecessary ``IP``/``ip`` prefixes as possible. However, if a prefix |
|
319 | the code, but in general we should remove as many unnecessary ``IP``/``ip`` | |
294 | seems absolutely necessary the more specific ``IPY`` or ``ipy`` are preferred. |
|
320 | prefixes as possible. However, if a prefix seems absolutely necessary the more | |
|
321 | specific ``IPY`` or ``ipy`` are preferred. | |||
295 |
|
322 | |||
296 | .. _devel_testing: |
|
323 | .. _devel_testing: | |
297 |
|
324 | |||
298 | Testing system |
|
325 | Testing system | |
299 | ============== |
|
326 | ============== | |
300 |
|
327 | |||
301 |
It is extremely important that all code contributed to IPython has tests. Tests |
|
328 | It is extremely important that all code contributed to IPython has tests. Tests | |
302 |
be written as unittests, doctests or as entities that the `Nose`_ |
|
329 | should be written as unittests, doctests or as entities that the `Nose`_ | |
303 |
find. Regardless of how the tests are written, we will use |
|
330 | testing package will find. Regardless of how the tests are written, we will use | |
304 |
running the tests. `Nose`_ will be required to run |
|
331 | `Nose`_ for discovering and running the tests. `Nose`_ will be required to run | |
305 | not be required to simply use IPython. |
|
332 | the IPython test suite, but will not be required to simply use IPython. | |
306 |
|
333 | |||
307 | .. _Nose: http://code.google.com/p/python-nose/ |
|
334 | .. _Nose: http://code.google.com/p/python-nose/ | |
308 |
|
335 | |||
309 |
Tests of `Twisted`__ using code should be written by subclassing the |
|
336 | Tests of `Twisted`__ using code should be written by subclassing the | |
310 |
that comes with ``twisted.trial.unittest``. When this is |
|
337 | ``TestCase`` class that comes with ``twisted.trial.unittest``. When this is | |
311 |
run the tests and the twisted reactor will be |
|
338 | done, `Nose`_ will be able to run the tests and the twisted reactor will be | |
|
339 | handled correctly. | |||
312 |
|
340 | |||
313 | .. __: http://www.twistedmatrix.com |
|
341 | .. __: http://www.twistedmatrix.com | |
314 |
|
342 | |||
315 |
Each subpackage in IPython should have its own ``tests`` directory that |
|
343 | Each subpackage in IPython should have its own ``tests`` directory that | |
316 |
of the tests for that subpackage. This allows each subpackage to |
|
344 | contains all of the tests for that subpackage. This allows each subpackage to | |
317 |
a subpackage has any dependencies beyond the Python |
|
345 | be self-contained. If a subpackage has any dependencies beyond the Python | |
318 | that subpackage should be skipped if the dependencies are not found. This is very |
|
346 | standard library, the tests for that subpackage should be skipped if the | |
319 | important so users don't get tests failing simply because they don't have dependencies. |
|
347 | dependencies are not found. This is very important so users don't get tests | |
|
348 | failing simply because they don't have dependencies. | |||
320 |
|
349 | |||
321 |
We also need to look into use Noses ability to tag tests to allow a more |
|
350 | We also need to look into use Noses ability to tag tests to allow a more | |
322 | approach of running tests. |
|
351 | modular approach of running tests. | |
323 |
|
352 | |||
324 | .. _devel_config: |
|
353 | .. _devel_config: | |
325 |
|
354 | |||
326 | Configuration system |
|
355 | Configuration system | |
327 | ==================== |
|
356 | ==================== | |
328 |
|
357 | |||
329 | IPython uses `.ini`_ files for configuration purposes. This represents a huge |
|
358 | IPython uses `.ini`_ files for configuration purposes. This represents a huge | |
330 |
improvement over the configuration system used in IPython. IPython works with |
|
359 | improvement over the configuration system used in IPython. IPython works with | |
331 | files using the `ConfigObj`_ package, which IPython includes as |
|
360 | these files using the `ConfigObj`_ package, which IPython includes as | |
332 | ``ipython1/external/configobj.py``. |
|
361 | ``ipython1/external/configobj.py``. | |
333 |
|
362 | |||
334 |
Currently, we are using raw `ConfigObj`_ objects themselves. Each subpackage of |
|
363 | Currently, we are using raw `ConfigObj`_ objects themselves. Each subpackage of | |
335 |
should contain a ``config`` subdirectory that contains all of the |
|
364 | IPython should contain a ``config`` subdirectory that contains all of the | |
336 |
information for the subpackage. To see how configuration |
|
365 | configuration information for the subpackage. To see how configuration | |
337 | with defaults) see at the examples in ``ipython1/kernel/config`` and |
|
366 | information is defined (along with defaults) see at the examples in | |
338 | ``ipython1/core/config``. Likewise, to see how the configuration information is used, |
|
367 | ``ipython1/kernel/config`` and ``ipython1/core/config``. Likewise, to see how | |
339 | see examples in ``ipython1/kernel/scripts/ipengine.py``. |
|
368 | the configuration information is used, see examples in | |
340 |
|
369 | ``ipython1/kernel/scripts/ipengine.py``. | ||
341 | Eventually, we will add a new layer on top of the raw `ConfigObj`_ objects. We are |
|
370 | ||
342 | calling this new layer, ``tconfig``, as it will use a `Traits`_-like validation model. |
|
371 | Eventually, we will add a new layer on top of the raw `ConfigObj`_ objects. We | |
343 | We won't actually use `Traits`_, but will implement something similar in pure Python. |
|
372 | are calling this new layer, ``tconfig``, as it will use a `Traits`_-like | |
344 | But, even in this new system, we will still use `ConfigObj`_ and `.ini`_ files |
|
373 | validation model. We won't actually use `Traits`_, but will implement | |
345 | underneath the hood. Talk to Fernando if you are interested in working on this part of |
|
374 | something similar in pure Python. But, even in this new system, we will still | |
346 | IPython. The current prototype of ``tconfig`` is located in the IPython sandbox. |
|
375 | use `ConfigObj`_ and `.ini`_ files underneath the hood. Talk to Fernando if you | |
|
376 | are interested in working on this part of IPython. The current prototype of | |||
|
377 | ``tconfig`` is located in the IPython sandbox. | |||
347 |
|
378 | |||
348 | .. _.ini: http://docs.python.org/lib/module-ConfigParser.html |
|
379 | .. _.ini: http://docs.python.org/lib/module-ConfigParser.html | |
349 | .. _ConfigObj: http://www.voidspace.org.uk/python/configobj.html |
|
380 | .. _ConfigObj: http://www.voidspace.org.uk/python/configobj.html | |
350 | .. _Traits: http://code.enthought.com/traits/ |
|
381 | .. _Traits: http://code.enthought.com/traits/ | |
351 |
|
382 | |||
352 | Installation and testing scenarios |
|
383 | Installation and testing scenarios | |
353 | ================================== |
|
384 | ================================== | |
354 |
|
385 | |||
355 | This section outlines the various scenarios that we need to test before we release an IPython version. These scenarios represent different ways of installing IPython and its dependencies. |
|
386 | This section outlines the various scenarios that we need to test before we | |
|
387 | release an IPython version. These scenarios represent different ways of | |||
|
388 | installing IPython and its dependencies. | |||
356 |
|
389 | |||
357 | Installation scenarios under Linux and OS X |
|
390 | Installation scenarios under Linux and OS X | |
358 | ------------------------------------------- |
|
391 | ------------------------------------------- | |
359 |
|
392 | |||
360 | 1. Install from tarball using `python setup.py install`. |
|
393 | 1. Install from tarball using ``python setup.py install``. | |
361 | a. With only readline+nose dependencies installed. |
|
394 | a. With only readline+nose dependencies installed. | |
362 | b. With all dependencies installed (readline, zope.interface, |
|
395 | b. With all dependencies installed (readline, zope.interface, Twisted, | |
363 |
|
|
396 | foolscap, Sphinx, nose, pyOpenSSL). | |
|
397 | ||||
364 | 2. Install using easy_install. |
|
398 | 2. Install using easy_install. | |
|
399 | ||||
365 | a. With only readline+nose dependencies installed. |
|
400 | a. With only readline+nose dependencies installed. | |
366 | i. Default dependencies: `easy_install ipython-0.9.beta3-py2.5.egg` |
|
401 | i. Default dependencies: ``easy_install ipython-0.9.beta3-py2.5.egg`` | |
367 | ii. Optional dependency sets: `easy_install -f ipython-0.9.beta3-py2.5.egg IPython[kernel,doc,test,security]` |
|
402 | ii. Optional dependency sets: ``easy_install -f ipython-0.9.beta3-py2.5.egg IPython[kernel,doc,test,security]`` | |
|
403 | ||||
368 | b. With all dependencies already installed. |
|
404 | b. With all dependencies already installed. | |
|
405 | ||||
369 |
|
406 | |||
370 | Installation scenarios under Win32 |
|
407 | Installation scenarios under Win32 | |
371 | ---------------------------------- |
|
408 | ---------------------------------- | |
372 |
|
409 | |||
373 | 1. Install everything from .exe installers |
|
410 | 1. Install everything from .exe installers | |
374 | 2. easy_install? |
|
411 | 2. easy_install? | |
375 |
|
412 | |||
376 |
|
413 | |||
377 | Tests to run for these scenarios |
|
414 | Tests to run for these scenarios | |
378 | -------------------------------- |
|
415 | -------------------------------- | |
379 |
|
416 | |||
380 | 1. Run the full test suite. |
|
417 | 1. Run the full test suite. | |
381 | 2. Start a controller and engines and try a few things by hand. |
|
418 | 2. Start a controller and engines and try a few things by hand. | |
382 | a. Using ipcluster. |
|
419 | a. Using ipcluster. | |
383 | b. Using ipcontroller/ipengine by hand. |
|
420 | b. Using ipcontroller/ipengine by hand. | |
|
421 | ||||
384 | 3. Run a few of the parallel examples. |
|
422 | 3. Run a few of the parallel examples. | |
385 | 4. Try the kernel with and without security with and without PyOpenSSL |
|
423 | 4. Try the kernel with and without security with and without PyOpenSSL | |
386 | installed. |
|
424 | installed. | |
387 | 5. Beat on the IPython terminal a bunch. |
|
425 | 5. Beat on the IPython terminal a bunch. | |
388 | 6. Make sure that furl files are being put in proper locations. |
|
426 | 6. Make sure that furl files are being put in proper locations. | |
389 |
|
||||
390 |
|
||||
391 |
|
||||
392 |
|
||||
393 |
|
||||
394 |
|
||||
395 |
|
||||
396 |
|
||||
397 |
|
@@ -1,9 +1,10 b'' | |||||
1 | ================== |
|
1 | ================== | |
2 | Development |
|
2 | Development | |
3 | ================== |
|
3 | ================== | |
4 |
|
4 | |||
5 | .. toctree:: |
|
5 | .. toctree:: | |
6 | :maxdepth: 2 |
|
6 | :maxdepth: 2 | |
7 |
|
7 | |||
8 | development.txt |
|
8 | development.txt | |
9 | roadmap.txt |
|
9 | roadmap.txt | |
|
10 | notification_blueprint.txt |
@@ -1,47 +1,49 b'' | |||||
1 |
.. |
|
1 | .. _notification: | |
2 |
|
2 | |||
3 | ========================================== |
|
3 | ========================================== | |
4 | IPython.kernel.core.notification blueprint |
|
4 | IPython.kernel.core.notification blueprint | |
5 | ========================================== |
|
5 | ========================================== | |
6 |
|
6 | |||
7 | Overview |
|
7 | Overview | |
8 | ======== |
|
8 | ======== | |
9 | The :mod:`IPython.kernel.core.notification` module will provide a simple implementation of a notification center and support for the observer pattern within the :mod:`IPython.kernel.core`. The main intended use case is to provide notification of Interpreter events to an observing frontend during the execution of a single block of code. |
|
9 | The :mod:`IPython.kernel.core.notification` module will provide a simple implementation of a notification center and support for the observer pattern within the :mod:`IPython.kernel.core`. The main intended use case is to provide notification of Interpreter events to an observing frontend during the execution of a single block of code. | |
10 |
|
10 | |||
11 | Functional Requirements |
|
11 | Functional Requirements | |
12 | ======================= |
|
12 | ======================= | |
13 | The notification center must: |
|
13 | The notification center must: | |
14 |
|
|
14 | * Provide synchronous notification of events to all registered observers. | |
15 |
|
|
15 | * Provide typed or labeled notification types | |
16 |
|
|
16 | * Allow observers to register callbacks for individual or all notification types | |
17 |
|
|
17 | * Allow observers to register callbacks for events from individual or all notifying objects | |
18 |
|
|
18 | * Notification to the observer consists of the notification type, notifying object and user-supplied extra information [implementation: as keyword parameters to the registered callback] | |
19 |
|
|
19 | * Perform as O(1) in the case of no registered observers. | |
20 |
|
|
20 | * Permit out-of-process or cross-network extension. | |
21 |
|
21 | |||
22 | What's not included |
|
22 | What's not included | |
23 | ============================================================== |
|
23 | ============================================================== | |
24 | As written, the :mod:`IPython.kernel.core.notificaiton` module does not: |
|
24 | As written, the :mod:`IPython.kernel.core.notificaiton` module does not: | |
25 |
|
|
25 | * Provide out-of-process or network notifications [these should be handled by a separate, Twisted aware module in :mod:`IPython.kernel`]. | |
26 |
|
|
26 | * Provide zope.interface-style interfaces for the notification system [these should also be provided by the :mod:`IPython.kernel` module] | |
27 |
|
27 | |||
28 | Use Cases |
|
28 | Use Cases | |
29 | ========= |
|
29 | ========= | |
30 | The following use cases describe the main intended uses of the notificaiton module and illustrate the main success scenario for each use case: |
|
30 | The following use cases describe the main intended uses of the notificaiton module and illustrate the main success scenario for each use case: | |
31 |
|
31 | |||
32 |
|
|
32 | 1. Dwight Schroot is writing a frontend for the IPython project. His frontend is stuck in the stone age and must communicate synchronously with an IPython.kernel.core.Interpreter instance. Because code is executed in blocks by the Interpreter, Dwight's UI freezes every time he executes a long block of code. To keep track of the progress of his long running block, Dwight adds the following code to his frontend's set-up code:: | |
33 | from IPython.kernel.core.notification import NotificationCenter |
|
33 | ||
34 | center = NotificationCenter.sharedNotificationCenter |
|
34 | from IPython.kernel.core.notification import NotificationCenter | |
35 | center.registerObserver(self, type=IPython.kernel.core.Interpreter.STDOUT_NOTIFICATION_TYPE, notifying_object=self.interpreter, callback=self.stdout_notification) |
|
35 | center = NotificationCenter.sharedNotificationCenter | |
36 |
|
36 | center.registerObserver(self, type=IPython.kernel.core.Interpreter.STDOUT_NOTIFICATION_TYPE, notifying_object=self.interpreter, callback=self.stdout_notification) | ||
37 | and elsewhere in his front end:: |
|
37 | ||
38 | def stdout_notification(self, type, notifying_object, out_string=None): |
|
38 | and elsewhere in his front end:: | |
39 | self.writeStdOut(out_string) |
|
39 | ||
40 |
|
40 | def stdout_notification(self, type, notifying_object, out_string=None): | ||
41 | If everything works, the Interpreter will (according to its published API) fire a notification via the :data:`IPython.kernel.core.notification.sharedCenter` of type :const:`STD_OUT_NOTIFICATION_TYPE` before writing anything to stdout [it's up to the Intereter implementation to figure out when to do this]. The notificaiton center will then call the registered callbacks for that event type (in this case, Dwight's frontend's stdout_notification method). Again, according to its API, the Interpreter provides an additional keyword argument when firing the notificaiton of out_string, a copy of the string it will write to stdout. |
|
41 | self.writeStdOut(out_string) | |
42 |
|
42 | |||
43 | Like magic, Dwight's frontend is able to provide output, even during long-running calculations. Now if Jim could just convince Dwight to use Twisted... |
|
43 | If everything works, the Interpreter will (according to its published API) fire a notification via the :data:`IPython.kernel.core.notification.sharedCenter` of type :const:`STD_OUT_NOTIFICATION_TYPE` before writing anything to stdout [it's up to the Intereter implementation to figure out when to do this]. The notificaiton center will then call the registered callbacks for that event type (in this case, Dwight's frontend's stdout_notification method). Again, according to its API, the Interpreter provides an additional keyword argument when firing the notificaiton of out_string, a copy of the string it will write to stdout. | |
44 |
|
44 | |||
45 | 2. Boss Hog is writing a frontend for the IPython project. Because Boss Hog is stuck in the stone age, his frontend will be written in a new Fortran-like dialect of python and will run only from the command line. Because he doesn't need any fancy notification system and is used to worrying about every cycle on his rat-wheel powered mini, Boss Hog is adamant that the new notification system not produce any performance penalty. As they say in Hazard county, there's no such thing as a free lunch. If he wanted zero overhead, he should have kept using IPython 0.8. Instead, those tricky Duke boys slide in a suped-up bridge-out jumpin' awkwardly confederate-lovin' notification module that imparts only a constant (and small) performance penalty when the Interpreter (or any other object) fires an event for which there are no registered observers. Of course, the same notificaiton-enabled Interpreter can then be used in frontends that require notifications, thus saving the IPython project from a nasty civil war. |
|
45 | Like magic, Dwight's frontend is able to provide output, even during long-running calculations. Now if Jim could just convince Dwight to use Twisted... | |
46 |
|
46 | |||
47 | 3. Barry is wrting a frontend for the IPython project. Because Barry's front end is the *new hotness*, it uses an asynchronous event model to communicate with a Twisted :mod:`~IPython.kernel.engineservice` that communicates with the IPython :class:`~IPython.kernel.core.interpreter.Interpreter`. Using the :mod:`IPython.kernel.notification` module, an asynchronous wrapper on the :mod:`IPython.kernel.core.notification` module, Barry's frontend can register for notifications from the interpreter that are delivered asynchronously. Even if Barry's frontend is running on a separate process or even host from the Interpreter, the notifications are delivered, as if by dark and twisted magic. Just like Dwight's frontend, Barry's frontend can now recieve notifications of e.g. writing to stdout/stderr, opening/closing an external file, an exception in the executing code, etc. No newline at end of file |
|
47 | 2. Boss Hog is writing a frontend for the IPython project. Because Boss Hog is stuck in the stone age, his frontend will be written in a new Fortran-like dialect of python and will run only from the command line. Because he doesn't need any fancy notification system and is used to worrying about every cycle on his rat-wheel powered mini, Boss Hog is adamant that the new notification system not produce any performance penalty. As they say in Hazard county, there's no such thing as a free lunch. If he wanted zero overhead, he should have kept using IPython 0.8. Instead, those tricky Duke boys slide in a suped-up bridge-out jumpin' awkwardly confederate-lovin' notification module that imparts only a constant (and small) performance penalty when the Interpreter (or any other object) fires an event for which there are no registered observers. Of course, the same notificaiton-enabled Interpreter can then be used in frontends that require notifications, thus saving the IPython project from a nasty civil war. | |
|
48 | ||||
|
49 | 3. Barry is wrting a frontend for the IPython project. Because Barry's front end is the *new hotness*, it uses an asynchronous event model to communicate with a Twisted :mod:`~IPython.kernel.engineservice` that communicates with the IPython :class:`~IPython.kernel.core.interpreter.Interpreter`. Using the :mod:`IPython.kernel.notification` module, an asynchronous wrapper on the :mod:`IPython.kernel.core.notification` module, Barry's frontend can register for notifications from the interpreter that are delivered asynchronously. Even if Barry's frontend is running on a separate process or even host from the Interpreter, the notifications are delivered, as if by dark and twisted magic. Just like Dwight's frontend, Barry's frontend can now recieve notifications of e.g. writing to stdout/stderr, opening/closing an external file, an exception in the executing code, etc. No newline at end of file |
@@ -1,96 +1,107 b'' | |||||
1 | .. _roadmap: |
|
1 | .. _roadmap: | |
2 |
|
2 | |||
3 | =================== |
|
3 | =================== | |
4 | Development roadmap |
|
4 | Development roadmap | |
5 | =================== |
|
5 | =================== | |
6 |
|
6 | |||
7 | .. contents:: |
|
7 | .. contents:: | |
8 |
|
8 | |||
9 | IPython is an ambitious project that is still under heavy development. However, we want IPython to become useful to as many people as possible, as quickly as possible. To help us accomplish this, we are laying out a roadmap of where we are headed and what needs to happen to get there. Hopefully, this will help the IPython developers figure out the best things to work on for each upcoming release. |
|
9 | IPython is an ambitious project that is still under heavy development. However, we want IPython to become useful to as many people as possible, as quickly as possible. To help us accomplish this, we are laying out a roadmap of where we are headed and what needs to happen to get there. Hopefully, this will help the IPython developers figure out the best things to work on for each upcoming release. | |
10 |
|
10 | |||
11 | Speaking of releases, we are going to begin releasing a new version of IPython every four weeks. We are hoping that a regular release schedule, along with a clear roadmap of where we are headed will propel the project forward. |
|
11 | Speaking of releases, we are going to begin releasing a new version of IPython every four weeks. We are hoping that a regular release schedule, along with a clear roadmap of where we are headed will propel the project forward. | |
12 |
|
12 | |||
13 | Where are we headed |
|
13 | Where are we headed | |
14 | =================== |
|
14 | =================== | |
15 |
|
15 | |||
16 | Our goal with IPython is simple: to provide a *powerful*, *robust* and *easy to use* framework for parallel computing. While there are other secondary goals you will hear us talking about at various times, this is the primary goal of IPython that frames the roadmap. |
|
16 | Our goal with IPython is simple: to provide a *powerful*, *robust* and *easy to use* framework for parallel computing. While there are other secondary goals you will hear us talking about at various times, this is the primary goal of IPython that frames the roadmap. | |
17 |
|
17 | |||
18 | Steps along the way |
|
18 | Steps along the way | |
19 | =================== |
|
19 | =================== | |
20 |
|
20 | |||
21 | Here we describe the various things that we need to work on to accomplish this goal. |
|
21 | Here we describe the various things that we need to work on to accomplish this goal. | |
22 |
|
22 | |||
23 | Setting up for regular release schedule |
|
23 | Setting up for regular release schedule | |
24 | --------------------------------------- |
|
24 | --------------------------------------- | |
25 |
|
25 | |||
26 | We would like to begin to release IPython regularly (probably a 4 week release cycle). To get ready for this, we need to revisit the development guidelines and put in information about releasing IPython. |
|
26 | We would like to begin to release IPython regularly (probably a 4 week release cycle). To get ready for this, we need to revisit the development guidelines and put in information about releasing IPython. | |
27 |
|
27 | |||
28 | Process startup and management |
|
28 | Process startup and management | |
29 | ------------------------------ |
|
29 | ------------------------------ | |
30 |
|
30 | |||
31 | IPython is implemented using a distributed set of processes that communicate using TCP/IP network channels. Currently, users have to start each of the various processes separately using command line scripts. This is both difficult and error prone. Furthermore, there are a number of things that often need to be managed once the processes have been started, such as the sending of signals and the shutting down and cleaning up of processes. |
|
31 | IPython is implemented using a distributed set of processes that communicate using TCP/IP network channels. Currently, users have to start each of the various processes separately using command line scripts. This is both difficult and error prone. Furthermore, there are a number of things that often need to be managed once the processes have been started, such as the sending of signals and the shutting down and cleaning up of processes. | |
32 |
|
32 | |||
33 | We need to build a system that makes it trivial for users to start and manage IPython processes. This system should have the following properties: |
|
33 | We need to build a system that makes it trivial for users to start and manage IPython processes. This system should have the following properties: | |
34 |
|
34 | |||
35 |
|
|
35 | * It should possible to do everything through an extremely simple API that users | |
36 |
|
|
36 | can call from their own Python script. No shell commands should be needed. | |
37 | * This simple API should be configured using standard .ini files. |
|
37 | ||
38 | * The system should make it possible to start processes using a number of different |
|
38 | * This simple API should be configured using standard .ini files. | |
39 | approaches: SSH, PBS/Torque, Xgrid, Windows Server, mpirun, etc. |
|
39 | ||
40 | * The controller and engine processes should each have a daemon for monitoring, |
|
40 | * The system should make it possible to start processes using a number of different | |
41 | signaling and clean up. |
|
41 | approaches: SSH, PBS/Torque, Xgrid, Windows Server, mpirun, etc. | |
42 | * The system should be secure. |
|
42 | ||
43 | * The system should work under all the major operating systems, including |
|
43 | * The controller and engine processes should each have a daemon for monitoring, | |
44 | Windows. |
|
44 | signaling and clean up. | |
|
45 | ||||
|
46 | * The system should be secure. | |||
|
47 | ||||
|
48 | * The system should work under all the major operating systems, including | |||
|
49 | Windows. | |||
45 |
|
50 | |||
46 | Initial work has begun on the daemon infrastructure, and some of the needed logic is contained in the ipcluster script. |
|
51 | Initial work has begun on the daemon infrastructure, and some of the needed logic is contained in the ipcluster script. | |
47 |
|
52 | |||
48 | Ease of use/high-level approaches to parallelism |
|
53 | Ease of use/high-level approaches to parallelism | |
49 | ------------------------------------------------ |
|
54 | ------------------------------------------------ | |
50 |
|
55 | |||
51 | While our current API for clients is well designed, we can still do a lot better in designing a user-facing API that is super simple. The main goal here is that it should take *almost no extra code* for users to get their code running in parallel. For this to be possible, we need to tie into Python's standard idioms that enable efficient coding. The biggest ones we are looking at are using context managers (i.e., Python 2.5's ``with`` statement) and decorators. Initial work on this front has begun, but more work is needed. |
|
56 | While our current API for clients is well designed, we can still do a lot better in designing a user-facing API that is super simple. The main goal here is that it should take *almost no extra code* for users to get their code running in parallel. For this to be possible, we need to tie into Python's standard idioms that enable efficient coding. The biggest ones we are looking at are using context managers (i.e., Python 2.5's ``with`` statement) and decorators. Initial work on this front has begun, but more work is needed. | |
52 |
|
57 | |||
53 | We also need to think about new models for expressing parallelism. This is fun work as most of the foundation has already been established. |
|
58 | We also need to think about new models for expressing parallelism. This is fun work as most of the foundation has already been established. | |
54 |
|
59 | |||
55 | Security |
|
60 | Security | |
56 | -------- |
|
61 | -------- | |
57 |
|
62 | |||
58 | Currently, IPython has no built in security or security model. Because we would like IPython to be usable on public computer systems and over wide area networks, we need to come up with a robust solution for security. Here are some of the specific things that need to be included: |
|
63 | Currently, IPython has no built in security or security model. Because we would like IPython to be usable on public computer systems and over wide area networks, we need to come up with a robust solution for security. Here are some of the specific things that need to be included: | |
59 |
|
64 | |||
60 |
|
|
65 | * User authentication between all processes (engines, controller and clients). | |
61 | * Optional TSL/SSL based encryption of all communication channels. |
|
66 | ||
62 | * A good way of picking network ports so multiple users on the same system can |
|
67 | * Optional TSL/SSL based encryption of all communication channels. | |
63 | run their own controller and engines without interfering with those of others. |
|
68 | ||
64 | * A clear model for security that enables users to evaluate the security risks |
|
69 | * A good way of picking network ports so multiple users on the same system can | |
65 | associated with using IPython in various manners. |
|
70 | run their own controller and engines without interfering with those of others. | |
|
71 | ||||
|
72 | * A clear model for security that enables users to evaluate the security risks | |||
|
73 | associated with using IPython in various manners. | |||
66 |
|
74 | |||
67 | For the implementation of this, we plan on using Twisted's support for SSL and authentication. One things that we really should look at is the `Foolscap`_ network protocol, which provides many of these things out of the box. |
|
75 | For the implementation of this, we plan on using Twisted's support for SSL and authentication. One things that we really should look at is the `Foolscap`_ network protocol, which provides many of these things out of the box. | |
68 |
|
76 | |||
69 | .. _Foolscap: http://foolscap.lothar.com/trac |
|
77 | .. _Foolscap: http://foolscap.lothar.com/trac | |
70 |
|
78 | |||
71 | The security work needs to be done in conjunction with other network protocol stuff. |
|
79 | The security work needs to be done in conjunction with other network protocol stuff. | |
72 |
|
80 | |||
|
81 | As of the 0.9 release of IPython, we are using Foolscap and we have implemented | |||
|
82 | a full security model. | |||
|
83 | ||||
73 | Latent performance issues |
|
84 | Latent performance issues | |
74 | ------------------------- |
|
85 | ------------------------- | |
75 |
|
86 | |||
76 | Currently, we have a number of performance issues that are waiting to bite users: |
|
87 | Currently, we have a number of performance issues that are waiting to bite users: | |
77 |
|
88 | |||
78 | * The controller store a large amount of state in Python dictionaries. Under heavy |
|
89 | * The controller store a large amount of state in Python dictionaries. Under heavy | |
79 | usage, these dicts with get very large, causing memory usage problems. We need to |
|
90 | usage, these dicts with get very large, causing memory usage problems. We need to | |
80 | develop more scalable solutions to this problem, such as using a sqlite database |
|
91 | develop more scalable solutions to this problem, such as using a sqlite database | |
81 | to store this state. This will also help the controller to be more fault tolerant. |
|
92 | to store this state. This will also help the controller to be more fault tolerant. | |
82 | * Currently, the client to controller connections are done through XML-RPC using |
|
93 | * Currently, the client to controller connections are done through XML-RPC using | |
83 | HTTP 1.0. This is very inefficient as XML-RPC is a very verbose protocol and |
|
94 | HTTP 1.0. This is very inefficient as XML-RPC is a very verbose protocol and | |
84 | each request must be handled with a new connection. We need to move these network |
|
95 | each request must be handled with a new connection. We need to move these network | |
85 | connections over to PB or Foolscap. |
|
96 | connections over to PB or Foolscap. Done! | |
86 | * We currently don't have a good way of handling large objects in the controller. |
|
97 | * We currently don't have a good way of handling large objects in the controller. | |
87 | The biggest problem is that because we don't have any way of streaming objects, |
|
98 | The biggest problem is that because we don't have any way of streaming objects, | |
88 | we get lots of temporary copies in the low-level buffers. We need to implement |
|
99 | we get lots of temporary copies in the low-level buffers. We need to implement | |
89 | a better serialization approach and true streaming support. |
|
100 | a better serialization approach and true streaming support. | |
90 | * The controller currently unpickles and repickles objects. We need to use the |
|
101 | * The controller currently unpickles and repickles objects. We need to use the | |
91 | [push|pull]_serialized methods instead. |
|
102 | [push|pull]_serialized methods instead. | |
92 | * Currently the controller is a bottleneck. We need the ability to scale the |
|
103 | * Currently the controller is a bottleneck. We need the ability to scale the | |
93 | controller by aggregating multiple controllers into one effective controller. |
|
104 | controller by aggregating multiple controllers into one effective controller. | |
94 |
|
105 | |||
95 |
|
106 | |||
96 |
|
107 |
@@ -1,93 +1,105 b'' | |||||
1 | .. _faq: |
|
1 | .. _faq: | |
2 |
|
2 | |||
3 | ======================================== |
|
3 | ======================================== | |
4 | Frequently asked questions |
|
4 | Frequently asked questions | |
5 | ======================================== |
|
5 | ======================================== | |
6 |
|
6 | |||
7 | General questions |
|
7 | General questions | |
8 | ================= |
|
8 | ================= | |
9 |
|
9 | |||
10 | Questions about parallel computing with IPython |
|
10 | Questions about parallel computing with IPython | |
11 | ================================================ |
|
11 | ================================================ | |
12 |
|
12 | |||
13 | Will IPython speed my Python code up? |
|
13 | Will IPython speed my Python code up? | |
14 | -------------------------------------- |
|
14 | -------------------------------------- | |
15 |
|
15 | |||
16 | Yes and no. When converting a serial code to run in parallel, there often many |
|
16 | Yes and no. When converting a serial code to run in parallel, there often many | |
17 | difficulty questions that need to be answered, such as: |
|
17 | difficulty questions that need to be answered, such as: | |
18 |
|
18 | |||
19 |
|
|
19 | * How should data be decomposed onto the set of processors? | |
20 | * What are the data movement patterns? |
|
20 | ||
21 | * Can the algorithm be structured to minimize data movement? |
|
21 | * What are the data movement patterns? | |
22 | * Is dynamic load balancing important? |
|
22 | ||
|
23 | * Can the algorithm be structured to minimize data movement? | |||
|
24 | ||||
|
25 | * Is dynamic load balancing important? | |||
23 |
|
26 | |||
24 | We can't answer such questions for you. This is the hard (but fun) work of parallel |
|
27 | We can't answer such questions for you. This is the hard (but fun) work of parallel | |
25 | computing. But, once you understand these things IPython will make it easier for you to |
|
28 | computing. But, once you understand these things IPython will make it easier for you to | |
26 | implement a good solution quickly. Most importantly, you will be able to use the |
|
29 | implement a good solution quickly. Most importantly, you will be able to use the | |
27 | resulting parallel code interactively. |
|
30 | resulting parallel code interactively. | |
28 |
|
31 | |||
29 | With that said, if your problem is trivial to parallelize, IPython has a number of |
|
32 | With that said, if your problem is trivial to parallelize, IPython has a number of | |
30 | different interfaces that will enable you to parallelize things is almost no time at |
|
33 | different interfaces that will enable you to parallelize things is almost no time at | |
31 |
all. A good place to start is the ``map`` method of our |
|
34 | all. A good place to start is the ``map`` method of our :class:`MultiEngineClient`. | |
32 |
|
||||
33 | .. _multiengine interface: ./parallel_multiengine |
|
|||
34 |
|
35 | |||
35 | What is the best way to use MPI from Python? |
|
36 | What is the best way to use MPI from Python? | |
36 | -------------------------------------------- |
|
37 | -------------------------------------------- | |
37 |
|
38 | |||
38 | What about all the other parallel computing packages in Python? |
|
39 | What about all the other parallel computing packages in Python? | |
39 | --------------------------------------------------------------- |
|
40 | --------------------------------------------------------------- | |
40 |
|
41 | |||
41 | Some of the unique characteristic of IPython are: |
|
42 | Some of the unique characteristic of IPython are: | |
42 |
|
43 | |||
43 |
|
|
44 | * IPython is the only architecture that abstracts out the notion of a | |
44 |
|
|
45 | parallel computation in such a way that new models of parallel computing | |
45 |
|
|
46 | can be explored quickly and easily. If you don't like the models we | |
46 |
|
|
47 | provide, you can simply create your own using the capabilities we provide. | |
47 | * IPython is asynchronous from the ground up (we use `Twisted`_). |
|
48 | ||
48 | * IPython's architecture is designed to avoid subtle problems |
|
49 | * IPython is asynchronous from the ground up (we use `Twisted`_). | |
49 | that emerge because of Python's global interpreter lock (GIL). |
|
50 | ||
50 |
|
|
51 | * IPython's architecture is designed to avoid subtle problems | |
51 | of novel parallel computing models, it is fully interoperable with |
|
52 | that emerge because of Python's global interpreter lock (GIL). | |
52 | traditional MPI applications. |
|
53 | ||
53 | * IPython has been used and tested extensively on modern supercomputers. |
|
54 | * While IPython's architecture is designed to support a wide range | |
54 | * IPython's networking layers are completely modular. Thus, is |
|
55 | of novel parallel computing models, it is fully interoperable with | |
55 | straightforward to replace our existing network protocols with |
|
56 | traditional MPI applications. | |
56 | high performance alternatives (ones based upon Myranet/Infiniband). |
|
57 | ||
57 | * IPython is designed from the ground up to support collaborative |
|
58 | * IPython has been used and tested extensively on modern supercomputers. | |
58 | parallel computing. This enables multiple users to actively develop |
|
59 | ||
59 | and run the *same* parallel computation. |
|
60 | * IPython's networking layers are completely modular. Thus, is | |
60 | * Interactivity is a central goal for us. While IPython does not have |
|
61 | straightforward to replace our existing network protocols with | |
61 | to be used interactivly, is can be. |
|
62 | high performance alternatives (ones based upon Myranet/Infiniband). | |
62 |
|
|
63 | ||
|
64 | * IPython is designed from the ground up to support collaborative | |||
|
65 | parallel computing. This enables multiple users to actively develop | |||
|
66 | and run the *same* parallel computation. | |||
|
67 | ||||
|
68 | * Interactivity is a central goal for us. While IPython does not have | |||
|
69 | to be used interactivly, it can be. | |||
|
70 | ||||
63 | .. _Twisted: http://www.twistedmatrix.com |
|
71 | .. _Twisted: http://www.twistedmatrix.com | |
64 |
|
72 | |||
65 | Why The IPython controller a bottleneck in my parallel calculation? |
|
73 | Why The IPython controller a bottleneck in my parallel calculation? | |
66 | ------------------------------------------------------------------- |
|
74 | ------------------------------------------------------------------- | |
67 |
|
75 | |||
68 | A golden rule in parallel computing is that you should only move data around if you |
|
76 | A golden rule in parallel computing is that you should only move data around if you | |
69 | absolutely need to. The main reason that the controller becomes a bottleneck is that |
|
77 | absolutely need to. The main reason that the controller becomes a bottleneck is that | |
70 | too much data is being pushed and pulled to and from the engines. If your algorithm |
|
78 | too much data is being pushed and pulled to and from the engines. If your algorithm | |
71 | is structured in this way, you really should think about alternative ways of |
|
79 | is structured in this way, you really should think about alternative ways of | |
72 | handling the data movement. Here are some ideas: |
|
80 | handling the data movement. Here are some ideas: | |
73 |
|
81 | |||
74 |
|
|
82 | 1. Have the engines write data to files on the locals disks of the engines. | |
75 | 2. Have the engines write data to files on a file system that is shared by |
|
83 | ||
76 | the engines. |
|
84 | 2. Have the engines write data to files on a file system that is shared by | |
77 | 3. Have the engines write data to a database that is shared by the engines. |
|
85 | the engines. | |
78 | 4. Simply keep data in the persistent memory of the engines and move the |
|
86 | ||
79 | computation to the data (rather than the data to the computation). |
|
87 | 3. Have the engines write data to a database that is shared by the engines. | |
80 | 5. See if you can pass data directly between engines using MPI. |
|
88 | ||
|
89 | 4. Simply keep data in the persistent memory of the engines and move the | |||
|
90 | computation to the data (rather than the data to the computation). | |||
|
91 | ||||
|
92 | 5. See if you can pass data directly between engines using MPI. | |||
81 |
|
93 | |||
82 | Isn't Python slow to be used for high-performance parallel computing? |
|
94 | Isn't Python slow to be used for high-performance parallel computing? | |
83 | --------------------------------------------------------------------- |
|
95 | --------------------------------------------------------------------- | |
84 |
|
96 | |||
85 |
|
97 | |||
86 |
|
98 | |||
87 |
|
99 | |||
88 |
|
100 | |||
89 |
|
101 | |||
90 |
|
102 | |||
91 |
|
103 | |||
92 |
|
104 | |||
93 |
|
105 |
@@ -1,56 +1,38 b'' | |||||
1 | .. _history: |
|
1 | .. _history: | |
2 |
|
2 | |||
3 | ======= |
|
3 | ======= | |
4 | History |
|
4 | History | |
5 | ======= |
|
5 | ======= | |
6 |
|
6 | |||
7 | Origins |
|
7 | Origins | |
8 | ======= |
|
8 | ======= | |
9 |
|
9 | |||
10 | The current IPython system grew out of the following three projects: |
|
10 | IPython was starting in 2001 by Fernando Perez. IPython as we know it | |
11 |
|
11 | today grew out of the following three projects: | ||
12 | * [ipython] by Fernando Pérez. I was working on adding |
|
12 | ||
13 | Mathematica-type prompts and a flexible configuration system |
|
13 | * ipython by Fernando Pérez. I was working on adding | |
14 | (something better than $PYTHONSTARTUP) to the standard Python |
|
14 | Mathematica-type prompts and a flexible configuration system | |
15 | interactive interpreter. |
|
15 | (something better than $PYTHONSTARTUP) to the standard Python | |
16 | * [IPP] by Janko Hauser. Very well organized, great usability. Had |
|
16 | interactive interpreter. | |
17 | an old help system. IPP was used as the 'container' code into |
|
17 | * IPP by Janko Hauser. Very well organized, great usability. Had | |
18 | which I added the functionality from ipython and LazyPython. |
|
18 | an old help system. IPP was used as the 'container' code into | |
19 | * [LazyPython] by Nathan Gray. Simple but very powerful. The quick |
|
19 | which I added the functionality from ipython and LazyPython. | |
20 | syntax (auto parens, auto quotes) and verbose/colored tracebacks |
|
20 | * LazyPython by Nathan Gray. Simple but very powerful. The quick | |
21 | were all taken from here. |
|
21 | syntax (auto parens, auto quotes) and verbose/colored tracebacks | |
22 |
|
22 | were all taken from here. | ||
23 | When I found out about IPP and LazyPython I tried to join all three |
|
23 | ||
24 | into a unified system. I thought this could provide a very nice |
|
24 | Here is how Fernando describes it: | |
25 | working environment, both for regular programming and scientific |
|
25 | ||
26 | computing: shell-like features, IDL/Matlab numerics, Mathematica-type |
|
26 | When I found out about IPP and LazyPython I tried to join all three | |
27 | prompt history and great object introspection and help facilities. I |
|
27 | into a unified system. I thought this could provide a very nice | |
28 | think it worked reasonably well, though it was a lot more work than I |
|
28 | working environment, both for regular programming and scientific | |
29 | had initially planned. |
|
29 | computing: shell-like features, IDL/Matlab numerics, Mathematica-type | |
30 |
|
30 | prompt history and great object introspection and help facilities. I | ||
31 |
|
31 | think it worked reasonably well, though it was a lot more work than I | ||
32 | Current status |
|
32 | had initially planned. | |
33 | ============== |
|
33 | ||
34 |
|
34 | Today and how we got here | ||
35 | The above listed features work, and quite well for the most part. But |
|
35 | ========================= | |
36 | until a major internal restructuring is done (see below), only bug |
|
36 | ||
37 | fixing will be done, no other features will be added (unless very minor |
|
37 | This needs to be filled in. | |
38 | and well localized in the cleaner parts of the code). |
|
38 | ||
39 |
|
||||
40 | IPython consists of some 18000 lines of pure python code, of which |
|
|||
41 | roughly two thirds is reasonably clean. The rest is, messy code which |
|
|||
42 | needs a massive restructuring before any further major work is done. |
|
|||
43 | Even the messy code is fairly well documented though, and most of the |
|
|||
44 | problems in the (non-existent) class design are well pointed to by a |
|
|||
45 | PyChecker run. So the rewriting work isn't that bad, it will just be |
|
|||
46 | time-consuming. |
|
|||
47 |
|
||||
48 |
|
||||
49 | Future |
|
|||
50 | ------ |
|
|||
51 |
|
||||
52 | See the separate new_design document for details. Ultimately, I would |
|
|||
53 | like to see IPython become part of the standard Python distribution as a |
|
|||
54 | 'big brother with batteries' to the standard Python interactive |
|
|||
55 | interpreter. But that will never happen with the current state of the |
|
|||
56 | code, so all contributions are welcome. No newline at end of file |
|
@@ -1,28 +1,32 b'' | |||||
1 | ===================== |
|
1 | ===================== | |
2 | IPython Documentation |
|
2 | IPython Documentation | |
3 | ===================== |
|
3 | ===================== | |
4 |
|
4 | |||
5 | Contents |
|
5 | .. htmlonly:: | |
6 | ======== |
|
6 | ||
|
7 | :Release: |version| | |||
|
8 | :Date: |today| | |||
|
9 | ||||
|
10 | Contents: | |||
7 |
|
11 | |||
8 | .. toctree:: |
|
12 | .. toctree:: | |
9 |
:maxdepth: |
|
13 | :maxdepth: 2 | |
10 |
|
14 | |||
11 | overview.txt |
|
15 | overview.txt | |
12 | install/index.txt |
|
16 | install/index.txt | |
13 | interactive/index.txt |
|
17 | interactive/index.txt | |
14 | parallel/index.txt |
|
18 | parallel/index.txt | |
15 | config/index.txt |
|
19 | config/index.txt | |
16 | changes.txt |
|
20 | changes.txt | |
17 | development/index.txt |
|
21 | development/index.txt | |
18 | faq.txt |
|
22 | faq.txt | |
19 | history.txt |
|
23 | history.txt | |
20 | license_and_copyright.txt |
|
24 | license_and_copyright.txt | |
21 | credits.txt |
|
25 | credits.txt | |
22 |
|
26 | |||
23 | Indices and tables |
|
|||
24 | ================== |
|
|||
25 |
|
27 | |||
26 | * :ref:`genindex` |
|
28 | .. htmlonly:: | |
27 | * :ref:`modindex` |
|
29 | ||
28 | * :ref:`search` No newline at end of file |
|
30 | * :ref:`genindex` | |
|
31 | * :ref:`modindex` | |||
|
32 | * :ref:`search` |
@@ -1,11 +1,10 b'' | |||||
1 | .. _install_index: |
|
1 | .. _install_index: | |
2 |
|
2 | |||
3 | ================== |
|
3 | ================== | |
4 | Installation |
|
4 | Installation | |
5 | ================== |
|
5 | ================== | |
6 |
|
6 | |||
7 | .. toctree:: |
|
7 | .. toctree:: | |
8 | :maxdepth: 2 |
|
8 | :maxdepth: 2 | |
9 |
|
9 | |||
10 |
|
|
10 | install.txt | |
11 | advanced.txt |
|
@@ -1,3163 +1,3162 b'' | |||||
1 | .. IPython documentation master file, created by sphinx-quickstart.py on Mon Mar 24 17:01:34 2008. |
|
1 | .. IPython documentation master file, created by sphinx-quickstart.py on Mon Mar 24 17:01:34 2008. | |
2 | You can adapt this file completely to your liking, but it should at least |
|
2 | You can adapt this file completely to your liking, but it should at least | |
3 | contain the root 'toctree' directive. |
|
3 | contain the root 'toctree' directive. | |
4 |
|
4 | |||
5 | ================= |
|
5 | ================= | |
6 | IPython reference |
|
6 | IPython reference | |
7 | ================= |
|
7 | ================= | |
8 |
|
8 | |||
9 | .. contents:: |
|
9 | .. contents:: | |
10 |
|
10 | |||
11 |
.. _ |
|
11 | .. _command_line_options: | |
12 |
|
12 | |||
13 | Command-line usage |
|
13 | Command-line usage | |
14 | ================== |
|
14 | ================== | |
15 |
|
15 | |||
16 | You start IPython with the command:: |
|
16 | You start IPython with the command:: | |
17 |
|
17 | |||
18 | $ ipython [options] files |
|
18 | $ ipython [options] files | |
19 |
|
19 | |||
20 | If invoked with no options, it executes all the files listed in sequence |
|
20 | If invoked with no options, it executes all the files listed in sequence | |
21 | and drops you into the interpreter while still acknowledging any options |
|
21 | and drops you into the interpreter while still acknowledging any options | |
22 | you may have set in your ipythonrc file. This behavior is different from |
|
22 | you may have set in your ipythonrc file. This behavior is different from | |
23 | standard Python, which when called as python -i will only execute one |
|
23 | standard Python, which when called as python -i will only execute one | |
24 | file and ignore your configuration setup. |
|
24 | file and ignore your configuration setup. | |
25 |
|
25 | |||
26 | Please note that some of the configuration options are not available at |
|
26 | Please note that some of the configuration options are not available at | |
27 | the command line, simply because they are not practical here. Look into |
|
27 | the command line, simply because they are not practical here. Look into | |
28 | your ipythonrc configuration file for details on those. This file |
|
28 | your ipythonrc configuration file for details on those. This file | |
29 | typically installed in the $HOME/.ipython directory. For Windows users, |
|
29 | typically installed in the $HOME/.ipython directory. For Windows users, | |
30 | $HOME resolves to C:\\Documents and Settings\\YourUserName in most |
|
30 | $HOME resolves to C:\\Documents and Settings\\YourUserName in most | |
31 | instances. In the rest of this text, we will refer to this directory as |
|
31 | instances. In the rest of this text, we will refer to this directory as | |
32 | IPYTHONDIR. |
|
32 | IPYTHONDIR. | |
33 |
|
33 | |||
34 | .. _Threading options: |
|
34 | .. _Threading options: | |
35 |
|
35 | |||
36 |
|
36 | |||
37 | Special Threading Options |
|
37 | Special Threading Options | |
38 | ------------------------- |
|
38 | ------------------------- | |
39 |
|
39 | |||
40 | The following special options are ONLY valid at the beginning of the |
|
40 | The following special options are ONLY valid at the beginning of the | |
41 | command line, and not later. This is because they control the initial- |
|
41 | command line, and not later. This is because they control the initial- | |
42 | ization of ipython itself, before the normal option-handling mechanism |
|
42 | ization of ipython itself, before the normal option-handling mechanism | |
43 | is active. |
|
43 | is active. | |
44 |
|
44 | |||
45 | -gthread, -qthread, -q4thread, -wthread, -pylab: |
|
45 | -gthread, -qthread, -q4thread, -wthread, -pylab: | |
46 | Only one of these can be given, and it can only be given as |
|
46 | Only one of these can be given, and it can only be given as | |
47 | the first option passed to IPython (it will have no effect in |
|
47 | the first option passed to IPython (it will have no effect in | |
48 | any other position). They provide threading support for the |
|
48 | any other position). They provide threading support for the | |
49 | GTK, Qt (versions 3 and 4) and WXPython toolkits, and for the |
|
49 | GTK, Qt (versions 3 and 4) and WXPython toolkits, and for the | |
50 | matplotlib library. |
|
50 | matplotlib library. | |
51 |
|
51 | |||
52 | With any of the first four options, IPython starts running a |
|
52 | With any of the first four options, IPython starts running a | |
53 | separate thread for the graphical toolkit's operation, so that |
|
53 | separate thread for the graphical toolkit's operation, so that | |
54 | you can open and control graphical elements from within an |
|
54 | you can open and control graphical elements from within an | |
55 | IPython command line, without blocking. All four provide |
|
55 | IPython command line, without blocking. All four provide | |
56 | essentially the same functionality, respectively for GTK, Qt3, |
|
56 | essentially the same functionality, respectively for GTK, Qt3, | |
57 | Qt4 and WXWidgets (via their Python interfaces). |
|
57 | Qt4 and WXWidgets (via their Python interfaces). | |
58 |
|
58 | |||
59 | Note that with -wthread, you can additionally use the |
|
59 | Note that with -wthread, you can additionally use the | |
60 | -wxversion option to request a specific version of wx to be |
|
60 | -wxversion option to request a specific version of wx to be | |
61 | used. This requires that you have the wxversion Python module |
|
61 | used. This requires that you have the wxversion Python module | |
62 | installed, which is part of recent wxPython distributions. |
|
62 | installed, which is part of recent wxPython distributions. | |
63 |
|
63 | |||
64 | If -pylab is given, IPython loads special support for the mat |
|
64 | If -pylab is given, IPython loads special support for the mat | |
65 | plotlib library (http://matplotlib.sourceforge.net), allowing |
|
65 | plotlib library (http://matplotlib.sourceforge.net), allowing | |
66 | interactive usage of any of its backends as defined in the |
|
66 | interactive usage of any of its backends as defined in the | |
67 | user's ~/.matplotlib/matplotlibrc file. It automatically |
|
67 | user's ~/.matplotlib/matplotlibrc file. It automatically | |
68 | activates GTK, Qt or WX threading for IPyhton if the choice of |
|
68 | activates GTK, Qt or WX threading for IPyhton if the choice of | |
69 | matplotlib backend requires it. It also modifies the %run |
|
69 | matplotlib backend requires it. It also modifies the %run | |
70 | command to correctly execute (without blocking) any |
|
70 | command to correctly execute (without blocking) any | |
71 | matplotlib-based script which calls show() at the end. |
|
71 | matplotlib-based script which calls show() at the end. | |
72 |
|
72 | |||
73 | -tk |
|
73 | -tk | |
74 | The -g/q/q4/wthread options, and -pylab (if matplotlib is |
|
74 | The -g/q/q4/wthread options, and -pylab (if matplotlib is | |
75 | configured to use GTK, Qt3, Qt4 or WX), will normally block Tk |
|
75 | configured to use GTK, Qt3, Qt4 or WX), will normally block Tk | |
76 | graphical interfaces. This means that when either GTK, Qt or WX |
|
76 | graphical interfaces. This means that when either GTK, Qt or WX | |
77 | threading is active, any attempt to open a Tk GUI will result in a |
|
77 | threading is active, any attempt to open a Tk GUI will result in a | |
78 | dead window, and possibly cause the Python interpreter to crash. |
|
78 | dead window, and possibly cause the Python interpreter to crash. | |
79 | An extra option, -tk, is available to address this issue. It can |
|
79 | An extra option, -tk, is available to address this issue. It can | |
80 | only be given as a second option after any of the above (-gthread, |
|
80 | only be given as a second option after any of the above (-gthread, | |
81 | -wthread or -pylab). |
|
81 | -wthread or -pylab). | |
82 |
|
82 | |||
83 | If -tk is given, IPython will try to coordinate Tk threading |
|
83 | If -tk is given, IPython will try to coordinate Tk threading | |
84 | with GTK, Qt or WX. This is however potentially unreliable, and |
|
84 | with GTK, Qt or WX. This is however potentially unreliable, and | |
85 | you will have to test on your platform and Python configuration to |
|
85 | you will have to test on your platform and Python configuration to | |
86 | determine whether it works for you. Debian users have reported |
|
86 | determine whether it works for you. Debian users have reported | |
87 | success, apparently due to the fact that Debian builds all of Tcl, |
|
87 | success, apparently due to the fact that Debian builds all of Tcl, | |
88 | Tk, Tkinter and Python with pthreads support. Under other Linux |
|
88 | Tk, Tkinter and Python with pthreads support. Under other Linux | |
89 | environments (such as Fedora Core 2/3), this option has caused |
|
89 | environments (such as Fedora Core 2/3), this option has caused | |
90 | random crashes and lockups of the Python interpreter. Under other |
|
90 | random crashes and lockups of the Python interpreter. Under other | |
91 | operating systems (Mac OSX and Windows), you'll need to try it to |
|
91 | operating systems (Mac OSX and Windows), you'll need to try it to | |
92 | find out, since currently no user reports are available. |
|
92 | find out, since currently no user reports are available. | |
93 |
|
93 | |||
94 | There is unfortunately no way for IPython to determine at run time |
|
94 | There is unfortunately no way for IPython to determine at run time | |
95 | whether -tk will work reliably or not, so you will need to do some |
|
95 | whether -tk will work reliably or not, so you will need to do some | |
96 | experiments before relying on it for regular work. |
|
96 | experiments before relying on it for regular work. | |
97 |
|
97 | |||
98 |
|
98 | |||
99 |
|
99 | |||
100 | Regular Options |
|
100 | Regular Options | |
101 | --------------- |
|
101 | --------------- | |
102 |
|
102 | |||
103 | After the above threading options have been given, regular options can |
|
103 | After the above threading options have been given, regular options can | |
104 | follow in any order. All options can be abbreviated to their shortest |
|
104 | follow in any order. All options can be abbreviated to their shortest | |
105 | non-ambiguous form and are case-sensitive. One or two dashes can be |
|
105 | non-ambiguous form and are case-sensitive. One or two dashes can be | |
106 | used. Some options have an alternate short form, indicated after a ``|``. |
|
106 | used. Some options have an alternate short form, indicated after a ``|``. | |
107 |
|
107 | |||
108 | Most options can also be set from your ipythonrc configuration file. See |
|
108 | Most options can also be set from your ipythonrc configuration file. See | |
109 | the provided example for more details on what the options do. Options |
|
109 | the provided example for more details on what the options do. Options | |
110 | given at the command line override the values set in the ipythonrc file. |
|
110 | given at the command line override the values set in the ipythonrc file. | |
111 |
|
111 | |||
112 | All options with a [no] prepended can be specified in negated form |
|
112 | All options with a [no] prepended can be specified in negated form | |
113 | (-nooption instead of -option) to turn the feature off. |
|
113 | (-nooption instead of -option) to turn the feature off. | |
114 |
|
114 | |||
115 | -help print a help message and exit. |
|
115 | -help print a help message and exit. | |
116 |
|
116 | |||
117 | -pylab |
|
117 | -pylab | |
118 | this can only be given as the first option passed to IPython |
|
118 | this can only be given as the first option passed to IPython | |
119 | (it will have no effect in any other position). It adds |
|
119 | (it will have no effect in any other position). It adds | |
120 | special support for the matplotlib library |
|
120 | special support for the matplotlib library | |
121 | (http://matplotlib.sourceforge.ne), allowing interactive usage |
|
121 | (http://matplotlib.sourceforge.ne), allowing interactive usage | |
122 | of any of its backends as defined in the user's .matplotlibrc |
|
122 | of any of its backends as defined in the user's .matplotlibrc | |
123 | file. It automatically activates GTK or WX threading for |
|
123 | file. It automatically activates GTK or WX threading for | |
124 | IPyhton if the choice of matplotlib backend requires it. It |
|
124 | IPyhton if the choice of matplotlib backend requires it. It | |
125 | also modifies the %run command to correctly execute (without |
|
125 | also modifies the %run command to correctly execute (without | |
126 | blocking) any matplotlib-based script which calls show() at |
|
126 | blocking) any matplotlib-based script which calls show() at | |
127 | the end. See `Matplotlib support`_ for more details. |
|
127 | the end. See `Matplotlib support`_ for more details. | |
128 |
|
128 | |||
129 | -autocall <val> |
|
129 | -autocall <val> | |
130 | Make IPython automatically call any callable object even if you |
|
130 | Make IPython automatically call any callable object even if you | |
131 | didn't type explicit parentheses. For example, 'str 43' becomes |
|
131 | didn't type explicit parentheses. For example, 'str 43' becomes | |
132 | 'str(43)' automatically. The value can be '0' to disable the feature, |
|
132 | 'str(43)' automatically. The value can be '0' to disable the feature, | |
133 | '1' for smart autocall, where it is not applied if there are no more |
|
133 | '1' for smart autocall, where it is not applied if there are no more | |
134 | arguments on the line, and '2' for full autocall, where all callable |
|
134 | arguments on the line, and '2' for full autocall, where all callable | |
135 | objects are automatically called (even if no arguments are |
|
135 | objects are automatically called (even if no arguments are | |
136 | present). The default is '1'. |
|
136 | present). The default is '1'. | |
137 |
|
137 | |||
138 | -[no]autoindent |
|
138 | -[no]autoindent | |
139 | Turn automatic indentation on/off. |
|
139 | Turn automatic indentation on/off. | |
140 |
|
140 | |||
141 | -[no]automagic |
|
141 | -[no]automagic | |
142 | make magic commands automatic (without needing their first character |
|
142 | make magic commands automatic (without needing their first character | |
143 | to be %). Type %magic at the IPython prompt for more information. |
|
143 | to be %). Type %magic at the IPython prompt for more information. | |
144 |
|
144 | |||
145 | -[no]autoedit_syntax |
|
145 | -[no]autoedit_syntax | |
146 | When a syntax error occurs after editing a file, automatically |
|
146 | When a syntax error occurs after editing a file, automatically | |
147 | open the file to the trouble causing line for convenient |
|
147 | open the file to the trouble causing line for convenient | |
148 | fixing. |
|
148 | fixing. | |
149 |
|
149 | |||
150 | -[no]banner Print the initial information banner (default on). |
|
150 | -[no]banner Print the initial information banner (default on). | |
151 |
|
151 | |||
152 | -c <command> |
|
152 | -c <command> | |
153 | execute the given command string. This is similar to the -c |
|
153 | execute the given command string. This is similar to the -c | |
154 | option in the normal Python interpreter. |
|
154 | option in the normal Python interpreter. | |
155 |
|
155 | |||
156 | -cache_size, cs <n> |
|
156 | -cache_size, cs <n> | |
157 | size of the output cache (maximum number of entries to hold in |
|
157 | size of the output cache (maximum number of entries to hold in | |
158 | memory). The default is 1000, you can change it permanently in your |
|
158 | memory). The default is 1000, you can change it permanently in your | |
159 | config file. Setting it to 0 completely disables the caching system, |
|
159 | config file. Setting it to 0 completely disables the caching system, | |
160 | and the minimum value accepted is 20 (if you provide a value less than |
|
160 | and the minimum value accepted is 20 (if you provide a value less than | |
161 | 20, it is reset to 0 and a warning is issued) This limit is defined |
|
161 | 20, it is reset to 0 and a warning is issued) This limit is defined | |
162 | because otherwise you'll spend more time re-flushing a too small cache |
|
162 | because otherwise you'll spend more time re-flushing a too small cache | |
163 | than working. |
|
163 | than working. | |
164 |
|
164 | |||
165 | -classic, cl |
|
165 | -classic, cl | |
166 | Gives IPython a similar feel to the classic Python |
|
166 | Gives IPython a similar feel to the classic Python | |
167 | prompt. |
|
167 | prompt. | |
168 |
|
168 | |||
169 | -colors <scheme> |
|
169 | -colors <scheme> | |
170 | Color scheme for prompts and exception reporting. Currently |
|
170 | Color scheme for prompts and exception reporting. Currently | |
171 | implemented: NoColor, Linux and LightBG. |
|
171 | implemented: NoColor, Linux and LightBG. | |
172 |
|
172 | |||
173 | -[no]color_info |
|
173 | -[no]color_info | |
174 | IPython can display information about objects via a set of functions, |
|
174 | IPython can display information about objects via a set of functions, | |
175 | and optionally can use colors for this, syntax highlighting source |
|
175 | and optionally can use colors for this, syntax highlighting source | |
176 | code and various other elements. However, because this information is |
|
176 | code and various other elements. However, because this information is | |
177 | passed through a pager (like 'less') and many pagers get confused with |
|
177 | passed through a pager (like 'less') and many pagers get confused with | |
178 | color codes, this option is off by default. You can test it and turn |
|
178 | color codes, this option is off by default. You can test it and turn | |
179 | it on permanently in your ipythonrc file if it works for you. As a |
|
179 | it on permanently in your ipythonrc file if it works for you. As a | |
180 | reference, the 'less' pager supplied with Mandrake 8.2 works ok, but |
|
180 | reference, the 'less' pager supplied with Mandrake 8.2 works ok, but | |
181 | that in RedHat 7.2 doesn't. |
|
181 | that in RedHat 7.2 doesn't. | |
182 |
|
182 | |||
183 | Test it and turn it on permanently if it works with your |
|
183 | Test it and turn it on permanently if it works with your | |
184 | system. The magic function %color_info allows you to toggle this |
|
184 | system. The magic function %color_info allows you to toggle this | |
185 | interactively for testing. |
|
185 | interactively for testing. | |
186 |
|
186 | |||
187 | -[no]debug |
|
187 | -[no]debug | |
188 | Show information about the loading process. Very useful to pin down |
|
188 | Show information about the loading process. Very useful to pin down | |
189 | problems with your configuration files or to get details about |
|
189 | problems with your configuration files or to get details about | |
190 | session restores. |
|
190 | session restores. | |
191 |
|
191 | |||
192 | -[no]deep_reload: |
|
192 | -[no]deep_reload: | |
193 | IPython can use the deep_reload module which reloads changes in |
|
193 | IPython can use the deep_reload module which reloads changes in | |
194 | modules recursively (it replaces the reload() function, so you don't |
|
194 | modules recursively (it replaces the reload() function, so you don't | |
195 | need to change anything to use it). deep_reload() forces a full |
|
195 | need to change anything to use it). deep_reload() forces a full | |
196 | reload of modules whose code may have changed, which the default |
|
196 | reload of modules whose code may have changed, which the default | |
197 | reload() function does not. |
|
197 | reload() function does not. | |
198 |
|
198 | |||
199 | When deep_reload is off, IPython will use the normal reload(), |
|
199 | When deep_reload is off, IPython will use the normal reload(), | |
200 | but deep_reload will still be available as dreload(). This |
|
200 | but deep_reload will still be available as dreload(). This | |
201 | feature is off by default [which means that you have both |
|
201 | feature is off by default [which means that you have both | |
202 | normal reload() and dreload()]. |
|
202 | normal reload() and dreload()]. | |
203 |
|
203 | |||
204 | -editor <name> |
|
204 | -editor <name> | |
205 | Which editor to use with the %edit command. By default, |
|
205 | Which editor to use with the %edit command. By default, | |
206 | IPython will honor your EDITOR environment variable (if not |
|
206 | IPython will honor your EDITOR environment variable (if not | |
207 | set, vi is the Unix default and notepad the Windows one). |
|
207 | set, vi is the Unix default and notepad the Windows one). | |
208 | Since this editor is invoked on the fly by IPython and is |
|
208 | Since this editor is invoked on the fly by IPython and is | |
209 | meant for editing small code snippets, you may want to use a |
|
209 | meant for editing small code snippets, you may want to use a | |
210 | small, lightweight editor here (in case your default EDITOR is |
|
210 | small, lightweight editor here (in case your default EDITOR is | |
211 | something like Emacs). |
|
211 | something like Emacs). | |
212 |
|
212 | |||
213 | -ipythondir <name> |
|
213 | -ipythondir <name> | |
214 | name of your IPython configuration directory IPYTHONDIR. This |
|
214 | name of your IPython configuration directory IPYTHONDIR. This | |
215 | can also be specified through the environment variable |
|
215 | can also be specified through the environment variable | |
216 | IPYTHONDIR. |
|
216 | IPYTHONDIR. | |
217 |
|
217 | |||
218 | -log, l |
|
218 | -log, l | |
219 | generate a log file of all input. The file is named |
|
219 | generate a log file of all input. The file is named | |
220 | ipython_log.py in your current directory (which prevents logs |
|
220 | ipython_log.py in your current directory (which prevents logs | |
221 | from multiple IPython sessions from trampling each other). You |
|
221 | from multiple IPython sessions from trampling each other). You | |
222 | can use this to later restore a session by loading your |
|
222 | can use this to later restore a session by loading your | |
223 | logfile as a file to be executed with option -logplay (see |
|
223 | logfile as a file to be executed with option -logplay (see | |
224 | below). |
|
224 | below). | |
225 |
|
225 | |||
226 | -logfile, lf <name> specify the name of your logfile. |
|
226 | -logfile, lf <name> specify the name of your logfile. | |
227 |
|
227 | |||
228 | -logplay, lp <name> |
|
228 | -logplay, lp <name> | |
229 |
|
229 | |||
230 | you can replay a previous log. For restoring a session as close as |
|
230 | you can replay a previous log. For restoring a session as close as | |
231 | possible to the state you left it in, use this option (don't just run |
|
231 | possible to the state you left it in, use this option (don't just run | |
232 | the logfile). With -logplay, IPython will try to reconstruct the |
|
232 | the logfile). With -logplay, IPython will try to reconstruct the | |
233 | previous working environment in full, not just execute the commands in |
|
233 | previous working environment in full, not just execute the commands in | |
234 | the logfile. |
|
234 | the logfile. | |
235 |
|
235 | |||
236 | When a session is restored, logging is automatically turned on |
|
236 | When a session is restored, logging is automatically turned on | |
237 | again with the name of the logfile it was invoked with (it is |
|
237 | again with the name of the logfile it was invoked with (it is | |
238 | read from the log header). So once you've turned logging on for |
|
238 | read from the log header). So once you've turned logging on for | |
239 | a session, you can quit IPython and reload it as many times as |
|
239 | a session, you can quit IPython and reload it as many times as | |
240 | you want and it will continue to log its history and restore |
|
240 | you want and it will continue to log its history and restore | |
241 | from the beginning every time. |
|
241 | from the beginning every time. | |
242 |
|
242 | |||
243 | Caveats: there are limitations in this option. The history |
|
243 | Caveats: there are limitations in this option. The history | |
244 | variables _i*,_* and _dh don't get restored properly. In the |
|
244 | variables _i*,_* and _dh don't get restored properly. In the | |
245 | future we will try to implement full session saving by writing |
|
245 | future we will try to implement full session saving by writing | |
246 | and retrieving a 'snapshot' of the memory state of IPython. But |
|
246 | and retrieving a 'snapshot' of the memory state of IPython. But | |
247 | our first attempts failed because of inherent limitations of |
|
247 | our first attempts failed because of inherent limitations of | |
248 | Python's Pickle module, so this may have to wait. |
|
248 | Python's Pickle module, so this may have to wait. | |
249 |
|
249 | |||
250 | -[no]messages |
|
250 | -[no]messages | |
251 | Print messages which IPython collects about its startup |
|
251 | Print messages which IPython collects about its startup | |
252 | process (default on). |
|
252 | process (default on). | |
253 |
|
253 | |||
254 | -[no]pdb |
|
254 | -[no]pdb | |
255 | Automatically call the pdb debugger after every uncaught |
|
255 | Automatically call the pdb debugger after every uncaught | |
256 | exception. If you are used to debugging using pdb, this puts |
|
256 | exception. If you are used to debugging using pdb, this puts | |
257 | you automatically inside of it after any call (either in |
|
257 | you automatically inside of it after any call (either in | |
258 | IPython or in code called by it) which triggers an exception |
|
258 | IPython or in code called by it) which triggers an exception | |
259 | which goes uncaught. |
|
259 | which goes uncaught. | |
260 |
|
260 | |||
261 | -pydb |
|
261 | -pydb | |
262 | Makes IPython use the third party "pydb" package as debugger, |
|
262 | Makes IPython use the third party "pydb" package as debugger, | |
263 | instead of pdb. Requires that pydb is installed. |
|
263 | instead of pdb. Requires that pydb is installed. | |
264 |
|
264 | |||
265 | -[no]pprint |
|
265 | -[no]pprint | |
266 | ipython can optionally use the pprint (pretty printer) module |
|
266 | ipython can optionally use the pprint (pretty printer) module | |
267 | for displaying results. pprint tends to give a nicer display |
|
267 | for displaying results. pprint tends to give a nicer display | |
268 | of nested data structures. If you like it, you can turn it on |
|
268 | of nested data structures. If you like it, you can turn it on | |
269 | permanently in your config file (default off). |
|
269 | permanently in your config file (default off). | |
270 |
|
270 | |||
271 | -profile, p <name> |
|
271 | -profile, p <name> | |
272 |
|
272 | |||
273 | assume that your config file is ipythonrc-<name> or |
|
273 | assume that your config file is ipythonrc-<name> or | |
274 | ipy_profile_<name>.py (looks in current dir first, then in |
|
274 | ipy_profile_<name>.py (looks in current dir first, then in | |
275 | IPYTHONDIR). This is a quick way to keep and load multiple |
|
275 | IPYTHONDIR). This is a quick way to keep and load multiple | |
276 | config files for different tasks, especially if you use the |
|
276 | config files for different tasks, especially if you use the | |
277 | include option of config files. You can keep a basic |
|
277 | include option of config files. You can keep a basic | |
278 | IPYTHONDIR/ipythonrc file and then have other 'profiles' which |
|
278 | IPYTHONDIR/ipythonrc file and then have other 'profiles' which | |
279 | include this one and load extra things for particular |
|
279 | include this one and load extra things for particular | |
280 | tasks. For example: |
|
280 | tasks. For example: | |
281 |
|
281 | |||
282 | 1. $HOME/.ipython/ipythonrc : load basic things you always want. |
|
282 | 1. $HOME/.ipython/ipythonrc : load basic things you always want. | |
283 | 2. $HOME/.ipython/ipythonrc-math : load (1) and basic math-related modules. |
|
283 | 2. $HOME/.ipython/ipythonrc-math : load (1) and basic math-related modules. | |
284 | 3. $HOME/.ipython/ipythonrc-numeric : load (1) and Numeric and plotting modules. |
|
284 | 3. $HOME/.ipython/ipythonrc-numeric : load (1) and Numeric and plotting modules. | |
285 |
|
285 | |||
286 | Since it is possible to create an endless loop by having |
|
286 | Since it is possible to create an endless loop by having | |
287 | circular file inclusions, IPython will stop if it reaches 15 |
|
287 | circular file inclusions, IPython will stop if it reaches 15 | |
288 | recursive inclusions. |
|
288 | recursive inclusions. | |
289 |
|
289 | |||
290 | -prompt_in1, pi1 <string> |
|
290 | -prompt_in1, pi1 <string> | |
291 | Specify the string used for input prompts. Note that if you |
|
291 | ||
292 | are using numbered prompts, the number is represented with a |
|
292 | Specify the string used for input prompts. Note that if you are using | |
293 | '\#' in the string. Don't forget to quote strings with spaces |
|
293 | numbered prompts, the number is represented with a '\#' in the | |
294 | embedded in them. Default: 'In [\#]:'. Sec. Prompts_ |
|
294 | string. Don't forget to quote strings with spaces embedded in | |
295 | discusses in detail all the available escapes to customize |
|
295 | them. Default: 'In [\#]:'. The :ref:`prompts section <prompts>` | |
296 | your prompts. |
|
296 | discusses in detail all the available escapes to customize your | |
|
297 | prompts. | |||
297 |
|
298 | |||
298 | -prompt_in2, pi2 <string> |
|
299 | -prompt_in2, pi2 <string> | |
299 | Similar to the previous option, but used for the continuation |
|
300 | Similar to the previous option, but used for the continuation | |
300 | prompts. The special sequence '\D' is similar to '\#', but |
|
301 | prompts. The special sequence '\D' is similar to '\#', but | |
301 | with all digits replaced dots (so you can have your |
|
302 | with all digits replaced dots (so you can have your | |
302 | continuation prompt aligned with your input prompt). Default: |
|
303 | continuation prompt aligned with your input prompt). Default: | |
303 | ' .\D.:' (note three spaces at the start for alignment with |
|
304 | ' .\D.:' (note three spaces at the start for alignment with | |
304 | 'In [\#]'). |
|
305 | 'In [\#]'). | |
305 |
|
306 | |||
306 | -prompt_out,po <string> |
|
307 | -prompt_out,po <string> | |
307 | String used for output prompts, also uses numbers like |
|
308 | String used for output prompts, also uses numbers like | |
308 | prompt_in1. Default: 'Out[\#]:' |
|
309 | prompt_in1. Default: 'Out[\#]:' | |
309 |
|
310 | |||
310 | -quick start in bare bones mode (no config file loaded). |
|
311 | -quick start in bare bones mode (no config file loaded). | |
311 |
|
312 | |||
312 | -rcfile <name> |
|
313 | -rcfile <name> | |
313 | name of your IPython resource configuration file. Normally |
|
314 | name of your IPython resource configuration file. Normally | |
314 | IPython loads ipythonrc (from current directory) or |
|
315 | IPython loads ipythonrc (from current directory) or | |
315 | IPYTHONDIR/ipythonrc. |
|
316 | IPYTHONDIR/ipythonrc. | |
316 |
|
317 | |||
317 | If the loading of your config file fails, IPython starts with |
|
318 | If the loading of your config file fails, IPython starts with | |
318 | a bare bones configuration (no modules loaded at all). |
|
319 | a bare bones configuration (no modules loaded at all). | |
319 |
|
320 | |||
320 | -[no]readline |
|
321 | -[no]readline | |
321 | use the readline library, which is needed to support name |
|
322 | use the readline library, which is needed to support name | |
322 | completion and command history, among other things. It is |
|
323 | completion and command history, among other things. It is | |
323 | enabled by default, but may cause problems for users of |
|
324 | enabled by default, but may cause problems for users of | |
324 | X/Emacs in Python comint or shell buffers. |
|
325 | X/Emacs in Python comint or shell buffers. | |
325 |
|
326 | |||
326 | Note that X/Emacs 'eterm' buffers (opened with M-x term) support |
|
327 | Note that X/Emacs 'eterm' buffers (opened with M-x term) support | |
327 | IPython's readline and syntax coloring fine, only 'emacs' (M-x |
|
328 | IPython's readline and syntax coloring fine, only 'emacs' (M-x | |
328 | shell and C-c !) buffers do not. |
|
329 | shell and C-c !) buffers do not. | |
329 |
|
330 | |||
330 | -screen_length, sl <n> |
|
331 | -screen_length, sl <n> | |
331 | number of lines of your screen. This is used to control |
|
332 | number of lines of your screen. This is used to control | |
332 | printing of very long strings. Strings longer than this number |
|
333 | printing of very long strings. Strings longer than this number | |
333 | of lines will be sent through a pager instead of directly |
|
334 | of lines will be sent through a pager instead of directly | |
334 | printed. |
|
335 | printed. | |
335 |
|
336 | |||
336 | The default value for this is 0, which means IPython will |
|
337 | The default value for this is 0, which means IPython will | |
337 | auto-detect your screen size every time it needs to print certain |
|
338 | auto-detect your screen size every time it needs to print certain | |
338 | potentially long strings (this doesn't change the behavior of the |
|
339 | potentially long strings (this doesn't change the behavior of the | |
339 | 'print' keyword, it's only triggered internally). If for some |
|
340 | 'print' keyword, it's only triggered internally). If for some | |
340 | reason this isn't working well (it needs curses support), specify |
|
341 | reason this isn't working well (it needs curses support), specify | |
341 | it yourself. Otherwise don't change the default. |
|
342 | it yourself. Otherwise don't change the default. | |
342 |
|
343 | |||
343 | -separate_in, si <string> |
|
344 | -separate_in, si <string> | |
344 |
|
345 | |||
345 | separator before input prompts. |
|
346 | separator before input prompts. | |
346 | Default: '\n' |
|
347 | Default: '\n' | |
347 |
|
348 | |||
348 | -separate_out, so <string> |
|
349 | -separate_out, so <string> | |
349 | separator before output prompts. |
|
350 | separator before output prompts. | |
350 | Default: nothing. |
|
351 | Default: nothing. | |
351 |
|
352 | |||
352 | -separate_out2, so2 |
|
353 | -separate_out2, so2 | |
353 | separator after output prompts. |
|
354 | separator after output prompts. | |
354 | Default: nothing. |
|
355 | Default: nothing. | |
355 | For these three options, use the value 0 to specify no separator. |
|
356 | For these three options, use the value 0 to specify no separator. | |
356 |
|
357 | |||
357 | -nosep |
|
358 | -nosep | |
358 | shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 |
|
359 | shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 | |
359 | 0'. Simply removes all input/output separators. |
|
360 | 0'. Simply removes all input/output separators. | |
360 |
|
361 | |||
361 | -upgrade |
|
362 | -upgrade | |
362 | allows you to upgrade your IPYTHONDIR configuration when you |
|
363 | allows you to upgrade your IPYTHONDIR configuration when you | |
363 | install a new version of IPython. Since new versions may |
|
364 | install a new version of IPython. Since new versions may | |
364 | include new command line options or example files, this copies |
|
365 | include new command line options or example files, this copies | |
365 | updated ipythonrc-type files. However, it backs up (with a |
|
366 | updated ipythonrc-type files. However, it backs up (with a | |
366 | .old extension) all files which it overwrites so that you can |
|
367 | .old extension) all files which it overwrites so that you can | |
367 | merge back any customizations you might have in your personal |
|
368 | merge back any customizations you might have in your personal | |
368 | files. Note that you should probably use %upgrade instead, |
|
369 | files. Note that you should probably use %upgrade instead, | |
369 | it's a safer alternative. |
|
370 | it's a safer alternative. | |
370 |
|
371 | |||
371 |
|
372 | |||
372 | -Version print version information and exit. |
|
373 | -Version print version information and exit. | |
373 |
|
374 | |||
374 | -wxversion <string> |
|
375 | -wxversion <string> | |
375 | Select a specific version of wxPython (used in conjunction |
|
376 | Select a specific version of wxPython (used in conjunction | |
376 | with -wthread). Requires the wxversion module, part of recent |
|
377 | with -wthread). Requires the wxversion module, part of recent | |
377 | wxPython distributions |
|
378 | wxPython distributions | |
378 |
|
379 | |||
379 | -xmode <modename> |
|
380 | -xmode <modename> | |
380 |
|
381 | |||
381 | Mode for exception reporting. |
|
382 | Mode for exception reporting. | |
382 |
|
383 | |||
383 | Valid modes: Plain, Context and Verbose. |
|
384 | Valid modes: Plain, Context and Verbose. | |
384 |
|
385 | |||
385 | * Plain: similar to python's normal traceback printing. |
|
386 | * Plain: similar to python's normal traceback printing. | |
386 | * Context: prints 5 lines of context source code around each |
|
387 | * Context: prints 5 lines of context source code around each | |
387 | line in the traceback. |
|
388 | line in the traceback. | |
388 | * Verbose: similar to Context, but additionally prints the |
|
389 | * Verbose: similar to Context, but additionally prints the | |
389 | variables currently visible where the exception happened |
|
390 | variables currently visible where the exception happened | |
390 | (shortening their strings if too long). This can potentially be |
|
391 | (shortening their strings if too long). This can potentially be | |
391 | very slow, if you happen to have a huge data structure whose |
|
392 | very slow, if you happen to have a huge data structure whose | |
392 | string representation is complex to compute. Your computer may |
|
393 | string representation is complex to compute. Your computer may | |
393 | appear to freeze for a while with cpu usage at 100%. If this |
|
394 | appear to freeze for a while with cpu usage at 100%. If this | |
394 | occurs, you can cancel the traceback with Ctrl-C (maybe hitting it |
|
395 | occurs, you can cancel the traceback with Ctrl-C (maybe hitting it | |
395 | more than once). |
|
396 | more than once). | |
396 |
|
397 | |||
397 | Interactive use |
|
398 | Interactive use | |
398 | =============== |
|
399 | =============== | |
399 |
|
400 | |||
400 | Warning: IPython relies on the existence of a global variable called |
|
401 | Warning: IPython relies on the existence of a global variable called | |
401 | _ip which controls the shell itself. If you redefine _ip to anything, |
|
402 | _ip which controls the shell itself. If you redefine _ip to anything, | |
402 | bizarre behavior will quickly occur. |
|
403 | bizarre behavior will quickly occur. | |
403 |
|
404 | |||
404 | Other than the above warning, IPython is meant to work as a drop-in |
|
405 | Other than the above warning, IPython is meant to work as a drop-in | |
405 | replacement for the standard interactive interpreter. As such, any code |
|
406 | replacement for the standard interactive interpreter. As such, any code | |
406 | which is valid python should execute normally under IPython (cases where |
|
407 | which is valid python should execute normally under IPython (cases where | |
407 | this is not true should be reported as bugs). It does, however, offer |
|
408 | this is not true should be reported as bugs). It does, however, offer | |
408 | many features which are not available at a standard python prompt. What |
|
409 | many features which are not available at a standard python prompt. What | |
409 | follows is a list of these. |
|
410 | follows is a list of these. | |
410 |
|
411 | |||
411 |
|
412 | |||
412 | Caution for Windows users |
|
413 | Caution for Windows users | |
413 | ------------------------- |
|
414 | ------------------------- | |
414 |
|
415 | |||
415 | Windows, unfortunately, uses the '\' character as a path |
|
416 | Windows, unfortunately, uses the '\' character as a path | |
416 | separator. This is a terrible choice, because '\' also represents the |
|
417 | separator. This is a terrible choice, because '\' also represents the | |
417 | escape character in most modern programming languages, including |
|
418 | escape character in most modern programming languages, including | |
418 | Python. For this reason, using '/' character is recommended if you |
|
419 | Python. For this reason, using '/' character is recommended if you | |
419 | have problems with ``\``. However, in Windows commands '/' flags |
|
420 | have problems with ``\``. However, in Windows commands '/' flags | |
420 | options, so you can not use it for the root directory. This means that |
|
421 | options, so you can not use it for the root directory. This means that | |
421 | paths beginning at the root must be typed in a contrived manner like: |
|
422 | paths beginning at the root must be typed in a contrived manner like: | |
422 | ``%copy \opt/foo/bar.txt \tmp`` |
|
423 | ``%copy \opt/foo/bar.txt \tmp`` | |
423 |
|
424 | |||
424 | .. _magic: |
|
425 | .. _magic: | |
425 |
|
426 | |||
426 | Magic command system |
|
427 | Magic command system | |
427 | -------------------- |
|
428 | -------------------- | |
428 |
|
429 | |||
429 | IPython will treat any line whose first character is a % as a special |
|
430 | IPython will treat any line whose first character is a % as a special | |
430 | call to a 'magic' function. These allow you to control the behavior of |
|
431 | call to a 'magic' function. These allow you to control the behavior of | |
431 | IPython itself, plus a lot of system-type features. They are all |
|
432 | IPython itself, plus a lot of system-type features. They are all | |
432 | prefixed with a % character, but parameters are given without |
|
433 | prefixed with a % character, but parameters are given without | |
433 | parentheses or quotes. |
|
434 | parentheses or quotes. | |
434 |
|
435 | |||
435 | Example: typing '%cd mydir' (without the quotes) changes you working |
|
436 | Example: typing '%cd mydir' (without the quotes) changes you working | |
436 | directory to 'mydir', if it exists. |
|
437 | directory to 'mydir', if it exists. | |
437 |
|
438 | |||
438 | If you have 'automagic' enabled (in your ipythonrc file, via the command |
|
439 | If you have 'automagic' enabled (in your ipythonrc file, via the command | |
439 | line option -automagic or with the %automagic function), you don't need |
|
440 | line option -automagic or with the %automagic function), you don't need | |
440 | to type in the % explicitly. IPython will scan its internal list of |
|
441 | to type in the % explicitly. IPython will scan its internal list of | |
441 | magic functions and call one if it exists. With automagic on you can |
|
442 | magic functions and call one if it exists. With automagic on you can | |
442 | then just type 'cd mydir' to go to directory 'mydir'. The automagic |
|
443 | then just type 'cd mydir' to go to directory 'mydir'. The automagic | |
443 | system has the lowest possible precedence in name searches, so defining |
|
444 | system has the lowest possible precedence in name searches, so defining | |
444 | an identifier with the same name as an existing magic function will |
|
445 | an identifier with the same name as an existing magic function will | |
445 | shadow it for automagic use. You can still access the shadowed magic |
|
446 | shadow it for automagic use. You can still access the shadowed magic | |
446 | function by explicitly using the % character at the beginning of the line. |
|
447 | function by explicitly using the % character at the beginning of the line. | |
447 |
|
448 | |||
448 | An example (with automagic on) should clarify all this:: |
|
449 | An example (with automagic on) should clarify all this:: | |
449 |
|
450 | |||
450 | In [1]: cd ipython # %cd is called by automagic |
|
451 | In [1]: cd ipython # %cd is called by automagic | |
451 |
|
452 | |||
452 | /home/fperez/ipython |
|
453 | /home/fperez/ipython | |
453 |
|
454 | |||
454 | In [2]: cd=1 # now cd is just a variable |
|
455 | In [2]: cd=1 # now cd is just a variable | |
455 |
|
456 | |||
456 | In [3]: cd .. # and doesn't work as a function anymore |
|
457 | In [3]: cd .. # and doesn't work as a function anymore | |
457 |
|
458 | |||
458 | ------------------------------ |
|
459 | ------------------------------ | |
459 |
|
460 | |||
460 | File "<console>", line 1 |
|
461 | File "<console>", line 1 | |
461 |
|
462 | |||
462 | cd .. |
|
463 | cd .. | |
463 |
|
464 | |||
464 | ^ |
|
465 | ^ | |
465 |
|
466 | |||
466 | SyntaxError: invalid syntax |
|
467 | SyntaxError: invalid syntax | |
467 |
|
468 | |||
468 | In [4]: %cd .. # but %cd always works |
|
469 | In [4]: %cd .. # but %cd always works | |
469 |
|
470 | |||
470 | /home/fperez |
|
471 | /home/fperez | |
471 |
|
472 | |||
472 | In [5]: del cd # if you remove the cd variable |
|
473 | In [5]: del cd # if you remove the cd variable | |
473 |
|
474 | |||
474 | In [6]: cd ipython # automagic can work again |
|
475 | In [6]: cd ipython # automagic can work again | |
475 |
|
476 | |||
476 | /home/fperez/ipython |
|
477 | /home/fperez/ipython | |
477 |
|
478 | |||
478 | You can define your own magic functions to extend the system. The |
|
479 | You can define your own magic functions to extend the system. The | |
479 | following example defines a new magic command, %impall:: |
|
480 | following example defines a new magic command, %impall:: | |
480 |
|
481 | |||
481 | import IPython.ipapi |
|
482 | import IPython.ipapi | |
482 |
|
483 | |||
483 | ip = IPython.ipapi.get() |
|
484 | ip = IPython.ipapi.get() | |
484 |
|
485 | |||
485 | def doimp(self, arg): |
|
486 | def doimp(self, arg): | |
486 |
|
487 | |||
487 | ip = self.api |
|
488 | ip = self.api | |
488 |
|
489 | |||
489 | ip.ex("import %s; reload(%s); from %s import *" % ( |
|
490 | ip.ex("import %s; reload(%s); from %s import *" % ( | |
490 |
|
491 | |||
491 | arg,arg,arg) |
|
492 | arg,arg,arg) | |
492 |
|
493 | |||
493 | ) |
|
494 | ) | |
494 |
|
495 | |||
495 | ip.expose_magic('impall', doimp) |
|
496 | ip.expose_magic('impall', doimp) | |
496 |
|
497 | |||
497 | You can also define your own aliased names for magic functions. In your |
|
498 | You can also define your own aliased names for magic functions. In your | |
498 | ipythonrc file, placing a line like: |
|
499 | ipythonrc file, placing a line like: | |
499 |
|
500 | |||
500 | execute __IP.magic_cl = __IP.magic_clear |
|
501 | execute __IP.magic_cl = __IP.magic_clear | |
501 |
|
502 | |||
502 | will define %cl as a new name for %clear. |
|
503 | will define %cl as a new name for %clear. | |
503 |
|
504 | |||
504 | Type %magic for more information, including a list of all available |
|
505 | Type %magic for more information, including a list of all available | |
505 | magic functions at any time and their docstrings. You can also type |
|
506 | magic functions at any time and their docstrings. You can also type | |
506 | %magic_function_name? (see sec. 6.4 <#sec:dyn-object-info> for |
|
507 | %magic_function_name? (see sec. 6.4 <#sec:dyn-object-info> for | |
507 | information on the '?' system) to get information about any particular |
|
508 | information on the '?' system) to get information about any particular | |
508 | magic function you are interested in. |
|
509 | magic function you are interested in. | |
509 |
|
510 | |||
510 |
|
511 | |||
511 | Magic commands |
|
512 | Magic commands | |
512 | -------------- |
|
513 | -------------- | |
513 |
|
514 | |||
514 | The rest of this section is automatically generated for each release |
|
515 | The rest of this section is automatically generated for each release | |
515 | from the docstrings in the IPython code. Therefore the formatting is |
|
516 | from the docstrings in the IPython code. Therefore the formatting is | |
516 | somewhat minimal, but this method has the advantage of having |
|
517 | somewhat minimal, but this method has the advantage of having | |
517 | information always in sync with the code. |
|
518 | information always in sync with the code. | |
518 |
|
519 | |||
519 | A list of all the magic commands available in IPython's default |
|
520 | A list of all the magic commands available in IPython's default | |
520 | installation follows. This is similar to what you'll see by simply |
|
521 | installation follows. This is similar to what you'll see by simply | |
521 | typing %magic at the prompt, but that will also give you information |
|
522 | typing %magic at the prompt, but that will also give you information | |
522 | about magic commands you may have added as part of your personal |
|
523 | about magic commands you may have added as part of your personal | |
523 | customizations. |
|
524 | customizations. | |
524 |
|
525 | |||
525 | .. magic_start |
|
526 | .. magic_start | |
526 |
|
527 | |||
527 | **%Exit**:: |
|
528 | **%Exit**:: | |
528 |
|
529 | |||
529 | Exit IPython without confirmation. |
|
530 | Exit IPython without confirmation. | |
530 |
|
531 | |||
531 | **%Pprint**:: |
|
532 | **%Pprint**:: | |
532 |
|
533 | |||
533 | Toggle pretty printing on/off. |
|
534 | Toggle pretty printing on/off. | |
534 |
|
535 | |||
535 | **%alias**:: |
|
536 | **%alias**:: | |
536 |
|
537 | |||
537 | Define an alias for a system command. |
|
538 | Define an alias for a system command. | |
538 |
|
539 | |||
539 | '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd' |
|
540 | '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd' | |
540 |
|
541 | |||
541 | Then, typing 'alias_name params' will execute the system command 'cmd |
|
542 | Then, typing 'alias_name params' will execute the system command 'cmd | |
542 | params' (from your underlying operating system). |
|
543 | params' (from your underlying operating system). | |
543 |
|
544 | |||
544 | Aliases have lower precedence than magic functions and Python normal |
|
545 | Aliases have lower precedence than magic functions and Python normal | |
545 | variables, so if 'foo' is both a Python variable and an alias, the |
|
546 | variables, so if 'foo' is both a Python variable and an alias, the | |
546 | alias can not be executed until 'del foo' removes the Python variable. |
|
547 | alias can not be executed until 'del foo' removes the Python variable. | |
547 |
|
548 | |||
548 | You can use the %l specifier in an alias definition to represent the |
|
549 | You can use the %l specifier in an alias definition to represent the | |
549 | whole line when the alias is called. For example: |
|
550 | whole line when the alias is called. For example: | |
550 |
|
551 | |||
551 | In [2]: alias all echo "Input in brackets: <%l>"\ |
|
552 | In [2]: alias all echo "Input in brackets: <%l>"\ | |
552 | In [3]: all hello world\ |
|
553 | In [3]: all hello world\ | |
553 | Input in brackets: <hello world> |
|
554 | Input in brackets: <hello world> | |
554 |
|
555 | |||
555 | You can also define aliases with parameters using %s specifiers (one |
|
556 | You can also define aliases with parameters using %s specifiers (one | |
556 | per parameter): |
|
557 | per parameter): | |
557 |
|
558 | |||
558 | In [1]: alias parts echo first %s second %s\ |
|
559 | In [1]: alias parts echo first %s second %s\ | |
559 | In [2]: %parts A B\ |
|
560 | In [2]: %parts A B\ | |
560 | first A second B\ |
|
561 | first A second B\ | |
561 | In [3]: %parts A\ |
|
562 | In [3]: %parts A\ | |
562 | Incorrect number of arguments: 2 expected.\ |
|
563 | Incorrect number of arguments: 2 expected.\ | |
563 | parts is an alias to: 'echo first %s second %s' |
|
564 | parts is an alias to: 'echo first %s second %s' | |
564 |
|
565 | |||
565 | Note that %l and %s are mutually exclusive. You can only use one or |
|
566 | Note that %l and %s are mutually exclusive. You can only use one or | |
566 | the other in your aliases. |
|
567 | the other in your aliases. | |
567 |
|
568 | |||
568 | Aliases expand Python variables just like system calls using ! or !! |
|
569 | Aliases expand Python variables just like system calls using ! or !! | |
569 | do: all expressions prefixed with '$' get expanded. For details of |
|
570 | do: all expressions prefixed with '$' get expanded. For details of | |
570 | the semantic rules, see PEP-215: |
|
571 | the semantic rules, see PEP-215: | |
571 | http://www.python.org/peps/pep-0215.html. This is the library used by |
|
572 | http://www.python.org/peps/pep-0215.html. This is the library used by | |
572 | IPython for variable expansion. If you want to access a true shell |
|
573 | IPython for variable expansion. If you want to access a true shell | |
573 | variable, an extra $ is necessary to prevent its expansion by IPython: |
|
574 | variable, an extra $ is necessary to prevent its expansion by IPython: | |
574 |
|
575 | |||
575 | In [6]: alias show echo\ |
|
576 | In [6]: alias show echo\ | |
576 | In [7]: PATH='A Python string'\ |
|
577 | In [7]: PATH='A Python string'\ | |
577 | In [8]: show $PATH\ |
|
578 | In [8]: show $PATH\ | |
578 | A Python string\ |
|
579 | A Python string\ | |
579 | In [9]: show $$PATH\ |
|
580 | In [9]: show $$PATH\ | |
580 | /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:... |
|
581 | /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:... | |
581 |
|
582 | |||
582 | You can use the alias facility to acess all of $PATH. See the %rehash |
|
583 | You can use the alias facility to acess all of $PATH. See the %rehash | |
583 | and %rehashx functions, which automatically create aliases for the |
|
584 | and %rehashx functions, which automatically create aliases for the | |
584 | contents of your $PATH. |
|
585 | contents of your $PATH. | |
585 |
|
586 | |||
586 | If called with no parameters, %alias prints the current alias table. |
|
587 | If called with no parameters, %alias prints the current alias table. | |
587 |
|
588 | |||
588 | **%autocall**:: |
|
589 | **%autocall**:: | |
589 |
|
590 | |||
590 | Make functions callable without having to type parentheses. |
|
591 | Make functions callable without having to type parentheses. | |
591 |
|
592 | |||
592 | Usage: |
|
593 | Usage: | |
593 |
|
594 | |||
594 | %autocall [mode] |
|
595 | %autocall [mode] | |
595 |
|
596 | |||
596 | The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the |
|
597 | The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the | |
597 | value is toggled on and off (remembering the previous state). |
|
598 | value is toggled on and off (remembering the previous state). | |
598 |
|
599 | |||
599 | In more detail, these values mean: |
|
600 | In more detail, these values mean: | |
600 |
|
601 | |||
601 | 0 -> fully disabled |
|
602 | 0 -> fully disabled | |
602 |
|
603 | |||
603 | 1 -> active, but do not apply if there are no arguments on the line. |
|
604 | 1 -> active, but do not apply if there are no arguments on the line. | |
604 |
|
605 | |||
605 | In this mode, you get: |
|
606 | In this mode, you get: | |
606 |
|
607 | |||
607 | In [1]: callable |
|
608 | In [1]: callable | |
608 | Out[1]: <built-in function callable> |
|
609 | Out[1]: <built-in function callable> | |
609 |
|
610 | |||
610 | In [2]: callable 'hello' |
|
611 | In [2]: callable 'hello' | |
611 | ------> callable('hello') |
|
612 | ------> callable('hello') | |
612 | Out[2]: False |
|
613 | Out[2]: False | |
613 |
|
614 | |||
614 | 2 -> Active always. Even if no arguments are present, the callable |
|
615 | 2 -> Active always. Even if no arguments are present, the callable | |
615 | object is called: |
|
616 | object is called: | |
616 |
|
617 | |||
617 | In [4]: callable |
|
618 | In [4]: callable | |
618 | ------> callable() |
|
619 | ------> callable() | |
619 |
|
620 | |||
620 | Note that even with autocall off, you can still use '/' at the start of |
|
621 | Note that even with autocall off, you can still use '/' at the start of | |
621 | a line to treat the first argument on the command line as a function |
|
622 | a line to treat the first argument on the command line as a function | |
622 | and add parentheses to it: |
|
623 | and add parentheses to it: | |
623 |
|
624 | |||
624 | In [8]: /str 43 |
|
625 | In [8]: /str 43 | |
625 | ------> str(43) |
|
626 | ------> str(43) | |
626 | Out[8]: '43' |
|
627 | Out[8]: '43' | |
627 |
|
628 | |||
628 | **%autoindent**:: |
|
629 | **%autoindent**:: | |
629 |
|
630 | |||
630 | Toggle autoindent on/off (if available). |
|
631 | Toggle autoindent on/off (if available). | |
631 |
|
632 | |||
632 | **%automagic**:: |
|
633 | **%automagic**:: | |
633 |
|
634 | |||
634 | Make magic functions callable without having to type the initial %. |
|
635 | Make magic functions callable without having to type the initial %. | |
635 |
|
636 | |||
636 | Without argumentsl toggles on/off (when off, you must call it as |
|
637 | Without argumentsl toggles on/off (when off, you must call it as | |
637 | %automagic, of course). With arguments it sets the value, and you can |
|
638 | %automagic, of course). With arguments it sets the value, and you can | |
638 | use any of (case insensitive): |
|
639 | use any of (case insensitive): | |
639 |
|
640 | |||
640 | - on,1,True: to activate |
|
641 | - on,1,True: to activate | |
641 |
|
642 | |||
642 | - off,0,False: to deactivate. |
|
643 | - off,0,False: to deactivate. | |
643 |
|
644 | |||
644 | Note that magic functions have lowest priority, so if there's a |
|
645 | Note that magic functions have lowest priority, so if there's a | |
645 | variable whose name collides with that of a magic fn, automagic won't |
|
646 | variable whose name collides with that of a magic fn, automagic won't | |
646 | work for that function (you get the variable instead). However, if you |
|
647 | work for that function (you get the variable instead). However, if you | |
647 | delete the variable (del var), the previously shadowed magic function |
|
648 | delete the variable (del var), the previously shadowed magic function | |
648 | becomes visible to automagic again. |
|
649 | becomes visible to automagic again. | |
649 |
|
650 | |||
650 | **%bg**:: |
|
651 | **%bg**:: | |
651 |
|
652 | |||
652 | Run a job in the background, in a separate thread. |
|
653 | Run a job in the background, in a separate thread. | |
653 |
|
654 | |||
654 | For example, |
|
655 | For example, | |
655 |
|
656 | |||
656 | %bg myfunc(x,y,z=1) |
|
657 | %bg myfunc(x,y,z=1) | |
657 |
|
658 | |||
658 | will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the |
|
659 | will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the | |
659 | execution starts, a message will be printed indicating the job |
|
660 | execution starts, a message will be printed indicating the job | |
660 | number. If your job number is 5, you can use |
|
661 | number. If your job number is 5, you can use | |
661 |
|
662 | |||
662 | myvar = jobs.result(5) or myvar = jobs[5].result |
|
663 | myvar = jobs.result(5) or myvar = jobs[5].result | |
663 |
|
664 | |||
664 | to assign this result to variable 'myvar'. |
|
665 | to assign this result to variable 'myvar'. | |
665 |
|
666 | |||
666 | IPython has a job manager, accessible via the 'jobs' object. You can |
|
667 | IPython has a job manager, accessible via the 'jobs' object. You can | |
667 | type jobs? to get more information about it, and use jobs.<TAB> to see |
|
668 | type jobs? to get more information about it, and use jobs.<TAB> to see | |
668 | its attributes. All attributes not starting with an underscore are |
|
669 | its attributes. All attributes not starting with an underscore are | |
669 | meant for public use. |
|
670 | meant for public use. | |
670 |
|
671 | |||
671 | In particular, look at the jobs.new() method, which is used to create |
|
672 | In particular, look at the jobs.new() method, which is used to create | |
672 | new jobs. This magic %bg function is just a convenience wrapper |
|
673 | new jobs. This magic %bg function is just a convenience wrapper | |
673 | around jobs.new(), for expression-based jobs. If you want to create a |
|
674 | around jobs.new(), for expression-based jobs. If you want to create a | |
674 | new job with an explicit function object and arguments, you must call |
|
675 | new job with an explicit function object and arguments, you must call | |
675 | jobs.new() directly. |
|
676 | jobs.new() directly. | |
676 |
|
677 | |||
677 | The jobs.new docstring also describes in detail several important |
|
678 | The jobs.new docstring also describes in detail several important | |
678 | caveats associated with a thread-based model for background job |
|
679 | caveats associated with a thread-based model for background job | |
679 | execution. Type jobs.new? for details. |
|
680 | execution. Type jobs.new? for details. | |
680 |
|
681 | |||
681 | You can check the status of all jobs with jobs.status(). |
|
682 | You can check the status of all jobs with jobs.status(). | |
682 |
|
683 | |||
683 | The jobs variable is set by IPython into the Python builtin namespace. |
|
684 | The jobs variable is set by IPython into the Python builtin namespace. | |
684 | If you ever declare a variable named 'jobs', you will shadow this |
|
685 | If you ever declare a variable named 'jobs', you will shadow this | |
685 | name. You can either delete your global jobs variable to regain |
|
686 | name. You can either delete your global jobs variable to regain | |
686 | access to the job manager, or make a new name and assign it manually |
|
687 | access to the job manager, or make a new name and assign it manually | |
687 | to the manager (stored in IPython's namespace). For example, to |
|
688 | to the manager (stored in IPython's namespace). For example, to | |
688 | assign the job manager to the Jobs name, use: |
|
689 | assign the job manager to the Jobs name, use: | |
689 |
|
690 | |||
690 | Jobs = __builtins__.jobs |
|
691 | Jobs = __builtins__.jobs | |
691 |
|
692 | |||
692 | **%bookmark**:: |
|
693 | **%bookmark**:: | |
693 |
|
694 | |||
694 | Manage IPython's bookmark system. |
|
695 | Manage IPython's bookmark system. | |
695 |
|
696 | |||
696 | %bookmark <name> - set bookmark to current dir |
|
697 | %bookmark <name> - set bookmark to current dir | |
697 | %bookmark <name> <dir> - set bookmark to <dir> |
|
698 | %bookmark <name> <dir> - set bookmark to <dir> | |
698 | %bookmark -l - list all bookmarks |
|
699 | %bookmark -l - list all bookmarks | |
699 | %bookmark -d <name> - remove bookmark |
|
700 | %bookmark -d <name> - remove bookmark | |
700 | %bookmark -r - remove all bookmarks |
|
701 | %bookmark -r - remove all bookmarks | |
701 |
|
702 | |||
702 | You can later on access a bookmarked folder with: |
|
703 | You can later on access a bookmarked folder with: | |
703 | %cd -b <name> |
|
704 | %cd -b <name> | |
704 | or simply '%cd <name>' if there is no directory called <name> AND |
|
705 | or simply '%cd <name>' if there is no directory called <name> AND | |
705 | there is such a bookmark defined. |
|
706 | there is such a bookmark defined. | |
706 |
|
707 | |||
707 | Your bookmarks persist through IPython sessions, but they are |
|
708 | Your bookmarks persist through IPython sessions, but they are | |
708 | associated with each profile. |
|
709 | associated with each profile. | |
709 |
|
710 | |||
710 | **%cd**:: |
|
711 | **%cd**:: | |
711 |
|
712 | |||
712 | Change the current working directory. |
|
713 | Change the current working directory. | |
713 |
|
714 | |||
714 | This command automatically maintains an internal list of directories |
|
715 | This command automatically maintains an internal list of directories | |
715 | you visit during your IPython session, in the variable _dh. The |
|
716 | you visit during your IPython session, in the variable _dh. The | |
716 | command %dhist shows this history nicely formatted. You can also |
|
717 | command %dhist shows this history nicely formatted. You can also | |
717 | do 'cd -<tab>' to see directory history conveniently. |
|
718 | do 'cd -<tab>' to see directory history conveniently. | |
718 |
|
719 | |||
719 | Usage: |
|
720 | Usage: | |
720 |
|
721 | |||
721 | cd 'dir': changes to directory 'dir'. |
|
722 | cd 'dir': changes to directory 'dir'. | |
722 |
|
723 | |||
723 | cd -: changes to the last visited directory. |
|
724 | cd -: changes to the last visited directory. | |
724 |
|
725 | |||
725 | cd -<n>: changes to the n-th directory in the directory history. |
|
726 | cd -<n>: changes to the n-th directory in the directory history. | |
726 |
|
727 | |||
727 | cd -b <bookmark_name>: jump to a bookmark set by %bookmark |
|
728 | cd -b <bookmark_name>: jump to a bookmark set by %bookmark | |
728 | (note: cd <bookmark_name> is enough if there is no |
|
729 | (note: cd <bookmark_name> is enough if there is no | |
729 | directory <bookmark_name>, but a bookmark with the name exists.) |
|
730 | directory <bookmark_name>, but a bookmark with the name exists.) | |
730 | 'cd -b <tab>' allows you to tab-complete bookmark names. |
|
731 | 'cd -b <tab>' allows you to tab-complete bookmark names. | |
731 |
|
732 | |||
732 | Options: |
|
733 | Options: | |
733 |
|
734 | |||
734 | -q: quiet. Do not print the working directory after the cd command is |
|
735 | -q: quiet. Do not print the working directory after the cd command is | |
735 | executed. By default IPython's cd command does print this directory, |
|
736 | executed. By default IPython's cd command does print this directory, | |
736 | since the default prompts do not display path information. |
|
737 | since the default prompts do not display path information. | |
737 |
|
738 | |||
738 | Note that !cd doesn't work for this purpose because the shell where |
|
739 | Note that !cd doesn't work for this purpose because the shell where | |
739 | !command runs is immediately discarded after executing 'command'. |
|
740 | !command runs is immediately discarded after executing 'command'. | |
740 |
|
741 | |||
741 | **%clear**:: |
|
742 | **%clear**:: | |
742 |
|
743 | |||
743 | Clear various data (e.g. stored history data) |
|
744 | Clear various data (e.g. stored history data) | |
744 |
|
745 | |||
745 | %clear out - clear output history |
|
746 | %clear out - clear output history | |
746 | %clear in - clear input history |
|
747 | %clear in - clear input history | |
747 | %clear shadow_compress - Compresses shadow history (to speed up ipython) |
|
748 | %clear shadow_compress - Compresses shadow history (to speed up ipython) | |
748 | %clear shadow_nuke - permanently erase all entries in shadow history |
|
749 | %clear shadow_nuke - permanently erase all entries in shadow history | |
749 | %clear dhist - clear dir history |
|
750 | %clear dhist - clear dir history | |
750 |
|
751 | |||
751 | **%color_info**:: |
|
752 | **%color_info**:: | |
752 |
|
753 | |||
753 | Toggle color_info. |
|
754 | Toggle color_info. | |
754 |
|
755 | |||
755 | The color_info configuration parameter controls whether colors are |
|
756 | The color_info configuration parameter controls whether colors are | |
756 | used for displaying object details (by things like %psource, %pfile or |
|
757 | used for displaying object details (by things like %psource, %pfile or | |
757 | the '?' system). This function toggles this value with each call. |
|
758 | the '?' system). This function toggles this value with each call. | |
758 |
|
759 | |||
759 | Note that unless you have a fairly recent pager (less works better |
|
760 | Note that unless you have a fairly recent pager (less works better | |
760 | than more) in your system, using colored object information displays |
|
761 | than more) in your system, using colored object information displays | |
761 | will not work properly. Test it and see. |
|
762 | will not work properly. Test it and see. | |
762 |
|
763 | |||
763 | **%colors**:: |
|
764 | **%colors**:: | |
764 |
|
765 | |||
765 | Switch color scheme for prompts, info system and exception handlers. |
|
766 | Switch color scheme for prompts, info system and exception handlers. | |
766 |
|
767 | |||
767 | Currently implemented schemes: NoColor, Linux, LightBG. |
|
768 | Currently implemented schemes: NoColor, Linux, LightBG. | |
768 |
|
769 | |||
769 | Color scheme names are not case-sensitive. |
|
770 | Color scheme names are not case-sensitive. | |
770 |
|
771 | |||
771 | **%cpaste**:: |
|
772 | **%cpaste**:: | |
772 |
|
773 | |||
773 | Allows you to paste & execute a pre-formatted code block from clipboard |
|
774 | Allows you to paste & execute a pre-formatted code block from clipboard | |
774 |
|
775 | |||
775 | You must terminate the block with '--' (two minus-signs) alone on the |
|
776 | You must terminate the block with '--' (two minus-signs) alone on the | |
776 | line. You can also provide your own sentinel with '%paste -s %%' ('%%' |
|
777 | line. You can also provide your own sentinel with '%paste -s %%' ('%%' | |
777 | is the new sentinel for this operation) |
|
778 | is the new sentinel for this operation) | |
778 |
|
779 | |||
779 | The block is dedented prior to execution to enable execution of method |
|
780 | The block is dedented prior to execution to enable execution of method | |
780 | definitions. '>' and '+' characters at the beginning of a line are |
|
781 | definitions. '>' and '+' characters at the beginning of a line are | |
781 | ignored, to allow pasting directly from e-mails or diff files. The |
|
782 | ignored, to allow pasting directly from e-mails or diff files. The | |
782 | executed block is also assigned to variable named 'pasted_block' for |
|
783 | executed block is also assigned to variable named 'pasted_block' for | |
783 | later editing with '%edit pasted_block'. |
|
784 | later editing with '%edit pasted_block'. | |
784 |
|
785 | |||
785 | You can also pass a variable name as an argument, e.g. '%cpaste foo'. |
|
786 | You can also pass a variable name as an argument, e.g. '%cpaste foo'. | |
786 | This assigns the pasted block to variable 'foo' as string, without |
|
787 | This assigns the pasted block to variable 'foo' as string, without | |
787 | dedenting or executing it. |
|
788 | dedenting or executing it. | |
788 |
|
789 | |||
789 | Do not be alarmed by garbled output on Windows (it's a readline bug). |
|
790 | Do not be alarmed by garbled output on Windows (it's a readline bug). | |
790 | Just press enter and type -- (and press enter again) and the block |
|
791 | Just press enter and type -- (and press enter again) and the block | |
791 | will be what was just pasted. |
|
792 | will be what was just pasted. | |
792 |
|
793 | |||
793 | IPython statements (magics, shell escapes) are not supported (yet). |
|
794 | IPython statements (magics, shell escapes) are not supported (yet). | |
794 |
|
795 | |||
795 | **%debug**:: |
|
796 | **%debug**:: | |
796 |
|
797 | |||
797 | Activate the interactive debugger in post-mortem mode. |
|
798 | Activate the interactive debugger in post-mortem mode. | |
798 |
|
799 | |||
799 | If an exception has just occurred, this lets you inspect its stack |
|
800 | If an exception has just occurred, this lets you inspect its stack | |
800 | frames interactively. Note that this will always work only on the last |
|
801 | frames interactively. Note that this will always work only on the last | |
801 | traceback that occurred, so you must call this quickly after an |
|
802 | traceback that occurred, so you must call this quickly after an | |
802 | exception that you wish to inspect has fired, because if another one |
|
803 | exception that you wish to inspect has fired, because if another one | |
803 | occurs, it clobbers the previous one. |
|
804 | occurs, it clobbers the previous one. | |
804 |
|
805 | |||
805 | If you want IPython to automatically do this on every exception, see |
|
806 | If you want IPython to automatically do this on every exception, see | |
806 | the %pdb magic for more details. |
|
807 | the %pdb magic for more details. | |
807 |
|
808 | |||
808 | **%dhist**:: |
|
809 | **%dhist**:: | |
809 |
|
810 | |||
810 | Print your history of visited directories. |
|
811 | Print your history of visited directories. | |
811 |
|
812 | |||
812 | %dhist -> print full history\ |
|
813 | %dhist -> print full history\ | |
813 | %dhist n -> print last n entries only\ |
|
814 | %dhist n -> print last n entries only\ | |
814 | %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\ |
|
815 | %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\ | |
815 |
|
816 | |||
816 | This history is automatically maintained by the %cd command, and |
|
817 | This history is automatically maintained by the %cd command, and | |
817 | always available as the global list variable _dh. You can use %cd -<n> |
|
818 | always available as the global list variable _dh. You can use %cd -<n> | |
818 | to go to directory number <n>. |
|
819 | to go to directory number <n>. | |
819 |
|
820 | |||
820 | Note that most of time, you should view directory history by entering |
|
821 | Note that most of time, you should view directory history by entering | |
821 | cd -<TAB>. |
|
822 | cd -<TAB>. | |
822 |
|
823 | |||
823 | **%dirs**:: |
|
824 | **%dirs**:: | |
824 |
|
825 | |||
825 | Return the current directory stack. |
|
826 | Return the current directory stack. | |
826 |
|
827 | |||
827 | **%doctest_mode**:: |
|
828 | **%doctest_mode**:: | |
828 |
|
829 | |||
829 | Toggle doctest mode on and off. |
|
830 | Toggle doctest mode on and off. | |
830 |
|
831 | |||
831 | This mode allows you to toggle the prompt behavior between normal |
|
832 | This mode allows you to toggle the prompt behavior between normal | |
832 | IPython prompts and ones that are as similar to the default IPython |
|
833 | IPython prompts and ones that are as similar to the default IPython | |
833 | interpreter as possible. |
|
834 | interpreter as possible. | |
834 |
|
835 | |||
835 | It also supports the pasting of code snippets that have leading '>>>' |
|
836 | It also supports the pasting of code snippets that have leading '>>>' | |
836 | and '...' prompts in them. This means that you can paste doctests from |
|
837 | and '...' prompts in them. This means that you can paste doctests from | |
837 | files or docstrings (even if they have leading whitespace), and the |
|
838 | files or docstrings (even if they have leading whitespace), and the | |
838 | code will execute correctly. You can then use '%history -tn' to see |
|
839 | code will execute correctly. You can then use '%history -tn' to see | |
839 | the translated history without line numbers; this will give you the |
|
840 | the translated history without line numbers; this will give you the | |
840 | input after removal of all the leading prompts and whitespace, which |
|
841 | input after removal of all the leading prompts and whitespace, which | |
841 | can be pasted back into an editor. |
|
842 | can be pasted back into an editor. | |
842 |
|
843 | |||
843 | With these features, you can switch into this mode easily whenever you |
|
844 | With these features, you can switch into this mode easily whenever you | |
844 | need to do testing and changes to doctests, without having to leave |
|
845 | need to do testing and changes to doctests, without having to leave | |
845 | your existing IPython session. |
|
846 | your existing IPython session. | |
846 |
|
847 | |||
847 | **%ed**:: |
|
848 | **%ed**:: | |
848 |
|
849 | |||
849 | Alias to %edit. |
|
850 | Alias to %edit. | |
850 |
|
851 | |||
851 | **%edit**:: |
|
852 | **%edit**:: | |
852 |
|
853 | |||
853 | Bring up an editor and execute the resulting code. |
|
854 | Bring up an editor and execute the resulting code. | |
854 |
|
855 | |||
855 | Usage: |
|
856 | Usage: | |
856 | %edit [options] [args] |
|
857 | %edit [options] [args] | |
857 |
|
858 | |||
858 | %edit runs IPython's editor hook. The default version of this hook is |
|
859 | %edit runs IPython's editor hook. The default version of this hook is | |
859 | set to call the __IPYTHON__.rc.editor command. This is read from your |
|
860 | set to call the __IPYTHON__.rc.editor command. This is read from your | |
860 | environment variable $EDITOR. If this isn't found, it will default to |
|
861 | environment variable $EDITOR. If this isn't found, it will default to | |
861 | vi under Linux/Unix and to notepad under Windows. See the end of this |
|
862 | vi under Linux/Unix and to notepad under Windows. See the end of this | |
862 | docstring for how to change the editor hook. |
|
863 | docstring for how to change the editor hook. | |
863 |
|
864 | |||
864 | You can also set the value of this editor via the command line option |
|
865 | You can also set the value of this editor via the command line option | |
865 | '-editor' or in your ipythonrc file. This is useful if you wish to use |
|
866 | '-editor' or in your ipythonrc file. This is useful if you wish to use | |
866 | specifically for IPython an editor different from your typical default |
|
867 | specifically for IPython an editor different from your typical default | |
867 | (and for Windows users who typically don't set environment variables). |
|
868 | (and for Windows users who typically don't set environment variables). | |
868 |
|
869 | |||
869 | This command allows you to conveniently edit multi-line code right in |
|
870 | This command allows you to conveniently edit multi-line code right in | |
870 | your IPython session. |
|
871 | your IPython session. | |
871 |
|
872 | |||
872 | If called without arguments, %edit opens up an empty editor with a |
|
873 | If called without arguments, %edit opens up an empty editor with a | |
873 | temporary file and will execute the contents of this file when you |
|
874 | temporary file and will execute the contents of this file when you | |
874 | close it (don't forget to save it!). |
|
875 | close it (don't forget to save it!). | |
875 |
|
876 | |||
876 |
|
877 | |||
877 | Options: |
|
878 | Options: | |
878 |
|
879 | |||
879 | -n <number>: open the editor at a specified line number. By default, |
|
880 | -n <number>: open the editor at a specified line number. By default, | |
880 | the IPython editor hook uses the unix syntax 'editor +N filename', but |
|
881 | the IPython editor hook uses the unix syntax 'editor +N filename', but | |
881 | you can configure this by providing your own modified hook if your |
|
882 | you can configure this by providing your own modified hook if your | |
882 | favorite editor supports line-number specifications with a different |
|
883 | favorite editor supports line-number specifications with a different | |
883 | syntax. |
|
884 | syntax. | |
884 |
|
885 | |||
885 | -p: this will call the editor with the same data as the previous time |
|
886 | -p: this will call the editor with the same data as the previous time | |
886 | it was used, regardless of how long ago (in your current session) it |
|
887 | it was used, regardless of how long ago (in your current session) it | |
887 | was. |
|
888 | was. | |
888 |
|
889 | |||
889 | -r: use 'raw' input. This option only applies to input taken from the |
|
890 | -r: use 'raw' input. This option only applies to input taken from the | |
890 | user's history. By default, the 'processed' history is used, so that |
|
891 | user's history. By default, the 'processed' history is used, so that | |
891 | magics are loaded in their transformed version to valid Python. If |
|
892 | magics are loaded in their transformed version to valid Python. If | |
892 | this option is given, the raw input as typed as the command line is |
|
893 | this option is given, the raw input as typed as the command line is | |
893 | used instead. When you exit the editor, it will be executed by |
|
894 | used instead. When you exit the editor, it will be executed by | |
894 | IPython's own processor. |
|
895 | IPython's own processor. | |
895 |
|
896 | |||
896 | -x: do not execute the edited code immediately upon exit. This is |
|
897 | -x: do not execute the edited code immediately upon exit. This is | |
897 | mainly useful if you are editing programs which need to be called with |
|
898 | mainly useful if you are editing programs which need to be called with | |
898 | command line arguments, which you can then do using %run. |
|
899 | command line arguments, which you can then do using %run. | |
899 |
|
900 | |||
900 |
|
901 | |||
901 | Arguments: |
|
902 | Arguments: | |
902 |
|
903 | |||
903 | If arguments are given, the following possibilites exist: |
|
904 | If arguments are given, the following possibilites exist: | |
904 |
|
905 | |||
905 | - The arguments are numbers or pairs of colon-separated numbers (like |
|
906 | - The arguments are numbers or pairs of colon-separated numbers (like | |
906 | 1 4:8 9). These are interpreted as lines of previous input to be |
|
907 | 1 4:8 9). These are interpreted as lines of previous input to be | |
907 | loaded into the editor. The syntax is the same of the %macro command. |
|
908 | loaded into the editor. The syntax is the same of the %macro command. | |
908 |
|
909 | |||
909 | - If the argument doesn't start with a number, it is evaluated as a |
|
910 | - If the argument doesn't start with a number, it is evaluated as a | |
910 | variable and its contents loaded into the editor. You can thus edit |
|
911 | variable and its contents loaded into the editor. You can thus edit | |
911 | any string which contains python code (including the result of |
|
912 | any string which contains python code (including the result of | |
912 | previous edits). |
|
913 | previous edits). | |
913 |
|
914 | |||
914 | - If the argument is the name of an object (other than a string), |
|
915 | - If the argument is the name of an object (other than a string), | |
915 | IPython will try to locate the file where it was defined and open the |
|
916 | IPython will try to locate the file where it was defined and open the | |
916 | editor at the point where it is defined. You can use `%edit function` |
|
917 | editor at the point where it is defined. You can use `%edit function` | |
917 | to load an editor exactly at the point where 'function' is defined, |
|
918 | to load an editor exactly at the point where 'function' is defined, | |
918 | edit it and have the file be executed automatically. |
|
919 | edit it and have the file be executed automatically. | |
919 |
|
920 | |||
920 | If the object is a macro (see %macro for details), this opens up your |
|
921 | If the object is a macro (see %macro for details), this opens up your | |
921 | specified editor with a temporary file containing the macro's data. |
|
922 | specified editor with a temporary file containing the macro's data. | |
922 | Upon exit, the macro is reloaded with the contents of the file. |
|
923 | Upon exit, the macro is reloaded with the contents of the file. | |
923 |
|
924 | |||
924 | Note: opening at an exact line is only supported under Unix, and some |
|
925 | Note: opening at an exact line is only supported under Unix, and some | |
925 | editors (like kedit and gedit up to Gnome 2.8) do not understand the |
|
926 | editors (like kedit and gedit up to Gnome 2.8) do not understand the | |
926 | '+NUMBER' parameter necessary for this feature. Good editors like |
|
927 | '+NUMBER' parameter necessary for this feature. Good editors like | |
927 | (X)Emacs, vi, jed, pico and joe all do. |
|
928 | (X)Emacs, vi, jed, pico and joe all do. | |
928 |
|
929 | |||
929 | - If the argument is not found as a variable, IPython will look for a |
|
930 | - If the argument is not found as a variable, IPython will look for a | |
930 | file with that name (adding .py if necessary) and load it into the |
|
931 | file with that name (adding .py if necessary) and load it into the | |
931 | editor. It will execute its contents with execfile() when you exit, |
|
932 | editor. It will execute its contents with execfile() when you exit, | |
932 | loading any code in the file into your interactive namespace. |
|
933 | loading any code in the file into your interactive namespace. | |
933 |
|
934 | |||
934 | After executing your code, %edit will return as output the code you |
|
935 | After executing your code, %edit will return as output the code you | |
935 | typed in the editor (except when it was an existing file). This way |
|
936 | typed in the editor (except when it was an existing file). This way | |
936 | you can reload the code in further invocations of %edit as a variable, |
|
937 | you can reload the code in further invocations of %edit as a variable, | |
937 | via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of |
|
938 | via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of | |
938 | the output. |
|
939 | the output. | |
939 |
|
940 | |||
940 | Note that %edit is also available through the alias %ed. |
|
941 | Note that %edit is also available through the alias %ed. | |
941 |
|
942 | |||
942 | This is an example of creating a simple function inside the editor and |
|
943 | This is an example of creating a simple function inside the editor and | |
943 | then modifying it. First, start up the editor: |
|
944 | then modifying it. First, start up the editor: | |
944 |
|
945 | |||
945 | In [1]: ed\ |
|
946 | In [1]: ed\ | |
946 | Editing... done. Executing edited code...\ |
|
947 | Editing... done. Executing edited code...\ | |
947 | Out[1]: 'def foo():\n print "foo() was defined in an editing session"\n' |
|
948 | Out[1]: 'def foo():\n print "foo() was defined in an editing session"\n' | |
948 |
|
949 | |||
949 | We can then call the function foo(): |
|
950 | We can then call the function foo(): | |
950 |
|
951 | |||
951 | In [2]: foo()\ |
|
952 | In [2]: foo()\ | |
952 | foo() was defined in an editing session |
|
953 | foo() was defined in an editing session | |
953 |
|
954 | |||
954 | Now we edit foo. IPython automatically loads the editor with the |
|
955 | Now we edit foo. IPython automatically loads the editor with the | |
955 | (temporary) file where foo() was previously defined: |
|
956 | (temporary) file where foo() was previously defined: | |
956 |
|
957 | |||
957 | In [3]: ed foo\ |
|
958 | In [3]: ed foo\ | |
958 | Editing... done. Executing edited code... |
|
959 | Editing... done. Executing edited code... | |
959 |
|
960 | |||
960 | And if we call foo() again we get the modified version: |
|
961 | And if we call foo() again we get the modified version: | |
961 |
|
962 | |||
962 | In [4]: foo()\ |
|
963 | In [4]: foo()\ | |
963 | foo() has now been changed! |
|
964 | foo() has now been changed! | |
964 |
|
965 | |||
965 | Here is an example of how to edit a code snippet successive |
|
966 | Here is an example of how to edit a code snippet successive | |
966 | times. First we call the editor: |
|
967 | times. First we call the editor: | |
967 |
|
968 | |||
968 | In [8]: ed\ |
|
969 | In [8]: ed\ | |
969 | Editing... done. Executing edited code...\ |
|
970 | Editing... done. Executing edited code...\ | |
970 | hello\ |
|
971 | hello\ | |
971 | Out[8]: "print 'hello'\n" |
|
972 | Out[8]: "print 'hello'\n" | |
972 |
|
973 | |||
973 | Now we call it again with the previous output (stored in _): |
|
974 | Now we call it again with the previous output (stored in _): | |
974 |
|
975 | |||
975 | In [9]: ed _\ |
|
976 | In [9]: ed _\ | |
976 | Editing... done. Executing edited code...\ |
|
977 | Editing... done. Executing edited code...\ | |
977 | hello world\ |
|
978 | hello world\ | |
978 | Out[9]: "print 'hello world'\n" |
|
979 | Out[9]: "print 'hello world'\n" | |
979 |
|
980 | |||
980 | Now we call it with the output #8 (stored in _8, also as Out[8]): |
|
981 | Now we call it with the output #8 (stored in _8, also as Out[8]): | |
981 |
|
982 | |||
982 | In [10]: ed _8\ |
|
983 | In [10]: ed _8\ | |
983 | Editing... done. Executing edited code...\ |
|
984 | Editing... done. Executing edited code...\ | |
984 | hello again\ |
|
985 | hello again\ | |
985 | Out[10]: "print 'hello again'\n" |
|
986 | Out[10]: "print 'hello again'\n" | |
986 |
|
987 | |||
987 |
|
988 | |||
988 | Changing the default editor hook: |
|
989 | Changing the default editor hook: | |
989 |
|
990 | |||
990 | If you wish to write your own editor hook, you can put it in a |
|
991 | If you wish to write your own editor hook, you can put it in a | |
991 | configuration file which you load at startup time. The default hook |
|
992 | configuration file which you load at startup time. The default hook | |
992 | is defined in the IPython.hooks module, and you can use that as a |
|
993 | is defined in the IPython.hooks module, and you can use that as a | |
993 | starting example for further modifications. That file also has |
|
994 | starting example for further modifications. That file also has | |
994 | general instructions on how to set a new hook for use once you've |
|
995 | general instructions on how to set a new hook for use once you've | |
995 | defined it. |
|
996 | defined it. | |
996 |
|
997 | |||
997 | **%env**:: |
|
998 | **%env**:: | |
998 |
|
999 | |||
999 | List environment variables. |
|
1000 | List environment variables. | |
1000 |
|
1001 | |||
1001 | **%exit**:: |
|
1002 | **%exit**:: | |
1002 |
|
1003 | |||
1003 | Exit IPython, confirming if configured to do so. |
|
1004 | Exit IPython, confirming if configured to do so. | |
1004 |
|
1005 | |||
1005 | You can configure whether IPython asks for confirmation upon exit by |
|
1006 | You can configure whether IPython asks for confirmation upon exit by | |
1006 | setting the confirm_exit flag in the ipythonrc file. |
|
1007 | setting the confirm_exit flag in the ipythonrc file. | |
1007 |
|
1008 | |||
1008 | **%hist**:: |
|
1009 | **%hist**:: | |
1009 |
|
1010 | |||
1010 | Alternate name for %history. |
|
1011 | Alternate name for %history. | |
1011 |
|
1012 | |||
1012 | **%history**:: |
|
1013 | **%history**:: | |
1013 |
|
1014 | |||
1014 | Print input history (_i<n> variables), with most recent last. |
|
1015 | Print input history (_i<n> variables), with most recent last. | |
1015 |
|
1016 | |||
1016 | %history -> print at most 40 inputs (some may be multi-line)\ |
|
1017 | %history -> print at most 40 inputs (some may be multi-line)\ | |
1017 | %history n -> print at most n inputs\ |
|
1018 | %history n -> print at most n inputs\ | |
1018 | %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\ |
|
1019 | %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\ | |
1019 |
|
1020 | |||
1020 | Each input's number <n> is shown, and is accessible as the |
|
1021 | Each input's number <n> is shown, and is accessible as the | |
1021 | automatically generated variable _i<n>. Multi-line statements are |
|
1022 | automatically generated variable _i<n>. Multi-line statements are | |
1022 | printed starting at a new line for easy copy/paste. |
|
1023 | printed starting at a new line for easy copy/paste. | |
1023 |
|
1024 | |||
1024 |
|
1025 | |||
1025 | Options: |
|
1026 | Options: | |
1026 |
|
1027 | |||
1027 | -n: do NOT print line numbers. This is useful if you want to get a |
|
1028 | -n: do NOT print line numbers. This is useful if you want to get a | |
1028 | printout of many lines which can be directly pasted into a text |
|
1029 | printout of many lines which can be directly pasted into a text | |
1029 | editor. |
|
1030 | editor. | |
1030 |
|
1031 | |||
1031 | This feature is only available if numbered prompts are in use. |
|
1032 | This feature is only available if numbered prompts are in use. | |
1032 |
|
1033 | |||
1033 | -t: (default) print the 'translated' history, as IPython understands it. |
|
1034 | -t: (default) print the 'translated' history, as IPython understands it. | |
1034 | IPython filters your input and converts it all into valid Python source |
|
1035 | IPython filters your input and converts it all into valid Python source | |
1035 | before executing it (things like magics or aliases are turned into |
|
1036 | before executing it (things like magics or aliases are turned into | |
1036 | function calls, for example). With this option, you'll see the native |
|
1037 | function calls, for example). With this option, you'll see the native | |
1037 | history instead of the user-entered version: '%cd /' will be seen as |
|
1038 | history instead of the user-entered version: '%cd /' will be seen as | |
1038 | '_ip.magic("%cd /")' instead of '%cd /'. |
|
1039 | '_ip.magic("%cd /")' instead of '%cd /'. | |
1039 |
|
1040 | |||
1040 | -r: print the 'raw' history, i.e. the actual commands you typed. |
|
1041 | -r: print the 'raw' history, i.e. the actual commands you typed. | |
1041 |
|
1042 | |||
1042 | -g: treat the arg as a pattern to grep for in (full) history. |
|
1043 | -g: treat the arg as a pattern to grep for in (full) history. | |
1043 | This includes the "shadow history" (almost all commands ever written). |
|
1044 | This includes the "shadow history" (almost all commands ever written). | |
1044 | Use '%hist -g' to show full shadow history (may be very long). |
|
1045 | Use '%hist -g' to show full shadow history (may be very long). | |
1045 | In shadow history, every index nuwber starts with 0. |
|
1046 | In shadow history, every index nuwber starts with 0. | |
1046 |
|
1047 | |||
1047 | -f FILENAME: instead of printing the output to the screen, redirect it to |
|
1048 | -f FILENAME: instead of printing the output to the screen, redirect it to | |
1048 | the given file. The file is always overwritten, though IPython asks for |
|
1049 | the given file. The file is always overwritten, though IPython asks for | |
1049 | confirmation first if it already exists. |
|
1050 | confirmation first if it already exists. | |
1050 |
|
1051 | |||
1051 | **%logoff**:: |
|
1052 | **%logoff**:: | |
1052 |
|
1053 | |||
1053 | Temporarily stop logging. |
|
1054 | Temporarily stop logging. | |
1054 |
|
1055 | |||
1055 | You must have previously started logging. |
|
1056 | You must have previously started logging. | |
1056 |
|
1057 | |||
1057 | **%logon**:: |
|
1058 | **%logon**:: | |
1058 |
|
1059 | |||
1059 | Restart logging. |
|
1060 | Restart logging. | |
1060 |
|
1061 | |||
1061 | This function is for restarting logging which you've temporarily |
|
1062 | This function is for restarting logging which you've temporarily | |
1062 | stopped with %logoff. For starting logging for the first time, you |
|
1063 | stopped with %logoff. For starting logging for the first time, you | |
1063 | must use the %logstart function, which allows you to specify an |
|
1064 | must use the %logstart function, which allows you to specify an | |
1064 | optional log filename. |
|
1065 | optional log filename. | |
1065 |
|
1066 | |||
1066 | **%logstart**:: |
|
1067 | **%logstart**:: | |
1067 |
|
1068 | |||
1068 | Start logging anywhere in a session. |
|
1069 | Start logging anywhere in a session. | |
1069 |
|
1070 | |||
1070 | %logstart [-o|-r|-t] [log_name [log_mode]] |
|
1071 | %logstart [-o|-r|-t] [log_name [log_mode]] | |
1071 |
|
1072 | |||
1072 | If no name is given, it defaults to a file named 'ipython_log.py' in your |
|
1073 | If no name is given, it defaults to a file named 'ipython_log.py' in your | |
1073 | current directory, in 'rotate' mode (see below). |
|
1074 | current directory, in 'rotate' mode (see below). | |
1074 |
|
1075 | |||
1075 | '%logstart name' saves to file 'name' in 'backup' mode. It saves your |
|
1076 | '%logstart name' saves to file 'name' in 'backup' mode. It saves your | |
1076 | history up to that point and then continues logging. |
|
1077 | history up to that point and then continues logging. | |
1077 |
|
1078 | |||
1078 | %logstart takes a second optional parameter: logging mode. This can be one |
|
1079 | %logstart takes a second optional parameter: logging mode. This can be one | |
1079 | of (note that the modes are given unquoted):\ |
|
1080 | of (note that the modes are given unquoted):\ | |
1080 | append: well, that says it.\ |
|
1081 | append: well, that says it.\ | |
1081 | backup: rename (if exists) to name~ and start name.\ |
|
1082 | backup: rename (if exists) to name~ and start name.\ | |
1082 | global: single logfile in your home dir, appended to.\ |
|
1083 | global: single logfile in your home dir, appended to.\ | |
1083 | over : overwrite existing log.\ |
|
1084 | over : overwrite existing log.\ | |
1084 | rotate: create rotating logs name.1~, name.2~, etc. |
|
1085 | rotate: create rotating logs name.1~, name.2~, etc. | |
1085 |
|
1086 | |||
1086 | Options: |
|
1087 | Options: | |
1087 |
|
1088 | |||
1088 | -o: log also IPython's output. In this mode, all commands which |
|
1089 | -o: log also IPython's output. In this mode, all commands which | |
1089 | generate an Out[NN] prompt are recorded to the logfile, right after |
|
1090 | generate an Out[NN] prompt are recorded to the logfile, right after | |
1090 | their corresponding input line. The output lines are always |
|
1091 | their corresponding input line. The output lines are always | |
1091 | prepended with a '#[Out]# ' marker, so that the log remains valid |
|
1092 | prepended with a '#[Out]# ' marker, so that the log remains valid | |
1092 | Python code. |
|
1093 | Python code. | |
1093 |
|
1094 | |||
1094 | Since this marker is always the same, filtering only the output from |
|
1095 | Since this marker is always the same, filtering only the output from | |
1095 | a log is very easy, using for example a simple awk call: |
|
1096 | a log is very easy, using for example a simple awk call: | |
1096 |
|
1097 | |||
1097 | awk -F'#\[Out\]# ' '{if($2) {print $2}}' ipython_log.py |
|
1098 | awk -F'#\[Out\]# ' '{if($2) {print $2}}' ipython_log.py | |
1098 |
|
1099 | |||
1099 | -r: log 'raw' input. Normally, IPython's logs contain the processed |
|
1100 | -r: log 'raw' input. Normally, IPython's logs contain the processed | |
1100 | input, so that user lines are logged in their final form, converted |
|
1101 | input, so that user lines are logged in their final form, converted | |
1101 | into valid Python. For example, %Exit is logged as |
|
1102 | into valid Python. For example, %Exit is logged as | |
1102 | '_ip.magic("Exit"). If the -r flag is given, all input is logged |
|
1103 | '_ip.magic("Exit"). If the -r flag is given, all input is logged | |
1103 | exactly as typed, with no transformations applied. |
|
1104 | exactly as typed, with no transformations applied. | |
1104 |
|
1105 | |||
1105 | -t: put timestamps before each input line logged (these are put in |
|
1106 | -t: put timestamps before each input line logged (these are put in | |
1106 | comments). |
|
1107 | comments). | |
1107 |
|
1108 | |||
1108 | **%logstate**:: |
|
1109 | **%logstate**:: | |
1109 |
|
1110 | |||
1110 | Print the status of the logging system. |
|
1111 | Print the status of the logging system. | |
1111 |
|
1112 | |||
1112 | **%logstop**:: |
|
1113 | **%logstop**:: | |
1113 |
|
1114 | |||
1114 | Fully stop logging and close log file. |
|
1115 | Fully stop logging and close log file. | |
1115 |
|
1116 | |||
1116 | In order to start logging again, a new %logstart call needs to be made, |
|
1117 | In order to start logging again, a new %logstart call needs to be made, | |
1117 | possibly (though not necessarily) with a new filename, mode and other |
|
1118 | possibly (though not necessarily) with a new filename, mode and other | |
1118 | options. |
|
1119 | options. | |
1119 |
|
1120 | |||
1120 | **%lsmagic**:: |
|
1121 | **%lsmagic**:: | |
1121 |
|
1122 | |||
1122 | List currently available magic functions. |
|
1123 | List currently available magic functions. | |
1123 |
|
1124 | |||
1124 | **%macro**:: |
|
1125 | **%macro**:: | |
1125 |
|
1126 | |||
1126 | Define a set of input lines as a macro for future re-execution. |
|
1127 | Define a set of input lines as a macro for future re-execution. | |
1127 |
|
1128 | |||
1128 | Usage:\ |
|
1129 | Usage:\ | |
1129 | %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ... |
|
1130 | %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ... | |
1130 |
|
1131 | |||
1131 | Options: |
|
1132 | Options: | |
1132 |
|
1133 | |||
1133 | -r: use 'raw' input. By default, the 'processed' history is used, |
|
1134 | -r: use 'raw' input. By default, the 'processed' history is used, | |
1134 | so that magics are loaded in their transformed version to valid |
|
1135 | so that magics are loaded in their transformed version to valid | |
1135 | Python. If this option is given, the raw input as typed as the |
|
1136 | Python. If this option is given, the raw input as typed as the | |
1136 | command line is used instead. |
|
1137 | command line is used instead. | |
1137 |
|
1138 | |||
1138 | This will define a global variable called `name` which is a string |
|
1139 | This will define a global variable called `name` which is a string | |
1139 | made of joining the slices and lines you specify (n1,n2,... numbers |
|
1140 | made of joining the slices and lines you specify (n1,n2,... numbers | |
1140 | above) from your input history into a single string. This variable |
|
1141 | above) from your input history into a single string. This variable | |
1141 | acts like an automatic function which re-executes those lines as if |
|
1142 | acts like an automatic function which re-executes those lines as if | |
1142 | you had typed them. You just type 'name' at the prompt and the code |
|
1143 | you had typed them. You just type 'name' at the prompt and the code | |
1143 | executes. |
|
1144 | executes. | |
1144 |
|
1145 | |||
1145 | The notation for indicating number ranges is: n1-n2 means 'use line |
|
1146 | The notation for indicating number ranges is: n1-n2 means 'use line | |
1146 | numbers n1,...n2' (the endpoint is included). That is, '5-7' means |
|
1147 | numbers n1,...n2' (the endpoint is included). That is, '5-7' means | |
1147 | using the lines numbered 5,6 and 7. |
|
1148 | using the lines numbered 5,6 and 7. | |
1148 |
|
1149 | |||
1149 | Note: as a 'hidden' feature, you can also use traditional python slice |
|
1150 | Note: as a 'hidden' feature, you can also use traditional python slice | |
1150 | notation, where N:M means numbers N through M-1. |
|
1151 | notation, where N:M means numbers N through M-1. | |
1151 |
|
1152 | |||
1152 | For example, if your history contains (%hist prints it): |
|
1153 | For example, if your history contains (%hist prints it): | |
1153 |
|
1154 | |||
1154 | 44: x=1\ |
|
1155 | 44: x=1\ | |
1155 | 45: y=3\ |
|
1156 | 45: y=3\ | |
1156 | 46: z=x+y\ |
|
1157 | 46: z=x+y\ | |
1157 | 47: print x\ |
|
1158 | 47: print x\ | |
1158 | 48: a=5\ |
|
1159 | 48: a=5\ | |
1159 | 49: print 'x',x,'y',y\ |
|
1160 | 49: print 'x',x,'y',y\ | |
1160 |
|
1161 | |||
1161 | you can create a macro with lines 44 through 47 (included) and line 49 |
|
1162 | you can create a macro with lines 44 through 47 (included) and line 49 | |
1162 | called my_macro with: |
|
1163 | called my_macro with: | |
1163 |
|
1164 | |||
1164 | In [51]: %macro my_macro 44-47 49 |
|
1165 | In [51]: %macro my_macro 44-47 49 | |
1165 |
|
1166 | |||
1166 | Now, typing `my_macro` (without quotes) will re-execute all this code |
|
1167 | Now, typing `my_macro` (without quotes) will re-execute all this code | |
1167 | in one pass. |
|
1168 | in one pass. | |
1168 |
|
1169 | |||
1169 | You don't need to give the line-numbers in order, and any given line |
|
1170 | You don't need to give the line-numbers in order, and any given line | |
1170 | number can appear multiple times. You can assemble macros with any |
|
1171 | number can appear multiple times. You can assemble macros with any | |
1171 | lines from your input history in any order. |
|
1172 | lines from your input history in any order. | |
1172 |
|
1173 | |||
1173 | The macro is a simple object which holds its value in an attribute, |
|
1174 | The macro is a simple object which holds its value in an attribute, | |
1174 | but IPython's display system checks for macros and executes them as |
|
1175 | but IPython's display system checks for macros and executes them as | |
1175 | code instead of printing them when you type their name. |
|
1176 | code instead of printing them when you type their name. | |
1176 |
|
1177 | |||
1177 | You can view a macro's contents by explicitly printing it with: |
|
1178 | You can view a macro's contents by explicitly printing it with: | |
1178 |
|
1179 | |||
1179 | 'print macro_name'. |
|
1180 | 'print macro_name'. | |
1180 |
|
1181 | |||
1181 | For one-off cases which DON'T contain magic function calls in them you |
|
1182 | For one-off cases which DON'T contain magic function calls in them you | |
1182 | can obtain similar results by explicitly executing slices from your |
|
1183 | can obtain similar results by explicitly executing slices from your | |
1183 | input history with: |
|
1184 | input history with: | |
1184 |
|
1185 | |||
1185 | In [60]: exec In[44:48]+In[49] |
|
1186 | In [60]: exec In[44:48]+In[49] | |
1186 |
|
1187 | |||
1187 | **%magic**:: |
|
1188 | **%magic**:: | |
1188 |
|
1189 | |||
1189 | Print information about the magic function system. |
|
1190 | Print information about the magic function system. | |
1190 |
|
1191 | |||
1191 | **%mglob**:: |
|
1192 | **%mglob**:: | |
1192 |
|
1193 | |||
1193 | This program allows specifying filenames with "mglob" mechanism. |
|
1194 | This program allows specifying filenames with "mglob" mechanism. | |
1194 | Supported syntax in globs (wilcard matching patterns):: |
|
1195 | Supported syntax in globs (wilcard matching patterns):: | |
1195 |
|
1196 | |||
1196 | *.cpp ?ellowo* |
|
1197 | *.cpp ?ellowo* | |
1197 | - obvious. Differs from normal glob in that dirs are not included. |
|
1198 | - obvious. Differs from normal glob in that dirs are not included. | |
1198 | Unix users might want to write this as: "*.cpp" "?ellowo*" |
|
1199 | Unix users might want to write this as: "*.cpp" "?ellowo*" | |
1199 | rec:/usr/share=*.txt,*.doc |
|
1200 | rec:/usr/share=*.txt,*.doc | |
1200 | - get all *.txt and *.doc under /usr/share, |
|
1201 | - get all *.txt and *.doc under /usr/share, | |
1201 | recursively |
|
1202 | recursively | |
1202 | rec:/usr/share |
|
1203 | rec:/usr/share | |
1203 | - All files under /usr/share, recursively |
|
1204 | - All files under /usr/share, recursively | |
1204 | rec:*.py |
|
1205 | rec:*.py | |
1205 | - All .py files under current working dir, recursively |
|
1206 | - All .py files under current working dir, recursively | |
1206 | foo |
|
1207 | foo | |
1207 | - File or dir foo |
|
1208 | - File or dir foo | |
1208 | !*.bak readme* |
|
1209 | !*.bak readme* | |
1209 | - readme*, exclude files ending with .bak |
|
1210 | - readme*, exclude files ending with .bak | |
1210 | !.svn/ !.hg/ !*_Data/ rec:. |
|
1211 | !.svn/ !.hg/ !*_Data/ rec:. | |
1211 | - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse. |
|
1212 | - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse. | |
1212 | Trailing / is the key, \ does not work! |
|
1213 | Trailing / is the key, \ does not work! | |
1213 | dir:foo |
|
1214 | dir:foo | |
1214 | - the directory foo if it exists (not files in foo) |
|
1215 | - the directory foo if it exists (not files in foo) | |
1215 | dir:* |
|
1216 | dir:* | |
1216 | - all directories in current folder |
|
1217 | - all directories in current folder | |
1217 | foo.py bar.* !h* rec:*.py |
|
1218 | foo.py bar.* !h* rec:*.py | |
1218 | - Obvious. !h* exclusion only applies for rec:*.py. |
|
1219 | - Obvious. !h* exclusion only applies for rec:*.py. | |
1219 | foo.py is *not* included twice. |
|
1220 | foo.py is *not* included twice. | |
1220 | @filelist.txt |
|
1221 | @filelist.txt | |
1221 | - All files listed in 'filelist.txt' file, on separate lines. |
|
1222 | - All files listed in 'filelist.txt' file, on separate lines. | |
1222 |
|
1223 | |||
1223 | **%page**:: |
|
1224 | **%page**:: | |
1224 |
|
1225 | |||
1225 | Pretty print the object and display it through a pager. |
|
1226 | Pretty print the object and display it through a pager. | |
1226 |
|
1227 | |||
1227 | %page [options] OBJECT |
|
1228 | %page [options] OBJECT | |
1228 |
|
1229 | |||
1229 | If no object is given, use _ (last output). |
|
1230 | If no object is given, use _ (last output). | |
1230 |
|
1231 | |||
1231 | Options: |
|
1232 | Options: | |
1232 |
|
1233 | |||
1233 | -r: page str(object), don't pretty-print it. |
|
1234 | -r: page str(object), don't pretty-print it. | |
1234 |
|
1235 | |||
1235 | **%pdb**:: |
|
1236 | **%pdb**:: | |
1236 |
|
1237 | |||
1237 | Control the automatic calling of the pdb interactive debugger. |
|
1238 | Control the automatic calling of the pdb interactive debugger. | |
1238 |
|
1239 | |||
1239 | Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without |
|
1240 | Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without | |
1240 | argument it works as a toggle. |
|
1241 | argument it works as a toggle. | |
1241 |
|
1242 | |||
1242 | When an exception is triggered, IPython can optionally call the |
|
1243 | When an exception is triggered, IPython can optionally call the | |
1243 | interactive pdb debugger after the traceback printout. %pdb toggles |
|
1244 | interactive pdb debugger after the traceback printout. %pdb toggles | |
1244 | this feature on and off. |
|
1245 | this feature on and off. | |
1245 |
|
1246 | |||
1246 | The initial state of this feature is set in your ipythonrc |
|
1247 | The initial state of this feature is set in your ipythonrc | |
1247 | configuration file (the variable is called 'pdb'). |
|
1248 | configuration file (the variable is called 'pdb'). | |
1248 |
|
1249 | |||
1249 | If you want to just activate the debugger AFTER an exception has fired, |
|
1250 | If you want to just activate the debugger AFTER an exception has fired, | |
1250 | without having to type '%pdb on' and rerunning your code, you can use |
|
1251 | without having to type '%pdb on' and rerunning your code, you can use | |
1251 | the %debug magic. |
|
1252 | the %debug magic. | |
1252 |
|
1253 | |||
1253 | **%pdef**:: |
|
1254 | **%pdef**:: | |
1254 |
|
1255 | |||
1255 | Print the definition header for any callable object. |
|
1256 | Print the definition header for any callable object. | |
1256 |
|
1257 | |||
1257 | If the object is a class, print the constructor information. |
|
1258 | If the object is a class, print the constructor information. | |
1258 |
|
1259 | |||
1259 | **%pdoc**:: |
|
1260 | **%pdoc**:: | |
1260 |
|
1261 | |||
1261 | Print the docstring for an object. |
|
1262 | Print the docstring for an object. | |
1262 |
|
1263 | |||
1263 | If the given object is a class, it will print both the class and the |
|
1264 | If the given object is a class, it will print both the class and the | |
1264 | constructor docstrings. |
|
1265 | constructor docstrings. | |
1265 |
|
1266 | |||
1266 | **%pfile**:: |
|
1267 | **%pfile**:: | |
1267 |
|
1268 | |||
1268 | Print (or run through pager) the file where an object is defined. |
|
1269 | Print (or run through pager) the file where an object is defined. | |
1269 |
|
1270 | |||
1270 | The file opens at the line where the object definition begins. IPython |
|
1271 | The file opens at the line where the object definition begins. IPython | |
1271 | will honor the environment variable PAGER if set, and otherwise will |
|
1272 | will honor the environment variable PAGER if set, and otherwise will | |
1272 | do its best to print the file in a convenient form. |
|
1273 | do its best to print the file in a convenient form. | |
1273 |
|
1274 | |||
1274 | If the given argument is not an object currently defined, IPython will |
|
1275 | If the given argument is not an object currently defined, IPython will | |
1275 | try to interpret it as a filename (automatically adding a .py extension |
|
1276 | try to interpret it as a filename (automatically adding a .py extension | |
1276 | if needed). You can thus use %pfile as a syntax highlighting code |
|
1277 | if needed). You can thus use %pfile as a syntax highlighting code | |
1277 | viewer. |
|
1278 | viewer. | |
1278 |
|
1279 | |||
1279 | **%pinfo**:: |
|
1280 | **%pinfo**:: | |
1280 |
|
1281 | |||
1281 | Provide detailed information about an object. |
|
1282 | Provide detailed information about an object. | |
1282 |
|
1283 | |||
1283 | '%pinfo object' is just a synonym for object? or ?object. |
|
1284 | '%pinfo object' is just a synonym for object? or ?object. | |
1284 |
|
1285 | |||
1285 | **%popd**:: |
|
1286 | **%popd**:: | |
1286 |
|
1287 | |||
1287 | Change to directory popped off the top of the stack. |
|
1288 | Change to directory popped off the top of the stack. | |
1288 |
|
1289 | |||
1289 | **%profile**:: |
|
1290 | **%profile**:: | |
1290 |
|
1291 | |||
1291 | Print your currently active IPyhton profile. |
|
1292 | Print your currently active IPyhton profile. | |
1292 |
|
1293 | |||
1293 | **%prun**:: |
|
1294 | **%prun**:: | |
1294 |
|
1295 | |||
1295 | Run a statement through the python code profiler. |
|
1296 | Run a statement through the python code profiler. | |
1296 |
|
1297 | |||
1297 | Usage:\ |
|
1298 | Usage:\ | |
1298 | %prun [options] statement |
|
1299 | %prun [options] statement | |
1299 |
|
1300 | |||
1300 | The given statement (which doesn't require quote marks) is run via the |
|
1301 | The given statement (which doesn't require quote marks) is run via the | |
1301 | python profiler in a manner similar to the profile.run() function. |
|
1302 | python profiler in a manner similar to the profile.run() function. | |
1302 | Namespaces are internally managed to work correctly; profile.run |
|
1303 | Namespaces are internally managed to work correctly; profile.run | |
1303 | cannot be used in IPython because it makes certain assumptions about |
|
1304 | cannot be used in IPython because it makes certain assumptions about | |
1304 | namespaces which do not hold under IPython. |
|
1305 | namespaces which do not hold under IPython. | |
1305 |
|
1306 | |||
1306 | Options: |
|
1307 | Options: | |
1307 |
|
1308 | |||
1308 | -l <limit>: you can place restrictions on what or how much of the |
|
1309 | -l <limit>: you can place restrictions on what or how much of the | |
1309 | profile gets printed. The limit value can be: |
|
1310 | profile gets printed. The limit value can be: | |
1310 |
|
1311 | |||
1311 | * A string: only information for function names containing this string |
|
1312 | * A string: only information for function names containing this string | |
1312 | is printed. |
|
1313 | is printed. | |
1313 |
|
1314 | |||
1314 | * An integer: only these many lines are printed. |
|
1315 | * An integer: only these many lines are printed. | |
1315 |
|
1316 | |||
1316 | * A float (between 0 and 1): this fraction of the report is printed |
|
1317 | * A float (between 0 and 1): this fraction of the report is printed | |
1317 | (for example, use a limit of 0.4 to see the topmost 40% only). |
|
1318 | (for example, use a limit of 0.4 to see the topmost 40% only). | |
1318 |
|
1319 | |||
1319 | You can combine several limits with repeated use of the option. For |
|
1320 | You can combine several limits with repeated use of the option. For | |
1320 | example, '-l __init__ -l 5' will print only the topmost 5 lines of |
|
1321 | example, '-l __init__ -l 5' will print only the topmost 5 lines of | |
1321 | information about class constructors. |
|
1322 | information about class constructors. | |
1322 |
|
1323 | |||
1323 | -r: return the pstats.Stats object generated by the profiling. This |
|
1324 | -r: return the pstats.Stats object generated by the profiling. This | |
1324 | object has all the information about the profile in it, and you can |
|
1325 | object has all the information about the profile in it, and you can | |
1325 | later use it for further analysis or in other functions. |
|
1326 | later use it for further analysis or in other functions. | |
1326 |
|
1327 | |||
1327 | -s <key>: sort profile by given key. You can provide more than one key |
|
1328 | -s <key>: sort profile by given key. You can provide more than one key | |
1328 | by using the option several times: '-s key1 -s key2 -s key3...'. The |
|
1329 | by using the option several times: '-s key1 -s key2 -s key3...'. The | |
1329 | default sorting key is 'time'. |
|
1330 | default sorting key is 'time'. | |
1330 |
|
1331 | |||
1331 | The following is copied verbatim from the profile documentation |
|
1332 | The following is copied verbatim from the profile documentation | |
1332 | referenced below: |
|
1333 | referenced below: | |
1333 |
|
1334 | |||
1334 | When more than one key is provided, additional keys are used as |
|
1335 | When more than one key is provided, additional keys are used as | |
1335 | secondary criteria when the there is equality in all keys selected |
|
1336 | secondary criteria when the there is equality in all keys selected | |
1336 | before them. |
|
1337 | before them. | |
1337 |
|
1338 | |||
1338 | Abbreviations can be used for any key names, as long as the |
|
1339 | Abbreviations can be used for any key names, as long as the | |
1339 | abbreviation is unambiguous. The following are the keys currently |
|
1340 | abbreviation is unambiguous. The following are the keys currently | |
1340 | defined: |
|
1341 | defined: | |
1341 |
|
1342 | |||
1342 | Valid Arg Meaning\ |
|
1343 | Valid Arg Meaning\ | |
1343 | "calls" call count\ |
|
1344 | "calls" call count\ | |
1344 | "cumulative" cumulative time\ |
|
1345 | "cumulative" cumulative time\ | |
1345 | "file" file name\ |
|
1346 | "file" file name\ | |
1346 | "module" file name\ |
|
1347 | "module" file name\ | |
1347 | "pcalls" primitive call count\ |
|
1348 | "pcalls" primitive call count\ | |
1348 | "line" line number\ |
|
1349 | "line" line number\ | |
1349 | "name" function name\ |
|
1350 | "name" function name\ | |
1350 | "nfl" name/file/line\ |
|
1351 | "nfl" name/file/line\ | |
1351 | "stdname" standard name\ |
|
1352 | "stdname" standard name\ | |
1352 | "time" internal time |
|
1353 | "time" internal time | |
1353 |
|
1354 | |||
1354 | Note that all sorts on statistics are in descending order (placing |
|
1355 | Note that all sorts on statistics are in descending order (placing | |
1355 | most time consuming items first), where as name, file, and line number |
|
1356 | most time consuming items first), where as name, file, and line number | |
1356 | searches are in ascending order (i.e., alphabetical). The subtle |
|
1357 | searches are in ascending order (i.e., alphabetical). The subtle | |
1357 | distinction between "nfl" and "stdname" is that the standard name is a |
|
1358 | distinction between "nfl" and "stdname" is that the standard name is a | |
1358 | sort of the name as printed, which means that the embedded line |
|
1359 | sort of the name as printed, which means that the embedded line | |
1359 | numbers get compared in an odd way. For example, lines 3, 20, and 40 |
|
1360 | numbers get compared in an odd way. For example, lines 3, 20, and 40 | |
1360 | would (if the file names were the same) appear in the string order |
|
1361 | would (if the file names were the same) appear in the string order | |
1361 | "20" "3" and "40". In contrast, "nfl" does a numeric compare of the |
|
1362 | "20" "3" and "40". In contrast, "nfl" does a numeric compare of the | |
1362 | line numbers. In fact, sort_stats("nfl") is the same as |
|
1363 | line numbers. In fact, sort_stats("nfl") is the same as | |
1363 | sort_stats("name", "file", "line"). |
|
1364 | sort_stats("name", "file", "line"). | |
1364 |
|
1365 | |||
1365 | -T <filename>: save profile results as shown on screen to a text |
|
1366 | -T <filename>: save profile results as shown on screen to a text | |
1366 | file. The profile is still shown on screen. |
|
1367 | file. The profile is still shown on screen. | |
1367 |
|
1368 | |||
1368 | -D <filename>: save (via dump_stats) profile statistics to given |
|
1369 | -D <filename>: save (via dump_stats) profile statistics to given | |
1369 | filename. This data is in a format understod by the pstats module, and |
|
1370 | filename. This data is in a format understod by the pstats module, and | |
1370 | is generated by a call to the dump_stats() method of profile |
|
1371 | is generated by a call to the dump_stats() method of profile | |
1371 | objects. The profile is still shown on screen. |
|
1372 | objects. The profile is still shown on screen. | |
1372 |
|
1373 | |||
1373 | If you want to run complete programs under the profiler's control, use |
|
1374 | If you want to run complete programs under the profiler's control, use | |
1374 | '%run -p [prof_opts] filename.py [args to program]' where prof_opts |
|
1375 | '%run -p [prof_opts] filename.py [args to program]' where prof_opts | |
1375 | contains profiler specific options as described here. |
|
1376 | contains profiler specific options as described here. | |
1376 |
|
1377 | |||
1377 | You can read the complete documentation for the profile module with:\ |
|
1378 | You can read the complete documentation for the profile module with:\ | |
1378 | In [1]: import profile; profile.help() |
|
1379 | In [1]: import profile; profile.help() | |
1379 |
|
1380 | |||
1380 | **%psearch**:: |
|
1381 | **%psearch**:: | |
1381 |
|
1382 | |||
1382 | Search for object in namespaces by wildcard. |
|
1383 | Search for object in namespaces by wildcard. | |
1383 |
|
1384 | |||
1384 | %psearch [options] PATTERN [OBJECT TYPE] |
|
1385 | %psearch [options] PATTERN [OBJECT TYPE] | |
1385 |
|
1386 | |||
1386 | Note: ? can be used as a synonym for %psearch, at the beginning or at |
|
1387 | Note: ? can be used as a synonym for %psearch, at the beginning or at | |
1387 | the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the |
|
1388 | the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the | |
1388 | rest of the command line must be unchanged (options come first), so |
|
1389 | rest of the command line must be unchanged (options come first), so | |
1389 | for example the following forms are equivalent |
|
1390 | for example the following forms are equivalent | |
1390 |
|
1391 | |||
1391 | %psearch -i a* function |
|
1392 | %psearch -i a* function | |
1392 | -i a* function? |
|
1393 | -i a* function? | |
1393 | ?-i a* function |
|
1394 | ?-i a* function | |
1394 |
|
1395 | |||
1395 | Arguments: |
|
1396 | Arguments: | |
1396 |
|
1397 | |||
1397 | PATTERN |
|
1398 | PATTERN | |
1398 |
|
1399 | |||
1399 | where PATTERN is a string containing * as a wildcard similar to its |
|
1400 | where PATTERN is a string containing * as a wildcard similar to its | |
1400 | use in a shell. The pattern is matched in all namespaces on the |
|
1401 | use in a shell. The pattern is matched in all namespaces on the | |
1401 | search path. By default objects starting with a single _ are not |
|
1402 | search path. By default objects starting with a single _ are not | |
1402 | matched, many IPython generated objects have a single |
|
1403 | matched, many IPython generated objects have a single | |
1403 | underscore. The default is case insensitive matching. Matching is |
|
1404 | underscore. The default is case insensitive matching. Matching is | |
1404 | also done on the attributes of objects and not only on the objects |
|
1405 | also done on the attributes of objects and not only on the objects | |
1405 | in a module. |
|
1406 | in a module. | |
1406 |
|
1407 | |||
1407 | [OBJECT TYPE] |
|
1408 | [OBJECT TYPE] | |
1408 |
|
1409 | |||
1409 | Is the name of a python type from the types module. The name is |
|
1410 | Is the name of a python type from the types module. The name is | |
1410 | given in lowercase without the ending type, ex. StringType is |
|
1411 | given in lowercase without the ending type, ex. StringType is | |
1411 | written string. By adding a type here only objects matching the |
|
1412 | written string. By adding a type here only objects matching the | |
1412 | given type are matched. Using all here makes the pattern match all |
|
1413 | given type are matched. Using all here makes the pattern match all | |
1413 | types (this is the default). |
|
1414 | types (this is the default). | |
1414 |
|
1415 | |||
1415 | Options: |
|
1416 | Options: | |
1416 |
|
1417 | |||
1417 | -a: makes the pattern match even objects whose names start with a |
|
1418 | -a: makes the pattern match even objects whose names start with a | |
1418 | single underscore. These names are normally ommitted from the |
|
1419 | single underscore. These names are normally ommitted from the | |
1419 | search. |
|
1420 | search. | |
1420 |
|
1421 | |||
1421 | -i/-c: make the pattern case insensitive/sensitive. If neither of |
|
1422 | -i/-c: make the pattern case insensitive/sensitive. If neither of | |
1422 | these options is given, the default is read from your ipythonrc |
|
1423 | these options is given, the default is read from your ipythonrc | |
1423 | file. The option name which sets this value is |
|
1424 | file. The option name which sets this value is | |
1424 | 'wildcards_case_sensitive'. If this option is not specified in your |
|
1425 | 'wildcards_case_sensitive'. If this option is not specified in your | |
1425 | ipythonrc file, IPython's internal default is to do a case sensitive |
|
1426 | ipythonrc file, IPython's internal default is to do a case sensitive | |
1426 | search. |
|
1427 | search. | |
1427 |
|
1428 | |||
1428 | -e/-s NAMESPACE: exclude/search a given namespace. The pattern you |
|
1429 | -e/-s NAMESPACE: exclude/search a given namespace. The pattern you | |
1429 | specifiy can be searched in any of the following namespaces: |
|
1430 | specifiy can be searched in any of the following namespaces: | |
1430 | 'builtin', 'user', 'user_global','internal', 'alias', where |
|
1431 | 'builtin', 'user', 'user_global','internal', 'alias', where | |
1431 | 'builtin' and 'user' are the search defaults. Note that you should |
|
1432 | 'builtin' and 'user' are the search defaults. Note that you should | |
1432 | not use quotes when specifying namespaces. |
|
1433 | not use quotes when specifying namespaces. | |
1433 |
|
1434 | |||
1434 | 'Builtin' contains the python module builtin, 'user' contains all |
|
1435 | 'Builtin' contains the python module builtin, 'user' contains all | |
1435 | user data, 'alias' only contain the shell aliases and no python |
|
1436 | user data, 'alias' only contain the shell aliases and no python | |
1436 | objects, 'internal' contains objects used by IPython. The |
|
1437 | objects, 'internal' contains objects used by IPython. The | |
1437 | 'user_global' namespace is only used by embedded IPython instances, |
|
1438 | 'user_global' namespace is only used by embedded IPython instances, | |
1438 | and it contains module-level globals. You can add namespaces to the |
|
1439 | and it contains module-level globals. You can add namespaces to the | |
1439 | search with -s or exclude them with -e (these options can be given |
|
1440 | search with -s or exclude them with -e (these options can be given | |
1440 | more than once). |
|
1441 | more than once). | |
1441 |
|
1442 | |||
1442 | Examples: |
|
1443 | Examples: | |
1443 |
|
1444 | |||
1444 | %psearch a* -> objects beginning with an a |
|
1445 | %psearch a* -> objects beginning with an a | |
1445 | %psearch -e builtin a* -> objects NOT in the builtin space starting in a |
|
1446 | %psearch -e builtin a* -> objects NOT in the builtin space starting in a | |
1446 | %psearch a* function -> all functions beginning with an a |
|
1447 | %psearch a* function -> all functions beginning with an a | |
1447 | %psearch re.e* -> objects beginning with an e in module re |
|
1448 | %psearch re.e* -> objects beginning with an e in module re | |
1448 | %psearch r*.e* -> objects that start with e in modules starting in r |
|
1449 | %psearch r*.e* -> objects that start with e in modules starting in r | |
1449 | %psearch r*.* string -> all strings in modules beginning with r |
|
1450 | %psearch r*.* string -> all strings in modules beginning with r | |
1450 |
|
1451 | |||
1451 | Case sensitve search: |
|
1452 | Case sensitve search: | |
1452 |
|
1453 | |||
1453 | %psearch -c a* list all object beginning with lower case a |
|
1454 | %psearch -c a* list all object beginning with lower case a | |
1454 |
|
1455 | |||
1455 | Show objects beginning with a single _: |
|
1456 | Show objects beginning with a single _: | |
1456 |
|
1457 | |||
1457 | %psearch -a _* list objects beginning with a single underscore |
|
1458 | %psearch -a _* list objects beginning with a single underscore | |
1458 |
|
1459 | |||
1459 | **%psource**:: |
|
1460 | **%psource**:: | |
1460 |
|
1461 | |||
1461 | Print (or run through pager) the source code for an object. |
|
1462 | Print (or run through pager) the source code for an object. | |
1462 |
|
1463 | |||
1463 | **%pushd**:: |
|
1464 | **%pushd**:: | |
1464 |
|
1465 | |||
1465 | Place the current dir on stack and change directory. |
|
1466 | Place the current dir on stack and change directory. | |
1466 |
|
1467 | |||
1467 | Usage:\ |
|
1468 | Usage:\ | |
1468 | %pushd ['dirname'] |
|
1469 | %pushd ['dirname'] | |
1469 |
|
1470 | |||
1470 | **%pwd**:: |
|
1471 | **%pwd**:: | |
1471 |
|
1472 | |||
1472 | Return the current working directory path. |
|
1473 | Return the current working directory path. | |
1473 |
|
1474 | |||
1474 | **%pycat**:: |
|
1475 | **%pycat**:: | |
1475 |
|
1476 | |||
1476 | Show a syntax-highlighted file through a pager. |
|
1477 | Show a syntax-highlighted file through a pager. | |
1477 |
|
1478 | |||
1478 | This magic is similar to the cat utility, but it will assume the file |
|
1479 | This magic is similar to the cat utility, but it will assume the file | |
1479 | to be Python source and will show it with syntax highlighting. |
|
1480 | to be Python source and will show it with syntax highlighting. | |
1480 |
|
1481 | |||
1481 | **%quickref**:: |
|
1482 | **%quickref**:: | |
1482 |
|
1483 | |||
1483 | Show a quick reference sheet |
|
1484 | Show a quick reference sheet | |
1484 |
|
1485 | |||
1485 | **%quit**:: |
|
1486 | **%quit**:: | |
1486 |
|
1487 | |||
1487 | Exit IPython, confirming if configured to do so (like %exit) |
|
1488 | Exit IPython, confirming if configured to do so (like %exit) | |
1488 |
|
1489 | |||
1489 | **%r**:: |
|
1490 | **%r**:: | |
1490 |
|
1491 | |||
1491 | Repeat previous input. |
|
1492 | Repeat previous input. | |
1492 |
|
1493 | |||
1493 | Note: Consider using the more powerfull %rep instead! |
|
1494 | Note: Consider using the more powerfull %rep instead! | |
1494 |
|
1495 | |||
1495 | If given an argument, repeats the previous command which starts with |
|
1496 | If given an argument, repeats the previous command which starts with | |
1496 | the same string, otherwise it just repeats the previous input. |
|
1497 | the same string, otherwise it just repeats the previous input. | |
1497 |
|
1498 | |||
1498 | Shell escaped commands (with ! as first character) are not recognized |
|
1499 | Shell escaped commands (with ! as first character) are not recognized | |
1499 | by this system, only pure python code and magic commands. |
|
1500 | by this system, only pure python code and magic commands. | |
1500 |
|
1501 | |||
1501 | **%rehashdir**:: |
|
1502 | **%rehashdir**:: | |
1502 |
|
1503 | |||
1503 | Add executables in all specified dirs to alias table |
|
1504 | Add executables in all specified dirs to alias table | |
1504 |
|
1505 | |||
1505 | Usage: |
|
1506 | Usage: | |
1506 |
|
1507 | |||
1507 | %rehashdir c:/bin;c:/tools |
|
1508 | %rehashdir c:/bin;c:/tools | |
1508 | - Add all executables under c:/bin and c:/tools to alias table, in |
|
1509 | - Add all executables under c:/bin and c:/tools to alias table, in | |
1509 | order to make them directly executable from any directory. |
|
1510 | order to make them directly executable from any directory. | |
1510 |
|
1511 | |||
1511 | Without arguments, add all executables in current directory. |
|
1512 | Without arguments, add all executables in current directory. | |
1512 |
|
1513 | |||
1513 | **%rehashx**:: |
|
1514 | **%rehashx**:: | |
1514 |
|
1515 | |||
1515 | Update the alias table with all executable files in $PATH. |
|
1516 | Update the alias table with all executable files in $PATH. | |
1516 |
|
1517 | |||
1517 | This version explicitly checks that every entry in $PATH is a file |
|
1518 | This version explicitly checks that every entry in $PATH is a file | |
1518 | with execute access (os.X_OK), so it is much slower than %rehash. |
|
1519 | with execute access (os.X_OK), so it is much slower than %rehash. | |
1519 |
|
1520 | |||
1520 | Under Windows, it checks executability as a match agains a |
|
1521 | Under Windows, it checks executability as a match agains a | |
1521 | '|'-separated string of extensions, stored in the IPython config |
|
1522 | '|'-separated string of extensions, stored in the IPython config | |
1522 | variable win_exec_ext. This defaults to 'exe|com|bat'. |
|
1523 | variable win_exec_ext. This defaults to 'exe|com|bat'. | |
1523 |
|
1524 | |||
1524 | This function also resets the root module cache of module completer, |
|
1525 | This function also resets the root module cache of module completer, | |
1525 | used on slow filesystems. |
|
1526 | used on slow filesystems. | |
1526 |
|
1527 | |||
1527 | **%rep**:: |
|
1528 | **%rep**:: | |
1528 |
|
1529 | |||
1529 | Repeat a command, or get command to input line for editing |
|
1530 | Repeat a command, or get command to input line for editing | |
1530 |
|
1531 | |||
1531 | - %rep (no arguments): |
|
1532 | - %rep (no arguments): | |
1532 |
|
1533 | |||
1533 | Place a string version of last computation result (stored in the special '_' |
|
1534 | Place a string version of last computation result (stored in the special '_' | |
1534 | variable) to the next input prompt. Allows you to create elaborate command |
|
1535 | variable) to the next input prompt. Allows you to create elaborate command | |
1535 | lines without using copy-paste:: |
|
1536 | lines without using copy-paste:: | |
1536 |
|
1537 | |||
1537 | $ l = ["hei", "vaan"] |
|
1538 | $ l = ["hei", "vaan"] | |
1538 | $ "".join(l) |
|
1539 | $ "".join(l) | |
1539 | ==> heivaan |
|
1540 | ==> heivaan | |
1540 | $ %rep |
|
1541 | $ %rep | |
1541 | $ heivaan_ <== cursor blinking |
|
1542 | $ heivaan_ <== cursor blinking | |
1542 |
|
1543 | |||
1543 | %rep 45 |
|
1544 | %rep 45 | |
1544 |
|
1545 | |||
1545 | Place history line 45 to next input prompt. Use %hist to find out the |
|
1546 | Place history line 45 to next input prompt. Use %hist to find out the | |
1546 | number. |
|
1547 | number. | |
1547 |
|
1548 | |||
1548 | %rep 1-4 6-7 3 |
|
1549 | %rep 1-4 6-7 3 | |
1549 |
|
1550 | |||
1550 | Repeat the specified lines immediately. Input slice syntax is the same as |
|
1551 | Repeat the specified lines immediately. Input slice syntax is the same as | |
1551 | in %macro and %save. |
|
1552 | in %macro and %save. | |
1552 |
|
1553 | |||
1553 | %rep foo |
|
1554 | %rep foo | |
1554 |
|
1555 | |||
1555 | Place the most recent line that has the substring "foo" to next input. |
|
1556 | Place the most recent line that has the substring "foo" to next input. | |
1556 | (e.g. 'svn ci -m foobar'). |
|
1557 | (e.g. 'svn ci -m foobar'). | |
1557 |
|
1558 | |||
1558 | **%reset**:: |
|
1559 | **%reset**:: | |
1559 |
|
1560 | |||
1560 | Resets the namespace by removing all names defined by the user. |
|
1561 | Resets the namespace by removing all names defined by the user. | |
1561 |
|
1562 | |||
1562 | Input/Output history are left around in case you need them. |
|
1563 | Input/Output history are left around in case you need them. | |
1563 |
|
1564 | |||
1564 | **%run**:: |
|
1565 | **%run**:: | |
1565 |
|
1566 | |||
1566 | Run the named file inside IPython as a program. |
|
1567 | Run the named file inside IPython as a program. | |
1567 |
|
1568 | |||
1568 | Usage:\ |
|
1569 | Usage:\ | |
1569 | %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args] |
|
1570 | %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args] | |
1570 |
|
1571 | |||
1571 | Parameters after the filename are passed as command-line arguments to |
|
1572 | Parameters after the filename are passed as command-line arguments to | |
1572 | the program (put in sys.argv). Then, control returns to IPython's |
|
1573 | the program (put in sys.argv). Then, control returns to IPython's | |
1573 | prompt. |
|
1574 | prompt. | |
1574 |
|
1575 | |||
1575 | This is similar to running at a system prompt:\ |
|
1576 | This is similar to running at a system prompt:\ | |
1576 | $ python file args\ |
|
1577 | $ python file args\ | |
1577 | but with the advantage of giving you IPython's tracebacks, and of |
|
1578 | but with the advantage of giving you IPython's tracebacks, and of | |
1578 | loading all variables into your interactive namespace for further use |
|
1579 | loading all variables into your interactive namespace for further use | |
1579 | (unless -p is used, see below). |
|
1580 | (unless -p is used, see below). | |
1580 |
|
1581 | |||
1581 | The file is executed in a namespace initially consisting only of |
|
1582 | The file is executed in a namespace initially consisting only of | |
1582 | __name__=='__main__' and sys.argv constructed as indicated. It thus |
|
1583 | __name__=='__main__' and sys.argv constructed as indicated. It thus | |
1583 | sees its environment as if it were being run as a stand-alone program |
|
1584 | sees its environment as if it were being run as a stand-alone program | |
1584 | (except for sharing global objects such as previously imported |
|
1585 | (except for sharing global objects such as previously imported | |
1585 | modules). But after execution, the IPython interactive namespace gets |
|
1586 | modules). But after execution, the IPython interactive namespace gets | |
1586 | updated with all variables defined in the program (except for __name__ |
|
1587 | updated with all variables defined in the program (except for __name__ | |
1587 | and sys.argv). This allows for very convenient loading of code for |
|
1588 | and sys.argv). This allows for very convenient loading of code for | |
1588 | interactive work, while giving each program a 'clean sheet' to run in. |
|
1589 | interactive work, while giving each program a 'clean sheet' to run in. | |
1589 |
|
1590 | |||
1590 | Options: |
|
1591 | Options: | |
1591 |
|
1592 | |||
1592 | -n: __name__ is NOT set to '__main__', but to the running file's name |
|
1593 | -n: __name__ is NOT set to '__main__', but to the running file's name | |
1593 | without extension (as python does under import). This allows running |
|
1594 | without extension (as python does under import). This allows running | |
1594 | scripts and reloading the definitions in them without calling code |
|
1595 | scripts and reloading the definitions in them without calling code | |
1595 | protected by an ' if __name__ == "__main__" ' clause. |
|
1596 | protected by an ' if __name__ == "__main__" ' clause. | |
1596 |
|
1597 | |||
1597 | -i: run the file in IPython's namespace instead of an empty one. This |
|
1598 | -i: run the file in IPython's namespace instead of an empty one. This | |
1598 | is useful if you are experimenting with code written in a text editor |
|
1599 | is useful if you are experimenting with code written in a text editor | |
1599 | which depends on variables defined interactively. |
|
1600 | which depends on variables defined interactively. | |
1600 |
|
1601 | |||
1601 | -e: ignore sys.exit() calls or SystemExit exceptions in the script |
|
1602 | -e: ignore sys.exit() calls or SystemExit exceptions in the script | |
1602 | being run. This is particularly useful if IPython is being used to |
|
1603 | being run. This is particularly useful if IPython is being used to | |
1603 | run unittests, which always exit with a sys.exit() call. In such |
|
1604 | run unittests, which always exit with a sys.exit() call. In such | |
1604 | cases you are interested in the output of the test results, not in |
|
1605 | cases you are interested in the output of the test results, not in | |
1605 | seeing a traceback of the unittest module. |
|
1606 | seeing a traceback of the unittest module. | |
1606 |
|
1607 | |||
1607 | -t: print timing information at the end of the run. IPython will give |
|
1608 | -t: print timing information at the end of the run. IPython will give | |
1608 | you an estimated CPU time consumption for your script, which under |
|
1609 | you an estimated CPU time consumption for your script, which under | |
1609 | Unix uses the resource module to avoid the wraparound problems of |
|
1610 | Unix uses the resource module to avoid the wraparound problems of | |
1610 | time.clock(). Under Unix, an estimate of time spent on system tasks |
|
1611 | time.clock(). Under Unix, an estimate of time spent on system tasks | |
1611 | is also given (for Windows platforms this is reported as 0.0). |
|
1612 | is also given (for Windows platforms this is reported as 0.0). | |
1612 |
|
1613 | |||
1613 | If -t is given, an additional -N<N> option can be given, where <N> |
|
1614 | If -t is given, an additional -N<N> option can be given, where <N> | |
1614 | must be an integer indicating how many times you want the script to |
|
1615 | must be an integer indicating how many times you want the script to | |
1615 | run. The final timing report will include total and per run results. |
|
1616 | run. The final timing report will include total and per run results. | |
1616 |
|
1617 | |||
1617 | For example (testing the script uniq_stable.py): |
|
1618 | For example (testing the script uniq_stable.py): | |
1618 |
|
1619 | |||
1619 | In [1]: run -t uniq_stable |
|
1620 | In [1]: run -t uniq_stable | |
1620 |
|
1621 | |||
1621 | IPython CPU timings (estimated):\ |
|
1622 | IPython CPU timings (estimated):\ | |
1622 | User : 0.19597 s.\ |
|
1623 | User : 0.19597 s.\ | |
1623 | System: 0.0 s.\ |
|
1624 | System: 0.0 s.\ | |
1624 |
|
1625 | |||
1625 | In [2]: run -t -N5 uniq_stable |
|
1626 | In [2]: run -t -N5 uniq_stable | |
1626 |
|
1627 | |||
1627 | IPython CPU timings (estimated):\ |
|
1628 | IPython CPU timings (estimated):\ | |
1628 | Total runs performed: 5\ |
|
1629 | Total runs performed: 5\ | |
1629 | Times : Total Per run\ |
|
1630 | Times : Total Per run\ | |
1630 | User : 0.910862 s, 0.1821724 s.\ |
|
1631 | User : 0.910862 s, 0.1821724 s.\ | |
1631 | System: 0.0 s, 0.0 s. |
|
1632 | System: 0.0 s, 0.0 s. | |
1632 |
|
1633 | |||
1633 | -d: run your program under the control of pdb, the Python debugger. |
|
1634 | -d: run your program under the control of pdb, the Python debugger. | |
1634 | This allows you to execute your program step by step, watch variables, |
|
1635 | This allows you to execute your program step by step, watch variables, | |
1635 | etc. Internally, what IPython does is similar to calling: |
|
1636 | etc. Internally, what IPython does is similar to calling: | |
1636 |
|
1637 | |||
1637 | pdb.run('execfile("YOURFILENAME")') |
|
1638 | pdb.run('execfile("YOURFILENAME")') | |
1638 |
|
1639 | |||
1639 | with a breakpoint set on line 1 of your file. You can change the line |
|
1640 | with a breakpoint set on line 1 of your file. You can change the line | |
1640 | number for this automatic breakpoint to be <N> by using the -bN option |
|
1641 | number for this automatic breakpoint to be <N> by using the -bN option | |
1641 | (where N must be an integer). For example: |
|
1642 | (where N must be an integer). For example: | |
1642 |
|
1643 | |||
1643 | %run -d -b40 myscript |
|
1644 | %run -d -b40 myscript | |
1644 |
|
1645 | |||
1645 | will set the first breakpoint at line 40 in myscript.py. Note that |
|
1646 | will set the first breakpoint at line 40 in myscript.py. Note that | |
1646 | the first breakpoint must be set on a line which actually does |
|
1647 | the first breakpoint must be set on a line which actually does | |
1647 | something (not a comment or docstring) for it to stop execution. |
|
1648 | something (not a comment or docstring) for it to stop execution. | |
1648 |
|
1649 | |||
1649 | When the pdb debugger starts, you will see a (Pdb) prompt. You must |
|
1650 | When the pdb debugger starts, you will see a (Pdb) prompt. You must | |
1650 | first enter 'c' (without qoutes) to start execution up to the first |
|
1651 | first enter 'c' (without qoutes) to start execution up to the first | |
1651 | breakpoint. |
|
1652 | breakpoint. | |
1652 |
|
1653 | |||
1653 | Entering 'help' gives information about the use of the debugger. You |
|
1654 | Entering 'help' gives information about the use of the debugger. You | |
1654 | can easily see pdb's full documentation with "import pdb;pdb.help()" |
|
1655 | can easily see pdb's full documentation with "import pdb;pdb.help()" | |
1655 | at a prompt. |
|
1656 | at a prompt. | |
1656 |
|
1657 | |||
1657 | -p: run program under the control of the Python profiler module (which |
|
1658 | -p: run program under the control of the Python profiler module (which | |
1658 | prints a detailed report of execution times, function calls, etc). |
|
1659 | prints a detailed report of execution times, function calls, etc). | |
1659 |
|
1660 | |||
1660 | You can pass other options after -p which affect the behavior of the |
|
1661 | You can pass other options after -p which affect the behavior of the | |
1661 | profiler itself. See the docs for %prun for details. |
|
1662 | profiler itself. See the docs for %prun for details. | |
1662 |
|
1663 | |||
1663 | In this mode, the program's variables do NOT propagate back to the |
|
1664 | In this mode, the program's variables do NOT propagate back to the | |
1664 | IPython interactive namespace (because they remain in the namespace |
|
1665 | IPython interactive namespace (because they remain in the namespace | |
1665 | where the profiler executes them). |
|
1666 | where the profiler executes them). | |
1666 |
|
1667 | |||
1667 | Internally this triggers a call to %prun, see its documentation for |
|
1668 | Internally this triggers a call to %prun, see its documentation for | |
1668 | details on the options available specifically for profiling. |
|
1669 | details on the options available specifically for profiling. | |
1669 |
|
1670 | |||
1670 | There is one special usage for which the text above doesn't apply: |
|
1671 | There is one special usage for which the text above doesn't apply: | |
1671 | if the filename ends with .ipy, the file is run as ipython script, |
|
1672 | if the filename ends with .ipy, the file is run as ipython script, | |
1672 | just as if the commands were written on IPython prompt. |
|
1673 | just as if the commands were written on IPython prompt. | |
1673 |
|
1674 | |||
1674 | **%runlog**:: |
|
1675 | **%runlog**:: | |
1675 |
|
1676 | |||
1676 | Run files as logs. |
|
1677 | Run files as logs. | |
1677 |
|
1678 | |||
1678 | Usage:\ |
|
1679 | Usage:\ | |
1679 | %runlog file1 file2 ... |
|
1680 | %runlog file1 file2 ... | |
1680 |
|
1681 | |||
1681 | Run the named files (treating them as log files) in sequence inside |
|
1682 | Run the named files (treating them as log files) in sequence inside | |
1682 | the interpreter, and return to the prompt. This is much slower than |
|
1683 | the interpreter, and return to the prompt. This is much slower than | |
1683 | %run because each line is executed in a try/except block, but it |
|
1684 | %run because each line is executed in a try/except block, but it | |
1684 | allows running files with syntax errors in them. |
|
1685 | allows running files with syntax errors in them. | |
1685 |
|
1686 | |||
1686 | Normally IPython will guess when a file is one of its own logfiles, so |
|
1687 | Normally IPython will guess when a file is one of its own logfiles, so | |
1687 | you can typically use %run even for logs. This shorthand allows you to |
|
1688 | you can typically use %run even for logs. This shorthand allows you to | |
1688 | force any file to be treated as a log file. |
|
1689 | force any file to be treated as a log file. | |
1689 |
|
1690 | |||
1690 | **%save**:: |
|
1691 | **%save**:: | |
1691 |
|
1692 | |||
1692 | Save a set of lines to a given filename. |
|
1693 | Save a set of lines to a given filename. | |
1693 |
|
1694 | |||
1694 | Usage:\ |
|
1695 | Usage:\ | |
1695 | %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ... |
|
1696 | %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ... | |
1696 |
|
1697 | |||
1697 | Options: |
|
1698 | Options: | |
1698 |
|
1699 | |||
1699 | -r: use 'raw' input. By default, the 'processed' history is used, |
|
1700 | -r: use 'raw' input. By default, the 'processed' history is used, | |
1700 | so that magics are loaded in their transformed version to valid |
|
1701 | so that magics are loaded in their transformed version to valid | |
1701 | Python. If this option is given, the raw input as typed as the |
|
1702 | Python. If this option is given, the raw input as typed as the | |
1702 | command line is used instead. |
|
1703 | command line is used instead. | |
1703 |
|
1704 | |||
1704 | This function uses the same syntax as %macro for line extraction, but |
|
1705 | This function uses the same syntax as %macro for line extraction, but | |
1705 | instead of creating a macro it saves the resulting string to the |
|
1706 | instead of creating a macro it saves the resulting string to the | |
1706 | filename you specify. |
|
1707 | filename you specify. | |
1707 |
|
1708 | |||
1708 | It adds a '.py' extension to the file if you don't do so yourself, and |
|
1709 | It adds a '.py' extension to the file if you don't do so yourself, and | |
1709 | it asks for confirmation before overwriting existing files. |
|
1710 | it asks for confirmation before overwriting existing files. | |
1710 |
|
1711 | |||
1711 | **%sc**:: |
|
1712 | **%sc**:: | |
1712 |
|
1713 | |||
1713 | Shell capture - execute a shell command and capture its output. |
|
1714 | Shell capture - execute a shell command and capture its output. | |
1714 |
|
1715 | |||
1715 | DEPRECATED. Suboptimal, retained for backwards compatibility. |
|
1716 | DEPRECATED. Suboptimal, retained for backwards compatibility. | |
1716 |
|
1717 | |||
1717 | You should use the form 'var = !command' instead. Example: |
|
1718 | You should use the form 'var = !command' instead. Example: | |
1718 |
|
1719 | |||
1719 | "%sc -l myfiles = ls ~" should now be written as |
|
1720 | "%sc -l myfiles = ls ~" should now be written as | |
1720 |
|
1721 | |||
1721 | "myfiles = !ls ~" |
|
1722 | "myfiles = !ls ~" | |
1722 |
|
1723 | |||
1723 | myfiles.s, myfiles.l and myfiles.n still apply as documented |
|
1724 | myfiles.s, myfiles.l and myfiles.n still apply as documented | |
1724 | below. |
|
1725 | below. | |
1725 |
|
1726 | |||
1726 | -- |
|
1727 | -- | |
1727 | %sc [options] varname=command |
|
1728 | %sc [options] varname=command | |
1728 |
|
1729 | |||
1729 | IPython will run the given command using commands.getoutput(), and |
|
1730 | IPython will run the given command using commands.getoutput(), and | |
1730 | will then update the user's interactive namespace with a variable |
|
1731 | will then update the user's interactive namespace with a variable | |
1731 | called varname, containing the value of the call. Your command can |
|
1732 | called varname, containing the value of the call. Your command can | |
1732 | contain shell wildcards, pipes, etc. |
|
1733 | contain shell wildcards, pipes, etc. | |
1733 |
|
1734 | |||
1734 | The '=' sign in the syntax is mandatory, and the variable name you |
|
1735 | The '=' sign in the syntax is mandatory, and the variable name you | |
1735 | supply must follow Python's standard conventions for valid names. |
|
1736 | supply must follow Python's standard conventions for valid names. | |
1736 |
|
1737 | |||
1737 | (A special format without variable name exists for internal use) |
|
1738 | (A special format without variable name exists for internal use) | |
1738 |
|
1739 | |||
1739 | Options: |
|
1740 | Options: | |
1740 |
|
1741 | |||
1741 | -l: list output. Split the output on newlines into a list before |
|
1742 | -l: list output. Split the output on newlines into a list before | |
1742 | assigning it to the given variable. By default the output is stored |
|
1743 | assigning it to the given variable. By default the output is stored | |
1743 | as a single string. |
|
1744 | as a single string. | |
1744 |
|
1745 | |||
1745 | -v: verbose. Print the contents of the variable. |
|
1746 | -v: verbose. Print the contents of the variable. | |
1746 |
|
1747 | |||
1747 | In most cases you should not need to split as a list, because the |
|
1748 | In most cases you should not need to split as a list, because the | |
1748 | returned value is a special type of string which can automatically |
|
1749 | returned value is a special type of string which can automatically | |
1749 | provide its contents either as a list (split on newlines) or as a |
|
1750 | provide its contents either as a list (split on newlines) or as a | |
1750 | space-separated string. These are convenient, respectively, either |
|
1751 | space-separated string. These are convenient, respectively, either | |
1751 | for sequential processing or to be passed to a shell command. |
|
1752 | for sequential processing or to be passed to a shell command. | |
1752 |
|
1753 | |||
1753 | For example: |
|
1754 | For example: | |
1754 |
|
1755 | |||
1755 | # Capture into variable a |
|
1756 | # Capture into variable a | |
1756 | In [9]: sc a=ls *py |
|
1757 | In [9]: sc a=ls *py | |
1757 |
|
1758 | |||
1758 | # a is a string with embedded newlines |
|
1759 | # a is a string with embedded newlines | |
1759 | In [10]: a |
|
1760 | In [10]: a | |
1760 | Out[10]: 'setup.py win32_manual_post_install.py' |
|
1761 | Out[10]: 'setup.py win32_manual_post_install.py' | |
1761 |
|
1762 | |||
1762 | # which can be seen as a list: |
|
1763 | # which can be seen as a list: | |
1763 | In [11]: a.l |
|
1764 | In [11]: a.l | |
1764 | Out[11]: ['setup.py', 'win32_manual_post_install.py'] |
|
1765 | Out[11]: ['setup.py', 'win32_manual_post_install.py'] | |
1765 |
|
1766 | |||
1766 | # or as a whitespace-separated string: |
|
1767 | # or as a whitespace-separated string: | |
1767 | In [12]: a.s |
|
1768 | In [12]: a.s | |
1768 | Out[12]: 'setup.py win32_manual_post_install.py' |
|
1769 | Out[12]: 'setup.py win32_manual_post_install.py' | |
1769 |
|
1770 | |||
1770 | # a.s is useful to pass as a single command line: |
|
1771 | # a.s is useful to pass as a single command line: | |
1771 | In [13]: !wc -l $a.s |
|
1772 | In [13]: !wc -l $a.s | |
1772 | 146 setup.py |
|
1773 | 146 setup.py | |
1773 | 130 win32_manual_post_install.py |
|
1774 | 130 win32_manual_post_install.py | |
1774 | 276 total |
|
1775 | 276 total | |
1775 |
|
1776 | |||
1776 | # while the list form is useful to loop over: |
|
1777 | # while the list form is useful to loop over: | |
1777 | In [14]: for f in a.l: |
|
1778 | In [14]: for f in a.l: | |
1778 | ....: !wc -l $f |
|
1779 | ....: !wc -l $f | |
1779 | ....: |
|
1780 | ....: | |
1780 | 146 setup.py |
|
1781 | 146 setup.py | |
1781 | 130 win32_manual_post_install.py |
|
1782 | 130 win32_manual_post_install.py | |
1782 |
|
1783 | |||
1783 | Similiarly, the lists returned by the -l option are also special, in |
|
1784 | Similiarly, the lists returned by the -l option are also special, in | |
1784 | the sense that you can equally invoke the .s attribute on them to |
|
1785 | the sense that you can equally invoke the .s attribute on them to | |
1785 | automatically get a whitespace-separated string from their contents: |
|
1786 | automatically get a whitespace-separated string from their contents: | |
1786 |
|
1787 | |||
1787 | In [1]: sc -l b=ls *py |
|
1788 | In [1]: sc -l b=ls *py | |
1788 |
|
1789 | |||
1789 | In [2]: b |
|
1790 | In [2]: b | |
1790 | Out[2]: ['setup.py', 'win32_manual_post_install.py'] |
|
1791 | Out[2]: ['setup.py', 'win32_manual_post_install.py'] | |
1791 |
|
1792 | |||
1792 | In [3]: b.s |
|
1793 | In [3]: b.s | |
1793 | Out[3]: 'setup.py win32_manual_post_install.py' |
|
1794 | Out[3]: 'setup.py win32_manual_post_install.py' | |
1794 |
|
1795 | |||
1795 | In summary, both the lists and strings used for ouptut capture have |
|
1796 | In summary, both the lists and strings used for ouptut capture have | |
1796 | the following special attributes: |
|
1797 | the following special attributes: | |
1797 |
|
1798 | |||
1798 | .l (or .list) : value as list. |
|
1799 | .l (or .list) : value as list. | |
1799 | .n (or .nlstr): value as newline-separated string. |
|
1800 | .n (or .nlstr): value as newline-separated string. | |
1800 | .s (or .spstr): value as space-separated string. |
|
1801 | .s (or .spstr): value as space-separated string. | |
1801 |
|
1802 | |||
1802 | **%store**:: |
|
1803 | **%store**:: | |
1803 |
|
1804 | |||
1804 | Lightweight persistence for python variables. |
|
1805 | Lightweight persistence for python variables. | |
1805 |
|
1806 | |||
1806 | Example: |
|
1807 | Example: | |
1807 |
|
1808 | |||
1808 | ville@badger[~]|1> A = ['hello',10,'world']\ |
|
1809 | ville@badger[~]|1> A = ['hello',10,'world']\ | |
1809 | ville@badger[~]|2> %store A\ |
|
1810 | ville@badger[~]|2> %store A\ | |
1810 | ville@badger[~]|3> Exit |
|
1811 | ville@badger[~]|3> Exit | |
1811 |
|
1812 | |||
1812 | (IPython session is closed and started again...) |
|
1813 | (IPython session is closed and started again...) | |
1813 |
|
1814 | |||
1814 | ville@badger:~$ ipython -p pysh\ |
|
1815 | ville@badger:~$ ipython -p pysh\ | |
1815 | ville@badger[~]|1> print A |
|
1816 | ville@badger[~]|1> print A | |
1816 |
|
1817 | |||
1817 | ['hello', 10, 'world'] |
|
1818 | ['hello', 10, 'world'] | |
1818 |
|
1819 | |||
1819 | Usage: |
|
1820 | Usage: | |
1820 |
|
1821 | |||
1821 | %store - Show list of all variables and their current values\ |
|
1822 | %store - Show list of all variables and their current values\ | |
1822 | %store <var> - Store the *current* value of the variable to disk\ |
|
1823 | %store <var> - Store the *current* value of the variable to disk\ | |
1823 | %store -d <var> - Remove the variable and its value from storage\ |
|
1824 | %store -d <var> - Remove the variable and its value from storage\ | |
1824 | %store -z - Remove all variables from storage\ |
|
1825 | %store -z - Remove all variables from storage\ | |
1825 | %store -r - Refresh all variables from store (delete current vals)\ |
|
1826 | %store -r - Refresh all variables from store (delete current vals)\ | |
1826 | %store foo >a.txt - Store value of foo to new file a.txt\ |
|
1827 | %store foo >a.txt - Store value of foo to new file a.txt\ | |
1827 | %store foo >>a.txt - Append value of foo to file a.txt\ |
|
1828 | %store foo >>a.txt - Append value of foo to file a.txt\ | |
1828 |
|
1829 | |||
1829 | It should be noted that if you change the value of a variable, you |
|
1830 | It should be noted that if you change the value of a variable, you | |
1830 | need to %store it again if you want to persist the new value. |
|
1831 | need to %store it again if you want to persist the new value. | |
1831 |
|
1832 | |||
1832 | Note also that the variables will need to be pickleable; most basic |
|
1833 | Note also that the variables will need to be pickleable; most basic | |
1833 | python types can be safely %stored. |
|
1834 | python types can be safely %stored. | |
1834 |
|
1835 | |||
1835 | Also aliases can be %store'd across sessions. |
|
1836 | Also aliases can be %store'd across sessions. | |
1836 |
|
1837 | |||
1837 | **%sx**:: |
|
1838 | **%sx**:: | |
1838 |
|
1839 | |||
1839 | Shell execute - run a shell command and capture its output. |
|
1840 | Shell execute - run a shell command and capture its output. | |
1840 |
|
1841 | |||
1841 | %sx command |
|
1842 | %sx command | |
1842 |
|
1843 | |||
1843 | IPython will run the given command using commands.getoutput(), and |
|
1844 | IPython will run the given command using commands.getoutput(), and | |
1844 | return the result formatted as a list (split on '\n'). Since the |
|
1845 | return the result formatted as a list (split on '\n'). Since the | |
1845 | output is _returned_, it will be stored in ipython's regular output |
|
1846 | output is _returned_, it will be stored in ipython's regular output | |
1846 | cache Out[N] and in the '_N' automatic variables. |
|
1847 | cache Out[N] and in the '_N' automatic variables. | |
1847 |
|
1848 | |||
1848 | Notes: |
|
1849 | Notes: | |
1849 |
|
1850 | |||
1850 | 1) If an input line begins with '!!', then %sx is automatically |
|
1851 | 1) If an input line begins with '!!', then %sx is automatically | |
1851 | invoked. That is, while: |
|
1852 | invoked. That is, while: | |
1852 | !ls |
|
1853 | !ls | |
1853 | causes ipython to simply issue system('ls'), typing |
|
1854 | causes ipython to simply issue system('ls'), typing | |
1854 | !!ls |
|
1855 | !!ls | |
1855 | is a shorthand equivalent to: |
|
1856 | is a shorthand equivalent to: | |
1856 | %sx ls |
|
1857 | %sx ls | |
1857 |
|
1858 | |||
1858 | 2) %sx differs from %sc in that %sx automatically splits into a list, |
|
1859 | 2) %sx differs from %sc in that %sx automatically splits into a list, | |
1859 | like '%sc -l'. The reason for this is to make it as easy as possible |
|
1860 | like '%sc -l'. The reason for this is to make it as easy as possible | |
1860 | to process line-oriented shell output via further python commands. |
|
1861 | to process line-oriented shell output via further python commands. | |
1861 | %sc is meant to provide much finer control, but requires more |
|
1862 | %sc is meant to provide much finer control, but requires more | |
1862 | typing. |
|
1863 | typing. | |
1863 |
|
1864 | |||
1864 | 3) Just like %sc -l, this is a list with special attributes: |
|
1865 | 3) Just like %sc -l, this is a list with special attributes: | |
1865 |
|
1866 | |||
1866 | .l (or .list) : value as list. |
|
1867 | .l (or .list) : value as list. | |
1867 | .n (or .nlstr): value as newline-separated string. |
|
1868 | .n (or .nlstr): value as newline-separated string. | |
1868 | .s (or .spstr): value as whitespace-separated string. |
|
1869 | .s (or .spstr): value as whitespace-separated string. | |
1869 |
|
1870 | |||
1870 | This is very useful when trying to use such lists as arguments to |
|
1871 | This is very useful when trying to use such lists as arguments to | |
1871 | system commands. |
|
1872 | system commands. | |
1872 |
|
1873 | |||
1873 | **%system_verbose**:: |
|
1874 | **%system_verbose**:: | |
1874 |
|
1875 | |||
1875 | Set verbose printing of system calls. |
|
1876 | Set verbose printing of system calls. | |
1876 |
|
1877 | |||
1877 | If called without an argument, act as a toggle |
|
1878 | If called without an argument, act as a toggle | |
1878 |
|
1879 | |||
1879 | **%time**:: |
|
1880 | **%time**:: | |
1880 |
|
1881 | |||
1881 | Time execution of a Python statement or expression. |
|
1882 | Time execution of a Python statement or expression. | |
1882 |
|
1883 | |||
1883 | The CPU and wall clock times are printed, and the value of the |
|
1884 | The CPU and wall clock times are printed, and the value of the | |
1884 | expression (if any) is returned. Note that under Win32, system time |
|
1885 | expression (if any) is returned. Note that under Win32, system time | |
1885 | is always reported as 0, since it can not be measured. |
|
1886 | is always reported as 0, since it can not be measured. | |
1886 |
|
1887 | |||
1887 | This function provides very basic timing functionality. In Python |
|
1888 | This function provides very basic timing functionality. In Python | |
1888 | 2.3, the timeit module offers more control and sophistication, so this |
|
1889 | 2.3, the timeit module offers more control and sophistication, so this | |
1889 | could be rewritten to use it (patches welcome). |
|
1890 | could be rewritten to use it (patches welcome). | |
1890 |
|
1891 | |||
1891 | Some examples: |
|
1892 | Some examples: | |
1892 |
|
1893 | |||
1893 | In [1]: time 2**128 |
|
1894 | In [1]: time 2**128 | |
1894 | CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s |
|
1895 | CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s | |
1895 | Wall time: 0.00 |
|
1896 | Wall time: 0.00 | |
1896 | Out[1]: 340282366920938463463374607431768211456L |
|
1897 | Out[1]: 340282366920938463463374607431768211456L | |
1897 |
|
1898 | |||
1898 | In [2]: n = 1000000 |
|
1899 | In [2]: n = 1000000 | |
1899 |
|
1900 | |||
1900 | In [3]: time sum(range(n)) |
|
1901 | In [3]: time sum(range(n)) | |
1901 | CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s |
|
1902 | CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s | |
1902 | Wall time: 1.37 |
|
1903 | Wall time: 1.37 | |
1903 | Out[3]: 499999500000L |
|
1904 | Out[3]: 499999500000L | |
1904 |
|
1905 | |||
1905 | In [4]: time print 'hello world' |
|
1906 | In [4]: time print 'hello world' | |
1906 | hello world |
|
1907 | hello world | |
1907 | CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s |
|
1908 | CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s | |
1908 | Wall time: 0.00 |
|
1909 | Wall time: 0.00 | |
1909 |
|
1910 | |||
1910 | Note that the time needed by Python to compile the given expression |
|
1911 | Note that the time needed by Python to compile the given expression | |
1911 | will be reported if it is more than 0.1s. In this example, the |
|
1912 | will be reported if it is more than 0.1s. In this example, the | |
1912 | actual exponentiation is done by Python at compilation time, so while |
|
1913 | actual exponentiation is done by Python at compilation time, so while | |
1913 | the expression can take a noticeable amount of time to compute, that |
|
1914 | the expression can take a noticeable amount of time to compute, that | |
1914 | time is purely due to the compilation: |
|
1915 | time is purely due to the compilation: | |
1915 |
|
1916 | |||
1916 | In [5]: time 3**9999; |
|
1917 | In [5]: time 3**9999; | |
1917 | CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s |
|
1918 | CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s | |
1918 | Wall time: 0.00 s |
|
1919 | Wall time: 0.00 s | |
1919 |
|
1920 | |||
1920 | In [6]: time 3**999999; |
|
1921 | In [6]: time 3**999999; | |
1921 | CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s |
|
1922 | CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s | |
1922 | Wall time: 0.00 s |
|
1923 | Wall time: 0.00 s | |
1923 | Compiler : 0.78 s |
|
1924 | Compiler : 0.78 s | |
1924 |
|
1925 | |||
1925 | **%timeit**:: |
|
1926 | **%timeit**:: | |
1926 |
|
1927 | |||
1927 | Time execution of a Python statement or expression |
|
1928 | Time execution of a Python statement or expression | |
1928 |
|
1929 | |||
1929 | Usage:\ |
|
1930 | Usage:\ | |
1930 | %timeit [-n<N> -r<R> [-t|-c]] statement |
|
1931 | %timeit [-n<N> -r<R> [-t|-c]] statement | |
1931 |
|
1932 | |||
1932 | Time execution of a Python statement or expression using the timeit |
|
1933 | Time execution of a Python statement or expression using the timeit | |
1933 | module. |
|
1934 | module. | |
1934 |
|
1935 | |||
1935 | Options: |
|
1936 | Options: | |
1936 | -n<N>: execute the given statement <N> times in a loop. If this value |
|
1937 | -n<N>: execute the given statement <N> times in a loop. If this value | |
1937 | is not given, a fitting value is chosen. |
|
1938 | is not given, a fitting value is chosen. | |
1938 |
|
1939 | |||
1939 | -r<R>: repeat the loop iteration <R> times and take the best result. |
|
1940 | -r<R>: repeat the loop iteration <R> times and take the best result. | |
1940 | Default: 3 |
|
1941 | Default: 3 | |
1941 |
|
1942 | |||
1942 | -t: use time.time to measure the time, which is the default on Unix. |
|
1943 | -t: use time.time to measure the time, which is the default on Unix. | |
1943 | This function measures wall time. |
|
1944 | This function measures wall time. | |
1944 |
|
1945 | |||
1945 | -c: use time.clock to measure the time, which is the default on |
|
1946 | -c: use time.clock to measure the time, which is the default on | |
1946 | Windows and measures wall time. On Unix, resource.getrusage is used |
|
1947 | Windows and measures wall time. On Unix, resource.getrusage is used | |
1947 | instead and returns the CPU user time. |
|
1948 | instead and returns the CPU user time. | |
1948 |
|
1949 | |||
1949 | -p<P>: use a precision of <P> digits to display the timing result. |
|
1950 | -p<P>: use a precision of <P> digits to display the timing result. | |
1950 | Default: 3 |
|
1951 | Default: 3 | |
1951 |
|
1952 | |||
1952 |
|
1953 | |||
1953 | Examples:\ |
|
1954 | Examples:\ | |
1954 | In [1]: %timeit pass |
|
1955 | In [1]: %timeit pass | |
1955 | 10000000 loops, best of 3: 53.3 ns per loop |
|
1956 | 10000000 loops, best of 3: 53.3 ns per loop | |
1956 |
|
1957 | |||
1957 | In [2]: u = None |
|
1958 | In [2]: u = None | |
1958 |
|
1959 | |||
1959 | In [3]: %timeit u is None |
|
1960 | In [3]: %timeit u is None | |
1960 | 10000000 loops, best of 3: 184 ns per loop |
|
1961 | 10000000 loops, best of 3: 184 ns per loop | |
1961 |
|
1962 | |||
1962 | In [4]: %timeit -r 4 u == None |
|
1963 | In [4]: %timeit -r 4 u == None | |
1963 | 1000000 loops, best of 4: 242 ns per loop |
|
1964 | 1000000 loops, best of 4: 242 ns per loop | |
1964 |
|
1965 | |||
1965 | In [5]: import time |
|
1966 | In [5]: import time | |
1966 |
|
1967 | |||
1967 | In [6]: %timeit -n1 time.sleep(2) |
|
1968 | In [6]: %timeit -n1 time.sleep(2) | |
1968 | 1 loops, best of 3: 2 s per loop |
|
1969 | 1 loops, best of 3: 2 s per loop | |
1969 |
|
1970 | |||
1970 |
|
1971 | |||
1971 | The times reported by %timeit will be slightly higher than those |
|
1972 | The times reported by %timeit will be slightly higher than those | |
1972 | reported by the timeit.py script when variables are accessed. This is |
|
1973 | reported by the timeit.py script when variables are accessed. This is | |
1973 | due to the fact that %timeit executes the statement in the namespace |
|
1974 | due to the fact that %timeit executes the statement in the namespace | |
1974 | of the shell, compared with timeit.py, which uses a single setup |
|
1975 | of the shell, compared with timeit.py, which uses a single setup | |
1975 | statement to import function or create variables. Generally, the bias |
|
1976 | statement to import function or create variables. Generally, the bias | |
1976 | does not matter as long as results from timeit.py are not mixed with |
|
1977 | does not matter as long as results from timeit.py are not mixed with | |
1977 | those from %timeit. |
|
1978 | those from %timeit. | |
1978 |
|
1979 | |||
1979 | **%unalias**:: |
|
1980 | **%unalias**:: | |
1980 |
|
1981 | |||
1981 | Remove an alias |
|
1982 | Remove an alias | |
1982 |
|
1983 | |||
1983 | **%upgrade**:: |
|
1984 | **%upgrade**:: | |
1984 |
|
1985 | |||
1985 | Upgrade your IPython installation |
|
1986 | Upgrade your IPython installation | |
1986 |
|
1987 | |||
1987 | This will copy the config files that don't yet exist in your |
|
1988 | This will copy the config files that don't yet exist in your | |
1988 | ipython dir from the system config dir. Use this after upgrading |
|
1989 | ipython dir from the system config dir. Use this after upgrading | |
1989 | IPython if you don't wish to delete your .ipython dir. |
|
1990 | IPython if you don't wish to delete your .ipython dir. | |
1990 |
|
1991 | |||
1991 | Call with -nolegacy to get rid of ipythonrc* files (recommended for |
|
1992 | Call with -nolegacy to get rid of ipythonrc* files (recommended for | |
1992 | new users) |
|
1993 | new users) | |
1993 |
|
1994 | |||
1994 | **%which**:: |
|
1995 | **%which**:: | |
1995 |
|
1996 | |||
1996 | %which <cmd> => search PATH for files matching cmd. Also scans aliases. |
|
1997 | %which <cmd> => search PATH for files matching cmd. Also scans aliases. | |
1997 |
|
1998 | |||
1998 | Traverses PATH and prints all files (not just executables!) that match the |
|
1999 | Traverses PATH and prints all files (not just executables!) that match the | |
1999 | pattern on command line. Probably more useful in finding stuff |
|
2000 | pattern on command line. Probably more useful in finding stuff | |
2000 | interactively than 'which', which only prints the first matching item. |
|
2001 | interactively than 'which', which only prints the first matching item. | |
2001 |
|
2002 | |||
2002 | Also discovers and expands aliases, so you'll see what will be executed |
|
2003 | Also discovers and expands aliases, so you'll see what will be executed | |
2003 | when you call an alias. |
|
2004 | when you call an alias. | |
2004 |
|
2005 | |||
2005 | Example: |
|
2006 | Example: | |
2006 |
|
2007 | |||
2007 | [~]|62> %which d |
|
2008 | [~]|62> %which d | |
2008 | d -> ls -F --color=auto |
|
2009 | d -> ls -F --color=auto | |
2009 | == c:\cygwin\bin\ls.exe |
|
2010 | == c:\cygwin\bin\ls.exe | |
2010 | c:\cygwin\bin\d.exe |
|
2011 | c:\cygwin\bin\d.exe | |
2011 |
|
2012 | |||
2012 | [~]|64> %which diff* |
|
2013 | [~]|64> %which diff* | |
2013 | diff3 -> diff3 |
|
2014 | diff3 -> diff3 | |
2014 | == c:\cygwin\bin\diff3.exe |
|
2015 | == c:\cygwin\bin\diff3.exe | |
2015 | diff -> diff |
|
2016 | diff -> diff | |
2016 | == c:\cygwin\bin\diff.exe |
|
2017 | == c:\cygwin\bin\diff.exe | |
2017 | c:\cygwin\bin\diff.exe |
|
2018 | c:\cygwin\bin\diff.exe | |
2018 | c:\cygwin\bin\diff3.exe |
|
2019 | c:\cygwin\bin\diff3.exe | |
2019 |
|
2020 | |||
2020 | **%who**:: |
|
2021 | **%who**:: | |
2021 |
|
2022 | |||
2022 | Print all interactive variables, with some minimal formatting. |
|
2023 | Print all interactive variables, with some minimal formatting. | |
2023 |
|
2024 | |||
2024 | If any arguments are given, only variables whose type matches one of |
|
2025 | If any arguments are given, only variables whose type matches one of | |
2025 | these are printed. For example: |
|
2026 | these are printed. For example: | |
2026 |
|
2027 | |||
2027 | %who function str |
|
2028 | %who function str | |
2028 |
|
2029 | |||
2029 | will only list functions and strings, excluding all other types of |
|
2030 | will only list functions and strings, excluding all other types of | |
2030 | variables. To find the proper type names, simply use type(var) at a |
|
2031 | variables. To find the proper type names, simply use type(var) at a | |
2031 | command line to see how python prints type names. For example: |
|
2032 | command line to see how python prints type names. For example: | |
2032 |
|
2033 | |||
2033 | In [1]: type('hello')\ |
|
2034 | In [1]: type('hello')\ | |
2034 | Out[1]: <type 'str'> |
|
2035 | Out[1]: <type 'str'> | |
2035 |
|
2036 | |||
2036 | indicates that the type name for strings is 'str'. |
|
2037 | indicates that the type name for strings is 'str'. | |
2037 |
|
2038 | |||
2038 | %who always excludes executed names loaded through your configuration |
|
2039 | %who always excludes executed names loaded through your configuration | |
2039 | file and things which are internal to IPython. |
|
2040 | file and things which are internal to IPython. | |
2040 |
|
2041 | |||
2041 | This is deliberate, as typically you may load many modules and the |
|
2042 | This is deliberate, as typically you may load many modules and the | |
2042 | purpose of %who is to show you only what you've manually defined. |
|
2043 | purpose of %who is to show you only what you've manually defined. | |
2043 |
|
2044 | |||
2044 | **%who_ls**:: |
|
2045 | **%who_ls**:: | |
2045 |
|
2046 | |||
2046 | Return a sorted list of all interactive variables. |
|
2047 | Return a sorted list of all interactive variables. | |
2047 |
|
2048 | |||
2048 | If arguments are given, only variables of types matching these |
|
2049 | If arguments are given, only variables of types matching these | |
2049 | arguments are returned. |
|
2050 | arguments are returned. | |
2050 |
|
2051 | |||
2051 | **%whos**:: |
|
2052 | **%whos**:: | |
2052 |
|
2053 | |||
2053 | Like %who, but gives some extra information about each variable. |
|
2054 | Like %who, but gives some extra information about each variable. | |
2054 |
|
2055 | |||
2055 | The same type filtering of %who can be applied here. |
|
2056 | The same type filtering of %who can be applied here. | |
2056 |
|
2057 | |||
2057 | For all variables, the type is printed. Additionally it prints: |
|
2058 | For all variables, the type is printed. Additionally it prints: | |
2058 |
|
2059 | |||
2059 | - For {},[],(): their length. |
|
2060 | - For {},[],(): their length. | |
2060 |
|
2061 | |||
2061 | - For numpy and Numeric arrays, a summary with shape, number of |
|
2062 | - For numpy and Numeric arrays, a summary with shape, number of | |
2062 | elements, typecode and size in memory. |
|
2063 | elements, typecode and size in memory. | |
2063 |
|
2064 | |||
2064 | - Everything else: a string representation, snipping their middle if |
|
2065 | - Everything else: a string representation, snipping their middle if | |
2065 | too long. |
|
2066 | too long. | |
2066 |
|
2067 | |||
2067 | **%xmode**:: |
|
2068 | **%xmode**:: | |
2068 |
|
2069 | |||
2069 | Switch modes for the exception handlers. |
|
2070 | Switch modes for the exception handlers. | |
2070 |
|
2071 | |||
2071 | Valid modes: Plain, Context and Verbose. |
|
2072 | Valid modes: Plain, Context and Verbose. | |
2072 |
|
2073 | |||
2073 | If called without arguments, acts as a toggle. |
|
2074 | If called without arguments, acts as a toggle. | |
2074 |
|
2075 | |||
2075 | .. magic_end |
|
2076 | .. magic_end | |
2076 |
|
2077 | |||
2077 | Access to the standard Python help |
|
2078 | Access to the standard Python help | |
2078 | ---------------------------------- |
|
2079 | ---------------------------------- | |
2079 |
|
2080 | |||
2080 | As of Python 2.1, a help system is available with access to object |
|
2081 | As of Python 2.1, a help system is available with access to object docstrings | |
2081 |
|
|
2082 | and the Python manuals. Simply type 'help' (no quotes) to access it. You can | |
2082 |
|
|
2083 | also type help(object) to obtain information about a given object, and | |
2083 |
|
|
2084 | help('keyword') for information on a keyword. As noted :ref:`here | |
2084 |
|
|
2085 | <accessing_help>`, you need to properly configure your environment variable | |
2085 |
|
|
2086 | PYTHONDOCS for this feature to work correctly. | |
2086 |
|
2087 | |||
|
2088 | .. _dynamic_object_info: | |||
2087 |
|
2089 | |||
2088 | Dynamic object information |
|
2090 | Dynamic object information | |
2089 | -------------------------- |
|
2091 | -------------------------- | |
2090 |
|
2092 | |||
2091 | Typing ?word or word? prints detailed information about an object. If |
|
2093 | Typing ?word or word? prints detailed information about an object. If | |
2092 | certain strings in the object are too long (docstrings, code, etc.) they |
|
2094 | certain strings in the object are too long (docstrings, code, etc.) they | |
2093 | get snipped in the center for brevity. This system gives access variable |
|
2095 | get snipped in the center for brevity. This system gives access variable | |
2094 | types and values, full source code for any object (if available), |
|
2096 | types and values, full source code for any object (if available), | |
2095 | function prototypes and other useful information. |
|
2097 | function prototypes and other useful information. | |
2096 |
|
2098 | |||
2097 | Typing ??word or word?? gives access to the full information without |
|
2099 | Typing ??word or word?? gives access to the full information without | |
2098 | snipping long strings. Long strings are sent to the screen through the |
|
2100 | snipping long strings. Long strings are sent to the screen through the | |
2099 | less pager if longer than the screen and printed otherwise. On systems |
|
2101 | less pager if longer than the screen and printed otherwise. On systems | |
2100 | lacking the less command, IPython uses a very basic internal pager. |
|
2102 | lacking the less command, IPython uses a very basic internal pager. | |
2101 |
|
2103 | |||
2102 | The following magic functions are particularly useful for gathering |
|
2104 | The following magic functions are particularly useful for gathering | |
2103 | information about your working environment. You can get more details by |
|
2105 | information about your working environment. You can get more details by | |
2104 | typing %magic or querying them individually (use %function_name? with or |
|
2106 | typing %magic or querying them individually (use %function_name? with or | |
2105 | without the %), this is just a summary: |
|
2107 | without the %), this is just a summary: | |
2106 |
|
2108 | |||
2107 | * **%pdoc <object>**: Print (or run through a pager if too long) the |
|
2109 | * **%pdoc <object>**: Print (or run through a pager if too long) the | |
2108 | docstring for an object. If the given object is a class, it will |
|
2110 | docstring for an object. If the given object is a class, it will | |
2109 | print both the class and the constructor docstrings. |
|
2111 | print both the class and the constructor docstrings. | |
2110 | * **%pdef <object>**: Print the definition header for any callable |
|
2112 | * **%pdef <object>**: Print the definition header for any callable | |
2111 | object. If the object is a class, print the constructor information. |
|
2113 | object. If the object is a class, print the constructor information. | |
2112 | * **%psource <object>**: Print (or run through a pager if too long) |
|
2114 | * **%psource <object>**: Print (or run through a pager if too long) | |
2113 | the source code for an object. |
|
2115 | the source code for an object. | |
2114 | * **%pfile <object>**: Show the entire source file where an object was |
|
2116 | * **%pfile <object>**: Show the entire source file where an object was | |
2115 | defined via a pager, opening it at the line where the object |
|
2117 | defined via a pager, opening it at the line where the object | |
2116 | definition begins. |
|
2118 | definition begins. | |
2117 | * **%who/%whos**: These functions give information about identifiers |
|
2119 | * **%who/%whos**: These functions give information about identifiers | |
2118 | you have defined interactively (not things you loaded or defined |
|
2120 | you have defined interactively (not things you loaded or defined | |
2119 | in your configuration files). %who just prints a list of |
|
2121 | in your configuration files). %who just prints a list of | |
2120 | identifiers and %whos prints a table with some basic details about |
|
2122 | identifiers and %whos prints a table with some basic details about | |
2121 | each identifier. |
|
2123 | each identifier. | |
2122 |
|
2124 | |||
2123 | Note that the dynamic object information functions (?/??, %pdoc, %pfile, |
|
2125 | Note that the dynamic object information functions (?/??, %pdoc, %pfile, | |
2124 | %pdef, %psource) give you access to documentation even on things which |
|
2126 | %pdef, %psource) give you access to documentation even on things which | |
2125 | are not really defined as separate identifiers. Try for example typing |
|
2127 | are not really defined as separate identifiers. Try for example typing | |
2126 | {}.get? or after doing import os, type os.path.abspath??. |
|
2128 | {}.get? or after doing import os, type os.path.abspath??. | |
2127 |
|
2129 | |||
2128 |
|
2130 | |||
2129 |
.. _ |
|
2131 | .. _readline: | |
2130 |
|
2132 | |||
2131 | Readline-based features |
|
2133 | Readline-based features | |
2132 | ----------------------- |
|
2134 | ----------------------- | |
2133 |
|
2135 | |||
2134 | These features require the GNU readline library, so they won't work if |
|
2136 | These features require the GNU readline library, so they won't work if | |
2135 | your Python installation lacks readline support. We will first describe |
|
2137 | your Python installation lacks readline support. We will first describe | |
2136 | the default behavior IPython uses, and then how to change it to suit |
|
2138 | the default behavior IPython uses, and then how to change it to suit | |
2137 | your preferences. |
|
2139 | your preferences. | |
2138 |
|
2140 | |||
2139 |
|
2141 | |||
2140 | Command line completion |
|
2142 | Command line completion | |
2141 | +++++++++++++++++++++++ |
|
2143 | +++++++++++++++++++++++ | |
2142 |
|
2144 | |||
2143 | At any time, hitting TAB will complete any available python commands or |
|
2145 | At any time, hitting TAB will complete any available python commands or | |
2144 | variable names, and show you a list of the possible completions if |
|
2146 | variable names, and show you a list of the possible completions if | |
2145 | there's no unambiguous one. It will also complete filenames in the |
|
2147 | there's no unambiguous one. It will also complete filenames in the | |
2146 | current directory if no python names match what you've typed so far. |
|
2148 | current directory if no python names match what you've typed so far. | |
2147 |
|
2149 | |||
2148 |
|
2150 | |||
2149 | Search command history |
|
2151 | Search command history | |
2150 | ++++++++++++++++++++++ |
|
2152 | ++++++++++++++++++++++ | |
2151 |
|
2153 | |||
2152 | IPython provides two ways for searching through previous input and thus |
|
2154 | IPython provides two ways for searching through previous input and thus | |
2153 | reduce the need for repetitive typing: |
|
2155 | reduce the need for repetitive typing: | |
2154 |
|
2156 | |||
2155 | 1. Start typing, and then use Ctrl-p (previous,up) and Ctrl-n |
|
2157 | 1. Start typing, and then use Ctrl-p (previous,up) and Ctrl-n | |
2156 | (next,down) to search through only the history items that match |
|
2158 | (next,down) to search through only the history items that match | |
2157 | what you've typed so far. If you use Ctrl-p/Ctrl-n at a blank |
|
2159 | what you've typed so far. If you use Ctrl-p/Ctrl-n at a blank | |
2158 | prompt, they just behave like normal arrow keys. |
|
2160 | prompt, they just behave like normal arrow keys. | |
2159 | 2. Hit Ctrl-r: opens a search prompt. Begin typing and the system |
|
2161 | 2. Hit Ctrl-r: opens a search prompt. Begin typing and the system | |
2160 | searches your history for lines that contain what you've typed so |
|
2162 | searches your history for lines that contain what you've typed so | |
2161 | far, completing as much as it can. |
|
2163 | far, completing as much as it can. | |
2162 |
|
2164 | |||
2163 |
|
2165 | |||
2164 | Persistent command history across sessions |
|
2166 | Persistent command history across sessions | |
2165 | ++++++++++++++++++++++++++++++++++++++++++ |
|
2167 | ++++++++++++++++++++++++++++++++++++++++++ | |
2166 |
|
2168 | |||
2167 | IPython will save your input history when it leaves and reload it next |
|
2169 | IPython will save your input history when it leaves and reload it next | |
2168 | time you restart it. By default, the history file is named |
|
2170 | time you restart it. By default, the history file is named | |
2169 | $IPYTHONDIR/history, but if you've loaded a named profile, |
|
2171 | $IPYTHONDIR/history, but if you've loaded a named profile, | |
2170 | '-PROFILE_NAME' is appended to the name. This allows you to keep |
|
2172 | '-PROFILE_NAME' is appended to the name. This allows you to keep | |
2171 | separate histories related to various tasks: commands related to |
|
2173 | separate histories related to various tasks: commands related to | |
2172 | numerical work will not be clobbered by a system shell history, for |
|
2174 | numerical work will not be clobbered by a system shell history, for | |
2173 | example. |
|
2175 | example. | |
2174 |
|
2176 | |||
2175 |
|
2177 | |||
2176 | Autoindent |
|
2178 | Autoindent | |
2177 | ++++++++++ |
|
2179 | ++++++++++ | |
2178 |
|
2180 | |||
2179 | IPython can recognize lines ending in ':' and indent the next line, |
|
2181 | IPython can recognize lines ending in ':' and indent the next line, | |
2180 | while also un-indenting automatically after 'raise' or 'return'. |
|
2182 | while also un-indenting automatically after 'raise' or 'return'. | |
2181 |
|
2183 | |||
2182 | This feature uses the readline library, so it will honor your ~/.inputrc |
|
2184 | This feature uses the readline library, so it will honor your ~/.inputrc | |
2183 | configuration (or whatever file your INPUTRC variable points to). Adding |
|
2185 | configuration (or whatever file your INPUTRC variable points to). Adding | |
2184 | the following lines to your .inputrc file can make indenting/unindenting |
|
2186 | the following lines to your .inputrc file can make indenting/unindenting | |
2185 | more convenient (M-i indents, M-u unindents):: |
|
2187 | more convenient (M-i indents, M-u unindents):: | |
2186 |
|
2188 | |||
2187 | $if Python |
|
2189 | $if Python | |
2188 | "\M-i": " " |
|
2190 | "\M-i": " " | |
2189 | "\M-u": "\d\d\d\d" |
|
2191 | "\M-u": "\d\d\d\d" | |
2190 | $endif |
|
2192 | $endif | |
2191 |
|
2193 | |||
2192 | Note that there are 4 spaces between the quote marks after "M-i" above. |
|
2194 | Note that there are 4 spaces between the quote marks after "M-i" above. | |
2193 |
|
2195 | |||
2194 | Warning: this feature is ON by default, but it can cause problems with |
|
2196 | Warning: this feature is ON by default, but it can cause problems with | |
2195 | the pasting of multi-line indented code (the pasted code gets |
|
2197 | the pasting of multi-line indented code (the pasted code gets | |
2196 | re-indented on each line). A magic function %autoindent allows you to |
|
2198 | re-indented on each line). A magic function %autoindent allows you to | |
2197 | toggle it on/off at runtime. You can also disable it permanently on in |
|
2199 | toggle it on/off at runtime. You can also disable it permanently on in | |
2198 | your ipythonrc file (set autoindent 0). |
|
2200 | your ipythonrc file (set autoindent 0). | |
2199 |
|
2201 | |||
2200 |
|
2202 | |||
2201 | Customizing readline behavior |
|
2203 | Customizing readline behavior | |
2202 | +++++++++++++++++++++++++++++ |
|
2204 | +++++++++++++++++++++++++++++ | |
2203 |
|
2205 | |||
2204 | All these features are based on the GNU readline library, which has an |
|
2206 | All these features are based on the GNU readline library, which has an | |
2205 | extremely customizable interface. Normally, readline is configured via a |
|
2207 | extremely customizable interface. Normally, readline is configured via a | |
2206 | file which defines the behavior of the library; the details of the |
|
2208 | file which defines the behavior of the library; the details of the | |
2207 | syntax for this can be found in the readline documentation available |
|
2209 | syntax for this can be found in the readline documentation available | |
2208 | with your system or on the Internet. IPython doesn't read this file (if |
|
2210 | with your system or on the Internet. IPython doesn't read this file (if | |
2209 | it exists) directly, but it does support passing to readline valid |
|
2211 | it exists) directly, but it does support passing to readline valid | |
2210 | options via a simple interface. In brief, you can customize readline by |
|
2212 | options via a simple interface. In brief, you can customize readline by | |
2211 | setting the following options in your ipythonrc configuration file (note |
|
2213 | setting the following options in your ipythonrc configuration file (note | |
2212 | that these options can not be specified at the command line): |
|
2214 | that these options can not be specified at the command line): | |
2213 |
|
2215 | |||
2214 | * **readline_parse_and_bind**: this option can appear as many times as |
|
2216 | * **readline_parse_and_bind**: this option can appear as many times as | |
2215 | you want, each time defining a string to be executed via a |
|
2217 | you want, each time defining a string to be executed via a | |
2216 | readline.parse_and_bind() command. The syntax for valid commands |
|
2218 | readline.parse_and_bind() command. The syntax for valid commands | |
2217 | of this kind can be found by reading the documentation for the GNU |
|
2219 | of this kind can be found by reading the documentation for the GNU | |
2218 | readline library, as these commands are of the kind which readline |
|
2220 | readline library, as these commands are of the kind which readline | |
2219 | accepts in its configuration file. |
|
2221 | accepts in its configuration file. | |
2220 | * **readline_remove_delims**: a string of characters to be removed |
|
2222 | * **readline_remove_delims**: a string of characters to be removed | |
2221 | from the default word-delimiters list used by readline, so that |
|
2223 | from the default word-delimiters list used by readline, so that | |
2222 | completions may be performed on strings which contain them. Do not |
|
2224 | completions may be performed on strings which contain them. Do not | |
2223 | change the default value unless you know what you're doing. |
|
2225 | change the default value unless you know what you're doing. | |
2224 | * **readline_omit__names**: when tab-completion is enabled, hitting |
|
2226 | * **readline_omit__names**: when tab-completion is enabled, hitting | |
2225 | <tab> after a '.' in a name will complete all attributes of an |
|
2227 | <tab> after a '.' in a name will complete all attributes of an | |
2226 | object, including all the special methods whose names include |
|
2228 | object, including all the special methods whose names include | |
2227 | double underscores (like __getitem__ or __class__). If you'd |
|
2229 | double underscores (like __getitem__ or __class__). If you'd | |
2228 | rather not see these names by default, you can set this option to |
|
2230 | rather not see these names by default, you can set this option to | |
2229 | 1. Note that even when this option is set, you can still see those |
|
2231 | 1. Note that even when this option is set, you can still see those | |
2230 | names by explicitly typing a _ after the period and hitting <tab>: |
|
2232 | names by explicitly typing a _ after the period and hitting <tab>: | |
2231 | 'name._<tab>' will always complete attribute names starting with '_'. |
|
2233 | 'name._<tab>' will always complete attribute names starting with '_'. | |
2232 |
|
2234 | |||
2233 | This option is off by default so that new users see all |
|
2235 | This option is off by default so that new users see all | |
2234 | attributes of any objects they are dealing with. |
|
2236 | attributes of any objects they are dealing with. | |
2235 |
|
2237 | |||
2236 | You will find the default values along with a corresponding detailed |
|
2238 | You will find the default values along with a corresponding detailed | |
2237 | explanation in your ipythonrc file. |
|
2239 | explanation in your ipythonrc file. | |
2238 |
|
2240 | |||
2239 |
|
2241 | |||
2240 | Session logging and restoring |
|
2242 | Session logging and restoring | |
2241 | ----------------------------- |
|
2243 | ----------------------------- | |
2242 |
|
2244 | |||
2243 | You can log all input from a session either by starting IPython with |
|
2245 | You can log all input from a session either by starting IPython with the | |
2244 |
|
|
2246 | command line switches -log or -logfile (see :ref:`here <command_line_options>`) | |
2245 |
|
|
2247 | or by activating the logging at any moment with the magic function %logstart. | |
2246 | function %logstart. |
|
|||
2247 |
|
2248 | |||
2248 | Log files can later be reloaded with the -logplay option and IPython |
|
2249 | Log files can later be reloaded with the -logplay option and IPython | |
2249 | will attempt to 'replay' the log by executing all the lines in it, thus |
|
2250 | will attempt to 'replay' the log by executing all the lines in it, thus | |
2250 | restoring the state of a previous session. This feature is not quite |
|
2251 | restoring the state of a previous session. This feature is not quite | |
2251 | perfect, but can still be useful in many cases. |
|
2252 | perfect, but can still be useful in many cases. | |
2252 |
|
2253 | |||
2253 | The log files can also be used as a way to have a permanent record of |
|
2254 | The log files can also be used as a way to have a permanent record of | |
2254 | any code you wrote while experimenting. Log files are regular text files |
|
2255 | any code you wrote while experimenting. Log files are regular text files | |
2255 | which you can later open in your favorite text editor to extract code or |
|
2256 | which you can later open in your favorite text editor to extract code or | |
2256 | to 'clean them up' before using them to replay a session. |
|
2257 | to 'clean them up' before using them to replay a session. | |
2257 |
|
2258 | |||
2258 | The %logstart function for activating logging in mid-session is used as |
|
2259 | The %logstart function for activating logging in mid-session is used as | |
2259 | follows: |
|
2260 | follows: | |
2260 |
|
2261 | |||
2261 | %logstart [log_name [log_mode]] |
|
2262 | %logstart [log_name [log_mode]] | |
2262 |
|
2263 | |||
2263 | If no name is given, it defaults to a file named 'log' in your |
|
2264 | If no name is given, it defaults to a file named 'log' in your | |
2264 | IPYTHONDIR directory, in 'rotate' mode (see below). |
|
2265 | IPYTHONDIR directory, in 'rotate' mode (see below). | |
2265 |
|
2266 | |||
2266 | '%logstart name' saves to file 'name' in 'backup' mode. It saves your |
|
2267 | '%logstart name' saves to file 'name' in 'backup' mode. It saves your | |
2267 | history up to that point and then continues logging. |
|
2268 | history up to that point and then continues logging. | |
2268 |
|
2269 | |||
2269 | %logstart takes a second optional parameter: logging mode. This can be |
|
2270 | %logstart takes a second optional parameter: logging mode. This can be | |
2270 | one of (note that the modes are given unquoted): |
|
2271 | one of (note that the modes are given unquoted): | |
2271 |
|
2272 | |||
2272 | * [over:] overwrite existing log_name. |
|
2273 | * [over:] overwrite existing log_name. | |
2273 | * [backup:] rename (if exists) to log_name~ and start log_name. |
|
2274 | * [backup:] rename (if exists) to log_name~ and start log_name. | |
2274 | * [append:] well, that says it. |
|
2275 | * [append:] well, that says it. | |
2275 | * [rotate:] create rotating logs log_name.1~, log_name.2~, etc. |
|
2276 | * [rotate:] create rotating logs log_name.1~, log_name.2~, etc. | |
2276 |
|
2277 | |||
2277 | The %logoff and %logon functions allow you to temporarily stop and |
|
2278 | The %logoff and %logon functions allow you to temporarily stop and | |
2278 | resume logging to a file which had previously been started with |
|
2279 | resume logging to a file which had previously been started with | |
2279 | %logstart. They will fail (with an explanation) if you try to use them |
|
2280 | %logstart. They will fail (with an explanation) if you try to use them | |
2280 | before logging has been started. |
|
2281 | before logging has been started. | |
2281 |
|
2282 | |||
|
2283 | .. _system_shell_access: | |||
|
2284 | ||||
2282 | System shell access |
|
2285 | System shell access | |
2283 | ------------------- |
|
2286 | ------------------- | |
2284 |
|
2287 | |||
2285 | Any input line beginning with a ! character is passed verbatim (minus |
|
2288 | Any input line beginning with a ! character is passed verbatim (minus | |
2286 | the !, of course) to the underlying operating system. For example, |
|
2289 | the !, of course) to the underlying operating system. For example, | |
2287 | typing !ls will run 'ls' in the current directory. |
|
2290 | typing !ls will run 'ls' in the current directory. | |
2288 |
|
2291 | |||
2289 | Manual capture of command output |
|
2292 | Manual capture of command output | |
2290 | -------------------------------- |
|
2293 | -------------------------------- | |
2291 |
|
2294 | |||
2292 | If the input line begins with two exclamation marks, !!, the command is |
|
2295 | If the input line begins with two exclamation marks, !!, the command is | |
2293 | executed but its output is captured and returned as a python list, split |
|
2296 | executed but its output is captured and returned as a python list, split | |
2294 | on newlines. Any output sent by the subprocess to standard error is |
|
2297 | on newlines. Any output sent by the subprocess to standard error is | |
2295 | printed separately, so that the resulting list only captures standard |
|
2298 | printed separately, so that the resulting list only captures standard | |
2296 | output. The !! syntax is a shorthand for the %sx magic command. |
|
2299 | output. The !! syntax is a shorthand for the %sx magic command. | |
2297 |
|
2300 | |||
2298 | Finally, the %sc magic (short for 'shell capture') is similar to %sx, |
|
2301 | Finally, the %sc magic (short for 'shell capture') is similar to %sx, | |
2299 | but allowing more fine-grained control of the capture details, and |
|
2302 | but allowing more fine-grained control of the capture details, and | |
2300 | storing the result directly into a named variable. The direct use of |
|
2303 | storing the result directly into a named variable. The direct use of | |
2301 | %sc is now deprecated, and you should ise the ``var = !cmd`` syntax |
|
2304 | %sc is now deprecated, and you should ise the ``var = !cmd`` syntax | |
2302 | instead. |
|
2305 | instead. | |
2303 |
|
2306 | |||
2304 | IPython also allows you to expand the value of python variables when |
|
2307 | IPython also allows you to expand the value of python variables when | |
2305 | making system calls. Any python variable or expression which you prepend |
|
2308 | making system calls. Any python variable or expression which you prepend | |
2306 | with $ will get expanded before the system call is made:: |
|
2309 | with $ will get expanded before the system call is made:: | |
2307 |
|
2310 | |||
2308 | In [1]: pyvar='Hello world' |
|
2311 | In [1]: pyvar='Hello world' | |
2309 | In [2]: !echo "A python variable: $pyvar" |
|
2312 | In [2]: !echo "A python variable: $pyvar" | |
2310 | A python variable: Hello world |
|
2313 | A python variable: Hello world | |
2311 |
|
2314 | |||
2312 | If you want the shell to actually see a literal $, you need to type it |
|
2315 | If you want the shell to actually see a literal $, you need to type it | |
2313 | twice:: |
|
2316 | twice:: | |
2314 |
|
2317 | |||
2315 | In [3]: !echo "A system variable: $$HOME" |
|
2318 | In [3]: !echo "A system variable: $$HOME" | |
2316 | A system variable: /home/fperez |
|
2319 | A system variable: /home/fperez | |
2317 |
|
2320 | |||
2318 | You can pass arbitrary expressions, though you'll need to delimit them |
|
2321 | You can pass arbitrary expressions, though you'll need to delimit them | |
2319 | with {} if there is ambiguity as to the extent of the expression:: |
|
2322 | with {} if there is ambiguity as to the extent of the expression:: | |
2320 |
|
2323 | |||
2321 | In [5]: x=10 |
|
2324 | In [5]: x=10 | |
2322 | In [6]: y=20 |
|
2325 | In [6]: y=20 | |
2323 | In [13]: !echo $x+y |
|
2326 | In [13]: !echo $x+y | |
2324 | 10+y |
|
2327 | 10+y | |
2325 | In [7]: !echo ${x+y} |
|
2328 | In [7]: !echo ${x+y} | |
2326 | 30 |
|
2329 | 30 | |
2327 |
|
2330 | |||
2328 | Even object attributes can be expanded:: |
|
2331 | Even object attributes can be expanded:: | |
2329 |
|
2332 | |||
2330 | In [12]: !echo $sys.argv |
|
2333 | In [12]: !echo $sys.argv | |
2331 | [/home/fperez/usr/bin/ipython] |
|
2334 | [/home/fperez/usr/bin/ipython] | |
2332 |
|
2335 | |||
2333 |
|
2336 | |||
2334 | System command aliases |
|
2337 | System command aliases | |
2335 | ---------------------- |
|
2338 | ---------------------- | |
2336 |
|
2339 | |||
2337 | The %alias magic function and the alias option in the ipythonrc |
|
2340 | The %alias magic function and the alias option in the ipythonrc | |
2338 | configuration file allow you to define magic functions which are in fact |
|
2341 | configuration file allow you to define magic functions which are in fact | |
2339 | system shell commands. These aliases can have parameters. |
|
2342 | system shell commands. These aliases can have parameters. | |
2340 |
|
2343 | |||
2341 | '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd' |
|
2344 | '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd' | |
2342 |
|
2345 | |||
2343 | Then, typing '%alias_name params' will execute the system command 'cmd |
|
2346 | Then, typing '%alias_name params' will execute the system command 'cmd | |
2344 | params' (from your underlying operating system). |
|
2347 | params' (from your underlying operating system). | |
2345 |
|
2348 | |||
2346 | You can also define aliases with parameters using %s specifiers (one per |
|
2349 | You can also define aliases with parameters using %s specifiers (one per | |
2347 | parameter). The following example defines the %parts function as an |
|
2350 | parameter). The following example defines the %parts function as an | |
2348 | alias to the command 'echo first %s second %s' where each %s will be |
|
2351 | alias to the command 'echo first %s second %s' where each %s will be | |
2349 | replaced by a positional parameter to the call to %parts:: |
|
2352 | replaced by a positional parameter to the call to %parts:: | |
2350 |
|
2353 | |||
2351 | In [1]: alias parts echo first %s second %s |
|
2354 | In [1]: alias parts echo first %s second %s | |
2352 | In [2]: %parts A B |
|
2355 | In [2]: %parts A B | |
2353 | first A second B |
|
2356 | first A second B | |
2354 | In [3]: %parts A |
|
2357 | In [3]: %parts A | |
2355 | Incorrect number of arguments: 2 expected. |
|
2358 | Incorrect number of arguments: 2 expected. | |
2356 | parts is an alias to: 'echo first %s second %s' |
|
2359 | parts is an alias to: 'echo first %s second %s' | |
2357 |
|
2360 | |||
2358 | If called with no parameters, %alias prints the table of currently |
|
2361 | If called with no parameters, %alias prints the table of currently | |
2359 | defined aliases. |
|
2362 | defined aliases. | |
2360 |
|
2363 | |||
2361 | The %rehash/rehashx magics allow you to load your entire $PATH as |
|
2364 | The %rehash/rehashx magics allow you to load your entire $PATH as | |
2362 | ipython aliases. See their respective docstrings (or sec. 6.2 |
|
2365 | ipython aliases. See their respective docstrings (or sec. 6.2 | |
2363 | <#sec:magic> for further details). |
|
2366 | <#sec:magic> for further details). | |
2364 |
|
2367 | |||
2365 |
|
2368 | |||
2366 | .. _dreload: |
|
2369 | .. _dreload: | |
2367 |
|
2370 | |||
2368 | Recursive reload |
|
2371 | Recursive reload | |
2369 | ---------------- |
|
2372 | ---------------- | |
2370 |
|
2373 | |||
2371 | The dreload function does a recursive reload of a module: changes made |
|
2374 | The dreload function does a recursive reload of a module: changes made | |
2372 | to the module since you imported will actually be available without |
|
2375 | to the module since you imported will actually be available without | |
2373 | having to exit. |
|
2376 | having to exit. | |
2374 |
|
2377 | |||
2375 |
|
2378 | |||
2376 | Verbose and colored exception traceback printouts |
|
2379 | Verbose and colored exception traceback printouts | |
2377 | ------------------------------------------------- |
|
2380 | ------------------------------------------------- | |
2378 |
|
2381 | |||
2379 | IPython provides the option to see very detailed exception tracebacks, |
|
2382 | IPython provides the option to see very detailed exception tracebacks, | |
2380 | which can be especially useful when debugging large programs. You can |
|
2383 | which can be especially useful when debugging large programs. You can | |
2381 | run any Python file with the %run function to benefit from these |
|
2384 | run any Python file with the %run function to benefit from these | |
2382 | detailed tracebacks. Furthermore, both normal and verbose tracebacks can |
|
2385 | detailed tracebacks. Furthermore, both normal and verbose tracebacks can | |
2383 | be colored (if your terminal supports it) which makes them much easier |
|
2386 | be colored (if your terminal supports it) which makes them much easier | |
2384 | to parse visually. |
|
2387 | to parse visually. | |
2385 |
|
2388 | |||
2386 | See the magic xmode and colors functions for details (just type %magic). |
|
2389 | See the magic xmode and colors functions for details (just type %magic). | |
2387 |
|
2390 | |||
2388 | These features are basically a terminal version of Ka-Ping Yee's cgitb |
|
2391 | These features are basically a terminal version of Ka-Ping Yee's cgitb | |
2389 | module, now part of the standard Python library. |
|
2392 | module, now part of the standard Python library. | |
2390 |
|
2393 | |||
2391 |
|
2394 | |||
2392 |
.. _ |
|
2395 | .. _input_caching: | |
2393 |
|
2396 | |||
2394 | Input caching system |
|
2397 | Input caching system | |
2395 | -------------------- |
|
2398 | -------------------- | |
2396 |
|
2399 | |||
2397 | IPython offers numbered prompts (In/Out) with input and output caching. |
|
2400 | IPython offers numbered prompts (In/Out) with input and output caching. | |
2398 | All input is saved and can be retrieved as variables (besides the usual |
|
2401 | All input is saved and can be retrieved as variables (besides the usual | |
2399 | arrow key recall). |
|
2402 | arrow key recall). | |
2400 |
|
2403 | |||
2401 | The following GLOBAL variables always exist (so don't overwrite them!): |
|
2404 | The following GLOBAL variables always exist (so don't overwrite them!): | |
2402 | _i: stores previous input. _ii: next previous. _iii: next-next previous. |
|
2405 | _i: stores previous input. _ii: next previous. _iii: next-next previous. | |
2403 | _ih : a list of all input _ih[n] is the input from line n and this list |
|
2406 | _ih : a list of all input _ih[n] is the input from line n and this list | |
2404 | is aliased to the global variable In. If you overwrite In with a |
|
2407 | is aliased to the global variable In. If you overwrite In with a | |
2405 | variable of your own, you can remake the assignment to the internal list |
|
2408 | variable of your own, you can remake the assignment to the internal list | |
2406 | with a simple 'In=_ih'. |
|
2409 | with a simple 'In=_ih'. | |
2407 |
|
2410 | |||
2408 | Additionally, global variables named _i<n> are dynamically created (<n> |
|
2411 | Additionally, global variables named _i<n> are dynamically created (<n> | |
2409 | being the prompt counter), such that |
|
2412 | being the prompt counter), such that | |
2410 | _i<n> == _ih[<n>] == In[<n>]. |
|
2413 | _i<n> == _ih[<n>] == In[<n>]. | |
2411 |
|
2414 | |||
2412 | For example, what you typed at prompt 14 is available as _i14, _ih[14] |
|
2415 | For example, what you typed at prompt 14 is available as _i14, _ih[14] | |
2413 | and In[14]. |
|
2416 | and In[14]. | |
2414 |
|
2417 | |||
2415 | This allows you to easily cut and paste multi line interactive prompts |
|
2418 | This allows you to easily cut and paste multi line interactive prompts | |
2416 | by printing them out: they print like a clean string, without prompt |
|
2419 | by printing them out: they print like a clean string, without prompt | |
2417 | characters. You can also manipulate them like regular variables (they |
|
2420 | characters. You can also manipulate them like regular variables (they | |
2418 | are strings), modify or exec them (typing 'exec _i9' will re-execute the |
|
2421 | are strings), modify or exec them (typing 'exec _i9' will re-execute the | |
2419 | contents of input prompt 9, 'exec In[9:14]+In[18]' will re-execute lines |
|
2422 | contents of input prompt 9, 'exec In[9:14]+In[18]' will re-execute lines | |
2420 | 9 through 13 and line 18). |
|
2423 | 9 through 13 and line 18). | |
2421 |
|
2424 | |||
2422 | You can also re-execute multiple lines of input easily by using the |
|
2425 | You can also re-execute multiple lines of input easily by using the | |
2423 | magic %macro function (which automates the process and allows |
|
2426 | magic %macro function (which automates the process and allows | |
2424 | re-execution without having to type 'exec' every time). The macro system |
|
2427 | re-execution without having to type 'exec' every time). The macro system | |
2425 | also allows you to re-execute previous lines which include magic |
|
2428 | also allows you to re-execute previous lines which include magic | |
2426 | function calls (which require special processing). Type %macro? or see |
|
2429 | function calls (which require special processing). Type %macro? or see | |
2427 | sec. 6.2 <#sec:magic> for more details on the macro system. |
|
2430 | sec. 6.2 <#sec:magic> for more details on the macro system. | |
2428 |
|
2431 | |||
2429 | A history function %hist allows you to see any part of your input |
|
2432 | A history function %hist allows you to see any part of your input | |
2430 | history by printing a range of the _i variables. |
|
2433 | history by printing a range of the _i variables. | |
2431 |
|
2434 | |||
2432 |
.. _ |
|
2435 | .. _output_caching: | |
2433 |
|
2436 | |||
2434 | Output caching system |
|
2437 | Output caching system | |
2435 | --------------------- |
|
2438 | --------------------- | |
2436 |
|
2439 | |||
2437 | For output that is returned from actions, a system similar to the input |
|
2440 | For output that is returned from actions, a system similar to the input | |
2438 | cache exists but using _ instead of _i. Only actions that produce a |
|
2441 | cache exists but using _ instead of _i. Only actions that produce a | |
2439 | result (NOT assignments, for example) are cached. If you are familiar |
|
2442 | result (NOT assignments, for example) are cached. If you are familiar | |
2440 | with Mathematica, IPython's _ variables behave exactly like |
|
2443 | with Mathematica, IPython's _ variables behave exactly like | |
2441 | Mathematica's % variables. |
|
2444 | Mathematica's % variables. | |
2442 |
|
2445 | |||
2443 | The following GLOBAL variables always exist (so don't overwrite them!): |
|
2446 | The following GLOBAL variables always exist (so don't overwrite them!): | |
2444 |
|
2447 | |||
2445 | * [_] (a single underscore) : stores previous output, like Python's |
|
2448 | * [_] (a single underscore) : stores previous output, like Python's | |
2446 | default interpreter. |
|
2449 | default interpreter. | |
2447 | * [__] (two underscores): next previous. |
|
2450 | * [__] (two underscores): next previous. | |
2448 | * [___] (three underscores): next-next previous. |
|
2451 | * [___] (three underscores): next-next previous. | |
2449 |
|
2452 | |||
2450 | Additionally, global variables named _<n> are dynamically created (<n> |
|
2453 | Additionally, global variables named _<n> are dynamically created (<n> | |
2451 | being the prompt counter), such that the result of output <n> is always |
|
2454 | being the prompt counter), such that the result of output <n> is always | |
2452 | available as _<n> (don't use the angle brackets, just the number, e.g. |
|
2455 | available as _<n> (don't use the angle brackets, just the number, e.g. | |
2453 | _21). |
|
2456 | _21). | |
2454 |
|
2457 | |||
2455 | These global variables are all stored in a global dictionary (not a |
|
2458 | These global variables are all stored in a global dictionary (not a | |
2456 | list, since it only has entries for lines which returned a result) |
|
2459 | list, since it only has entries for lines which returned a result) | |
2457 | available under the names _oh and Out (similar to _ih and In). So the |
|
2460 | available under the names _oh and Out (similar to _ih and In). So the | |
2458 | output from line 12 can be obtained as _12, Out[12] or _oh[12]. If you |
|
2461 | output from line 12 can be obtained as _12, Out[12] or _oh[12]. If you | |
2459 | accidentally overwrite the Out variable you can recover it by typing |
|
2462 | accidentally overwrite the Out variable you can recover it by typing | |
2460 | 'Out=_oh' at the prompt. |
|
2463 | 'Out=_oh' at the prompt. | |
2461 |
|
2464 | |||
2462 | This system obviously can potentially put heavy memory demands on your |
|
2465 | This system obviously can potentially put heavy memory demands on your | |
2463 | system, since it prevents Python's garbage collector from removing any |
|
2466 | system, since it prevents Python's garbage collector from removing any | |
2464 | previously computed results. You can control how many results are kept |
|
2467 | previously computed results. You can control how many results are kept | |
2465 | in memory with the option (at the command line or in your ipythonrc |
|
2468 | in memory with the option (at the command line or in your ipythonrc | |
2466 | file) cache_size. If you set it to 0, the whole system is completely |
|
2469 | file) cache_size. If you set it to 0, the whole system is completely | |
2467 | disabled and the prompts revert to the classic '>>>' of normal Python. |
|
2470 | disabled and the prompts revert to the classic '>>>' of normal Python. | |
2468 |
|
2471 | |||
2469 |
|
2472 | |||
2470 | Directory history |
|
2473 | Directory history | |
2471 | ----------------- |
|
2474 | ----------------- | |
2472 |
|
2475 | |||
2473 | Your history of visited directories is kept in the global list _dh, and |
|
2476 | Your history of visited directories is kept in the global list _dh, and | |
2474 | the magic %cd command can be used to go to any entry in that list. The |
|
2477 | the magic %cd command can be used to go to any entry in that list. The | |
2475 | %dhist command allows you to view this history. do ``cd -<TAB`` to |
|
2478 | %dhist command allows you to view this history. do ``cd -<TAB`` to | |
2476 | conventiently view the directory history. |
|
2479 | conventiently view the directory history. | |
2477 |
|
2480 | |||
2478 |
|
2481 | |||
2479 | Automatic parentheses and quotes |
|
2482 | Automatic parentheses and quotes | |
2480 | -------------------------------- |
|
2483 | -------------------------------- | |
2481 |
|
2484 | |||
2482 | These features were adapted from Nathan Gray's LazyPython. They are |
|
2485 | These features were adapted from Nathan Gray's LazyPython. They are | |
2483 | meant to allow less typing for common situations. |
|
2486 | meant to allow less typing for common situations. | |
2484 |
|
2487 | |||
2485 |
|
2488 | |||
2486 | Automatic parentheses |
|
2489 | Automatic parentheses | |
2487 | --------------------- |
|
2490 | --------------------- | |
2488 |
|
2491 | |||
2489 | Callable objects (i.e. functions, methods, etc) can be invoked like this |
|
2492 | Callable objects (i.e. functions, methods, etc) can be invoked like this | |
2490 | (notice the commas between the arguments):: |
|
2493 | (notice the commas between the arguments):: | |
2491 |
|
2494 | |||
2492 | >>> callable_ob arg1, arg2, arg3 |
|
2495 | >>> callable_ob arg1, arg2, arg3 | |
2493 |
|
2496 | |||
2494 | and the input will be translated to this:: |
|
2497 | and the input will be translated to this:: | |
2495 |
|
2498 | |||
2496 | -> callable_ob(arg1, arg2, arg3) |
|
2499 | -> callable_ob(arg1, arg2, arg3) | |
2497 |
|
2500 | |||
2498 | You can force automatic parentheses by using '/' as the first character |
|
2501 | You can force automatic parentheses by using '/' as the first character | |
2499 | of a line. For example:: |
|
2502 | of a line. For example:: | |
2500 |
|
2503 | |||
2501 | >>> /globals # becomes 'globals()' |
|
2504 | >>> /globals # becomes 'globals()' | |
2502 |
|
2505 | |||
2503 | Note that the '/' MUST be the first character on the line! This won't work:: |
|
2506 | Note that the '/' MUST be the first character on the line! This won't work:: | |
2504 |
|
2507 | |||
2505 | >>> print /globals # syntax error |
|
2508 | >>> print /globals # syntax error | |
2506 |
|
2509 | |||
2507 | In most cases the automatic algorithm should work, so you should rarely |
|
2510 | In most cases the automatic algorithm should work, so you should rarely | |
2508 | need to explicitly invoke /. One notable exception is if you are trying |
|
2511 | need to explicitly invoke /. One notable exception is if you are trying | |
2509 | to call a function with a list of tuples as arguments (the parenthesis |
|
2512 | to call a function with a list of tuples as arguments (the parenthesis | |
2510 | will confuse IPython):: |
|
2513 | will confuse IPython):: | |
2511 |
|
2514 | |||
2512 | In [1]: zip (1,2,3),(4,5,6) # won't work |
|
2515 | In [1]: zip (1,2,3),(4,5,6) # won't work | |
2513 |
|
2516 | |||
2514 | but this will work:: |
|
2517 | but this will work:: | |
2515 |
|
2518 | |||
2516 | In [2]: /zip (1,2,3),(4,5,6) |
|
2519 | In [2]: /zip (1,2,3),(4,5,6) | |
2517 | ---> zip ((1,2,3),(4,5,6)) |
|
2520 | ---> zip ((1,2,3),(4,5,6)) | |
2518 | Out[2]= [(1, 4), (2, 5), (3, 6)] |
|
2521 | Out[2]= [(1, 4), (2, 5), (3, 6)] | |
2519 |
|
2522 | |||
2520 | IPython tells you that it has altered your command line by displaying |
|
2523 | IPython tells you that it has altered your command line by displaying | |
2521 | the new command line preceded by ->. e.g.:: |
|
2524 | the new command line preceded by ->. e.g.:: | |
2522 |
|
2525 | |||
2523 | In [18]: callable list |
|
2526 | In [18]: callable list | |
2524 | ----> callable (list) |
|
2527 | ----> callable (list) | |
2525 |
|
2528 | |||
2526 |
|
2529 | |||
2527 | Automatic quoting |
|
2530 | Automatic quoting | |
2528 | ----------------- |
|
2531 | ----------------- | |
2529 |
|
2532 | |||
2530 | You can force automatic quoting of a function's arguments by using ',' |
|
2533 | You can force automatic quoting of a function's arguments by using ',' | |
2531 | or ';' as the first character of a line. For example:: |
|
2534 | or ';' as the first character of a line. For example:: | |
2532 |
|
2535 | |||
2533 | >>> ,my_function /home/me # becomes my_function("/home/me") |
|
2536 | >>> ,my_function /home/me # becomes my_function("/home/me") | |
2534 |
|
2537 | |||
2535 | If you use ';' instead, the whole argument is quoted as a single string |
|
2538 | If you use ';' instead, the whole argument is quoted as a single string | |
2536 | (while ',' splits on whitespace):: |
|
2539 | (while ',' splits on whitespace):: | |
2537 |
|
2540 | |||
2538 | >>> ,my_function a b c # becomes my_function("a","b","c") |
|
2541 | >>> ,my_function a b c # becomes my_function("a","b","c") | |
2539 |
|
2542 | |||
2540 | >>> ;my_function a b c # becomes my_function("a b c") |
|
2543 | >>> ;my_function a b c # becomes my_function("a b c") | |
2541 |
|
2544 | |||
2542 | Note that the ',' or ';' MUST be the first character on the line! This |
|
2545 | Note that the ',' or ';' MUST be the first character on the line! This | |
2543 | won't work:: |
|
2546 | won't work:: | |
2544 |
|
2547 | |||
2545 | >>> x = ,my_function /home/me # syntax error |
|
2548 | >>> x = ,my_function /home/me # syntax error | |
2546 |
|
2549 | |||
2547 | IPython as your default Python environment |
|
2550 | IPython as your default Python environment | |
2548 | ========================================== |
|
2551 | ========================================== | |
2549 |
|
2552 | |||
2550 | Python honors the environment variable PYTHONSTARTUP and will execute at |
|
2553 | Python honors the environment variable PYTHONSTARTUP and will execute at | |
2551 | startup the file referenced by this variable. If you put at the end of |
|
2554 | startup the file referenced by this variable. If you put at the end of | |
2552 | this file the following two lines of code:: |
|
2555 | this file the following two lines of code:: | |
2553 |
|
2556 | |||
2554 | import IPython |
|
2557 | import IPython | |
2555 | IPython.Shell.IPShell().mainloop(sys_exit=1) |
|
2558 | IPython.Shell.IPShell().mainloop(sys_exit=1) | |
2556 |
|
2559 | |||
2557 | then IPython will be your working environment anytime you start Python. |
|
2560 | then IPython will be your working environment anytime you start Python. | |
2558 | The sys_exit=1 is needed to have IPython issue a call to sys.exit() when |
|
2561 | The sys_exit=1 is needed to have IPython issue a call to sys.exit() when | |
2559 | it finishes, otherwise you'll be back at the normal Python '>>>' |
|
2562 | it finishes, otherwise you'll be back at the normal Python '>>>' | |
2560 | prompt. |
|
2563 | prompt. | |
2561 |
|
2564 | |||
2562 | This is probably useful to developers who manage multiple Python |
|
2565 | This is probably useful to developers who manage multiple Python | |
2563 | versions and don't want to have correspondingly multiple IPython |
|
2566 | versions and don't want to have correspondingly multiple IPython | |
2564 | versions. Note that in this mode, there is no way to pass IPython any |
|
2567 | versions. Note that in this mode, there is no way to pass IPython any | |
2565 | command-line options, as those are trapped first by Python itself. |
|
2568 | command-line options, as those are trapped first by Python itself. | |
2566 |
|
2569 | |||
2567 | .. _Embedding: |
|
2570 | .. _Embedding: | |
2568 |
|
2571 | |||
2569 | Embedding IPython |
|
2572 | Embedding IPython | |
2570 | ================= |
|
2573 | ================= | |
2571 |
|
2574 | |||
2572 | It is possible to start an IPython instance inside your own Python |
|
2575 | It is possible to start an IPython instance inside your own Python | |
2573 | programs. This allows you to evaluate dynamically the state of your |
|
2576 | programs. This allows you to evaluate dynamically the state of your | |
2574 | code, operate with your variables, analyze them, etc. Note however that |
|
2577 | code, operate with your variables, analyze them, etc. Note however that | |
2575 | any changes you make to values while in the shell do not propagate back |
|
2578 | any changes you make to values while in the shell do not propagate back | |
2576 | to the running code, so it is safe to modify your values because you |
|
2579 | to the running code, so it is safe to modify your values because you | |
2577 | won't break your code in bizarre ways by doing so. |
|
2580 | won't break your code in bizarre ways by doing so. | |
2578 |
|
2581 | |||
2579 | This feature allows you to easily have a fully functional python |
|
2582 | This feature allows you to easily have a fully functional python | |
2580 | environment for doing object introspection anywhere in your code with a |
|
2583 | environment for doing object introspection anywhere in your code with a | |
2581 | simple function call. In some cases a simple print statement is enough, |
|
2584 | simple function call. In some cases a simple print statement is enough, | |
2582 | but if you need to do more detailed analysis of a code fragment this |
|
2585 | but if you need to do more detailed analysis of a code fragment this | |
2583 | feature can be very valuable. |
|
2586 | feature can be very valuable. | |
2584 |
|
2587 | |||
2585 | It can also be useful in scientific computing situations where it is |
|
2588 | It can also be useful in scientific computing situations where it is | |
2586 | common to need to do some automatic, computationally intensive part and |
|
2589 | common to need to do some automatic, computationally intensive part and | |
2587 | then stop to look at data, plots, etc. |
|
2590 | then stop to look at data, plots, etc. | |
2588 | Opening an IPython instance will give you full access to your data and |
|
2591 | Opening an IPython instance will give you full access to your data and | |
2589 | functions, and you can resume program execution once you are done with |
|
2592 | functions, and you can resume program execution once you are done with | |
2590 | the interactive part (perhaps to stop again later, as many times as |
|
2593 | the interactive part (perhaps to stop again later, as many times as | |
2591 | needed). |
|
2594 | needed). | |
2592 |
|
2595 | |||
2593 | The following code snippet is the bare minimum you need to include in |
|
2596 | The following code snippet is the bare minimum you need to include in | |
2594 | your Python programs for this to work (detailed examples follow later):: |
|
2597 | your Python programs for this to work (detailed examples follow later):: | |
2595 |
|
2598 | |||
2596 | from IPython.Shell import IPShellEmbed |
|
2599 | from IPython.Shell import IPShellEmbed | |
2597 |
|
2600 | |||
2598 | ipshell = IPShellEmbed() |
|
2601 | ipshell = IPShellEmbed() | |
2599 |
|
2602 | |||
2600 | ipshell() # this call anywhere in your program will start IPython |
|
2603 | ipshell() # this call anywhere in your program will start IPython | |
2601 |
|
2604 | |||
2602 | You can run embedded instances even in code which is itself being run at |
|
2605 | You can run embedded instances even in code which is itself being run at | |
2603 | the IPython interactive prompt with '%run <filename>'. Since it's easy |
|
2606 | the IPython interactive prompt with '%run <filename>'. Since it's easy | |
2604 | to get lost as to where you are (in your top-level IPython or in your |
|
2607 | to get lost as to where you are (in your top-level IPython or in your | |
2605 | embedded one), it's a good idea in such cases to set the in/out prompts |
|
2608 | embedded one), it's a good idea in such cases to set the in/out prompts | |
2606 | to something different for the embedded instances. The code examples |
|
2609 | to something different for the embedded instances. The code examples | |
2607 | below illustrate this. |
|
2610 | below illustrate this. | |
2608 |
|
2611 | |||
2609 | You can also have multiple IPython instances in your program and open |
|
2612 | You can also have multiple IPython instances in your program and open | |
2610 | them separately, for example with different options for data |
|
2613 | them separately, for example with different options for data | |
2611 | presentation. If you close and open the same instance multiple times, |
|
2614 | presentation. If you close and open the same instance multiple times, | |
2612 | its prompt counters simply continue from each execution to the next. |
|
2615 | its prompt counters simply continue from each execution to the next. | |
2613 |
|
2616 | |||
2614 | Please look at the docstrings in the Shell.py module for more details on |
|
2617 | Please look at the docstrings in the Shell.py module for more details on | |
2615 | the use of this system. |
|
2618 | the use of this system. | |
2616 |
|
2619 | |||
2617 | The following sample file illustrating how to use the embedding |
|
2620 | The following sample file illustrating how to use the embedding | |
2618 | functionality is provided in the examples directory as example-embed.py. |
|
2621 | functionality is provided in the examples directory as example-embed.py. | |
2619 | It should be fairly self-explanatory:: |
|
2622 | It should be fairly self-explanatory:: | |
2620 |
|
2623 | |||
2621 |
|
2624 | |||
2622 | #!/usr/bin/env python |
|
2625 | #!/usr/bin/env python | |
2623 |
|
2626 | |||
2624 | """An example of how to embed an IPython shell into a running program. |
|
2627 | """An example of how to embed an IPython shell into a running program. | |
2625 |
|
2628 | |||
2626 | Please see the documentation in the IPython.Shell module for more details. |
|
2629 | Please see the documentation in the IPython.Shell module for more details. | |
2627 |
|
2630 | |||
2628 | The accompanying file example-embed-short.py has quick code fragments for |
|
2631 | The accompanying file example-embed-short.py has quick code fragments for | |
2629 | embedding which you can cut and paste in your code once you understand how |
|
2632 | embedding which you can cut and paste in your code once you understand how | |
2630 | things work. |
|
2633 | things work. | |
2631 |
|
2634 | |||
2632 | The code in this file is deliberately extra-verbose, meant for learning.""" |
|
2635 | The code in this file is deliberately extra-verbose, meant for learning.""" | |
2633 |
|
2636 | |||
2634 | # The basics to get you going: |
|
2637 | # The basics to get you going: | |
2635 |
|
2638 | |||
2636 | # IPython sets the __IPYTHON__ variable so you can know if you have nested |
|
2639 | # IPython sets the __IPYTHON__ variable so you can know if you have nested | |
2637 | # copies running. |
|
2640 | # copies running. | |
2638 |
|
2641 | |||
2639 | # Try running this code both at the command line and from inside IPython (with |
|
2642 | # Try running this code both at the command line and from inside IPython (with | |
2640 | # %run example-embed.py) |
|
2643 | # %run example-embed.py) | |
2641 | try: |
|
2644 | try: | |
2642 | __IPYTHON__ |
|
2645 | __IPYTHON__ | |
2643 | except NameError: |
|
2646 | except NameError: | |
2644 | nested = 0 |
|
2647 | nested = 0 | |
2645 | args = [''] |
|
2648 | args = [''] | |
2646 | else: |
|
2649 | else: | |
2647 | print "Running nested copies of IPython." |
|
2650 | print "Running nested copies of IPython." | |
2648 | print "The prompts for the nested copy have been modified" |
|
2651 | print "The prompts for the nested copy have been modified" | |
2649 | nested = 1 |
|
2652 | nested = 1 | |
2650 | # what the embedded instance will see as sys.argv: |
|
2653 | # what the embedded instance will see as sys.argv: | |
2651 | args = ['-pi1','In <\\#>: ','-pi2',' .\\D.: ', |
|
2654 | args = ['-pi1','In <\\#>: ','-pi2',' .\\D.: ', | |
2652 | '-po','Out<\\#>: ','-nosep'] |
|
2655 | '-po','Out<\\#>: ','-nosep'] | |
2653 |
|
2656 | |||
2654 | # First import the embeddable shell class |
|
2657 | # First import the embeddable shell class | |
2655 | from IPython.Shell import IPShellEmbed |
|
2658 | from IPython.Shell import IPShellEmbed | |
2656 |
|
2659 | |||
2657 | # Now create an instance of the embeddable shell. The first argument is a |
|
2660 | # Now create an instance of the embeddable shell. The first argument is a | |
2658 | # string with options exactly as you would type them if you were starting |
|
2661 | # string with options exactly as you would type them if you were starting | |
2659 | # IPython at the system command line. Any parameters you want to define for |
|
2662 | # IPython at the system command line. Any parameters you want to define for | |
2660 | # configuration can thus be specified here. |
|
2663 | # configuration can thus be specified here. | |
2661 | ipshell = IPShellEmbed(args, |
|
2664 | ipshell = IPShellEmbed(args, | |
2662 | banner = 'Dropping into IPython', |
|
2665 | banner = 'Dropping into IPython', | |
2663 | exit_msg = 'Leaving Interpreter, back to program.') |
|
2666 | exit_msg = 'Leaving Interpreter, back to program.') | |
2664 |
|
2667 | |||
2665 | # Make a second instance, you can have as many as you want. |
|
2668 | # Make a second instance, you can have as many as you want. | |
2666 | if nested: |
|
2669 | if nested: | |
2667 | args[1] = 'In2<\\#>' |
|
2670 | args[1] = 'In2<\\#>' | |
2668 | else: |
|
2671 | else: | |
2669 | args = ['-pi1','In2<\\#>: ','-pi2',' .\\D.: ', |
|
2672 | args = ['-pi1','In2<\\#>: ','-pi2',' .\\D.: ', | |
2670 | '-po','Out<\\#>: ','-nosep'] |
|
2673 | '-po','Out<\\#>: ','-nosep'] | |
2671 | ipshell2 = IPShellEmbed(args,banner = 'Second IPython instance.') |
|
2674 | ipshell2 = IPShellEmbed(args,banner = 'Second IPython instance.') | |
2672 |
|
2675 | |||
2673 | print '\nHello. This is printed from the main controller program.\n' |
|
2676 | print '\nHello. This is printed from the main controller program.\n' | |
2674 |
|
2677 | |||
2675 | # You can then call ipshell() anywhere you need it (with an optional |
|
2678 | # You can then call ipshell() anywhere you need it (with an optional | |
2676 | # message): |
|
2679 | # message): | |
2677 | ipshell('***Called from top level. ' |
|
2680 | ipshell('***Called from top level. ' | |
2678 | 'Hit Ctrl-D to exit interpreter and continue program.\n' |
|
2681 | 'Hit Ctrl-D to exit interpreter and continue program.\n' | |
2679 | 'Note that if you use %kill_embedded, you can fully deactivate\n' |
|
2682 | 'Note that if you use %kill_embedded, you can fully deactivate\n' | |
2680 | 'This embedded instance so it will never turn on again') |
|
2683 | 'This embedded instance so it will never turn on again') | |
2681 |
|
2684 | |||
2682 | print '\nBack in caller program, moving along...\n' |
|
2685 | print '\nBack in caller program, moving along...\n' | |
2683 |
|
2686 | |||
2684 | #--------------------------------------------------------------------------- |
|
2687 | #--------------------------------------------------------------------------- | |
2685 | # More details: |
|
2688 | # More details: | |
2686 |
|
2689 | |||
2687 | # IPShellEmbed instances don't print the standard system banner and |
|
2690 | # IPShellEmbed instances don't print the standard system banner and | |
2688 | # messages. The IPython banner (which actually may contain initialization |
|
2691 | # messages. The IPython banner (which actually may contain initialization | |
2689 | # messages) is available as <instance>.IP.BANNER in case you want it. |
|
2692 | # messages) is available as <instance>.IP.BANNER in case you want it. | |
2690 |
|
2693 | |||
2691 | # IPShellEmbed instances print the following information everytime they |
|
2694 | # IPShellEmbed instances print the following information everytime they | |
2692 | # start: |
|
2695 | # start: | |
2693 |
|
2696 | |||
2694 | # - A global startup banner. |
|
2697 | # - A global startup banner. | |
2695 |
|
2698 | |||
2696 | # - A call-specific header string, which you can use to indicate where in the |
|
2699 | # - A call-specific header string, which you can use to indicate where in the | |
2697 | # execution flow the shell is starting. |
|
2700 | # execution flow the shell is starting. | |
2698 |
|
2701 | |||
2699 | # They also print an exit message every time they exit. |
|
2702 | # They also print an exit message every time they exit. | |
2700 |
|
2703 | |||
2701 | # Both the startup banner and the exit message default to None, and can be set |
|
2704 | # Both the startup banner and the exit message default to None, and can be set | |
2702 | # either at the instance constructor or at any other time with the |
|
2705 | # either at the instance constructor or at any other time with the | |
2703 | # set_banner() and set_exit_msg() methods. |
|
2706 | # set_banner() and set_exit_msg() methods. | |
2704 |
|
2707 | |||
2705 | # The shell instance can be also put in 'dummy' mode globally or on a per-call |
|
2708 | # The shell instance can be also put in 'dummy' mode globally or on a per-call | |
2706 | # basis. This gives you fine control for debugging without having to change |
|
2709 | # basis. This gives you fine control for debugging without having to change | |
2707 | # code all over the place. |
|
2710 | # code all over the place. | |
2708 |
|
2711 | |||
2709 | # The code below illustrates all this. |
|
2712 | # The code below illustrates all this. | |
2710 |
|
2713 | |||
2711 |
|
2714 | |||
2712 | # This is how the global banner and exit_msg can be reset at any point |
|
2715 | # This is how the global banner and exit_msg can be reset at any point | |
2713 | ipshell.set_banner('Entering interpreter - New Banner') |
|
2716 | ipshell.set_banner('Entering interpreter - New Banner') | |
2714 | ipshell.set_exit_msg('Leaving interpreter - New exit_msg') |
|
2717 | ipshell.set_exit_msg('Leaving interpreter - New exit_msg') | |
2715 |
|
2718 | |||
2716 | def foo(m): |
|
2719 | def foo(m): | |
2717 | s = 'spam' |
|
2720 | s = 'spam' | |
2718 | ipshell('***In foo(). Try @whos, or print s or m:') |
|
2721 | ipshell('***In foo(). Try @whos, or print s or m:') | |
2719 | print 'foo says m = ',m |
|
2722 | print 'foo says m = ',m | |
2720 |
|
2723 | |||
2721 | def bar(n): |
|
2724 | def bar(n): | |
2722 | s = 'eggs' |
|
2725 | s = 'eggs' | |
2723 | ipshell('***In bar(). Try @whos, or print s or n:') |
|
2726 | ipshell('***In bar(). Try @whos, or print s or n:') | |
2724 | print 'bar says n = ',n |
|
2727 | print 'bar says n = ',n | |
2725 |
|
2728 | |||
2726 | # Some calls to the above functions which will trigger IPython: |
|
2729 | # Some calls to the above functions which will trigger IPython: | |
2727 | print 'Main program calling foo("eggs")\n' |
|
2730 | print 'Main program calling foo("eggs")\n' | |
2728 | foo('eggs') |
|
2731 | foo('eggs') | |
2729 |
|
2732 | |||
2730 | # The shell can be put in 'dummy' mode where calls to it silently return. This |
|
2733 | # The shell can be put in 'dummy' mode where calls to it silently return. This | |
2731 | # allows you, for example, to globally turn off debugging for a program with a |
|
2734 | # allows you, for example, to globally turn off debugging for a program with a | |
2732 | # single call. |
|
2735 | # single call. | |
2733 | ipshell.set_dummy_mode(1) |
|
2736 | ipshell.set_dummy_mode(1) | |
2734 | print '\nTrying to call IPython which is now "dummy":' |
|
2737 | print '\nTrying to call IPython which is now "dummy":' | |
2735 | ipshell() |
|
2738 | ipshell() | |
2736 | print 'Nothing happened...' |
|
2739 | print 'Nothing happened...' | |
2737 | # The global 'dummy' mode can still be overridden for a single call |
|
2740 | # The global 'dummy' mode can still be overridden for a single call | |
2738 | print '\nOverriding dummy mode manually:' |
|
2741 | print '\nOverriding dummy mode manually:' | |
2739 | ipshell(dummy=0) |
|
2742 | ipshell(dummy=0) | |
2740 |
|
2743 | |||
2741 | # Reactivate the IPython shell |
|
2744 | # Reactivate the IPython shell | |
2742 | ipshell.set_dummy_mode(0) |
|
2745 | ipshell.set_dummy_mode(0) | |
2743 |
|
2746 | |||
2744 | print 'You can even have multiple embedded instances:' |
|
2747 | print 'You can even have multiple embedded instances:' | |
2745 | ipshell2() |
|
2748 | ipshell2() | |
2746 |
|
2749 | |||
2747 | print '\nMain program calling bar("spam")\n' |
|
2750 | print '\nMain program calling bar("spam")\n' | |
2748 | bar('spam') |
|
2751 | bar('spam') | |
2749 |
|
2752 | |||
2750 | print 'Main program finished. Bye!' |
|
2753 | print 'Main program finished. Bye!' | |
2751 |
|
2754 | |||
2752 | #********************** End of file <example-embed.py> *********************** |
|
2755 | #********************** End of file <example-embed.py> *********************** | |
2753 |
|
2756 | |||
2754 | Once you understand how the system functions, you can use the following |
|
2757 | Once you understand how the system functions, you can use the following | |
2755 | code fragments in your programs which are ready for cut and paste:: |
|
2758 | code fragments in your programs which are ready for cut and paste:: | |
2756 |
|
2759 | |||
2757 |
|
2760 | |||
2758 | """Quick code snippets for embedding IPython into other programs. |
|
2761 | """Quick code snippets for embedding IPython into other programs. | |
2759 |
|
2762 | |||
2760 | See example-embed.py for full details, this file has the bare minimum code for |
|
2763 | See example-embed.py for full details, this file has the bare minimum code for | |
2761 | cut and paste use once you understand how to use the system.""" |
|
2764 | cut and paste use once you understand how to use the system.""" | |
2762 |
|
2765 | |||
2763 | #--------------------------------------------------------------------------- |
|
2766 | #--------------------------------------------------------------------------- | |
2764 | # This code loads IPython but modifies a few things if it detects it's running |
|
2767 | # This code loads IPython but modifies a few things if it detects it's running | |
2765 | # embedded in another IPython session (helps avoid confusion) |
|
2768 | # embedded in another IPython session (helps avoid confusion) | |
2766 |
|
2769 | |||
2767 | try: |
|
2770 | try: | |
2768 | __IPYTHON__ |
|
2771 | __IPYTHON__ | |
2769 | except NameError: |
|
2772 | except NameError: | |
2770 | argv = [''] |
|
2773 | argv = [''] | |
2771 | banner = exit_msg = '' |
|
2774 | banner = exit_msg = '' | |
2772 | else: |
|
2775 | else: | |
2773 | # Command-line options for IPython (a list like sys.argv) |
|
2776 | # Command-line options for IPython (a list like sys.argv) | |
2774 | argv = ['-pi1','In <\\#>:','-pi2',' .\\D.:','-po','Out<\\#>:'] |
|
2777 | argv = ['-pi1','In <\\#>:','-pi2',' .\\D.:','-po','Out<\\#>:'] | |
2775 | banner = '*** Nested interpreter ***' |
|
2778 | banner = '*** Nested interpreter ***' | |
2776 | exit_msg = '*** Back in main IPython ***' |
|
2779 | exit_msg = '*** Back in main IPython ***' | |
2777 |
|
2780 | |||
2778 | # First import the embeddable shell class |
|
2781 | # First import the embeddable shell class | |
2779 | from IPython.Shell import IPShellEmbed |
|
2782 | from IPython.Shell import IPShellEmbed | |
2780 | # Now create the IPython shell instance. Put ipshell() anywhere in your code |
|
2783 | # Now create the IPython shell instance. Put ipshell() anywhere in your code | |
2781 | # where you want it to open. |
|
2784 | # where you want it to open. | |
2782 | ipshell = IPShellEmbed(argv,banner=banner,exit_msg=exit_msg) |
|
2785 | ipshell = IPShellEmbed(argv,banner=banner,exit_msg=exit_msg) | |
2783 |
|
2786 | |||
2784 | #--------------------------------------------------------------------------- |
|
2787 | #--------------------------------------------------------------------------- | |
2785 | # This code will load an embeddable IPython shell always with no changes for |
|
2788 | # This code will load an embeddable IPython shell always with no changes for | |
2786 | # nested embededings. |
|
2789 | # nested embededings. | |
2787 |
|
2790 | |||
2788 | from IPython.Shell import IPShellEmbed |
|
2791 | from IPython.Shell import IPShellEmbed | |
2789 | ipshell = IPShellEmbed() |
|
2792 | ipshell = IPShellEmbed() | |
2790 | # Now ipshell() will open IPython anywhere in the code. |
|
2793 | # Now ipshell() will open IPython anywhere in the code. | |
2791 |
|
2794 | |||
2792 | #--------------------------------------------------------------------------- |
|
2795 | #--------------------------------------------------------------------------- | |
2793 | # This code loads an embeddable shell only if NOT running inside |
|
2796 | # This code loads an embeddable shell only if NOT running inside | |
2794 | # IPython. Inside IPython, the embeddable shell variable ipshell is just a |
|
2797 | # IPython. Inside IPython, the embeddable shell variable ipshell is just a | |
2795 | # dummy function. |
|
2798 | # dummy function. | |
2796 |
|
2799 | |||
2797 | try: |
|
2800 | try: | |
2798 | __IPYTHON__ |
|
2801 | __IPYTHON__ | |
2799 | except NameError: |
|
2802 | except NameError: | |
2800 | from IPython.Shell import IPShellEmbed |
|
2803 | from IPython.Shell import IPShellEmbed | |
2801 | ipshell = IPShellEmbed() |
|
2804 | ipshell = IPShellEmbed() | |
2802 | # Now ipshell() will open IPython anywhere in the code |
|
2805 | # Now ipshell() will open IPython anywhere in the code | |
2803 | else: |
|
2806 | else: | |
2804 | # Define a dummy ipshell() so the same code doesn't crash inside an |
|
2807 | # Define a dummy ipshell() so the same code doesn't crash inside an | |
2805 | # interactive IPython |
|
2808 | # interactive IPython | |
2806 | def ipshell(): pass |
|
2809 | def ipshell(): pass | |
2807 |
|
2810 | |||
2808 | #******************* End of file <example-embed-short.py> ******************** |
|
2811 | #******************* End of file <example-embed-short.py> ******************** | |
2809 |
|
2812 | |||
2810 | Using the Python debugger (pdb) |
|
2813 | Using the Python debugger (pdb) | |
2811 | =============================== |
|
2814 | =============================== | |
2812 |
|
2815 | |||
2813 | Running entire programs via pdb |
|
2816 | Running entire programs via pdb | |
2814 | ------------------------------- |
|
2817 | ------------------------------- | |
2815 |
|
2818 | |||
2816 | pdb, the Python debugger, is a powerful interactive debugger which |
|
2819 | pdb, the Python debugger, is a powerful interactive debugger which | |
2817 | allows you to step through code, set breakpoints, watch variables, |
|
2820 | allows you to step through code, set breakpoints, watch variables, | |
2818 | etc. IPython makes it very easy to start any script under the control |
|
2821 | etc. IPython makes it very easy to start any script under the control | |
2819 | of pdb, regardless of whether you have wrapped it into a 'main()' |
|
2822 | of pdb, regardless of whether you have wrapped it into a 'main()' | |
2820 | function or not. For this, simply type '%run -d myscript' at an |
|
2823 | function or not. For this, simply type '%run -d myscript' at an | |
2821 | IPython prompt. See the %run command's documentation (via '%run?' or |
|
2824 | IPython prompt. See the %run command's documentation (via '%run?' or | |
2822 | in Sec. magic_ for more details, including how to control where pdb |
|
2825 | in Sec. magic_ for more details, including how to control where pdb | |
2823 | will stop execution first. |
|
2826 | will stop execution first. | |
2824 |
|
2827 | |||
2825 | For more information on the use of the pdb debugger, read the included |
|
2828 | For more information on the use of the pdb debugger, read the included | |
2826 | pdb.doc file (part of the standard Python distribution). On a stock |
|
2829 | pdb.doc file (part of the standard Python distribution). On a stock | |
2827 | Linux system it is located at /usr/lib/python2.3/pdb.doc, but the |
|
2830 | Linux system it is located at /usr/lib/python2.3/pdb.doc, but the | |
2828 | easiest way to read it is by using the help() function of the pdb module |
|
2831 | easiest way to read it is by using the help() function of the pdb module | |
2829 | as follows (in an IPython prompt): |
|
2832 | as follows (in an IPython prompt): | |
2830 |
|
2833 | |||
2831 | In [1]: import pdb |
|
2834 | In [1]: import pdb | |
2832 | In [2]: pdb.help() |
|
2835 | In [2]: pdb.help() | |
2833 |
|
2836 | |||
2834 | This will load the pdb.doc document in a file viewer for you automatically. |
|
2837 | This will load the pdb.doc document in a file viewer for you automatically. | |
2835 |
|
2838 | |||
2836 |
|
2839 | |||
2837 | Automatic invocation of pdb on exceptions |
|
2840 | Automatic invocation of pdb on exceptions | |
2838 | ----------------------------------------- |
|
2841 | ----------------------------------------- | |
2839 |
|
2842 | |||
2840 | IPython, if started with the -pdb option (or if the option is set in |
|
2843 | IPython, if started with the -pdb option (or if the option is set in | |
2841 | your rc file) can call the Python pdb debugger every time your code |
|
2844 | your rc file) can call the Python pdb debugger every time your code | |
2842 | triggers an uncaught exception. This feature |
|
2845 | triggers an uncaught exception. This feature | |
2843 | can also be toggled at any time with the %pdb magic command. This can be |
|
2846 | can also be toggled at any time with the %pdb magic command. This can be | |
2844 | extremely useful in order to find the origin of subtle bugs, because pdb |
|
2847 | extremely useful in order to find the origin of subtle bugs, because pdb | |
2845 | opens up at the point in your code which triggered the exception, and |
|
2848 | opens up at the point in your code which triggered the exception, and | |
2846 | while your program is at this point 'dead', all the data is still |
|
2849 | while your program is at this point 'dead', all the data is still | |
2847 | available and you can walk up and down the stack frame and understand |
|
2850 | available and you can walk up and down the stack frame and understand | |
2848 | the origin of the problem. |
|
2851 | the origin of the problem. | |
2849 |
|
2852 | |||
2850 | Furthermore, you can use these debugging facilities both with the |
|
2853 | Furthermore, you can use these debugging facilities both with the | |
2851 | embedded IPython mode and without IPython at all. For an embedded shell |
|
2854 | embedded IPython mode and without IPython at all. For an embedded shell | |
2852 | (see sec. Embedding_), simply call the constructor with |
|
2855 | (see sec. Embedding_), simply call the constructor with | |
2853 | '-pdb' in the argument string and automatically pdb will be called if an |
|
2856 | '-pdb' in the argument string and automatically pdb will be called if an | |
2854 | uncaught exception is triggered by your code. |
|
2857 | uncaught exception is triggered by your code. | |
2855 |
|
2858 | |||
2856 | For stand-alone use of the feature in your programs which do not use |
|
2859 | For stand-alone use of the feature in your programs which do not use | |
2857 | IPython at all, put the following lines toward the top of your 'main' |
|
2860 | IPython at all, put the following lines toward the top of your 'main' | |
2858 | routine:: |
|
2861 | routine:: | |
2859 |
|
2862 | |||
2860 | import sys,IPython.ultraTB |
|
2863 | import sys,IPython.ultraTB | |
2861 | sys.excepthook = IPython.ultraTB.FormattedTB(mode='Verbose', |
|
2864 | sys.excepthook = IPython.ultraTB.FormattedTB(mode='Verbose', | |
2862 | color_scheme='Linux', call_pdb=1) |
|
2865 | color_scheme='Linux', call_pdb=1) | |
2863 |
|
2866 | |||
2864 | The mode keyword can be either 'Verbose' or 'Plain', giving either very |
|
2867 | The mode keyword can be either 'Verbose' or 'Plain', giving either very | |
2865 | detailed or normal tracebacks respectively. The color_scheme keyword can |
|
2868 | detailed or normal tracebacks respectively. The color_scheme keyword can | |
2866 | be one of 'NoColor', 'Linux' (default) or 'LightBG'. These are the same |
|
2869 | be one of 'NoColor', 'Linux' (default) or 'LightBG'. These are the same | |
2867 | options which can be set in IPython with -colors and -xmode. |
|
2870 | options which can be set in IPython with -colors and -xmode. | |
2868 |
|
2871 | |||
2869 | This will give any of your programs detailed, colored tracebacks with |
|
2872 | This will give any of your programs detailed, colored tracebacks with | |
2870 | automatic invocation of pdb. |
|
2873 | automatic invocation of pdb. | |
2871 |
|
2874 | |||
2872 |
|
2875 | |||
2873 | Extensions for syntax processing |
|
2876 | Extensions for syntax processing | |
2874 | ================================ |
|
2877 | ================================ | |
2875 |
|
2878 | |||
2876 | This isn't for the faint of heart, because the potential for breaking |
|
2879 | This isn't for the faint of heart, because the potential for breaking | |
2877 | things is quite high. But it can be a very powerful and useful feature. |
|
2880 | things is quite high. But it can be a very powerful and useful feature. | |
2878 | In a nutshell, you can redefine the way IPython processes the user input |
|
2881 | In a nutshell, you can redefine the way IPython processes the user input | |
2879 | line to accept new, special extensions to the syntax without needing to |
|
2882 | line to accept new, special extensions to the syntax without needing to | |
2880 | change any of IPython's own code. |
|
2883 | change any of IPython's own code. | |
2881 |
|
2884 | |||
2882 | In the IPython/Extensions directory you will find some examples |
|
2885 | In the IPython/Extensions directory you will find some examples | |
2883 | supplied, which we will briefly describe now. These can be used 'as is' |
|
2886 | supplied, which we will briefly describe now. These can be used 'as is' | |
2884 | (and both provide very useful functionality), or you can use them as a |
|
2887 | (and both provide very useful functionality), or you can use them as a | |
2885 | starting point for writing your own extensions. |
|
2888 | starting point for writing your own extensions. | |
2886 |
|
2889 | |||
2887 |
|
2890 | |||
2888 | Pasting of code starting with '>>> ' or '... ' |
|
2891 | Pasting of code starting with '>>> ' or '... ' | |
2889 | ---------------------------------------------- |
|
2892 | ---------------------------------------------- | |
2890 |
|
2893 | |||
2891 | In the python tutorial it is common to find code examples which have |
|
2894 | In the python tutorial it is common to find code examples which have | |
2892 | been taken from real python sessions. The problem with those is that all |
|
2895 | been taken from real python sessions. The problem with those is that all | |
2893 | the lines begin with either '>>> ' or '... ', which makes it impossible |
|
2896 | the lines begin with either '>>> ' or '... ', which makes it impossible | |
2894 | to paste them all at once. One must instead do a line by line manual |
|
2897 | to paste them all at once. One must instead do a line by line manual | |
2895 | copying, carefully removing the leading extraneous characters. |
|
2898 | copying, carefully removing the leading extraneous characters. | |
2896 |
|
2899 | |||
2897 | This extension identifies those starting characters and removes them |
|
2900 | This extension identifies those starting characters and removes them | |
2898 | from the input automatically, so that one can paste multi-line examples |
|
2901 | from the input automatically, so that one can paste multi-line examples | |
2899 | directly into IPython, saving a lot of time. Please look at the file |
|
2902 | directly into IPython, saving a lot of time. Please look at the file | |
2900 | InterpreterPasteInput.py in the IPython/Extensions directory for details |
|
2903 | InterpreterPasteInput.py in the IPython/Extensions directory for details | |
2901 | on how this is done. |
|
2904 | on how this is done. | |
2902 |
|
2905 | |||
2903 | IPython comes with a special profile enabling this feature, called |
|
2906 | IPython comes with a special profile enabling this feature, called | |
2904 | tutorial. Simply start IPython via 'ipython -p tutorial' and the feature |
|
2907 | tutorial. Simply start IPython via 'ipython -p tutorial' and the feature | |
2905 | will be available. In a normal IPython session you can activate the |
|
2908 | will be available. In a normal IPython session you can activate the | |
2906 | feature by importing the corresponding module with: |
|
2909 | feature by importing the corresponding module with: | |
2907 | In [1]: import IPython.Extensions.InterpreterPasteInput |
|
2910 | In [1]: import IPython.Extensions.InterpreterPasteInput | |
2908 |
|
2911 | |||
2909 | The following is a 'screenshot' of how things work when this extension |
|
2912 | The following is a 'screenshot' of how things work when this extension | |
2910 | is on, copying an example from the standard tutorial:: |
|
2913 | is on, copying an example from the standard tutorial:: | |
2911 |
|
2914 | |||
2912 | IPython profile: tutorial |
|
2915 | IPython profile: tutorial | |
2913 |
|
2916 | |||
2914 | *** Pasting of code with ">>>" or "..." has been enabled. |
|
2917 | *** Pasting of code with ">>>" or "..." has been enabled. | |
2915 |
|
2918 | |||
2916 | In [1]: >>> def fib2(n): # return Fibonacci series up to n |
|
2919 | In [1]: >>> def fib2(n): # return Fibonacci series up to n | |
2917 | ...: ... """Return a list containing the Fibonacci series up to |
|
2920 | ...: ... """Return a list containing the Fibonacci series up to | |
2918 | n.""" |
|
2921 | n.""" | |
2919 | ...: ... result = [] |
|
2922 | ...: ... result = [] | |
2920 | ...: ... a, b = 0, 1 |
|
2923 | ...: ... a, b = 0, 1 | |
2921 | ...: ... while b < n: |
|
2924 | ...: ... while b < n: | |
2922 | ...: ... result.append(b) # see below |
|
2925 | ...: ... result.append(b) # see below | |
2923 | ...: ... a, b = b, a+b |
|
2926 | ...: ... a, b = b, a+b | |
2924 | ...: ... return result |
|
2927 | ...: ... return result | |
2925 | ...: |
|
2928 | ...: | |
2926 |
|
2929 | |||
2927 | In [2]: fib2(10) |
|
2930 | In [2]: fib2(10) | |
2928 | Out[2]: [1, 1, 2, 3, 5, 8] |
|
2931 | Out[2]: [1, 1, 2, 3, 5, 8] | |
2929 |
|
2932 | |||
2930 | Note that as currently written, this extension does not recognize |
|
2933 | Note that as currently written, this extension does not recognize | |
2931 | IPython's prompts for pasting. Those are more complicated, since the |
|
2934 | IPython's prompts for pasting. Those are more complicated, since the | |
2932 | user can change them very easily, they involve numbers and can vary in |
|
2935 | user can change them very easily, they involve numbers and can vary in | |
2933 | length. One could however extract all the relevant information from the |
|
2936 | length. One could however extract all the relevant information from the | |
2934 | IPython instance and build an appropriate regular expression. This is |
|
2937 | IPython instance and build an appropriate regular expression. This is | |
2935 | left as an exercise for the reader. |
|
2938 | left as an exercise for the reader. | |
2936 |
|
2939 | |||
2937 |
|
2940 | |||
2938 | Input of physical quantities with units |
|
2941 | Input of physical quantities with units | |
2939 | --------------------------------------- |
|
2942 | --------------------------------------- | |
2940 |
|
2943 | |||
2941 | The module PhysicalQInput allows a simplified form of input for physical |
|
2944 | The module PhysicalQInput allows a simplified form of input for physical | |
2942 | quantities with units. This file is meant to be used in conjunction with |
|
2945 | quantities with units. This file is meant to be used in conjunction with | |
2943 | the PhysicalQInteractive module (in the same directory) and |
|
2946 | the PhysicalQInteractive module (in the same directory) and | |
2944 | Physics.PhysicalQuantities from Konrad Hinsen's ScientificPython |
|
2947 | Physics.PhysicalQuantities from Konrad Hinsen's ScientificPython | |
2945 | (http://dirac.cnrs-orleans.fr/ScientificPython/). |
|
2948 | (http://dirac.cnrs-orleans.fr/ScientificPython/). | |
2946 |
|
2949 | |||
2947 | The Physics.PhysicalQuantities module defines PhysicalQuantity objects, |
|
2950 | The Physics.PhysicalQuantities module defines PhysicalQuantity objects, | |
2948 | but these must be declared as instances of a class. For example, to |
|
2951 | but these must be declared as instances of a class. For example, to | |
2949 | define v as a velocity of 3 m/s, normally you would write:: |
|
2952 | define v as a velocity of 3 m/s, normally you would write:: | |
2950 |
|
2953 | |||
2951 | In [1]: v = PhysicalQuantity(3,'m/s') |
|
2954 | In [1]: v = PhysicalQuantity(3,'m/s') | |
2952 |
|
2955 | |||
2953 | Using the PhysicalQ_Input extension this can be input instead as: |
|
2956 | Using the PhysicalQ_Input extension this can be input instead as: | |
2954 | In [1]: v = 3 m/s |
|
2957 | In [1]: v = 3 m/s | |
2955 | which is much more convenient for interactive use (even though it is |
|
2958 | which is much more convenient for interactive use (even though it is | |
2956 | blatantly invalid Python syntax). |
|
2959 | blatantly invalid Python syntax). | |
2957 |
|
2960 | |||
2958 | The physics profile supplied with IPython (enabled via 'ipython -p |
|
2961 | The physics profile supplied with IPython (enabled via 'ipython -p | |
2959 | physics') uses these extensions, which you can also activate with: |
|
2962 | physics') uses these extensions, which you can also activate with: | |
2960 |
|
2963 | |||
2961 | from math import * # math MUST be imported BEFORE PhysicalQInteractive |
|
2964 | from math import * # math MUST be imported BEFORE PhysicalQInteractive | |
2962 | from IPython.Extensions.PhysicalQInteractive import * |
|
2965 | from IPython.Extensions.PhysicalQInteractive import * | |
2963 | import IPython.Extensions.PhysicalQInput |
|
2966 | import IPython.Extensions.PhysicalQInput | |
2964 |
|
2967 | |||
2965 |
|
2968 | |||
2966 | Threading support |
|
2969 | Threading support | |
2967 | ================= |
|
2970 | ================= | |
2968 |
|
2971 | |||
2969 | WARNING: The threading support is still somewhat experimental, and it |
|
2972 | WARNING: The threading support is still somewhat experimental, and it | |
2970 | has only seen reasonable testing under Linux. Threaded code is |
|
2973 | has only seen reasonable testing under Linux. Threaded code is | |
2971 | particularly tricky to debug, and it tends to show extremely |
|
2974 | particularly tricky to debug, and it tends to show extremely | |
2972 | platform-dependent behavior. Since I only have access to Linux machines, |
|
2975 | platform-dependent behavior. Since I only have access to Linux machines, | |
2973 | I will have to rely on user's experiences and assistance for this area |
|
2976 | I will have to rely on user's experiences and assistance for this area | |
2974 | of IPython to improve under other platforms. |
|
2977 | of IPython to improve under other platforms. | |
2975 |
|
2978 | |||
2976 | IPython, via the -gthread , -qthread, -q4thread and -wthread options |
|
2979 | IPython, via the -gthread , -qthread, -q4thread and -wthread options | |
2977 | (described in Sec. `Threading options`_), can run in |
|
2980 | (described in Sec. `Threading options`_), can run in | |
2978 | multithreaded mode to support pyGTK, Qt3, Qt4 and WXPython applications |
|
2981 | multithreaded mode to support pyGTK, Qt3, Qt4 and WXPython applications | |
2979 | respectively. These GUI toolkits need to control the python main loop of |
|
2982 | respectively. These GUI toolkits need to control the python main loop of | |
2980 | execution, so under a normal Python interpreter, starting a pyGTK, Qt3, |
|
2983 | execution, so under a normal Python interpreter, starting a pyGTK, Qt3, | |
2981 | Qt4 or WXPython application will immediately freeze the shell. |
|
2984 | Qt4 or WXPython application will immediately freeze the shell. | |
2982 |
|
2985 | |||
2983 | IPython, with one of these options (you can only use one at a time), |
|
2986 | IPython, with one of these options (you can only use one at a time), | |
2984 | separates the graphical loop and IPython's code execution run into |
|
2987 | separates the graphical loop and IPython's code execution run into | |
2985 | different threads. This allows you to test interactively (with %run, for |
|
2988 | different threads. This allows you to test interactively (with %run, for | |
2986 | example) your GUI code without blocking. |
|
2989 | example) your GUI code without blocking. | |
2987 |
|
2990 | |||
2988 | A nice mini-tutorial on using IPython along with the Qt Designer |
|
2991 | A nice mini-tutorial on using IPython along with the Qt Designer | |
2989 | application is available at the SciPy wiki: |
|
2992 | application is available at the SciPy wiki: | |
2990 | http://www.scipy.org/Cookbook/Matplotlib/Qt_with_IPython_and_Designer. |
|
2993 | http://www.scipy.org/Cookbook/Matplotlib/Qt_with_IPython_and_Designer. | |
2991 |
|
2994 | |||
2992 |
|
2995 | |||
2993 | Tk issues |
|
2996 | Tk issues | |
2994 | --------- |
|
2997 | --------- | |
2995 |
|
2998 | |||
2996 | As indicated in Sec. `Threading options`_, a special -tk option is |
|
2999 | As indicated in Sec. `Threading options`_, a special -tk option is | |
2997 | provided to try and allow Tk graphical applications to coexist |
|
3000 | provided to try and allow Tk graphical applications to coexist | |
2998 | interactively with WX, Qt or GTK ones. Whether this works at all, |
|
3001 | interactively with WX, Qt or GTK ones. Whether this works at all, | |
2999 | however, is very platform and configuration dependent. Please |
|
3002 | however, is very platform and configuration dependent. Please | |
3000 | experiment with simple test cases before committing to using this |
|
3003 | experiment with simple test cases before committing to using this | |
3001 | combination of Tk and GTK/Qt/WX threading in a production environment. |
|
3004 | combination of Tk and GTK/Qt/WX threading in a production environment. | |
3002 |
|
3005 | |||
3003 |
|
3006 | |||
3004 | I/O pitfalls |
|
3007 | I/O pitfalls | |
3005 | ------------ |
|
3008 | ------------ | |
3006 |
|
3009 | |||
3007 | Be mindful that the Python interpreter switches between threads every |
|
3010 | Be mindful that the Python interpreter switches between threads every | |
3008 | $N$ bytecodes, where the default value as of Python 2.3 is $N=100.$ This |
|
3011 | $N$ bytecodes, where the default value as of Python 2.3 is $N=100.$ This | |
3009 | value can be read by using the sys.getcheckinterval() function, and it |
|
3012 | value can be read by using the sys.getcheckinterval() function, and it | |
3010 | can be reset via sys.setcheckinterval(N). This switching of threads can |
|
3013 | can be reset via sys.setcheckinterval(N). This switching of threads can | |
3011 | cause subtly confusing effects if one of your threads is doing file I/O. |
|
3014 | cause subtly confusing effects if one of your threads is doing file I/O. | |
3012 | In text mode, most systems only flush file buffers when they encounter a |
|
3015 | In text mode, most systems only flush file buffers when they encounter a | |
3013 | '\n'. An instruction as simple as:: |
|
3016 | '\n'. An instruction as simple as:: | |
3014 |
|
3017 | |||
3015 | print >> filehandle, ''hello world'' |
|
3018 | print >> filehandle, ''hello world'' | |
3016 |
|
3019 | |||
3017 | actually consists of several bytecodes, so it is possible that the |
|
3020 | actually consists of several bytecodes, so it is possible that the | |
3018 | newline does not reach your file before the next thread switch. |
|
3021 | newline does not reach your file before the next thread switch. | |
3019 | Similarly, if you are writing to a file in binary mode, the file won't |
|
3022 | Similarly, if you are writing to a file in binary mode, the file won't | |
3020 | be flushed until the buffer fills, and your other thread may see |
|
3023 | be flushed until the buffer fills, and your other thread may see | |
3021 | apparently truncated files. |
|
3024 | apparently truncated files. | |
3022 |
|
3025 | |||
3023 | For this reason, if you are using IPython's thread support and have (for |
|
3026 | For this reason, if you are using IPython's thread support and have (for | |
3024 | example) a GUI application which will read data generated by files |
|
3027 | example) a GUI application which will read data generated by files | |
3025 | written to from the IPython thread, the safest approach is to open all |
|
3028 | written to from the IPython thread, the safest approach is to open all | |
3026 | of your files in unbuffered mode (the third argument to the file/open |
|
3029 | of your files in unbuffered mode (the third argument to the file/open | |
3027 | function is the buffering value):: |
|
3030 | function is the buffering value):: | |
3028 |
|
3031 | |||
3029 | filehandle = open(filename,mode,0) |
|
3032 | filehandle = open(filename,mode,0) | |
3030 |
|
3033 | |||
3031 | This is obviously a brute force way of avoiding race conditions with the |
|
3034 | This is obviously a brute force way of avoiding race conditions with the | |
3032 | file buffering. If you want to do it cleanly, and you have a resource |
|
3035 | file buffering. If you want to do it cleanly, and you have a resource | |
3033 | which is being shared by the interactive IPython loop and your GUI |
|
3036 | which is being shared by the interactive IPython loop and your GUI | |
3034 | thread, you should really handle it with thread locking and |
|
3037 | thread, you should really handle it with thread locking and | |
3035 | syncrhonization properties. The Python documentation discusses these. |
|
3038 | syncrhonization properties. The Python documentation discusses these. | |
3036 |
|
3039 | |||
3037 |
.. _ |
|
3040 | .. _interactive_demos: | |
3038 |
|
3041 | |||
3039 | Interactive demos with IPython |
|
3042 | Interactive demos with IPython | |
3040 | ============================== |
|
3043 | ============================== | |
3041 |
|
3044 | |||
3042 | IPython ships with a basic system for running scripts interactively in |
|
3045 | IPython ships with a basic system for running scripts interactively in | |
3043 | sections, useful when presenting code to audiences. A few tags embedded |
|
3046 | sections, useful when presenting code to audiences. A few tags embedded | |
3044 | in comments (so that the script remains valid Python code) divide a file |
|
3047 | in comments (so that the script remains valid Python code) divide a file | |
3045 | into separate blocks, and the demo can be run one block at a time, with |
|
3048 | into separate blocks, and the demo can be run one block at a time, with | |
3046 | IPython printing (with syntax highlighting) the block before executing |
|
3049 | IPython printing (with syntax highlighting) the block before executing | |
3047 | it, and returning to the interactive prompt after each block. The |
|
3050 | it, and returning to the interactive prompt after each block. The | |
3048 | interactive namespace is updated after each block is run with the |
|
3051 | interactive namespace is updated after each block is run with the | |
3049 | contents of the demo's namespace. |
|
3052 | contents of the demo's namespace. | |
3050 |
|
3053 | |||
3051 | This allows you to show a piece of code, run it and then execute |
|
3054 | This allows you to show a piece of code, run it and then execute | |
3052 | interactively commands based on the variables just created. Once you |
|
3055 | interactively commands based on the variables just created. Once you | |
3053 | want to continue, you simply execute the next block of the demo. The |
|
3056 | want to continue, you simply execute the next block of the demo. The | |
3054 | following listing shows the markup necessary for dividing a script into |
|
3057 | following listing shows the markup necessary for dividing a script into | |
3055 | sections for execution as a demo:: |
|
3058 | sections for execution as a demo:: | |
3056 |
|
3059 | |||
3057 |
|
3060 | |||
3058 | """A simple interactive demo to illustrate the use of IPython's Demo class. |
|
3061 | """A simple interactive demo to illustrate the use of IPython's Demo class. | |
3059 |
|
3062 | |||
3060 | Any python script can be run as a demo, but that does little more than showing |
|
3063 | Any python script can be run as a demo, but that does little more than showing | |
3061 | it on-screen, syntax-highlighted in one shot. If you add a little simple |
|
3064 | it on-screen, syntax-highlighted in one shot. If you add a little simple | |
3062 | markup, you can stop at specified intervals and return to the ipython prompt, |
|
3065 | markup, you can stop at specified intervals and return to the ipython prompt, | |
3063 | resuming execution later. |
|
3066 | resuming execution later. | |
3064 | """ |
|
3067 | """ | |
3065 |
|
3068 | |||
3066 | print 'Hello, welcome to an interactive IPython demo.' |
|
3069 | print 'Hello, welcome to an interactive IPython demo.' | |
3067 | print 'Executing this block should require confirmation before proceeding,' |
|
3070 | print 'Executing this block should require confirmation before proceeding,' | |
3068 | print 'unless auto_all has been set to true in the demo object' |
|
3071 | print 'unless auto_all has been set to true in the demo object' | |
3069 |
|
3072 | |||
3070 | # The mark below defines a block boundary, which is a point where IPython will |
|
3073 | # The mark below defines a block boundary, which is a point where IPython will | |
3071 | # stop execution and return to the interactive prompt. |
|
3074 | # stop execution and return to the interactive prompt. | |
3072 | # Note that in actual interactive execution, |
|
3075 | # Note that in actual interactive execution, | |
3073 | # <demo> --- stop --- |
|
3076 | # <demo> --- stop --- | |
3074 |
|
3077 | |||
3075 | x = 1 |
|
3078 | x = 1 | |
3076 | y = 2 |
|
3079 | y = 2 | |
3077 |
|
3080 | |||
3078 | # <demo> --- stop --- |
|
3081 | # <demo> --- stop --- | |
3079 |
|
3082 | |||
3080 | # the mark below makes this block as silent |
|
3083 | # the mark below makes this block as silent | |
3081 | # <demo> silent |
|
3084 | # <demo> silent | |
3082 |
|
3085 | |||
3083 | print 'This is a silent block, which gets executed but not printed.' |
|
3086 | print 'This is a silent block, which gets executed but not printed.' | |
3084 |
|
3087 | |||
3085 | # <demo> --- stop --- |
|
3088 | # <demo> --- stop --- | |
3086 | # <demo> auto |
|
3089 | # <demo> auto | |
3087 | print 'This is an automatic block.' |
|
3090 | print 'This is an automatic block.' | |
3088 | print 'It is executed without asking for confirmation, but printed.' |
|
3091 | print 'It is executed without asking for confirmation, but printed.' | |
3089 | z = x+y |
|
3092 | z = x+y | |
3090 |
|
3093 | |||
3091 | print 'z=',x |
|
3094 | print 'z=',x | |
3092 |
|
3095 | |||
3093 | # <demo> --- stop --- |
|
3096 | # <demo> --- stop --- | |
3094 | # This is just another normal block. |
|
3097 | # This is just another normal block. | |
3095 | print 'z is now:', z |
|
3098 | print 'z is now:', z | |
3096 |
|
3099 | |||
3097 | print 'bye!' |
|
3100 | print 'bye!' | |
3098 |
|
3101 | |||
3099 | In order to run a file as a demo, you must first make a Demo object out |
|
3102 | In order to run a file as a demo, you must first make a Demo object out | |
3100 | of it. If the file is named myscript.py, the following code will make a |
|
3103 | of it. If the file is named myscript.py, the following code will make a | |
3101 | demo:: |
|
3104 | demo:: | |
3102 |
|
3105 | |||
3103 | from IPython.demo import Demo |
|
3106 | from IPython.demo import Demo | |
3104 |
|
3107 | |||
3105 | mydemo = Demo('myscript.py') |
|
3108 | mydemo = Demo('myscript.py') | |
3106 |
|
3109 | |||
3107 | This creates the mydemo object, whose blocks you run one at a time by |
|
3110 | This creates the mydemo object, whose blocks you run one at a time by | |
3108 | simply calling the object with no arguments. If you have autocall active |
|
3111 | simply calling the object with no arguments. If you have autocall active | |
3109 | in IPython (the default), all you need to do is type:: |
|
3112 | in IPython (the default), all you need to do is type:: | |
3110 |
|
3113 | |||
3111 | mydemo |
|
3114 | mydemo | |
3112 |
|
3115 | |||
3113 | and IPython will call it, executing each block. Demo objects can be |
|
3116 | and IPython will call it, executing each block. Demo objects can be | |
3114 | restarted, you can move forward or back skipping blocks, re-execute the |
|
3117 | restarted, you can move forward or back skipping blocks, re-execute the | |
3115 | last block, etc. Simply use the Tab key on a demo object to see its |
|
3118 | last block, etc. Simply use the Tab key on a demo object to see its | |
3116 | methods, and call '?' on them to see their docstrings for more usage |
|
3119 | methods, and call '?' on them to see their docstrings for more usage | |
3117 | details. In addition, the demo module itself contains a comprehensive |
|
3120 | details. In addition, the demo module itself contains a comprehensive | |
3118 | docstring, which you can access via:: |
|
3121 | docstring, which you can access via:: | |
3119 |
|
3122 | |||
3120 | from IPython import demo |
|
3123 | from IPython import demo | |
3121 |
|
3124 | |||
3122 | demo? |
|
3125 | demo? | |
3123 |
|
3126 | |||
3124 | Limitations: It is important to note that these demos are limited to |
|
3127 | Limitations: It is important to note that these demos are limited to | |
3125 | fairly simple uses. In particular, you can not put division marks in |
|
3128 | fairly simple uses. In particular, you can not put division marks in | |
3126 | indented code (loops, if statements, function definitions, etc.) |
|
3129 | indented code (loops, if statements, function definitions, etc.) | |
3127 | Supporting something like this would basically require tracking the |
|
3130 | Supporting something like this would basically require tracking the | |
3128 | internal execution state of the Python interpreter, so only top-level |
|
3131 | internal execution state of the Python interpreter, so only top-level | |
3129 | divisions are allowed. If you want to be able to open an IPython |
|
3132 | divisions are allowed. If you want to be able to open an IPython | |
3130 | instance at an arbitrary point in a program, you can use IPython's |
|
3133 | instance at an arbitrary point in a program, you can use IPython's | |
3131 | embedding facilities, described in detail in Sec. 9 |
|
3134 | embedding facilities, described in detail in Sec. 9 | |
3132 |
|
3135 | |||
3133 |
|
3136 | |||
3134 | .. _Matplotlib support: |
|
3137 | .. _Matplotlib support: | |
3135 |
|
3138 | |||
3136 | Plotting with matplotlib |
|
3139 | Plotting with matplotlib | |
3137 | ======================== |
|
3140 | ======================== | |
3138 |
|
3141 | |||
3139 | The matplotlib library (http://matplotlib.sourceforge.net |
|
3142 | The matplotlib library (http://matplotlib.sourceforge.net | |
3140 | http://matplotlib.sourceforge.net) provides high quality 2D plotting for |
|
3143 | http://matplotlib.sourceforge.net) provides high quality 2D plotting for | |
3141 | Python. Matplotlib can produce plots on screen using a variety of GUI |
|
3144 | Python. Matplotlib can produce plots on screen using a variety of GUI | |
3142 | toolkits, including Tk, GTK and WXPython. It also provides a number of |
|
3145 | toolkits, including Tk, GTK and WXPython. It also provides a number of | |
3143 | commands useful for scientific computing, all with a syntax compatible |
|
3146 | commands useful for scientific computing, all with a syntax compatible | |
3144 | with that of the popular Matlab program. |
|
3147 | with that of the popular Matlab program. | |
3145 |
|
3148 | |||
3146 |
IPython accepts the special option -pylab ( |
|
3149 | IPython accepts the special option -pylab (see :ref:`here | |
3147 |
options` |
|
3150 | <command_line_options>`). This configures it to support matplotlib, honoring | |
3148 | settings in the .matplotlibrc file. IPython will detect the user's |
|
3151 | the settings in the .matplotlibrc file. IPython will detect the user's choice | |
3149 |
|
|
3152 | of matplotlib GUI backend, and automatically select the proper threading model | |
3150 |
|
|
3153 | to prevent blocking. It also sets matplotlib in interactive mode and modifies | |
3151 | interactive mode and modifies %run slightly, so that any |
|
3154 | %run slightly, so that any matplotlib-based script can be executed using %run | |
3152 | matplotlib-based script can be executed using %run and the final |
|
3155 | and the final show() command does not block the interactive shell. | |
3153 | show() command does not block the interactive shell. |
|
3156 | ||
3154 |
|
3157 | The -pylab option must be given first in order for IPython to configure its | ||
3155 | The -pylab option must be given first in order for IPython to |
|
3158 | threading mode. However, you can still issue other options afterwards. This | |
3156 | configure its threading mode. However, you can still issue other |
|
3159 | allows you to have a matplotlib-based environment customized with additional | |
3157 | options afterwards. This allows you to have a matplotlib-based |
|
3160 | modules using the standard IPython profile mechanism (see :ref:`here | |
3158 | environment customized with additional modules using the standard |
|
3161 | <profiles>`): ``ipython -pylab -p myprofile`` will load the profile defined in | |
3159 | IPython profile mechanism (Sec. Profiles_): ''ipython -pylab -p |
|
3162 | ipythonrc-myprofile after configuring matplotlib. | |
3160 | myprofile'' will load the profile defined in ipythonrc-myprofile after |
|
|||
3161 | configuring matplotlib. |
|
|||
3162 |
|
||||
3163 |
|
@@ -1,315 +1,317 b'' | |||||
1 | .. _tutorial: |
|
1 | .. _tutorial: | |
2 |
|
2 | |||
3 | ====================== |
|
3 | ====================== | |
4 | Quick IPython tutorial |
|
4 | Quick IPython tutorial | |
5 | ====================== |
|
5 | ====================== | |
6 |
|
6 | |||
7 | .. contents:: |
|
7 | .. contents:: | |
8 |
|
8 | |||
9 | IPython can be used as an improved replacement for the Python prompt, |
|
9 | IPython can be used as an improved replacement for the Python prompt, | |
10 | and for that you don't really need to read any more of this manual. But |
|
10 | and for that you don't really need to read any more of this manual. But | |
11 | in this section we'll try to summarize a few tips on how to make the |
|
11 | in this section we'll try to summarize a few tips on how to make the | |
12 | most effective use of it for everyday Python development, highlighting |
|
12 | most effective use of it for everyday Python development, highlighting | |
13 | things you might miss in the rest of the manual (which is getting long). |
|
13 | things you might miss in the rest of the manual (which is getting long). | |
14 | We'll give references to parts in the manual which provide more detail |
|
14 | We'll give references to parts in the manual which provide more detail | |
15 | when appropriate. |
|
15 | when appropriate. | |
16 |
|
16 | |||
17 | The following article by Jeremy Jones provides an introductory tutorial |
|
17 | The following article by Jeremy Jones provides an introductory tutorial | |
18 | about IPython: http://www.onlamp.com/pub/a/python/2005/01/27/ipython.html |
|
18 | about IPython: http://www.onlamp.com/pub/a/python/2005/01/27/ipython.html | |
19 |
|
19 | |||
20 | Highlights |
|
20 | Highlights | |
21 | ========== |
|
21 | ========== | |
22 |
|
22 | |||
23 | Tab completion |
|
23 | Tab completion | |
24 | -------------- |
|
24 | -------------- | |
25 |
|
25 | |||
26 | TAB-completion, especially for attributes, is a convenient way to explore the |
|
26 | TAB-completion, especially for attributes, is a convenient way to explore the | |
27 | structure of any object you're dealing with. Simply type object_name.<TAB> |
|
27 | structure of any object you're dealing with. Simply type object_name.<TAB> and | |
28 |
|
|
28 | a list of the object's attributes will be printed (see :ref:`the readline | |
29 |
more). Tab completion also works on file and directory |
|
29 | section <readline>` for more). Tab completion also works on file and directory | |
30 |
with IPython's alias system allows you to do from within |
|
30 | names, which combined with IPython's alias system allows you to do from within | |
31 | things you normally would need the system shell for. |
|
31 | IPython many of the things you normally would need the system shell for. | |
32 |
|
32 | |||
33 | Explore your objects |
|
33 | Explore your objects | |
34 | -------------------- |
|
34 | -------------------- | |
35 |
|
35 | |||
36 | Typing object_name? will print all sorts of details about any object, |
|
36 | Typing object_name? will print all sorts of details about any object, | |
37 | including docstrings, function definition lines (for call arguments) and |
|
37 | including docstrings, function definition lines (for call arguments) and | |
38 | constructor details for classes. The magic commands %pdoc, %pdef, %psource |
|
38 | constructor details for classes. The magic commands %pdoc, %pdef, %psource | |
39 | and %pfile will respectively print the docstring, function definition line, |
|
39 | and %pfile will respectively print the docstring, function definition line, | |
40 | full source code and the complete file for any object (when they can be |
|
40 | full source code and the complete file for any object (when they can be | |
41 | found). If automagic is on (it is by default), you don't need to type the '%' |
|
41 | found). If automagic is on (it is by default), you don't need to type the '%' | |
42 |
explicitly. See |
|
42 | explicitly. See :ref:`this section <dynamic_object_info>` for more. | |
43 |
|
43 | |||
44 | The `%run` magic command |
|
44 | The `%run` magic command | |
45 | ------------------------ |
|
45 | ------------------------ | |
46 |
|
46 | |||
47 | The %run magic command allows you to run any python script and load all of |
|
47 | The %run magic command allows you to run any python script and load all of its | |
48 |
|
|
48 | data directly into the interactive namespace. Since the file is re-read from | |
49 |
|
|
49 | disk each time, changes you make to it are reflected immediately (in contrast | |
50 |
|
|
50 | to the behavior of import). I rarely use import for code I am testing, relying | |
51 |
|
|
51 | on %run instead. See :ref:`this section <magic>` for more on this and other | |
52 |
|
|
52 | magic commands, or type the name of any magic command and ? to get details on | |
53 |
|
|
53 | it. See also :ref:`this section <dreload>` for a recursive reload command. %run | |
54 | also has special flags for timing the execution of your scripts (-t) and for |
|
54 | also has special flags for timing the execution of your scripts (-t) and for | |
55 | executing them under the control of either Python's pdb debugger (-d) or |
|
55 | executing them under the control of either Python's pdb debugger (-d) or | |
56 | profiler (-p). With all of these, %run can be used as the main tool for |
|
56 | profiler (-p). With all of these, %run can be used as the main tool for | |
57 | efficient interactive development of code which you write in your editor of |
|
57 | efficient interactive development of code which you write in your editor of | |
58 | choice. |
|
58 | choice. | |
59 |
|
59 | |||
60 | Debug a Python script |
|
60 | Debug a Python script | |
61 | --------------------- |
|
61 | --------------------- | |
62 |
|
62 | |||
63 | Use the Python debugger, pdb. The %pdb command allows you to toggle on and |
|
63 | Use the Python debugger, pdb. The %pdb command allows you to toggle on and off | |
64 |
|
|
64 | the automatic invocation of an IPython-enhanced pdb debugger (with coloring, | |
65 |
|
|
65 | tab completion and more) at any uncaught exception. The advantage of this is | |
66 |
|
|
66 | that pdb starts inside the function where the exception occurred, with all data | |
67 |
|
|
67 | still available. You can print variables, see code, execute statements and even | |
68 |
|
|
68 | walk up and down the call stack to track down the true source of the problem | |
69 |
|
|
69 | (which often is many layers in the stack above where the exception gets | |
70 |
|
|
70 | triggered). Running programs with %run and pdb active can be an efficient to | |
71 |
|
|
71 | develop and debug code, in many cases eliminating the need for print statements | |
72 |
|
|
72 | or external debugging tools. I often simply put a 1/0 in a place where I want | |
73 |
|
|
73 | to take a look so that pdb gets called, quickly view whatever variables I need | |
74 |
|
|
74 | to or test various pieces of code and then remove the 1/0. Note also that '%run | |
75 | the 1/0. Note also that '%run -d' activates pdb and automatically sets |
|
75 | -d' activates pdb and automatically sets initial breakpoints for you to step | |
76 | initial breakpoints for you to step through your code, watch variables, etc. |
|
76 | through your code, watch variables, etc. The :ref:`output caching section | |
77 |
|
|
77 | <output_caching>` has more details. | |
78 |
|
78 | |||
79 | Use the output cache |
|
79 | Use the output cache | |
80 | -------------------- |
|
80 | -------------------- | |
81 |
|
81 | |||
82 | All output results are automatically stored in a global dictionary named Out |
|
82 | All output results are automatically stored in a global dictionary named Out | |
83 | and variables named _1, _2, etc. alias them. For example, the result of input |
|
83 | and variables named _1, _2, etc. alias them. For example, the result of input | |
84 | line 4 is available either as Out[4] or as _4. Additionally, three variables |
|
84 | line 4 is available either as Out[4] or as _4. Additionally, three variables | |
85 | named _, __ and ___ are always kept updated with the for the last three |
|
85 | named _, __ and ___ are always kept updated with the for the last three | |
86 | results. This allows you to recall any previous result and further use it for |
|
86 | results. This allows you to recall any previous result and further use it for | |
87 |
new calculations. See |
|
87 | new calculations. See :ref:`the output caching section <output_caching>` for | |
|
88 | more. | |||
88 |
|
89 | |||
89 | Suppress output |
|
90 | Suppress output | |
90 | --------------- |
|
91 | --------------- | |
91 |
|
92 | |||
92 | Put a ';' at the end of a line to suppress the printing of output. This is |
|
93 | Put a ';' at the end of a line to suppress the printing of output. This is | |
93 | useful when doing calculations which generate long output you are not |
|
94 | useful when doing calculations which generate long output you are not | |
94 | interested in seeing. The _* variables and the Out[] list do get updated with |
|
95 | interested in seeing. The _* variables and the Out[] list do get updated with | |
95 | the contents of the output, even if it is not printed. You can thus still |
|
96 | the contents of the output, even if it is not printed. You can thus still | |
96 | access the generated results this way for further processing. |
|
97 | access the generated results this way for further processing. | |
97 |
|
98 | |||
98 | Input cache |
|
99 | Input cache | |
99 | ----------- |
|
100 | ----------- | |
100 |
|
101 | |||
101 | A similar system exists for caching input. All input is stored in a global |
|
102 | A similar system exists for caching input. All input is stored in a global | |
102 | list called In , so you can re-execute lines 22 through 28 plus line 34 by |
|
103 | list called In , so you can re-execute lines 22 through 28 plus line 34 by | |
103 | typing 'exec In[22:29]+In[34]' (using Python slicing notation). If you need |
|
104 | typing 'exec In[22:29]+In[34]' (using Python slicing notation). If you need | |
104 | to execute the same set of lines often, you can assign them to a macro with |
|
105 | to execute the same set of lines often, you can assign them to a macro with | |
105 |
the %macro function. See |
|
106 | the %macro function. See :ref:`here <input_caching>` for more. | |
106 |
|
107 | |||
107 | Use your input history |
|
108 | Use your input history | |
108 | ---------------------- |
|
109 | ---------------------- | |
109 |
|
110 | |||
110 | The %hist command can show you all previous input, without line numbers if |
|
111 | The %hist command can show you all previous input, without line numbers if | |
111 | desired (option -n) so you can directly copy and paste code either back in |
|
112 | desired (option -n) so you can directly copy and paste code either back in | |
112 | IPython or in a text editor. You can also save all your history by turning on |
|
113 | IPython or in a text editor. You can also save all your history by turning on | |
113 | logging via %logstart; these logs can later be either reloaded as IPython |
|
114 | logging via %logstart; these logs can later be either reloaded as IPython | |
114 | sessions or used as code for your programs. |
|
115 | sessions or used as code for your programs. | |
115 |
|
116 | |||
116 | Define your own system aliases |
|
117 | Define your own system aliases | |
117 | ------------------------------ |
|
118 | ------------------------------ | |
118 |
|
119 | |||
119 | Even though IPython gives you access to your system shell via the ! prefix, |
|
120 | Even though IPython gives you access to your system shell via the ! prefix, | |
120 | it is convenient to have aliases to the system commands you use most often. |
|
121 | it is convenient to have aliases to the system commands you use most often. | |
121 | This allows you to work seamlessly from inside IPython with the same commands |
|
122 | This allows you to work seamlessly from inside IPython with the same commands | |
122 | you are used to in your system shell. IPython comes with some pre-defined |
|
123 | you are used to in your system shell. IPython comes with some pre-defined | |
123 | aliases and a complete system for changing directories, both via a stack (see |
|
124 | aliases and a complete system for changing directories, both via a stack (see | |
124 | %pushd, %popd and %dhist) and via direct %cd. The latter keeps a history of |
|
125 | %pushd, %popd and %dhist) and via direct %cd. The latter keeps a history of | |
125 | visited directories and allows you to go to any previously visited one. |
|
126 | visited directories and allows you to go to any previously visited one. | |
126 |
|
127 | |||
127 | Call system shell commands |
|
128 | Call system shell commands | |
128 | -------------------------- |
|
129 | -------------------------- | |
129 |
|
130 | |||
130 | Use Python to manipulate the results of system commands. The '!!' special |
|
131 | Use Python to manipulate the results of system commands. The '!!' special | |
131 | syntax, and the %sc and %sx magic commands allow you to capture system output |
|
132 | syntax, and the %sc and %sx magic commands allow you to capture system output | |
132 | into Python variables. |
|
133 | into Python variables. | |
133 |
|
134 | |||
134 | Use Python variables when calling the shell |
|
135 | Use Python variables when calling the shell | |
135 | ------------------------------------------- |
|
136 | ------------------------------------------- | |
136 |
|
137 | |||
137 | Expand python variables when calling the shell (either via '!' and '!!' or |
|
138 | Expand python variables when calling the shell (either via '!' and '!!' or via | |
138 |
|
|
139 | aliases) by prepending a $ in front of them. You can also expand complete | |
139 |
python expressions. See |
|
140 | python expressions. See :ref:`our shell section <system_shell_access>` for | |
|
141 | more details. | |||
140 |
|
142 | |||
141 | Use profiles |
|
143 | Use profiles | |
142 | ------------ |
|
144 | ------------ | |
143 |
|
145 | |||
144 | Use profiles to maintain different configurations (modules to load, function |
|
146 | Use profiles to maintain different configurations (modules to load, function | |
145 | definitions, option settings) for particular tasks. You can then have |
|
147 | definitions, option settings) for particular tasks. You can then have | |
146 |
customized versions of IPython for specific purposes. |
|
148 | customized versions of IPython for specific purposes. :ref:`This section | |
147 | more. |
|
149 | <profiles>` has more details. | |
148 |
|
150 | |||
149 |
|
151 | |||
150 | Embed IPython in your programs |
|
152 | Embed IPython in your programs | |
151 | ------------------------------ |
|
153 | ------------------------------ | |
152 |
|
154 | |||
153 | A few lines of code are enough to load a complete IPython inside your own |
|
155 | A few lines of code are enough to load a complete IPython inside your own | |
154 | programs, giving you the ability to work with your data interactively after |
|
156 | programs, giving you the ability to work with your data interactively after | |
155 |
automatic processing has been completed. See |
|
157 | automatic processing has been completed. See :ref:`here <embedding>` for more. | |
156 |
|
158 | |||
157 | Use the Python profiler |
|
159 | Use the Python profiler | |
158 | ----------------------- |
|
160 | ----------------------- | |
159 |
|
161 | |||
160 | When dealing with performance issues, the %run command with a -p option |
|
162 | When dealing with performance issues, the %run command with a -p option | |
161 | allows you to run complete programs under the control of the Python profiler. |
|
163 | allows you to run complete programs under the control of the Python profiler. | |
162 | The %prun command does a similar job for single Python expressions (like |
|
164 | The %prun command does a similar job for single Python expressions (like | |
163 | function calls). |
|
165 | function calls). | |
164 |
|
166 | |||
165 | Use IPython to present interactive demos |
|
167 | Use IPython to present interactive demos | |
166 | ---------------------------------------- |
|
168 | ---------------------------------------- | |
167 |
|
169 | |||
168 | Use the IPython.demo.Demo class to load any Python script as an interactive |
|
170 | Use the IPython.demo.Demo class to load any Python script as an interactive | |
169 | demo. With a minimal amount of simple markup, you can control the execution |
|
171 | demo. With a minimal amount of simple markup, you can control the execution of | |
170 |
|
|
172 | the script, stopping as needed. See :ref:`here <interactive_demos>` for more. | |
171 |
|
173 | |||
172 | Run doctests |
|
174 | Run doctests | |
173 | ------------ |
|
175 | ------------ | |
174 |
|
176 | |||
175 | Run your doctests from within IPython for development and debugging. The |
|
177 | Run your doctests from within IPython for development and debugging. The | |
176 | special %doctest_mode command toggles a mode where the prompt, output and |
|
178 | special %doctest_mode command toggles a mode where the prompt, output and | |
177 | exceptions display matches as closely as possible that of the default Python |
|
179 | exceptions display matches as closely as possible that of the default Python | |
178 | interpreter. In addition, this mode allows you to directly paste in code that |
|
180 | interpreter. In addition, this mode allows you to directly paste in code that | |
179 | contains leading '>>>' prompts, even if they have extra leading whitespace |
|
181 | contains leading '>>>' prompts, even if they have extra leading whitespace | |
180 | (as is common in doctest files). This combined with the '%history -tn' call |
|
182 | (as is common in doctest files). This combined with the '%history -tn' call | |
181 | to see your translated history (with these extra prompts removed and no line |
|
183 | to see your translated history (with these extra prompts removed and no line | |
182 | numbers) allows for an easy doctest workflow, where you can go from doctest |
|
184 | numbers) allows for an easy doctest workflow, where you can go from doctest | |
183 | to interactive execution to pasting into valid Python code as needed. |
|
185 | to interactive execution to pasting into valid Python code as needed. | |
184 |
|
186 | |||
185 | Source code handling tips |
|
187 | Source code handling tips | |
186 | ========================= |
|
188 | ========================= | |
187 |
|
189 | |||
188 | IPython is a line-oriented program, without full control of the |
|
190 | IPython is a line-oriented program, without full control of the | |
189 | terminal. Therefore, it doesn't support true multiline editing. However, |
|
191 | terminal. Therefore, it doesn't support true multiline editing. However, | |
190 | it has a number of useful tools to help you in dealing effectively with |
|
192 | it has a number of useful tools to help you in dealing effectively with | |
191 | more complex editing. |
|
193 | more complex editing. | |
192 |
|
194 | |||
193 | The %edit command gives a reasonable approximation of multiline editing, |
|
195 | The %edit command gives a reasonable approximation of multiline editing, | |
194 | by invoking your favorite editor on the spot. IPython will execute the |
|
196 | by invoking your favorite editor on the spot. IPython will execute the | |
195 | code you type in there as if it were typed interactively. Type %edit? |
|
197 | code you type in there as if it were typed interactively. Type %edit? | |
196 | for the full details on the edit command. |
|
198 | for the full details on the edit command. | |
197 |
|
199 | |||
198 | If you have typed various commands during a session, which you'd like to |
|
200 | If you have typed various commands during a session, which you'd like to | |
199 | reuse, IPython provides you with a number of tools. Start by using %hist |
|
201 | reuse, IPython provides you with a number of tools. Start by using %hist | |
200 | to see your input history, so you can see the line numbers of all input. |
|
202 | to see your input history, so you can see the line numbers of all input. | |
201 | Let us say that you'd like to reuse lines 10 through 20, plus lines 24 |
|
203 | Let us say that you'd like to reuse lines 10 through 20, plus lines 24 | |
202 | and 28. All the commands below can operate on these with the syntax:: |
|
204 | and 28. All the commands below can operate on these with the syntax:: | |
203 |
|
205 | |||
204 | %command 10-20 24 28 |
|
206 | %command 10-20 24 28 | |
205 |
|
207 | |||
206 | where the command given can be: |
|
208 | where the command given can be: | |
207 |
|
209 | |||
208 | * %macro <macroname>: this stores the lines into a variable which, |
|
210 | * %macro <macroname>: this stores the lines into a variable which, | |
209 | when called at the prompt, re-executes the input. Macros can be |
|
211 | when called at the prompt, re-executes the input. Macros can be | |
210 | edited later using '%edit macroname', and they can be stored |
|
212 | edited later using '%edit macroname', and they can be stored | |
211 | persistently across sessions with '%store macroname' (the storage |
|
213 | persistently across sessions with '%store macroname' (the storage | |
212 | system is per-profile). The combination of quick macros, |
|
214 | system is per-profile). The combination of quick macros, | |
213 | persistent storage and editing, allows you to easily refine |
|
215 | persistent storage and editing, allows you to easily refine | |
214 | quick-and-dirty interactive input into permanent utilities, always |
|
216 | quick-and-dirty interactive input into permanent utilities, always | |
215 | available both in IPython and as files for general reuse. |
|
217 | available both in IPython and as files for general reuse. | |
216 | * %edit: this will open a text editor with those lines pre-loaded |
|
218 | * %edit: this will open a text editor with those lines pre-loaded | |
217 | for further modification. It will then execute the resulting |
|
219 | for further modification. It will then execute the resulting | |
218 | file's contents as if you had typed it at the prompt. |
|
220 | file's contents as if you had typed it at the prompt. | |
219 | * %save <filename>: this saves the lines directly to a named file on |
|
221 | * %save <filename>: this saves the lines directly to a named file on | |
220 | disk. |
|
222 | disk. | |
221 |
|
223 | |||
222 | While %macro saves input lines into memory for interactive re-execution, |
|
224 | While %macro saves input lines into memory for interactive re-execution, | |
223 | sometimes you'd like to save your input directly to a file. The %save |
|
225 | sometimes you'd like to save your input directly to a file. The %save | |
224 | magic does this: its input sytnax is the same as %macro, but it saves |
|
226 | magic does this: its input sytnax is the same as %macro, but it saves | |
225 | your input directly to a Python file. Note that the %logstart command |
|
227 | your input directly to a Python file. Note that the %logstart command | |
226 | also saves input, but it logs all input to disk (though you can |
|
228 | also saves input, but it logs all input to disk (though you can | |
227 | temporarily suspend it and reactivate it with %logoff/%logon); %save |
|
229 | temporarily suspend it and reactivate it with %logoff/%logon); %save | |
228 | allows you to select which lines of input you need to save. |
|
230 | allows you to select which lines of input you need to save. | |
229 |
|
231 | |||
230 |
|
232 | |||
231 | Lightweight 'version control' |
|
233 | Lightweight 'version control' | |
232 | ============================= |
|
234 | ============================= | |
233 |
|
235 | |||
234 | When you call %edit with no arguments, IPython opens an empty editor |
|
236 | When you call %edit with no arguments, IPython opens an empty editor | |
235 | with a temporary file, and it returns the contents of your editing |
|
237 | with a temporary file, and it returns the contents of your editing | |
236 | session as a string variable. Thanks to IPython's output caching |
|
238 | session as a string variable. Thanks to IPython's output caching | |
237 | mechanism, this is automatically stored:: |
|
239 | mechanism, this is automatically stored:: | |
238 |
|
240 | |||
239 | In [1]: %edit |
|
241 | In [1]: %edit | |
240 |
|
242 | |||
241 | IPython will make a temporary file named: /tmp/ipython_edit_yR-HCN.py |
|
243 | IPython will make a temporary file named: /tmp/ipython_edit_yR-HCN.py | |
242 |
|
244 | |||
243 | Editing... done. Executing edited code... |
|
245 | Editing... done. Executing edited code... | |
244 |
|
246 | |||
245 | hello - this is a temporary file |
|
247 | hello - this is a temporary file | |
246 |
|
248 | |||
247 | Out[1]: "print 'hello - this is a temporary file'\n" |
|
249 | Out[1]: "print 'hello - this is a temporary file'\n" | |
248 |
|
250 | |||
249 | Now, if you call '%edit -p', IPython tries to open an editor with the |
|
251 | Now, if you call '%edit -p', IPython tries to open an editor with the | |
250 | same data as the last time you used %edit. So if you haven't used %edit |
|
252 | same data as the last time you used %edit. So if you haven't used %edit | |
251 | in the meantime, this same contents will reopen; however, it will be |
|
253 | in the meantime, this same contents will reopen; however, it will be | |
252 | done in a new file. This means that if you make changes and you later |
|
254 | done in a new file. This means that if you make changes and you later | |
253 | want to find an old version, you can always retrieve it by using its |
|
255 | want to find an old version, you can always retrieve it by using its | |
254 | output number, via '%edit _NN', where NN is the number of the output |
|
256 | output number, via '%edit _NN', where NN is the number of the output | |
255 | prompt. |
|
257 | prompt. | |
256 |
|
258 | |||
257 | Continuing with the example above, this should illustrate this idea:: |
|
259 | Continuing with the example above, this should illustrate this idea:: | |
258 |
|
260 | |||
259 | In [2]: edit -p |
|
261 | In [2]: edit -p | |
260 |
|
262 | |||
261 | IPython will make a temporary file named: /tmp/ipython_edit_nA09Qk.py |
|
263 | IPython will make a temporary file named: /tmp/ipython_edit_nA09Qk.py | |
262 |
|
264 | |||
263 | Editing... done. Executing edited code... |
|
265 | Editing... done. Executing edited code... | |
264 |
|
266 | |||
265 | hello - now I made some changes |
|
267 | hello - now I made some changes | |
266 |
|
268 | |||
267 | Out[2]: "print 'hello - now I made some changes'\n" |
|
269 | Out[2]: "print 'hello - now I made some changes'\n" | |
268 |
|
270 | |||
269 | In [3]: edit _1 |
|
271 | In [3]: edit _1 | |
270 |
|
272 | |||
271 | IPython will make a temporary file named: /tmp/ipython_edit_gy6-zD.py |
|
273 | IPython will make a temporary file named: /tmp/ipython_edit_gy6-zD.py | |
272 |
|
274 | |||
273 | Editing... done. Executing edited code... |
|
275 | Editing... done. Executing edited code... | |
274 |
|
276 | |||
275 | hello - this is a temporary file |
|
277 | hello - this is a temporary file | |
276 |
|
278 | |||
277 | IPython version control at work :) |
|
279 | IPython version control at work :) | |
278 |
|
280 | |||
279 | Out[3]: "print 'hello - this is a temporary file'\nprint 'IPython version control at work :)'\n" |
|
281 | Out[3]: "print 'hello - this is a temporary file'\nprint 'IPython version control at work :)'\n" | |
280 |
|
282 | |||
281 |
|
283 | |||
282 | This section was written after a contribution by Alexander Belchenko on |
|
284 | This section was written after a contribution by Alexander Belchenko on | |
283 | the IPython user list. |
|
285 | the IPython user list. | |
284 |
|
286 | |||
285 |
|
287 | |||
286 | Effective logging |
|
288 | Effective logging | |
287 | ================= |
|
289 | ================= | |
288 |
|
290 | |||
289 | A very useful suggestion sent in by Robert Kern follows: |
|
291 | A very useful suggestion sent in by Robert Kern follows: | |
290 |
|
292 | |||
291 | I recently happened on a nifty way to keep tidy per-project log files. I |
|
293 | I recently happened on a nifty way to keep tidy per-project log files. I | |
292 | made a profile for my project (which is called "parkfield"):: |
|
294 | made a profile for my project (which is called "parkfield"):: | |
293 |
|
295 | |||
294 | include ipythonrc |
|
296 | include ipythonrc | |
295 |
|
297 | |||
296 | # cancel earlier logfile invocation: |
|
298 | # cancel earlier logfile invocation: | |
297 |
|
299 | |||
298 | logfile '' |
|
300 | logfile '' | |
299 |
|
301 | |||
300 | execute import time |
|
302 | execute import time | |
301 |
|
303 | |||
302 | execute __cmd = '/Users/kern/research/logfiles/parkfield-%s.log rotate' |
|
304 | execute __cmd = '/Users/kern/research/logfiles/parkfield-%s.log rotate' | |
303 |
|
305 | |||
304 | execute __IP.magic_logstart(__cmd % time.strftime('%Y-%m-%d')) |
|
306 | execute __IP.magic_logstart(__cmd % time.strftime('%Y-%m-%d')) | |
305 |
|
307 | |||
306 | I also added a shell alias for convenience:: |
|
308 | I also added a shell alias for convenience:: | |
307 |
|
309 | |||
308 | alias parkfield="ipython -pylab -profile parkfield" |
|
310 | alias parkfield="ipython -pylab -profile parkfield" | |
309 |
|
311 | |||
310 | Now I have a nice little directory with everything I ever type in, |
|
312 | Now I have a nice little directory with everything I ever type in, | |
311 | organized by project and date. |
|
313 | organized by project and date. | |
312 |
|
314 | |||
313 | Contribute your own: If you have your own favorite tip on using IPython |
|
315 | Contribute your own: If you have your own favorite tip on using IPython | |
314 | efficiently for a certain task (especially things which can't be done in |
|
316 | efficiently for a certain task (especially things which can't be done in | |
315 | the normal Python interpreter), don't hesitate to send it! |
|
317 | the normal Python interpreter), don't hesitate to send it! |
@@ -1,61 +1,87 b'' | |||||
1 | .. _license: |
|
1 | .. _license: | |
2 |
|
2 | |||
3 |
===================== |
|
3 | ===================== | |
4 |
License and Copyright |
|
4 | License and Copyright | |
5 |
===================== |
|
5 | ===================== | |
6 |
|
6 | |||
7 | This files needs to be updated to reflect what the new COPYING.txt files says about our license and copyright! |
|
7 | License | |
|
8 | ======= | |||
8 |
|
9 | |||
9 |
IPython is |
|
10 | IPython is licensed under the terms of the new or revised BSD license, as follows:: | |
10 | form can be found at: http://www.opensource.org/licenses/bsd-license.php. The full text of the |
|
|||
11 | IPython license is reproduced below:: |
|
|||
12 |
|
11 | |||
13 | IPython is released under a BSD-type license. |
|
12 | Copyright (c) 2008, IPython Development Team | |
14 |
|
13 | |||
15 | Copyright (c) 2001, 2002, 2003, 2004 Fernando Perez |
|
14 | All rights reserved. | |
16 | <fperez@colorado.edu>. |
|
|||
17 |
|
15 | |||
18 | Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and |
|
16 | Redistribution and use in source and binary forms, with or without modification, | |
19 | Nathaniel Gray <n8gray@caltech.edu>. |
|
17 | are permitted provided that the following conditions are met: | |
20 |
|
18 | |||
21 | All rights reserved. |
|
19 | Redistributions of source code must retain the above copyright notice, this list of | |
|
20 | conditions and the following disclaimer. | |||
|
21 | ||||
|
22 | Redistributions in binary form must reproduce the above copyright notice, this list | |||
|
23 | of conditions and the following disclaimer in the documentation and/or other | |||
|
24 | materials provided with the distribution. | |||
|
25 | ||||
|
26 | Neither the name of the IPython Development Team nor the names of its contributors | |||
|
27 | may be used to endorse or promote products derived from this software without | |||
|
28 | specific prior written permission. | |||
|
29 | ||||
|
30 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY | |||
|
31 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |||
|
32 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. | |||
|
33 | IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, | |||
|
34 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |||
|
35 | NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |||
|
36 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |||
|
37 | WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |||
|
38 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |||
|
39 | POSSIBILITY OF SUCH DAMAGE. | |||
|
40 | ||||
|
41 | About the IPython Development Team | |||
|
42 | ================================== | |||
|
43 | ||||
|
44 | Fernando Perez began IPython in 2001 based on code from Janko Hauser <jhauser@zscout.de> | |||
|
45 | and Nathaniel Gray <n8gray@caltech.edu>. Fernando is still the project lead. | |||
|
46 | ||||
|
47 | The IPython Development Team is the set of all contributors to the IPython project. | |||
|
48 | This includes all of the IPython subprojects. Here is a list of the currently active contributors: | |||
|
49 | ||||
|
50 | * Matthieu Brucher | |||
|
51 | * Ondrej Certik | |||
|
52 | * Laurent Dufrechou | |||
|
53 | * Robert Kern | |||
|
54 | * Brian E. Granger | |||
|
55 | * Fernando Perez (project leader) | |||
|
56 | * Benjamin Ragan-Kelley | |||
|
57 | * Ville M. Vainio | |||
|
58 | * Gael Varoququx | |||
|
59 | * Stefan van der Walt | |||
|
60 | * Tech-X Corporation | |||
|
61 | * Barry Wark | |||
|
62 | ||||
|
63 | If your name is missing, please add it. | |||
|
64 | ||||
|
65 | Our Copyright Policy | |||
|
66 | ==================== | |||
|
67 | ||||
|
68 | IPython uses a shared copyright model. Each contributor maintains copyright over | |||
|
69 | their contributions to IPython. But, it is important to note that these | |||
|
70 | contributions are typically only changes to the repositories. Thus, the IPython | |||
|
71 | source code, in its entirety is not the copyright of any single person or | |||
|
72 | institution. Instead, it is the collective copyright of the entire IPython | |||
|
73 | Development Team. If individual contributors want to maintain a record of what | |||
|
74 | changes/contributions they have specific copyright on, they should indicate their | |||
|
75 | copyright in the commit message of the change, when they commit the change to | |||
|
76 | one of the IPython repositories. | |||
22 |
|
77 | |||
23 | Redistribution and use in source and binary forms, with or without |
|
78 | Miscellaneous | |
24 | modification, are permitted provided that the following conditions |
|
79 | ============= | |
25 | are met: |
|
|||
26 |
|
||||
27 | a. Redistributions of source code must retain the above copyright |
|
|||
28 | notice, this list of conditions and the following disclaimer. |
|
|||
29 |
|
||||
30 | b. Redistributions in binary form must reproduce the above copyright |
|
|||
31 | notice, this list of conditions and the following disclaimer in the |
|
|||
32 | documentation and/or other materials provided with the distribution. |
|
|||
33 |
|
||||
34 | c. Neither the name of the copyright holders nor the names of any |
|
|||
35 | contributors to this software may be used to endorse or promote |
|
|||
36 | products derived from this software without specific prior written |
|
|||
37 | permission. |
|
|||
38 |
|
||||
39 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
|||
40 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
|||
41 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
|
|||
42 | FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
|
|||
43 | REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
|
|||
44 | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
|
|||
45 | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|
|||
46 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
|
|||
47 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|
|||
48 | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN |
|
|||
49 | ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
|
|||
50 | POSSIBILITY OF SUCH DAMAGE. |
|
|||
51 |
|
||||
52 | Individual authors are the holders of the copyright for their code and |
|
|||
53 | are listed in each file. |
|
|||
54 |
|
80 | |||
55 | Some files (DPyGetOpt.py, for example) may be licensed under different |
|
81 | Some files (DPyGetOpt.py, for example) may be licensed under different | |
56 | conditions. Ultimately each file indicates clearly the conditions under |
|
82 | conditions. Ultimately each file indicates clearly the conditions under | |
57 | which its author/authors have decided to publish the code. |
|
83 | which its author/authors have decided to publish the code. | |
58 |
|
84 | |||
59 | Versions of IPython up to and including 0.6.3 were released under the |
|
85 | Versions of IPython up to and including 0.6.3 were released under the | |
60 | GNU Lesser General Public License (LGPL), available at |
|
86 | GNU Lesser General Public License (LGPL), available at | |
61 | http://www.gnu.org/copyleft/lesser.html. No newline at end of file |
|
87 | http://www.gnu.org/copyleft/lesser.html. |
@@ -1,174 +1,233 b'' | |||||
1 | .. _overview: |
|
1 | .. _overview: | |
2 |
|
2 | |||
3 | ============ |
|
3 | ============ | |
4 | Introduction |
|
4 | Introduction | |
5 | ============ |
|
5 | ============ | |
6 |
|
6 | |||
7 | Overview |
|
7 | Overview | |
8 | ======== |
|
8 | ======== | |
9 |
|
9 | |||
10 | One of Python's most useful features is its interactive interpreter. |
|
10 | One of Python's most useful features is its interactive interpreter. | |
11 | This system allows very fast testing of ideas without the overhead of |
|
11 | This system allows very fast testing of ideas without the overhead of | |
12 | creating test files as is typical in most programming languages. |
|
12 | creating test files as is typical in most programming languages. | |
13 | However, the interpreter supplied with the standard Python distribution |
|
13 | However, the interpreter supplied with the standard Python distribution | |
14 | is somewhat limited for extended interactive use. |
|
14 | is somewhat limited for extended interactive use. | |
15 |
|
15 | |||
16 | The goal of IPython is to create a comprehensive environment for |
|
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 | has two main components: |
|
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 | All of IPython is open source (released under the revised BSD license). |
|
23 | All of IPython is open source (released under the revised BSD license). | |
24 |
|
24 | |||
25 | Enhanced interactive Python shell |
|
25 | Enhanced interactive Python shell | |
26 | ================================= |
|
26 | ================================= | |
27 |
|
27 | |||
28 |
IPython's interactive shell (`ipython`), has the following goals |
|
28 | IPython's interactive shell (:command:`ipython`), has the following goals, | |
29 |
|
29 | amongst others: | ||
30 | 1. Provide an interactive shell superior to Python's default. IPython |
|
30 | ||
31 | has many features for object introspection, system shell access, |
|
31 | 1. Provide an interactive shell superior to Python's default. IPython | |
32 | and its own special command system for adding functionality when |
|
32 | has many features for object introspection, system shell access, | |
33 | working interactively. It tries to be a very efficient environment |
|
33 | and its own special command system for adding functionality when | |
34 | both for Python code development and for exploration of problems |
|
34 | working interactively. It tries to be a very efficient environment | |
35 | using Python objects (in situations like data analysis). |
|
35 | both for Python code development and for exploration of problems | |
36 | 2. Serve as an embeddable, ready to use interpreter for your own |
|
36 | using Python objects (in situations like data analysis). | |
37 | programs. IPython can be started with a single call from inside |
|
37 | ||
38 | another program, providing access to the current namespace. This |
|
38 | 2. Serve as an embeddable, ready to use interpreter for your own | |
39 | can be very useful both for debugging purposes and for situations |
|
39 | programs. IPython can be started with a single call from inside | |
40 | where a blend of batch-processing and interactive exploration are |
|
40 | another program, providing access to the current namespace. This | |
41 | needed. |
|
41 | can be very useful both for debugging purposes and for situations | |
42 | 3. Offer a flexible framework which can be used as the base |
|
42 | where a blend of batch-processing and interactive exploration are | |
43 | environment for other systems with Python as the underlying |
|
43 | needed. New in the 0.9 version of IPython is a reusable wxPython | |
44 | language. Specifically scientific environments like Mathematica, |
|
44 | based IPython widget. | |
45 | IDL and Matlab inspired its design, but similar ideas can be |
|
45 | ||
46 | useful in many fields. |
|
46 | 3. Offer a flexible framework which can be used as the base | |
47 | 4. Allow interactive testing of threaded graphical toolkits. IPython |
|
47 | environment for other systems with Python as the underlying | |
48 | has support for interactive, non-blocking control of GTK, Qt and |
|
48 | language. Specifically scientific environments like Mathematica, | |
49 | WX applications via special threading flags. The normal Python |
|
49 | IDL and Matlab inspired its design, but similar ideas can be | |
50 | shell can only do this for Tkinter applications. |
|
50 | useful in many fields. | |
|
51 | ||||
|
52 | 4. Allow interactive testing of threaded graphical toolkits. IPython | |||
|
53 | has support for interactive, non-blocking control of GTK, Qt and | |||
|
54 | WX applications via special threading flags. The normal Python | |||
|
55 | shell can only do this for Tkinter applications. | |||
51 |
|
56 | |||
52 | Main features of the interactive shell |
|
57 | Main features of the interactive shell | |
53 | -------------------------------------- |
|
58 | -------------------------------------- | |
54 |
|
59 | |||
55 |
|
|
60 | * Dynamic object introspection. One can access docstrings, function | |
56 |
|
|
61 | definition prototypes, source code, source files and other details | |
57 |
|
|
62 | of any object accessible to the interpreter with a single | |
58 |
|
|
63 | keystroke (:samp:`?`, and using :samp:`??` provides additional detail). | |
59 | * Searching through modules and namespaces with :samp:`*` wildcards, both |
|
64 | ||
60 | when using the :samp:`?` system and via the :samp:`%psearch` command. |
|
65 | * Searching through modules and namespaces with :samp:`*` wildcards, both | |
61 | * Completion in the local namespace, by typing :kbd:`TAB` at the prompt. |
|
66 | when using the :samp:`?` system and via the :samp:`%psearch` command. | |
62 | This works for keywords, modules, methods, variables and files in the |
|
67 | ||
63 | current directory. This is supported via the readline library, and |
|
68 | * Completion in the local namespace, by typing :kbd:`TAB` at the prompt. | |
64 | full access to configuring readline's behavior is provided. |
|
69 | This works for keywords, modules, methods, variables and files in the | |
65 | Custom completers can be implemented easily for different purposes |
|
70 | current directory. This is supported via the readline library, and | |
66 | (system commands, magic arguments etc.) |
|
71 | full access to configuring readline's behavior is provided. | |
67 | * Numbered input/output prompts with command history (persistent |
|
72 | Custom completers can be implemented easily for different purposes | |
68 | across sessions and tied to each profile), full searching in this |
|
73 | (system commands, magic arguments etc.) | |
69 | history and caching of all input and output. |
|
74 | ||
70 | * User-extensible 'magic' commands. A set of commands prefixed with |
|
75 | * Numbered input/output prompts with command history (persistent | |
71 | :samp:`%` is available for controlling IPython itself and provides |
|
76 | across sessions and tied to each profile), full searching in this | |
72 | directory control, namespace information and many aliases to |
|
77 | history and caching of all input and output. | |
73 | common system shell commands. |
|
78 | ||
74 | * Alias facility for defining your own system aliases. |
|
79 | * User-extensible 'magic' commands. A set of commands prefixed with | |
75 | * Complete system shell access. Lines starting with :samp:`!` are passed |
|
80 | :samp:`%` is available for controlling IPython itself and provides | |
76 | directly to the system shell, and using :samp:`!!` or :samp:`var = !cmd` |
|
81 | directory control, namespace information and many aliases to | |
77 | captures shell output into python variables for further use. |
|
82 | common system shell commands. | |
78 | * Background execution of Python commands in a separate thread. |
|
83 | ||
79 | IPython has an internal job manager called jobs, and a |
|
84 | * Alias facility for defining your own system aliases. | |
80 | conveninence backgrounding magic function called :samp:`%bg`. |
|
85 | ||
81 | * The ability to expand python variables when calling the system |
|
86 | * Complete system shell access. Lines starting with :samp:`!` are passed | |
82 | shell. In a shell command, any python variable prefixed with :samp:`$` is |
|
87 | directly to the system shell, and using :samp:`!!` or :samp:`var = !cmd` | |
83 | expanded. A double :samp:`$$` allows passing a literal :samp:`$` to the shell (for |
|
88 | captures shell output into python variables for further use. | |
84 | access to shell and environment variables like :envvar:`PATH`). |
|
89 | ||
85 | * Filesystem navigation, via a magic :samp:`%cd` command, along with a |
|
90 | * Background execution of Python commands in a separate thread. | |
86 | persistent bookmark system (using :samp:`%bookmark`) for fast access to |
|
91 | IPython has an internal job manager called jobs, and a | |
87 | frequently visited directories. |
|
92 | convenience backgrounding magic function called :samp:`%bg`. | |
88 | * A lightweight persistence framework via the :samp:`%store` command, which |
|
93 | ||
89 | allows you to save arbitrary Python variables. These get restored |
|
94 | * The ability to expand python variables when calling the system | |
90 | automatically when your session restarts. |
|
95 | shell. In a shell command, any python variable prefixed with :samp:`$` is | |
91 | * Automatic indentation (optional) of code as you type (through the |
|
96 | expanded. A double :samp:`$$` allows passing a literal :samp:`$` to the shell (for | |
92 | readline library). |
|
97 | access to shell and environment variables like :envvar:`PATH`). | |
93 | * Macro system for quickly re-executing multiple lines of previous |
|
98 | ||
94 | input with a single name. Macros can be stored persistently via |
|
99 | * Filesystem navigation, via a magic :samp:`%cd` command, along with a | |
95 | :samp:`%store` and edited via :samp:`%edit`. |
|
100 | persistent bookmark system (using :samp:`%bookmark`) for fast access to | |
96 | * Session logging (you can then later use these logs as code in your |
|
101 | frequently visited directories. | |
97 | programs). Logs can optionally timestamp all input, and also store |
|
102 | ||
98 | session output (marked as comments, so the log remains valid |
|
103 | * A lightweight persistence framework via the :samp:`%store` command, which | |
99 | Python source code). |
|
104 | allows you to save arbitrary Python variables. These get restored | |
100 | * Session restoring: logs can be replayed to restore a previous |
|
105 | automatically when your session restarts. | |
101 | session to the state where you left it. |
|
106 | ||
102 | * Verbose and colored exception traceback printouts. Easier to parse |
|
107 | * Automatic indentation (optional) of code as you type (through the | |
103 | visually, and in verbose mode they produce a lot of useful |
|
108 | readline library). | |
104 | debugging information (basically a terminal version of the cgitb |
|
109 | ||
105 | module). |
|
110 | * Macro system for quickly re-executing multiple lines of previous | |
106 | * Auto-parentheses: callable objects can be executed without |
|
111 | input with a single name. Macros can be stored persistently via | |
107 | parentheses: :samp:`sin 3` is automatically converted to :samp:`sin(3)`. |
|
112 | :samp:`%store` and edited via :samp:`%edit`. | |
108 | * Auto-quoting: using :samp:`,`, or :samp:`;` as the first character forces |
|
113 | ||
109 | auto-quoting of the rest of the line: :samp:`,my_function a b` becomes |
|
114 | * Session logging (you can then later use these logs as code in your | |
110 | automatically :samp:`my_function("a","b")`, while :samp:`;my_function a b` |
|
115 | programs). Logs can optionally timestamp all input, and also store | |
111 | becomes :samp:`my_function("a b")`. |
|
116 | session output (marked as comments, so the log remains valid | |
112 | * Extensible input syntax. You can define filters that pre-process |
|
117 | Python source code). | |
113 | user input to simplify input in special situations. This allows |
|
118 | ||
114 | for example pasting multi-line code fragments which start with |
|
119 | * Session restoring: logs can be replayed to restore a previous | |
115 | :samp:`>>>` or :samp:`...` such as those from other python sessions or the |
|
120 | session to the state where you left it. | |
116 | standard Python documentation. |
|
121 | ||
117 | * Flexible configuration system. It uses a configuration file which |
|
122 | * Verbose and colored exception traceback printouts. Easier to parse | |
118 | allows permanent setting of all command-line options, module |
|
123 | visually, and in verbose mode they produce a lot of useful | |
119 | loading, code and file execution. The system allows recursive file |
|
124 | debugging information (basically a terminal version of the cgitb | |
120 | inclusion, so you can have a base file with defaults and layers |
|
125 | module). | |
121 | which load other customizations for particular projects. |
|
126 | ||
122 | * Embeddable. You can call IPython as a python shell inside your own |
|
127 | * Auto-parentheses: callable objects can be executed without | |
123 | python programs. This can be used both for debugging code or for |
|
128 | parentheses: :samp:`sin 3` is automatically converted to :samp:`sin(3)`. | |
124 | providing interactive abilities to your programs with knowledge |
|
129 | ||
125 | about the local namespaces (very useful in debugging and data |
|
130 | * Auto-quoting: using :samp:`,`, or :samp:`;` as the first character forces | |
126 | analysis situations). |
|
131 | auto-quoting of the rest of the line: :samp:`,my_function a b` becomes | |
127 | * Easy debugger access. You can set IPython to call up an enhanced |
|
132 | automatically :samp:`my_function("a","b")`, while :samp:`;my_function a b` | |
128 | version of the Python debugger (pdb) every time there is an |
|
133 | becomes :samp:`my_function("a b")`. | |
129 | uncaught exception. This drops you inside the code which triggered |
|
134 | ||
130 | the exception with all the data live and it is possible to |
|
135 | * Extensible input syntax. You can define filters that pre-process | |
131 | navigate the stack to rapidly isolate the source of a bug. The |
|
136 | user input to simplify input in special situations. This allows | |
132 | :samp:`%run` magic command (with the :samp:`-d` option) can run any script under |
|
137 | for example pasting multi-line code fragments which start with | |
133 | pdb's control, automatically setting initial breakpoints for you. |
|
138 | :samp:`>>>` or :samp:`...` such as those from other python sessions or the | |
134 | This version of pdb has IPython-specific improvements, including |
|
139 | standard Python documentation. | |
135 | tab-completion and traceback coloring support. For even easier |
|
140 | ||
136 | debugger access, try :samp:`%debug` after seeing an exception. winpdb is |
|
141 | * Flexible configuration system. It uses a configuration file which | |
137 | also supported, see ipy_winpdb extension. |
|
142 | allows permanent setting of all command-line options, module | |
138 | * Profiler support. You can run single statements (similar to |
|
143 | loading, code and file execution. The system allows recursive file | |
139 | :samp:`profile.run()`) or complete programs under the profiler's control. |
|
144 | inclusion, so you can have a base file with defaults and layers | |
140 | While this is possible with standard cProfile or profile modules, |
|
145 | which load other customizations for particular projects. | |
141 | IPython wraps this functionality with magic commands (see :samp:`%prun` |
|
146 | ||
142 | and :samp:`%run -p`) convenient for rapid interactive work. |
|
147 | * Embeddable. You can call IPython as a python shell inside your own | |
143 | * Doctest support. The special :samp:`%doctest_mode` command toggles a mode |
|
148 | python programs. This can be used both for debugging code or for | |
144 | that allows you to paste existing doctests (with leading :samp:`>>>` |
|
149 | providing interactive abilities to your programs with knowledge | |
145 | prompts and whitespace) and uses doctest-compatible prompts and |
|
150 | about the local namespaces (very useful in debugging and data | |
146 | output, so you can use IPython sessions as doctest code. |
|
151 | analysis situations). | |
|
152 | ||||
|
153 | * Easy debugger access. You can set IPython to call up an enhanced | |||
|
154 | version of the Python debugger (pdb) every time there is an | |||
|
155 | uncaught exception. This drops you inside the code which triggered | |||
|
156 | the exception with all the data live and it is possible to | |||
|
157 | navigate the stack to rapidly isolate the source of a bug. The | |||
|
158 | :samp:`%run` magic command (with the :samp:`-d` option) can run any script under | |||
|
159 | pdb's control, automatically setting initial breakpoints for you. | |||
|
160 | This version of pdb has IPython-specific improvements, including | |||
|
161 | tab-completion and traceback coloring support. For even easier | |||
|
162 | debugger access, try :samp:`%debug` after seeing an exception. winpdb is | |||
|
163 | also supported, see ipy_winpdb extension. | |||
|
164 | ||||
|
165 | * Profiler support. You can run single statements (similar to | |||
|
166 | :samp:`profile.run()`) or complete programs under the profiler's control. | |||
|
167 | While this is possible with standard cProfile or profile modules, | |||
|
168 | IPython wraps this functionality with magic commands (see :samp:`%prun` | |||
|
169 | and :samp:`%run -p`) convenient for rapid interactive work. | |||
|
170 | ||||
|
171 | * Doctest support. The special :samp:`%doctest_mode` command toggles a mode | |||
|
172 | that allows you to paste existing doctests (with leading :samp:`>>>` | |||
|
173 | prompts and whitespace) and uses doctest-compatible prompts and | |||
|
174 | output, so you can use IPython sessions as doctest code. | |||
147 |
|
175 | |||
148 | Interactive parallel computing |
|
176 | Interactive parallel computing | |
149 | ============================== |
|
177 | ============================== | |
150 |
|
178 | |||
151 | Increasingly, parallel computer hardware, such as multicore CPUs, clusters and supercomputers, is becoming ubiquitous. Over the last 3 years, we have developed an |
|
179 | Increasingly, parallel computer hardware, such as multicore CPUs, clusters and supercomputers, is becoming ubiquitous. Over the last 3 years, we have developed an | |
152 | architecture within IPython that allows such hardware to be used quickly and easily |
|
180 | architecture within IPython that allows such hardware to be used quickly and easily | |
153 | from Python. Moreover, this architecture is designed to support interactive and |
|
181 | from Python. Moreover, this architecture is designed to support interactive and | |
154 | collaborative parallel computing. |
|
182 | collaborative parallel computing. | |
155 |
|
183 | |||
|
184 | The main features of this system are: | |||
|
185 | ||||
|
186 | * Quickly parallelize Python code from an interactive Python/IPython session. | |||
|
187 | ||||
|
188 | * A flexible and dynamic process model that be deployed on anything from | |||
|
189 | multicore workstations to supercomputers. | |||
|
190 | ||||
|
191 | * An architecture that supports many different styles of parallelism, from | |||
|
192 | message passing to task farming. And all of these styles can be handled | |||
|
193 | interactively. | |||
|
194 | ||||
|
195 | * Both blocking and fully asynchronous interfaces. | |||
|
196 | ||||
|
197 | * High level APIs that enable many things to be parallelized in a few lines | |||
|
198 | of code. | |||
|
199 | ||||
|
200 | * Write parallel code that will run unchanged on everything from multicore | |||
|
201 | workstations to supercomputers. | |||
|
202 | ||||
|
203 | * Full integration with Message Passing libraries (MPI). | |||
|
204 | ||||
|
205 | * Capabilities based security model with full encryption of network connections. | |||
|
206 | ||||
|
207 | * Share live parallel jobs with other users securely. We call this collaborative | |||
|
208 | parallel computing. | |||
|
209 | ||||
|
210 | * Dynamically load balanced task farming system. | |||
|
211 | ||||
|
212 | * Robust error handling. Python exceptions raised in parallel execution are | |||
|
213 | gathered and presented to the top-level code. | |||
|
214 | ||||
156 | For more information, see our :ref:`overview <parallel_index>` of using IPython for |
|
215 | For more information, see our :ref:`overview <parallel_index>` of using IPython for | |
157 | parallel computing. |
|
216 | parallel computing. | |
158 |
|
217 | |||
159 | Portability and Python requirements |
|
218 | Portability and Python requirements | |
160 | ----------------------------------- |
|
219 | ----------------------------------- | |
161 |
|
220 | |||
162 | As of the 0.9 release, IPython requires Python 2.4 or greater. We have |
|
221 | As of the 0.9 release, IPython requires Python 2.4 or greater. We have | |
163 | not begun to test IPython on Python 2.6 or 3.0, but we expect it will |
|
222 | not begun to test IPython on Python 2.6 or 3.0, but we expect it will | |
164 | work with some minor changes. |
|
223 | work with some minor changes. | |
165 |
|
224 | |||
166 | IPython is known to work on the following operating systems: |
|
225 | IPython is known to work on the following operating systems: | |
167 |
|
226 | |||
168 | * Linux |
|
227 | * Linux | |
169 | * AIX |
|
228 | * AIX | |
170 | * Most other Unix-like OSs (Solaris, BSD, etc.) |
|
229 | * Most other Unix-like OSs (Solaris, BSD, etc.) | |
171 | * Mac OS X |
|
230 | * Mac OS X | |
172 | * Windows (CygWin, XP, Vista, etc.) |
|
231 | * Windows (CygWin, XP, Vista, etc.) | |
173 |
|
232 | |||
174 | See :ref:`here <install_index>` for instructions on how to install IPython. No newline at end of file |
|
233 | See :ref:`here <install_index>` for instructions on how to install IPython. |
@@ -1,17 +1,14 b'' | |||||
1 | .. _parallel_index: |
|
1 | .. _parallel_index: | |
2 |
|
2 | |||
3 | ==================================== |
|
3 | ==================================== | |
4 |
Using IPython for |
|
4 | Using IPython for parallel computing | |
5 | ==================================== |
|
5 | ==================================== | |
6 |
|
6 | |||
7 | User Documentation |
|
|||
8 | ================== |
|
|||
9 |
|
||||
10 | .. toctree:: |
|
7 | .. toctree:: | |
11 | :maxdepth: 2 |
|
8 | :maxdepth: 2 | |
12 |
|
9 | |||
13 | parallel_intro.txt |
|
10 | parallel_intro.txt | |
14 | parallel_multiengine.txt |
|
11 | parallel_multiengine.txt | |
15 | parallel_task.txt |
|
12 | parallel_task.txt | |
16 | parallel_mpi.txt |
|
13 | parallel_mpi.txt | |
17 |
|
14 |
@@ -1,242 +1,327 b'' | |||||
1 | .. _ip1par: |
|
1 | .. _ip1par: | |
2 |
|
2 | |||
3 |
============================ |
|
3 | ============================ | |
4 | Using IPython for parallel computing |
|
4 | Overview and getting started | |
5 |
============================ |
|
5 | ============================ | |
6 |
|
6 | |||
7 | .. contents:: |
|
7 | .. contents:: | |
8 |
|
8 | |||
9 | Introduction |
|
9 | Introduction | |
10 | ============ |
|
10 | ============ | |
11 |
|
11 | |||
12 |
This file gives an overview of IPython |
|
12 | This file gives an overview of IPython's sophisticated and | |
13 | powerful architecture for parallel and distributed computing. This |
|
13 | powerful architecture for parallel and distributed computing. This | |
14 | architecture abstracts out parallelism in a very general way, which |
|
14 | architecture abstracts out parallelism in a very general way, which | |
15 | enables IPython to support many different styles of parallelism |
|
15 | enables IPython to support many different styles of parallelism | |
16 | including: |
|
16 | including: | |
17 |
|
17 | |||
18 |
|
|
18 | * Single program, multiple data (SPMD) parallelism. | |
19 |
|
|
19 | * Multiple program, multiple data (MPMD) parallelism. | |
20 |
|
|
20 | * Message passing using ``MPI``. | |
21 |
|
|
21 | * Task farming. | |
22 |
|
|
22 | * Data parallel. | |
23 |
|
|
23 | * Combinations of these approaches. | |
24 |
|
|
24 | * Custom user defined approaches. | |
25 |
|
25 | |||
26 | Most importantly, IPython enables all types of parallel applications to |
|
26 | Most importantly, IPython enables all types of parallel applications to | |
27 | be developed, executed, debugged and monitored *interactively*. Hence, |
|
27 | be developed, executed, debugged and monitored *interactively*. Hence, | |
28 | the ``I`` in IPython. The following are some example usage cases for IPython: |
|
28 | the ``I`` in IPython. The following are some example usage cases for IPython: | |
29 |
|
29 | |||
30 |
|
|
30 | * Quickly parallelize algorithms that are embarrassingly parallel | |
31 |
|
|
31 | using a number of simple approaches. Many simple things can be | |
32 |
|
|
32 | parallelized interactively in one or two lines of code. | |
33 | * Steer traditional MPI applications on a supercomputer from an |
|
33 | ||
34 | IPython session on your laptop. |
|
34 | * Steer traditional MPI applications on a supercomputer from an | |
35 | * Analyze and visualize large datasets (that could be remote and/or |
|
35 | IPython session on your laptop. | |
36 | distributed) interactively using IPython and tools like |
|
36 | ||
37 | matplotlib/TVTK. |
|
37 | * Analyze and visualize large datasets (that could be remote and/or | |
38 | * Develop, test and debug new parallel algorithms |
|
38 | distributed) interactively using IPython and tools like | |
39 | (that may use MPI) interactively. |
|
39 | matplotlib/TVTK. | |
40 | * Tie together multiple MPI jobs running on different systems into |
|
40 | ||
41 | one giant distributed and parallel system. |
|
41 | * Develop, test and debug new parallel algorithms | |
42 | * Start a parallel job on your cluster and then have a remote |
|
42 | (that may use MPI) interactively. | |
43 | collaborator connect to it and pull back data into their |
|
43 | ||
44 | local IPython session for plotting and analysis. |
|
44 | * Tie together multiple MPI jobs running on different systems into | |
45 | * Run a set of tasks on a set of CPUs using dynamic load balancing. |
|
45 | one giant distributed and parallel system. | |
|
46 | ||||
|
47 | * Start a parallel job on your cluster and then have a remote | |||
|
48 | collaborator connect to it and pull back data into their | |||
|
49 | local IPython session for plotting and analysis. | |||
|
50 | ||||
|
51 | * Run a set of tasks on a set of CPUs using dynamic load balancing. | |||
46 |
|
52 | |||
47 | Architecture overview |
|
53 | Architecture overview | |
48 | ===================== |
|
54 | ===================== | |
49 |
|
55 | |||
50 | The IPython architecture consists of three components: |
|
56 | The IPython architecture consists of three components: | |
51 |
|
57 | |||
52 |
|
|
58 | * The IPython engine. | |
53 |
|
|
59 | * The IPython controller. | |
54 |
|
|
60 | * Various controller clients. | |
|
61 | ||||
|
62 | These components live in the :mod:`IPython.kernel` package and are | |||
|
63 | installed with IPython. They do, however, have additional dependencies | |||
|
64 | that must be installed. For more information, see our | |||
|
65 | :ref:`installation documentation <install_index>`. | |||
55 |
|
66 | |||
56 | IPython engine |
|
67 | IPython engine | |
57 | --------------- |
|
68 | --------------- | |
58 |
|
69 | |||
59 | The IPython engine is a Python instance that takes Python commands over a |
|
70 | The IPython engine is a Python instance that takes Python commands over a | |
60 | network connection. Eventually, the IPython engine will be a full IPython |
|
71 | network connection. Eventually, the IPython engine will be a full IPython | |
61 | interpreter, but for now, it is a regular Python interpreter. The engine |
|
72 | interpreter, but for now, it is a regular Python interpreter. The engine | |
62 | can also handle incoming and outgoing Python objects sent over a network |
|
73 | can also handle incoming and outgoing Python objects sent over a network | |
63 | connection. When multiple engines are started, parallel and distributed |
|
74 | connection. When multiple engines are started, parallel and distributed | |
64 | computing becomes possible. An important feature of an IPython engine is |
|
75 | computing becomes possible. An important feature of an IPython engine is | |
65 | that it blocks while user code is being executed. Read on for how the |
|
76 | that it blocks while user code is being executed. Read on for how the | |
66 | IPython controller solves this problem to expose a clean asynchronous API |
|
77 | IPython controller solves this problem to expose a clean asynchronous API | |
67 | to the user. |
|
78 | to the user. | |
68 |
|
79 | |||
69 | IPython controller |
|
80 | IPython controller | |
70 | ------------------ |
|
81 | ------------------ | |
71 |
|
82 | |||
72 | The IPython controller provides an interface for working with a set of |
|
83 | The IPython controller provides an interface for working with a set of | |
73 | engines. At an general level, the controller is a process to which |
|
84 | engines. At an general level, the controller is a process to which | |
74 | IPython engines can connect. For each connected engine, the controller |
|
85 | IPython engines can connect. For each connected engine, the controller | |
75 | manages a queue. All actions that can be performed on the engine go |
|
86 | manages a queue. All actions that can be performed on the engine go | |
76 | through this queue. While the engines themselves block when user code is |
|
87 | through this queue. While the engines themselves block when user code is | |
77 | run, the controller hides that from the user to provide a fully |
|
88 | run, the controller hides that from the user to provide a fully | |
78 |
asynchronous interface to a set of engines. |
|
89 | asynchronous interface to a set of engines. | |
79 | listens on a network port for engines to connect to it, it must be |
|
90 | ||
80 | started before any engines are started. |
|
91 | .. note:: | |
|
92 | ||||
|
93 | Because the controller listens on a network port for engines to | |||
|
94 | connect to it, it must be started *before* any engines are started. | |||
81 |
|
95 | |||
82 | The controller also provides a single point of contact for users who wish |
|
96 | The controller also provides a single point of contact for users who wish | |
83 | to utilize the engines connected to the controller. There are different |
|
97 | to utilize the engines connected to the controller. There are different | |
84 | ways of working with a controller. In IPython these ways correspond to different interfaces that the controller is adapted to. Currently we have two default interfaces to the controller: |
|
98 | ways of working with a controller. In IPython these ways correspond to different interfaces that the controller is adapted to. Currently we have two default interfaces to the controller: | |
85 |
|
99 | |||
86 | * The MultiEngine interface. |
|
100 | * The MultiEngine interface, which provides the simplest possible way of working | |
87 | * The Task interface. |
|
101 | with engines interactively. | |
|
102 | * The Task interface, which provides presents the engines as a load balanced | |||
|
103 | task farming system. | |||
88 |
|
104 | |||
89 | Advanced users can easily add new custom interfaces to enable other |
|
105 | Advanced users can easily add new custom interfaces to enable other | |
90 | styles of parallelism. |
|
106 | styles of parallelism. | |
91 |
|
107 | |||
92 | .. note:: |
|
108 | .. note:: | |
93 |
|
109 | |||
94 | A single controller and set of engines can be accessed |
|
110 | A single controller and set of engines can be accessed | |
95 | through multiple interfaces simultaneously. This opens the |
|
111 | through multiple interfaces simultaneously. This opens the | |
96 | door for lots of interesting things. |
|
112 | door for lots of interesting things. | |
97 |
|
113 | |||
98 | Controller clients |
|
114 | Controller clients | |
99 | ------------------ |
|
115 | ------------------ | |
100 |
|
116 | |||
101 | For each controller interface, there is a corresponding client. These |
|
117 | For each controller interface, there is a corresponding client. These | |
102 | clients allow users to interact with a set of engines through the |
|
118 | clients allow users to interact with a set of engines through the | |
103 | interface. |
|
119 | interface. Here are the two default clients: | |
|
120 | ||||
|
121 | * The :class:`MultiEngineClient` class. | |||
|
122 | * The :class:`TaskClient` class. | |||
104 |
|
123 | |||
105 | Security |
|
124 | Security | |
106 | -------- |
|
125 | -------- | |
107 |
|
126 | |||
108 |
By default (as long as `pyOpenSSL` is installed) all network connections between the controller and engines and the controller and clients are secure. What does this mean? First of all, all of the connections will be encrypted using SSL. Second, the connections are authenticated. We handle authentication in a `capabilities`__ based security model. In this model, a "capability (known in some systems as a key) is a communicable, unforgeable token of authority". Put simply, a capability is like a key to your house. If you have the key to your house, you can get in |
|
127 | By default (as long as `pyOpenSSL` is installed) all network connections between the controller and engines and the controller and clients are secure. What does this mean? First of all, all of the connections will be encrypted using SSL. Second, the connections are authenticated. We handle authentication in a `capabilities`__ based security model. In this model, a "capability (known in some systems as a key) is a communicable, unforgeable token of authority". Put simply, a capability is like a key to your house. If you have the key to your house, you can get in. If not, you can't. | |
109 |
|
128 | |||
110 | .. __: http://en.wikipedia.org/wiki/Capability-based_security |
|
129 | .. __: http://en.wikipedia.org/wiki/Capability-based_security | |
111 |
|
130 | |||
112 |
In our architecture, the controller is the only process that listens on network ports, and is thus responsible to creating these keys. In IPython, these keys are known as Foolscap URLs, or FURLs, because of the underlying network protocol we are using. As a user, you don't need to know anything about the details of these FURLs, other than that when the controller starts, it saves a set of FURLs to files named something.furl. The default location of these files is |
|
131 | In our architecture, the controller is the only process that listens on network ports, and is thus responsible to creating these keys. In IPython, these keys are known as Foolscap URLs, or FURLs, because of the underlying network protocol we are using. As a user, you don't need to know anything about the details of these FURLs, other than that when the controller starts, it saves a set of FURLs to files named :file:`something.furl`. The default location of these files is the :file:`~./ipython/security` directory. | |
113 |
|
132 | |||
114 | To connect and authenticate to the controller an engine or client simply needs to present an appropriate furl (that was originally created by the controller) to the controller. Thus, the .furl files need to be copied to a location where the clients and engines can find them. Typically, this is the ~./ipython directory on the host where the client/engine is running (which could be a different host than the controller). Once the .furl files are copied over, everything should work fine. |
|
133 | To connect and authenticate to the controller an engine or client simply needs to present an appropriate furl (that was originally created by the controller) to the controller. Thus, the .furl files need to be copied to a location where the clients and engines can find them. Typically, this is the :file:`~./ipython/security` directory on the host where the client/engine is running (which could be a different host than the controller). Once the .furl files are copied over, everything should work fine. | |
|
134 | ||||
|
135 | Currently, there are three .furl files that the controller creates: | |||
|
136 | ||||
|
137 | ipcontroller-engine.furl | |||
|
138 | This ``.furl`` file is the key that gives an engine the ability to connect | |||
|
139 | to a controller. | |||
|
140 | ||||
|
141 | ipcontroller-tc.furl | |||
|
142 | This ``.furl`` file is the key that a :class:`TaskClient` must use to | |||
|
143 | connect to the task interface of a controller. | |||
|
144 | ||||
|
145 | ipcontroller-mec.furl | |||
|
146 | This ``.furl`` file is the key that a :class:`MultiEngineClient` must use to | |||
|
147 | connect to the multiengine interface of a controller. | |||
|
148 | ||||
|
149 | More details of how these ``.furl`` files are used are given below. | |||
115 |
|
150 | |||
116 | Getting Started |
|
151 | Getting Started | |
117 | =============== |
|
152 | =============== | |
118 |
|
153 | |||
119 | To use IPython for parallel computing, you need to start one instance of |
|
154 | To use IPython for parallel computing, you need to start one instance of | |
120 | the controller and one or more instances of the engine. The controller |
|
155 | the controller and one or more instances of the engine. The controller | |
121 | and each engine can run on different machines or on the same machine. |
|
156 | and each engine can run on different machines or on the same machine. | |
122 | Because of this, there are many different possibilities for setting up |
|
157 | Because of this, there are many different possibilities for setting up | |
123 | the IP addresses and ports used by the various processes. |
|
158 | the IP addresses and ports used by the various processes. | |
124 |
|
159 | |||
125 | Starting the controller and engine on your local machine |
|
160 | Starting the controller and engine on your local machine | |
126 | -------------------------------------------------------- |
|
161 | -------------------------------------------------------- | |
127 |
|
162 | |||
128 | This is the simplest configuration that can be used and is useful for |
|
163 | This is the simplest configuration that can be used and is useful for | |
129 | testing the system and on machines that have multiple cores and/or |
|
164 | testing the system and on machines that have multiple cores and/or | |
130 |
multple CPUs. The easiest way of |
|
165 | multple CPUs. The easiest way of getting started is to use the :command:`ipcluster` | |
131 | command:: |
|
166 | command:: | |
132 |
|
167 | |||
133 | $ ipcluster -n 4 |
|
168 | $ ipcluster -n 4 | |
134 |
|
169 | |||
135 | This will start an IPython controller and then 4 engines that connect to |
|
170 | This will start an IPython controller and then 4 engines that connect to | |
136 | the controller. Lastly, the script will print out the Python commands |
|
171 | the controller. Lastly, the script will print out the Python commands | |
137 | that you can use to connect to the controller. It is that easy. |
|
172 | that you can use to connect to the controller. It is that easy. | |
138 |
|
173 | |||
139 | Underneath the hood, the ``ipcluster`` script uses two other top-level |
|
174 | .. warning:: | |
|
175 | ||||
|
176 | The :command:`ipcluster` does not currently work on Windows. We are | |||
|
177 | working on it though. | |||
|
178 | ||||
|
179 | Underneath the hood, the controller creates ``.furl`` files in the | |||
|
180 | :file:`~./ipython/security` directory. Because the engines are on the | |||
|
181 | same host, they automatically find the needed :file:`ipcontroller-engine.furl` | |||
|
182 | there and use it to connect to the controller. | |||
|
183 | ||||
|
184 | The :command:`ipcluster` script uses two other top-level | |||
140 | scripts that you can also use yourself. These scripts are |
|
185 | scripts that you can also use yourself. These scripts are | |
141 |
|
|
186 | :command:`ipcontroller`, which starts the controller and :command:`ipengine` which | |
142 | starts one engine. To use these scripts to start things on your local |
|
187 | starts one engine. To use these scripts to start things on your local | |
143 | machine, do the following. |
|
188 | machine, do the following. | |
144 |
|
189 | |||
145 | First start the controller:: |
|
190 | First start the controller:: | |
146 |
|
191 | |||
147 |
$ ipcontroller |
|
192 | $ ipcontroller | |
148 |
|
193 | |||
149 | Next, start however many instances of the engine you want using (repeatedly) the command:: |
|
194 | Next, start however many instances of the engine you want using (repeatedly) the command:: | |
150 |
|
195 | |||
151 |
$ ipengine |
|
196 | $ ipengine | |
|
197 | ||||
|
198 | The engines should start and automatically connect to the controller using the ``.furl`` files in :file:`~./ipython/security`. You are now ready to use the controller and engines from IPython. | |||
152 |
|
199 | |||
153 | .. warning:: |
|
200 | .. warning:: | |
154 |
|
201 | |||
155 | The order of the above operations is very important. You *must* |
|
202 | The order of the above operations is very important. You *must* | |
156 | start the controller before the engines, since the engines connect |
|
203 | start the controller before the engines, since the engines connect | |
157 | to the controller as they get started. |
|
204 | to the controller as they get started. | |
158 |
|
205 | |||
159 | On some platforms you may need to give these commands in the form |
|
206 | .. note:: | |
160 | ``(ipcontroller &)`` and ``(ipengine &)`` for them to work properly. The |
|
|||
161 | engines should start and automatically connect to the controller on the |
|
|||
162 | default ports, which are chosen for this type of setup. You are now ready |
|
|||
163 | to use the controller and engines from IPython. |
|
|||
164 |
|
207 | |||
165 | Starting the controller and engines on different machines |
|
208 | On some platforms (OS X), to put the controller and engine into the background | |
166 | --------------------------------------------------------- |
|
209 | you may need to give these commands in the form ``(ipcontroller &)`` | |
|
210 | and ``(ipengine &)`` (with the parentheses) for them to work properly. | |||
167 |
|
211 | |||
168 | This section needs to be updated to reflect the new Foolscap capabilities based |
|
|||
169 | model. |
|
|||
170 |
|
212 | |||
171 | Using ``ipcluster`` with ``ssh`` |
|
213 | Starting the controller and engines on different hosts | |
172 | -------------------------------- |
|
214 | ------------------------------------------------------ | |
173 |
|
215 | |||
174 | The ``ipcluster`` command can also start a controller and engines using |
|
216 | When the controller and engines are running on different hosts, things are | |
175 | ``ssh``. We need more documentation on this, but for now here is any |
|
217 | slightly more complicated, but the underlying ideas are the same: | |
176 | example startup script:: |
|
|||
177 |
|
218 | |||
178 | controller = dict(host='myhost', |
|
219 | 1. Start the controller on a host using :command:`ipcontroler`. | |
179 | engine_port=None, # default is 10105 |
|
220 | 2. Copy :file:`ipcontroller-engine.furl` from :file:`~./ipython/security` on the controller's host to the host where the engines will run. | |
180 | control_port=None, |
|
221 | 3. Use :command:`ipengine` on the engine's hosts to start the engines. | |
181 | ) |
|
|||
182 |
|
222 | |||
183 | # keys are hostnames, values are the number of engine on that host |
|
223 | The only thing you have to be careful of is to tell :command:`ipengine` where the :file:`ipcontroller-engine.furl` file is located. There are two ways you can do this: | |
184 | engines = dict(node1=2, |
|
224 | ||
185 | node2=2, |
|
225 | * Put :file:`ipcontroller-engine.furl` in the :file:`~./ipython/security` directory | |
186 | node3=2, |
|
226 | on the engine's host, where it will be found automatically. | |
187 | node3=2, |
|
227 | * Call :command:`ipengine` with the ``--furl-file=full_path_to_the_file`` flag. | |
188 | ) |
|
228 | ||
|
229 | The ``--furl-file`` flag works like this:: | |||
|
230 | ||||
|
231 | $ ipengine --furl-file=/path/to/my/ipcontroller-engine.furl | |||
|
232 | ||||
|
233 | .. note:: | |||
|
234 | ||||
|
235 | If the controller's and engine's hosts all have a shared file system | |||
|
236 | (:file:`~./ipython/security` is the same on all of them), then things | |||
|
237 | will just work! | |||
|
238 | ||||
|
239 | Make .furl files persistent | |||
|
240 | --------------------------- | |||
|
241 | ||||
|
242 | At fist glance it may seem that that managing the ``.furl`` files is a bit annoying. Going back to the house and key analogy, copying the ``.furl`` around each time you start the controller is like having to make a new key everytime you want to unlock the door and enter your house. As with your house, you want to be able to create the key (or ``.furl`` file) once, and then simply use it at any point in the future. | |||
|
243 | ||||
|
244 | This is possible. The only thing you have to do is decide what ports the controller will listen on for the engines and clients. This is done as follows:: | |||
|
245 | ||||
|
246 | $ ipcontroller --client-port=10101 --engine-port=10102 | |||
|
247 | ||||
|
248 | Then, just copy the furl files over the first time and you are set. You can start and stop the controller and engines any many times as you want in the future, just make sure to tell the controller to use the *same* ports. | |||
|
249 | ||||
|
250 | .. note:: | |||
|
251 | ||||
|
252 | You may ask the question: what ports does the controller listen on if you | |||
|
253 | don't tell is to use specific ones? The default is to use high random port | |||
|
254 | numbers. We do this for two reasons: i) to increase security through obcurity | |||
|
255 | and ii) to multiple controllers on a given host to start and automatically | |||
|
256 | use different ports. | |||
189 |
|
257 | |||
190 | Starting engines using ``mpirun`` |
|
258 | Starting engines using ``mpirun`` | |
191 | --------------------------------- |
|
259 | --------------------------------- | |
192 |
|
260 | |||
193 | The IPython engines can be started using ``mpirun``/``mpiexec``, even if |
|
261 | The IPython engines can be started using ``mpirun``/``mpiexec``, even if | |
194 | the engines don't call MPI_Init() or use the MPI API in any way. This is |
|
262 | the engines don't call ``MPI_Init()`` or use the MPI API in any way. This is | |
195 | supported on modern MPI implementations like `Open MPI`_.. This provides |
|
263 | supported on modern MPI implementations like `Open MPI`_.. This provides | |
196 | an really nice way of starting a bunch of engine. On a system with MPI |
|
264 | an really nice way of starting a bunch of engine. On a system with MPI | |
197 | installed you can do:: |
|
265 | installed you can do:: | |
198 |
|
266 | |||
199 | mpirun -n 4 ipengine --controller-port=10000 --controller-ip=host0 |
|
267 | mpirun -n 4 ipengine | |
|
268 | ||||
|
269 | to start 4 engine on a cluster. This works even if you don't have any | |||
|
270 | Python-MPI bindings installed. | |||
200 |
|
271 | |||
201 | .. _Open MPI: http://www.open-mpi.org/ |
|
272 | .. _Open MPI: http://www.open-mpi.org/ | |
202 |
|
273 | |||
203 | More details on using MPI with IPython can be found :ref:`here <parallelmpi>`. |
|
274 | More details on using MPI with IPython can be found :ref:`here <parallelmpi>`. | |
204 |
|
275 | |||
205 | Log files |
|
276 | Log files | |
206 | --------- |
|
277 | --------- | |
207 |
|
278 | |||
208 | All of the components of IPython have log files associated with them. |
|
279 | All of the components of IPython have log files associated with them. | |
209 | These log files can be extremely useful in debugging problems with |
|
280 | These log files can be extremely useful in debugging problems with | |
210 | IPython and can be found in the directory ``~/.ipython/log``. Sending |
|
281 | IPython and can be found in the directory ``~/.ipython/log``. Sending | |
211 | the log files to us will often help us to debug any problems. |
|
282 | the log files to us will often help us to debug any problems. | |
212 |
|
283 | |||
213 | Next Steps |
|
284 | Next Steps | |
214 | ========== |
|
285 | ========== | |
215 |
|
286 | |||
216 | Once you have started the IPython controller and one or more engines, you |
|
287 | Once you have started the IPython controller and one or more engines, you | |
217 |
are ready to use the engines to do som |
|
288 | are ready to use the engines to do something useful. To make sure | |
218 | everything is working correctly, try the following commands:: |
|
289 | everything is working correctly, try the following commands:: | |
219 |
|
290 | |||
220 | In [1]: from IPython.kernel import client |
|
291 | In [1]: from IPython.kernel import client | |
221 |
|
292 | |||
222 |
In [2]: mec = client.MultiEngineClient() |
|
293 | In [2]: mec = client.MultiEngineClient() | |
223 |
|
294 | |||
224 | In [4]: mec.get_ids() |
|
295 | In [4]: mec.get_ids() | |
225 | Out[4]: [0, 1, 2, 3] |
|
296 | Out[4]: [0, 1, 2, 3] | |
226 |
|
297 | |||
227 | In [5]: mec.execute('print "Hello World"') |
|
298 | In [5]: mec.execute('print "Hello World"') | |
228 | Out[5]: |
|
299 | Out[5]: | |
229 | <Results List> |
|
300 | <Results List> | |
230 | [0] In [1]: print "Hello World" |
|
301 | [0] In [1]: print "Hello World" | |
231 | [0] Out[1]: Hello World |
|
302 | [0] Out[1]: Hello World | |
232 |
|
303 | |||
233 | [1] In [1]: print "Hello World" |
|
304 | [1] In [1]: print "Hello World" | |
234 | [1] Out[1]: Hello World |
|
305 | [1] Out[1]: Hello World | |
235 |
|
306 | |||
236 | [2] In [1]: print "Hello World" |
|
307 | [2] In [1]: print "Hello World" | |
237 | [2] Out[1]: Hello World |
|
308 | [2] Out[1]: Hello World | |
238 |
|
309 | |||
239 | [3] In [1]: print "Hello World" |
|
310 | [3] In [1]: print "Hello World" | |
240 | [3] Out[1]: Hello World |
|
311 | [3] Out[1]: Hello World | |
241 |
|
312 | |||
242 | If this works, you are ready to learn more about the :ref:`MultiEngine <parallelmultiengine>` and :ref:`Task <paralleltask>` interfaces to the controller. |
|
313 | Remember, a client also needs to present a ``.furl`` file to the controller. How does this happen? When a multiengine client is created with no arguments, the client tries to find the corresponding ``.furl`` file in the local :file:`~./ipython/security` directory. If it finds it, you are set. If you have put the ``.furl`` file in a different location or it has a different name, create the client like this:: | |
|
314 | ||||
|
315 | mec = client.MultiEngineClient('/path/to/my/ipcontroller-mec.furl') | |||
|
316 | ||||
|
317 | Same thing hold true of creating a task client:: | |||
|
318 | ||||
|
319 | tc = client.TaskClient('/path/to/my/ipcontroller-tc.furl') | |||
|
320 | ||||
|
321 | You are now ready to learn more about the :ref:`MultiEngine <parallelmultiengine>` and :ref:`Task <paralleltask>` interfaces to the controller. | |||
|
322 | ||||
|
323 | .. note:: | |||
|
324 | ||||
|
325 | Don't forget that the engine, multiengine client and task client all have | |||
|
326 | *different* furl files. You must move *each* of these around to an appropriate | |||
|
327 | location so that the engines and clients can use them to connect to the controller. |
@@ -1,728 +1,783 b'' | |||||
1 | .. _parallelmultiengine: |
|
1 | .. _parallelmultiengine: | |
2 |
|
2 | |||
3 |
=============================== |
|
3 | =============================== | |
4 |
IPython's |
|
4 | IPython's multiengine interface | |
5 |
=============================== |
|
5 | =============================== | |
6 |
|
6 | |||
7 | .. contents:: |
|
7 | .. contents:: | |
8 |
|
8 | |||
9 |
The |
|
9 | The multiengine interface represents one possible way of working with a set of | |
10 |
|
|
10 | IPython engines. The basic idea behind the multiengine interface is that the | |
11 |
|
|
11 | capabilities of each engine are directly and explicitly exposed to the user. | |
12 |
Thus, in the |
|
12 | Thus, in the multiengine interface, each engine is given an id that is used to | |
13 |
|
|
13 | identify the engine and give it work to do. This interface is very intuitive | |
14 |
|
|
14 | and is designed with interactive usage in mind, and is thus the best place for | |
15 |
|
|
15 | new users of IPython to begin. | |
16 |
|
16 | |||
17 | Starting the IPython controller and engines |
|
17 | Starting the IPython controller and engines | |
18 | =========================================== |
|
18 | =========================================== | |
19 |
|
19 | |||
20 | To follow along with this tutorial, you will need to start the IPython |
|
20 | To follow along with this tutorial, you will need to start the IPython | |
21 | controller and four IPython engines. The simplest way of doing this is to |
|
21 | controller and four IPython engines. The simplest way of doing this is to use | |
22 |
|
|
22 | the :command:`ipcluster` command:: | |
23 |
|
23 | |||
24 | $ ipcluster -n 4 |
|
24 | $ ipcluster -n 4 | |
25 |
|
25 | |||
26 |
For more detailed information about starting the controller and engines, see |
|
26 | For more detailed information about starting the controller and engines, see | |
|
27 | our :ref:`introduction <ip1par>` to using IPython for parallel computing. | |||
27 |
|
28 | |||
28 | Creating a ``MultiEngineClient`` instance |
|
29 | Creating a ``MultiEngineClient`` instance | |
29 | ========================================= |
|
30 | ========================================= | |
30 |
|
31 | |||
31 |
The first step is to import the IPython |
|
32 | The first step is to import the IPython :mod:`IPython.kernel.client` module | |
|
33 | and then create a :class:`MultiEngineClient` instance:: | |||
32 |
|
34 | |||
33 | In [1]: from IPython.kernel import client |
|
35 | In [1]: from IPython.kernel import client | |
34 |
|
36 | |||
35 | In [2]: mec = client.MultiEngineClient() |
|
37 | In [2]: mec = client.MultiEngineClient() | |
36 |
|
38 | |||
37 | To make sure there are engines connected to the controller, use can get a list of engine ids:: |
|
39 | This form assumes that the :file:`ipcontroller-mec.furl` is in the | |
|
40 | :file:`~./ipython/security` directory on the client's host. If not, the | |||
|
41 | location of the ``.furl`` file must be given as an argument to the | |||
|
42 | constructor:: | |||
|
43 | ||||
|
44 | In[2]: mec = client.MultiEngineClient('/path/to/my/ipcontroller-mec.furl') | |||
|
45 | ||||
|
46 | To make sure there are engines connected to the controller, use can get a list | |||
|
47 | of engine ids:: | |||
38 |
|
48 | |||
39 | In [3]: mec.get_ids() |
|
49 | In [3]: mec.get_ids() | |
40 | Out[3]: [0, 1, 2, 3] |
|
50 | Out[3]: [0, 1, 2, 3] | |
41 |
|
51 | |||
42 | Here we see that there are four engines ready to do work for us. |
|
52 | Here we see that there are four engines ready to do work for us. | |
43 |
|
53 | |||
|
54 | Quick and easy parallelism | |||
|
55 | ========================== | |||
|
56 | ||||
|
57 | In many cases, you simply want to apply a Python function to a sequence of objects, but *in parallel*. The multiengine interface provides two simple ways of accomplishing this: a parallel version of :func:`map` and ``@parallel`` function decorator. | |||
|
58 | ||||
|
59 | Parallel map | |||
|
60 | ------------ | |||
|
61 | ||||
|
62 | Python's builtin :func:`map` functions allows a function to be applied to a | |||
|
63 | sequence element-by-element. This type of code is typically trivial to | |||
|
64 | parallelize. In fact, the multiengine interface in IPython already has a | |||
|
65 | parallel version of :meth:`map` that works just like its serial counterpart:: | |||
|
66 | ||||
|
67 | In [63]: serial_result = map(lambda x:x**10, range(32)) | |||
|
68 | ||||
|
69 | In [64]: parallel_result = mec.map(lambda x:x**10, range(32)) | |||
|
70 | ||||
|
71 | In [65]: serial_result==parallel_result | |||
|
72 | Out[65]: True | |||
|
73 | ||||
|
74 | .. note:: | |||
|
75 | ||||
|
76 | The multiengine interface version of :meth:`map` does not do any load | |||
|
77 | balancing. For a load balanced version, see the task interface. | |||
|
78 | ||||
|
79 | .. seealso:: | |||
|
80 | ||||
|
81 | The :meth:`map` method has a number of options that can be controlled by | |||
|
82 | the :meth:`mapper` method. See its docstring for more information. | |||
|
83 | ||||
|
84 | Parallel function decorator | |||
|
85 | --------------------------- | |||
|
86 | ||||
|
87 | Parallel functions are just like normal function, but they can be called on sequences and *in parallel*. The multiengine interface provides a decorator that turns any Python function into a parallel function:: | |||
|
88 | ||||
|
89 | In [10]: @mec.parallel() | |||
|
90 | ....: def f(x): | |||
|
91 | ....: return 10.0*x**4 | |||
|
92 | ....: | |||
|
93 | ||||
|
94 | In [11]: f(range(32)) # this is done in parallel | |||
|
95 | Out[11]: | |||
|
96 | [0.0,10.0,160.0,...] | |||
|
97 | ||||
|
98 | See the docstring for the :meth:`parallel` decorator for options. | |||
|
99 | ||||
44 | Running Python commands |
|
100 | Running Python commands | |
45 | ======================= |
|
101 | ======================= | |
46 |
|
102 | |||
47 | The most basic type of operation that can be performed on the engines is to execute Python code. Executing Python code can be done in blocking or non-blocking mode (blocking is default) using the ``execute`` method. |
|
103 | The most basic type of operation that can be performed on the engines is to | |
|
104 | execute Python code. Executing Python code can be done in blocking or | |||
|
105 | non-blocking mode (blocking is default) using the :meth:`execute` method. | |||
48 |
|
106 | |||
49 | Blocking execution |
|
107 | Blocking execution | |
50 | ------------------ |
|
108 | ------------------ | |
51 |
|
109 | |||
52 |
In blocking mode, the |
|
110 | In blocking mode, the :class:`MultiEngineClient` object (called ``mec`` in | |
53 | these examples) submits the command to the controller, which places the |
|
111 | these examples) submits the command to the controller, which places the | |
54 |
command in the engines' queues for execution. The |
|
112 | command in the engines' queues for execution. The :meth:`execute` call then | |
55 | blocks until the engines are done executing the command:: |
|
113 | blocks until the engines are done executing the command:: | |
56 |
|
114 | |||
57 | # The default is to run on all engines |
|
115 | # The default is to run on all engines | |
58 | In [4]: mec.execute('a=5') |
|
116 | In [4]: mec.execute('a=5') | |
59 | Out[4]: |
|
117 | Out[4]: | |
60 | <Results List> |
|
118 | <Results List> | |
61 | [0] In [1]: a=5 |
|
119 | [0] In [1]: a=5 | |
62 | [1] In [1]: a=5 |
|
120 | [1] In [1]: a=5 | |
63 | [2] In [1]: a=5 |
|
121 | [2] In [1]: a=5 | |
64 | [3] In [1]: a=5 |
|
122 | [3] In [1]: a=5 | |
65 |
|
123 | |||
66 | In [5]: mec.execute('b=10') |
|
124 | In [5]: mec.execute('b=10') | |
67 | Out[5]: |
|
125 | Out[5]: | |
68 | <Results List> |
|
126 | <Results List> | |
69 | [0] In [2]: b=10 |
|
127 | [0] In [2]: b=10 | |
70 | [1] In [2]: b=10 |
|
128 | [1] In [2]: b=10 | |
71 | [2] In [2]: b=10 |
|
129 | [2] In [2]: b=10 | |
72 | [3] In [2]: b=10 |
|
130 | [3] In [2]: b=10 | |
73 |
|
131 | |||
74 |
Python commands can be executed on specific engines by calling execute using |
|
132 | Python commands can be executed on specific engines by calling execute using | |
|
133 | the ``targets`` keyword argument:: | |||
75 |
|
134 | |||
76 | In [6]: mec.execute('c=a+b',targets=[0,2]) |
|
135 | In [6]: mec.execute('c=a+b',targets=[0,2]) | |
77 | Out[6]: |
|
136 | Out[6]: | |
78 | <Results List> |
|
137 | <Results List> | |
79 | [0] In [3]: c=a+b |
|
138 | [0] In [3]: c=a+b | |
80 | [2] In [3]: c=a+b |
|
139 | [2] In [3]: c=a+b | |
81 |
|
140 | |||
82 |
|
141 | |||
83 | In [7]: mec.execute('c=a-b',targets=[1,3]) |
|
142 | In [7]: mec.execute('c=a-b',targets=[1,3]) | |
84 | Out[7]: |
|
143 | Out[7]: | |
85 | <Results List> |
|
144 | <Results List> | |
86 | [1] In [3]: c=a-b |
|
145 | [1] In [3]: c=a-b | |
87 | [3] In [3]: c=a-b |
|
146 | [3] In [3]: c=a-b | |
88 |
|
147 | |||
89 |
|
148 | |||
90 | In [8]: mec.execute('print c') |
|
149 | In [8]: mec.execute('print c') | |
91 | Out[8]: |
|
150 | Out[8]: | |
92 | <Results List> |
|
151 | <Results List> | |
93 | [0] In [4]: print c |
|
152 | [0] In [4]: print c | |
94 | [0] Out[4]: 15 |
|
153 | [0] Out[4]: 15 | |
95 |
|
154 | |||
96 | [1] In [4]: print c |
|
155 | [1] In [4]: print c | |
97 | [1] Out[4]: -5 |
|
156 | [1] Out[4]: -5 | |
98 |
|
157 | |||
99 | [2] In [4]: print c |
|
158 | [2] In [4]: print c | |
100 | [2] Out[4]: 15 |
|
159 | [2] Out[4]: 15 | |
101 |
|
160 | |||
102 | [3] In [4]: print c |
|
161 | [3] In [4]: print c | |
103 | [3] Out[4]: -5 |
|
162 | [3] Out[4]: -5 | |
104 |
|
163 | |||
105 | This example also shows one of the most important things about the IPython engines: they have a persistent user namespaces. The ``execute`` method returns a Python ``dict`` that contains useful information:: |
|
164 | This example also shows one of the most important things about the IPython | |
|
165 | engines: they have a persistent user namespaces. The :meth:`execute` method | |||
|
166 | returns a Python ``dict`` that contains useful information:: | |||
106 |
|
167 | |||
107 | In [9]: result_dict = mec.execute('d=10; print d') |
|
168 | In [9]: result_dict = mec.execute('d=10; print d') | |
108 |
|
169 | |||
109 | In [10]: for r in result_dict: |
|
170 | In [10]: for r in result_dict: | |
110 | ....: print r |
|
171 | ....: print r | |
111 | ....: |
|
172 | ....: | |
112 | ....: |
|
173 | ....: | |
113 | {'input': {'translated': 'd=10; print d', 'raw': 'd=10; print d'}, 'number': 5, 'id': 0, 'stdout': '10\n'} |
|
174 | {'input': {'translated': 'd=10; print d', 'raw': 'd=10; print d'}, 'number': 5, 'id': 0, 'stdout': '10\n'} | |
114 | {'input': {'translated': 'd=10; print d', 'raw': 'd=10; print d'}, 'number': 5, 'id': 1, 'stdout': '10\n'} |
|
175 | {'input': {'translated': 'd=10; print d', 'raw': 'd=10; print d'}, 'number': 5, 'id': 1, 'stdout': '10\n'} | |
115 | {'input': {'translated': 'd=10; print d', 'raw': 'd=10; print d'}, 'number': 5, 'id': 2, 'stdout': '10\n'} |
|
176 | {'input': {'translated': 'd=10; print d', 'raw': 'd=10; print d'}, 'number': 5, 'id': 2, 'stdout': '10\n'} | |
116 | {'input': {'translated': 'd=10; print d', 'raw': 'd=10; print d'}, 'number': 5, 'id': 3, 'stdout': '10\n'} |
|
177 | {'input': {'translated': 'd=10; print d', 'raw': 'd=10; print d'}, 'number': 5, 'id': 3, 'stdout': '10\n'} | |
117 |
|
178 | |||
118 | Non-blocking execution |
|
179 | Non-blocking execution | |
119 | ---------------------- |
|
180 | ---------------------- | |
120 |
|
181 | |||
121 |
In non-blocking mode, |
|
182 | In non-blocking mode, :meth:`execute` submits the command to be executed and | |
122 | ``PendingResult`` object immediately. The ``PendingResult`` object gives you a way of getting a |
|
183 | then returns a :class:`PendingResult` object immediately. The | |
123 | result at a later time through its ``get_result`` method or ``r`` attribute. This allows you to |
|
184 | :class:`PendingResult` object gives you a way of getting a result at a later | |
124 | quickly submit long running commands without blocking your local Python/IPython session:: |
|
185 | time through its :meth:`get_result` method or :attr:`r` attribute. This allows | |
|
186 | you to quickly submit long running commands without blocking your local | |||
|
187 | Python/IPython session:: | |||
125 |
|
188 | |||
126 | # In blocking mode |
|
189 | # In blocking mode | |
127 | In [6]: mec.execute('import time') |
|
190 | In [6]: mec.execute('import time') | |
128 | Out[6]: |
|
191 | Out[6]: | |
129 | <Results List> |
|
192 | <Results List> | |
130 | [0] In [1]: import time |
|
193 | [0] In [1]: import time | |
131 | [1] In [1]: import time |
|
194 | [1] In [1]: import time | |
132 | [2] In [1]: import time |
|
195 | [2] In [1]: import time | |
133 | [3] In [1]: import time |
|
196 | [3] In [1]: import time | |
134 |
|
197 | |||
135 | # In non-blocking mode |
|
198 | # In non-blocking mode | |
136 | In [7]: pr = mec.execute('time.sleep(10)',block=False) |
|
199 | In [7]: pr = mec.execute('time.sleep(10)',block=False) | |
137 |
|
200 | |||
138 | # Now block for the result |
|
201 | # Now block for the result | |
139 | In [8]: pr.get_result() |
|
202 | In [8]: pr.get_result() | |
140 | Out[8]: |
|
203 | Out[8]: | |
141 | <Results List> |
|
204 | <Results List> | |
142 | [0] In [2]: time.sleep(10) |
|
205 | [0] In [2]: time.sleep(10) | |
143 | [1] In [2]: time.sleep(10) |
|
206 | [1] In [2]: time.sleep(10) | |
144 | [2] In [2]: time.sleep(10) |
|
207 | [2] In [2]: time.sleep(10) | |
145 | [3] In [2]: time.sleep(10) |
|
208 | [3] In [2]: time.sleep(10) | |
146 |
|
209 | |||
147 | # Again in non-blocking mode |
|
210 | # Again in non-blocking mode | |
148 | In [9]: pr = mec.execute('time.sleep(10)',block=False) |
|
211 | In [9]: pr = mec.execute('time.sleep(10)',block=False) | |
149 |
|
212 | |||
150 | # Poll to see if the result is ready |
|
213 | # Poll to see if the result is ready | |
151 | In [10]: pr.get_result(block=False) |
|
214 | In [10]: pr.get_result(block=False) | |
152 |
|
215 | |||
153 | # A shorthand for get_result(block=True) |
|
216 | # A shorthand for get_result(block=True) | |
154 | In [11]: pr.r |
|
217 | In [11]: pr.r | |
155 | Out[11]: |
|
218 | Out[11]: | |
156 | <Results List> |
|
219 | <Results List> | |
157 | [0] In [3]: time.sleep(10) |
|
220 | [0] In [3]: time.sleep(10) | |
158 | [1] In [3]: time.sleep(10) |
|
221 | [1] In [3]: time.sleep(10) | |
159 | [2] In [3]: time.sleep(10) |
|
222 | [2] In [3]: time.sleep(10) | |
160 | [3] In [3]: time.sleep(10) |
|
223 | [3] In [3]: time.sleep(10) | |
161 |
|
224 | |||
162 | Often, it is desirable to wait until a set of ``PendingResult`` objects are done. For this, there is a the method ``barrier``. This method takes a tuple of ``PendingResult`` objects and blocks until all of the associated results are ready:: |
|
225 | Often, it is desirable to wait until a set of :class:`PendingResult` objects | |
|
226 | are done. For this, there is a the method :meth:`barrier`. This method takes a | |||
|
227 | tuple of :class:`PendingResult` objects and blocks until all of the associated | |||
|
228 | results are ready:: | |||
163 |
|
229 | |||
164 | In [72]: mec.block=False |
|
230 | In [72]: mec.block=False | |
165 |
|
231 | |||
166 | # A trivial list of PendingResults objects |
|
232 | # A trivial list of PendingResults objects | |
167 | In [73]: pr_list = [mec.execute('time.sleep(3)') for i in range(10)] |
|
233 | In [73]: pr_list = [mec.execute('time.sleep(3)') for i in range(10)] | |
168 |
|
234 | |||
169 | # Wait until all of them are done |
|
235 | # Wait until all of them are done | |
170 | In [74]: mec.barrier(pr_list) |
|
236 | In [74]: mec.barrier(pr_list) | |
171 |
|
237 | |||
172 | # Then, their results are ready using get_result or the r attribute |
|
238 | # Then, their results are ready using get_result or the r attribute | |
173 | In [75]: pr_list[0].r |
|
239 | In [75]: pr_list[0].r | |
174 | Out[75]: |
|
240 | Out[75]: | |
175 | <Results List> |
|
241 | <Results List> | |
176 | [0] In [20]: time.sleep(3) |
|
242 | [0] In [20]: time.sleep(3) | |
177 | [1] In [19]: time.sleep(3) |
|
243 | [1] In [19]: time.sleep(3) | |
178 | [2] In [20]: time.sleep(3) |
|
244 | [2] In [20]: time.sleep(3) | |
179 | [3] In [19]: time.sleep(3) |
|
245 | [3] In [19]: time.sleep(3) | |
180 |
|
246 | |||
181 |
|
247 | |||
182 | The ``block`` and ``targets`` keyword arguments and attributes |
|
248 | The ``block`` and ``targets`` keyword arguments and attributes | |
183 | -------------------------------------------------------------- |
|
249 | -------------------------------------------------------------- | |
184 |
|
250 | |||
185 |
Most |
|
251 | Most methods in the multiengine interface (like :meth:`execute`) accept | |
186 | as keyword arguments. As we have seen above, these keyword arguments control the blocking mode |
|
252 | ``block`` and ``targets`` as keyword arguments. As we have seen above, these | |
187 | and which engines the command is applied to. The ``MultiEngineClient`` class also has ``block`` |
|
253 | keyword arguments control the blocking mode and which engines the command is | |
188 | and ``targets`` attributes that control the default behavior when the keyword arguments are not |
|
254 | applied to. The :class:`MultiEngineClient` class also has :attr:`block` and | |
189 | provided. Thus the following logic is used for ``block`` and ``targets``: |
|
255 | :attr:`targets` attributes that control the default behavior when the keyword | |
|
256 | arguments are not provided. Thus the following logic is used for :attr:`block` | |||
|
257 | and :attr:`targets`: | |||
190 |
|
258 | |||
191 |
|
|
259 | * If no keyword argument is provided, the instance attributes are used. | |
192 |
|
|
260 | * Keyword argument, if provided override the instance attributes. | |
193 |
|
261 | |||
194 | The following examples demonstrate how to use the instance attributes:: |
|
262 | The following examples demonstrate how to use the instance attributes:: | |
195 |
|
263 | |||
196 | In [16]: mec.targets = [0,2] |
|
264 | In [16]: mec.targets = [0,2] | |
197 |
|
265 | |||
198 | In [17]: mec.block = False |
|
266 | In [17]: mec.block = False | |
199 |
|
267 | |||
200 | In [18]: pr = mec.execute('a=5') |
|
268 | In [18]: pr = mec.execute('a=5') | |
201 |
|
269 | |||
202 | In [19]: pr.r |
|
270 | In [19]: pr.r | |
203 | Out[19]: |
|
271 | Out[19]: | |
204 | <Results List> |
|
272 | <Results List> | |
205 | [0] In [6]: a=5 |
|
273 | [0] In [6]: a=5 | |
206 | [2] In [6]: a=5 |
|
274 | [2] In [6]: a=5 | |
207 |
|
275 | |||
208 | # Note targets='all' means all engines |
|
276 | # Note targets='all' means all engines | |
209 | In [20]: mec.targets = 'all' |
|
277 | In [20]: mec.targets = 'all' | |
210 |
|
278 | |||
211 | In [21]: mec.block = True |
|
279 | In [21]: mec.block = True | |
212 |
|
280 | |||
213 | In [22]: mec.execute('b=10; print b') |
|
281 | In [22]: mec.execute('b=10; print b') | |
214 | Out[22]: |
|
282 | Out[22]: | |
215 | <Results List> |
|
283 | <Results List> | |
216 | [0] In [7]: b=10; print b |
|
284 | [0] In [7]: b=10; print b | |
217 | [0] Out[7]: 10 |
|
285 | [0] Out[7]: 10 | |
218 |
|
286 | |||
219 | [1] In [6]: b=10; print b |
|
287 | [1] In [6]: b=10; print b | |
220 | [1] Out[6]: 10 |
|
288 | [1] Out[6]: 10 | |
221 |
|
289 | |||
222 | [2] In [7]: b=10; print b |
|
290 | [2] In [7]: b=10; print b | |
223 | [2] Out[7]: 10 |
|
291 | [2] Out[7]: 10 | |
224 |
|
292 | |||
225 | [3] In [6]: b=10; print b |
|
293 | [3] In [6]: b=10; print b | |
226 | [3] Out[6]: 10 |
|
294 | [3] Out[6]: 10 | |
227 |
|
295 | |||
228 |
The |
|
296 | The :attr:`block` and :attr:`targets` instance attributes also determine the | |
229 | magic commands... |
|
297 | behavior of the parallel magic commands. | |
230 |
|
298 | |||
231 |
|
299 | |||
232 | Parallel magic commands |
|
300 | Parallel magic commands | |
233 | ----------------------- |
|
301 | ----------------------- | |
234 |
|
302 | |||
235 | We provide a few IPython magic commands (``%px``, ``%autopx`` and ``%result``) that make it more pleasant to execute Python commands on the engines interactively. These are simply shortcuts to ``execute`` and ``get_result``. The ``%px`` magic executes a single Python command on the engines specified by the `magicTargets``targets` attribute of the ``MultiEngineClient`` instance (by default this is 'all'):: |
|
303 | We provide a few IPython magic commands (``%px``, ``%autopx`` and ``%result``) | |
|
304 | that make it more pleasant to execute Python commands on the engines | |||
|
305 | interactively. These are simply shortcuts to :meth:`execute` and | |||
|
306 | :meth:`get_result`. The ``%px`` magic executes a single Python command on the | |||
|
307 | engines specified by the :attr:`targets` attribute of the | |||
|
308 | :class:`MultiEngineClient` instance (by default this is ``'all'``):: | |||
236 |
|
309 | |||
237 | # Make this MultiEngineClient active for parallel magic commands |
|
310 | # Make this MultiEngineClient active for parallel magic commands | |
238 | In [23]: mec.activate() |
|
311 | In [23]: mec.activate() | |
239 |
|
312 | |||
240 | In [24]: mec.block=True |
|
313 | In [24]: mec.block=True | |
241 |
|
314 | |||
242 | In [25]: import numpy |
|
315 | In [25]: import numpy | |
243 |
|
316 | |||
244 | In [26]: %px import numpy |
|
317 | In [26]: %px import numpy | |
245 | Executing command on Controller |
|
318 | Executing command on Controller | |
246 | Out[26]: |
|
319 | Out[26]: | |
247 | <Results List> |
|
320 | <Results List> | |
248 | [0] In [8]: import numpy |
|
321 | [0] In [8]: import numpy | |
249 | [1] In [7]: import numpy |
|
322 | [1] In [7]: import numpy | |
250 | [2] In [8]: import numpy |
|
323 | [2] In [8]: import numpy | |
251 | [3] In [7]: import numpy |
|
324 | [3] In [7]: import numpy | |
252 |
|
325 | |||
253 |
|
326 | |||
254 | In [27]: %px a = numpy.random.rand(2,2) |
|
327 | In [27]: %px a = numpy.random.rand(2,2) | |
255 | Executing command on Controller |
|
328 | Executing command on Controller | |
256 | Out[27]: |
|
329 | Out[27]: | |
257 | <Results List> |
|
330 | <Results List> | |
258 | [0] In [9]: a = numpy.random.rand(2,2) |
|
331 | [0] In [9]: a = numpy.random.rand(2,2) | |
259 | [1] In [8]: a = numpy.random.rand(2,2) |
|
332 | [1] In [8]: a = numpy.random.rand(2,2) | |
260 | [2] In [9]: a = numpy.random.rand(2,2) |
|
333 | [2] In [9]: a = numpy.random.rand(2,2) | |
261 | [3] In [8]: a = numpy.random.rand(2,2) |
|
334 | [3] In [8]: a = numpy.random.rand(2,2) | |
262 |
|
335 | |||
263 |
|
336 | |||
264 | In [28]: %px print numpy.linalg.eigvals(a) |
|
337 | In [28]: %px print numpy.linalg.eigvals(a) | |
265 | Executing command on Controller |
|
338 | Executing command on Controller | |
266 | Out[28]: |
|
339 | Out[28]: | |
267 | <Results List> |
|
340 | <Results List> | |
268 | [0] In [10]: print numpy.linalg.eigvals(a) |
|
341 | [0] In [10]: print numpy.linalg.eigvals(a) | |
269 | [0] Out[10]: [ 1.28167017 0.14197338] |
|
342 | [0] Out[10]: [ 1.28167017 0.14197338] | |
270 |
|
343 | |||
271 | [1] In [9]: print numpy.linalg.eigvals(a) |
|
344 | [1] In [9]: print numpy.linalg.eigvals(a) | |
272 | [1] Out[9]: [-0.14093616 1.27877273] |
|
345 | [1] Out[9]: [-0.14093616 1.27877273] | |
273 |
|
346 | |||
274 | [2] In [10]: print numpy.linalg.eigvals(a) |
|
347 | [2] In [10]: print numpy.linalg.eigvals(a) | |
275 | [2] Out[10]: [-0.37023573 1.06779409] |
|
348 | [2] Out[10]: [-0.37023573 1.06779409] | |
276 |
|
349 | |||
277 | [3] In [9]: print numpy.linalg.eigvals(a) |
|
350 | [3] In [9]: print numpy.linalg.eigvals(a) | |
278 | [3] Out[9]: [ 0.83664764 -0.25602658] |
|
351 | [3] Out[9]: [ 0.83664764 -0.25602658] | |
279 |
|
352 | |||
280 |
The ``%result`` magic gets and prints the stdin/stdout/stderr of the last |
|
353 | The ``%result`` magic gets and prints the stdin/stdout/stderr of the last | |
|
354 | command executed on each engine. It is simply a shortcut to the | |||
|
355 | :meth:`get_result` method:: | |||
281 |
|
356 | |||
282 | In [29]: %result |
|
357 | In [29]: %result | |
283 | Out[29]: |
|
358 | Out[29]: | |
284 | <Results List> |
|
359 | <Results List> | |
285 | [0] In [10]: print numpy.linalg.eigvals(a) |
|
360 | [0] In [10]: print numpy.linalg.eigvals(a) | |
286 | [0] Out[10]: [ 1.28167017 0.14197338] |
|
361 | [0] Out[10]: [ 1.28167017 0.14197338] | |
287 |
|
362 | |||
288 | [1] In [9]: print numpy.linalg.eigvals(a) |
|
363 | [1] In [9]: print numpy.linalg.eigvals(a) | |
289 | [1] Out[9]: [-0.14093616 1.27877273] |
|
364 | [1] Out[9]: [-0.14093616 1.27877273] | |
290 |
|
365 | |||
291 | [2] In [10]: print numpy.linalg.eigvals(a) |
|
366 | [2] In [10]: print numpy.linalg.eigvals(a) | |
292 | [2] Out[10]: [-0.37023573 1.06779409] |
|
367 | [2] Out[10]: [-0.37023573 1.06779409] | |
293 |
|
368 | |||
294 | [3] In [9]: print numpy.linalg.eigvals(a) |
|
369 | [3] In [9]: print numpy.linalg.eigvals(a) | |
295 | [3] Out[9]: [ 0.83664764 -0.25602658] |
|
370 | [3] Out[9]: [ 0.83664764 -0.25602658] | |
296 |
|
371 | |||
297 |
The ``%autopx`` magic switches to a mode where everything you type is executed |
|
372 | The ``%autopx`` magic switches to a mode where everything you type is executed | |
|
373 | on the engines given by the :attr:`targets` attribute:: | |||
298 |
|
374 | |||
299 | In [30]: mec.block=False |
|
375 | In [30]: mec.block=False | |
300 |
|
376 | |||
301 | In [31]: %autopx |
|
377 | In [31]: %autopx | |
302 | Auto Parallel Enabled |
|
378 | Auto Parallel Enabled | |
303 | Type %autopx to disable |
|
379 | Type %autopx to disable | |
304 |
|
380 | |||
305 | In [32]: max_evals = [] |
|
381 | In [32]: max_evals = [] | |
306 | <IPython.kernel.multiengineclient.PendingResult object at 0x17b8a70> |
|
382 | <IPython.kernel.multiengineclient.PendingResult object at 0x17b8a70> | |
307 |
|
383 | |||
308 | In [33]: for i in range(100): |
|
384 | In [33]: for i in range(100): | |
309 | ....: a = numpy.random.rand(10,10) |
|
385 | ....: a = numpy.random.rand(10,10) | |
310 | ....: a = a+a.transpose() |
|
386 | ....: a = a+a.transpose() | |
311 | ....: evals = numpy.linalg.eigvals(a) |
|
387 | ....: evals = numpy.linalg.eigvals(a) | |
312 | ....: max_evals.append(evals[0].real) |
|
388 | ....: max_evals.append(evals[0].real) | |
313 | ....: |
|
389 | ....: | |
314 | ....: |
|
390 | ....: | |
315 | <IPython.kernel.multiengineclient.PendingResult object at 0x17af8f0> |
|
391 | <IPython.kernel.multiengineclient.PendingResult object at 0x17af8f0> | |
316 |
|
392 | |||
317 | In [34]: %autopx |
|
393 | In [34]: %autopx | |
318 | Auto Parallel Disabled |
|
394 | Auto Parallel Disabled | |
319 |
|
395 | |||
320 | In [35]: mec.block=True |
|
396 | In [35]: mec.block=True | |
321 |
|
397 | |||
322 | In [36]: px print "Average max eigenvalue is: ", sum(max_evals)/len(max_evals) |
|
398 | In [36]: px print "Average max eigenvalue is: ", sum(max_evals)/len(max_evals) | |
323 | Executing command on Controller |
|
399 | Executing command on Controller | |
324 | Out[36]: |
|
400 | Out[36]: | |
325 | <Results List> |
|
401 | <Results List> | |
326 | [0] In [13]: print "Average max eigenvalue is: ", sum(max_evals)/len(max_evals) |
|
402 | [0] In [13]: print "Average max eigenvalue is: ", sum(max_evals)/len(max_evals) | |
327 | [0] Out[13]: Average max eigenvalue is: 10.1387247332 |
|
403 | [0] Out[13]: Average max eigenvalue is: 10.1387247332 | |
328 |
|
404 | |||
329 | [1] In [12]: print "Average max eigenvalue is: ", sum(max_evals)/len(max_evals) |
|
405 | [1] In [12]: print "Average max eigenvalue is: ", sum(max_evals)/len(max_evals) | |
330 | [1] Out[12]: Average max eigenvalue is: 10.2076902286 |
|
406 | [1] Out[12]: Average max eigenvalue is: 10.2076902286 | |
331 |
|
407 | |||
332 | [2] In [13]: print "Average max eigenvalue is: ", sum(max_evals)/len(max_evals) |
|
408 | [2] In [13]: print "Average max eigenvalue is: ", sum(max_evals)/len(max_evals) | |
333 | [2] Out[13]: Average max eigenvalue is: 10.1891484655 |
|
409 | [2] Out[13]: Average max eigenvalue is: 10.1891484655 | |
334 |
|
410 | |||
335 | [3] In [12]: print "Average max eigenvalue is: ", sum(max_evals)/len(max_evals) |
|
411 | [3] In [12]: print "Average max eigenvalue is: ", sum(max_evals)/len(max_evals) | |
336 | [3] Out[12]: Average max eigenvalue is: 10.1158837784 |
|
412 | [3] Out[12]: Average max eigenvalue is: 10.1158837784 | |
337 |
|
413 | |||
338 | Using the ``with`` statement of Python 2.5 |
|
|||
339 | ------------------------------------------ |
|
|||
340 |
|
414 | |||
341 | Python 2.5 introduced the ``with`` statement. The ``MultiEngineClient`` can be used with the ``with`` statement to execute a block of code on the engines indicated by the ``targets`` attribute:: |
|
415 | Moving Python objects around | |
|
416 | ============================ | |||
342 |
|
417 | |||
343 | In [3]: with mec: |
|
418 | In addition to executing code on engines, you can transfer Python objects to | |
344 | ...: client.remote() # Required so the following code is not run locally |
|
419 | and from your IPython session and the engines. In IPython, these operations | |
345 | ...: a = 10 |
|
420 | are called :meth:`push` (sending an object to the engines) and :meth:`pull` | |
346 | ...: b = 30 |
|
421 | (getting an object from the engines). | |
347 | ...: c = a+b |
|
|||
348 | ...: |
|
|||
349 | ...: |
|
|||
350 |
|
||||
351 | In [4]: mec.get_result() |
|
|||
352 | Out[4]: |
|
|||
353 | <Results List> |
|
|||
354 | [0] In [1]: a = 10 |
|
|||
355 | b = 30 |
|
|||
356 | c = a+b |
|
|||
357 |
|
||||
358 | [1] In [1]: a = 10 |
|
|||
359 | b = 30 |
|
|||
360 | c = a+b |
|
|||
361 |
|
||||
362 | [2] In [1]: a = 10 |
|
|||
363 | b = 30 |
|
|||
364 | c = a+b |
|
|||
365 |
|
||||
366 | [3] In [1]: a = 10 |
|
|||
367 | b = 30 |
|
|||
368 | c = a+b |
|
|||
369 |
|
||||
370 | This is basically another way of calling execute, but one with allows you to avoid writing code in strings. When used in this way, the attributes ``targets`` and ``block`` are used to control how the code is executed. For now, if you run code in non-blocking mode you won't have access to the ``PendingResult``. |
|
|||
371 |
|
||||
372 | Moving Python object around |
|
|||
373 | =========================== |
|
|||
374 |
|
||||
375 | In addition to executing code on engines, you can transfer Python objects to and from your |
|
|||
376 | IPython session and the engines. In IPython, these operations are called ``push`` (sending an |
|
|||
377 | object to the engines) and ``pull`` (getting an object from the engines). |
|
|||
378 |
|
422 | |||
379 | Basic push and pull |
|
423 | Basic push and pull | |
380 | ------------------- |
|
424 | ------------------- | |
381 |
|
425 | |||
382 |
Here are some examples of how you use |
|
426 | Here are some examples of how you use :meth:`push` and :meth:`pull`:: | |
383 |
|
427 | |||
384 | In [38]: mec.push(dict(a=1.03234,b=3453)) |
|
428 | In [38]: mec.push(dict(a=1.03234,b=3453)) | |
385 | Out[38]: [None, None, None, None] |
|
429 | Out[38]: [None, None, None, None] | |
386 |
|
430 | |||
387 | In [39]: mec.pull('a') |
|
431 | In [39]: mec.pull('a') | |
388 | Out[39]: [1.03234, 1.03234, 1.03234, 1.03234] |
|
432 | Out[39]: [1.03234, 1.03234, 1.03234, 1.03234] | |
389 |
|
433 | |||
390 | In [40]: mec.pull('b',targets=0) |
|
434 | In [40]: mec.pull('b',targets=0) | |
391 | Out[40]: [3453] |
|
435 | Out[40]: [3453] | |
392 |
|
436 | |||
393 | In [41]: mec.pull(('a','b')) |
|
437 | In [41]: mec.pull(('a','b')) | |
394 | Out[41]: [[1.03234, 3453], [1.03234, 3453], [1.03234, 3453], [1.03234, 3453]] |
|
438 | Out[41]: [[1.03234, 3453], [1.03234, 3453], [1.03234, 3453], [1.03234, 3453]] | |
395 |
|
439 | |||
396 | In [42]: mec.zip_pull(('a','b')) |
|
440 | In [42]: mec.zip_pull(('a','b')) | |
397 | Out[42]: [(1.03234, 1.03234, 1.03234, 1.03234), (3453, 3453, 3453, 3453)] |
|
441 | Out[42]: [(1.03234, 1.03234, 1.03234, 1.03234), (3453, 3453, 3453, 3453)] | |
398 |
|
442 | |||
399 | In [43]: mec.push(dict(c='speed')) |
|
443 | In [43]: mec.push(dict(c='speed')) | |
400 | Out[43]: [None, None, None, None] |
|
444 | Out[43]: [None, None, None, None] | |
401 |
|
445 | |||
402 | In [44]: %px print c |
|
446 | In [44]: %px print c | |
403 | Executing command on Controller |
|
447 | Executing command on Controller | |
404 | Out[44]: |
|
448 | Out[44]: | |
405 | <Results List> |
|
449 | <Results List> | |
406 | [0] In [14]: print c |
|
450 | [0] In [14]: print c | |
407 | [0] Out[14]: speed |
|
451 | [0] Out[14]: speed | |
408 |
|
452 | |||
409 | [1] In [13]: print c |
|
453 | [1] In [13]: print c | |
410 | [1] Out[13]: speed |
|
454 | [1] Out[13]: speed | |
411 |
|
455 | |||
412 | [2] In [14]: print c |
|
456 | [2] In [14]: print c | |
413 | [2] Out[14]: speed |
|
457 | [2] Out[14]: speed | |
414 |
|
458 | |||
415 | [3] In [13]: print c |
|
459 | [3] In [13]: print c | |
416 | [3] Out[13]: speed |
|
460 | [3] Out[13]: speed | |
417 |
|
461 | |||
418 |
In non-blocking mode |
|
462 | In non-blocking mode :meth:`push` and :meth:`pull` also return | |
|
463 | :class:`PendingResult` objects:: | |||
419 |
|
464 | |||
420 | In [47]: mec.block=False |
|
465 | In [47]: mec.block=False | |
421 |
|
466 | |||
422 | In [48]: pr = mec.pull('a') |
|
467 | In [48]: pr = mec.pull('a') | |
423 |
|
468 | |||
424 | In [49]: pr.r |
|
469 | In [49]: pr.r | |
425 | Out[49]: [1.03234, 1.03234, 1.03234, 1.03234] |
|
470 | Out[49]: [1.03234, 1.03234, 1.03234, 1.03234] | |
426 |
|
471 | |||
427 |
|
472 | |||
428 | Push and pull for functions |
|
473 | Push and pull for functions | |
429 | --------------------------- |
|
474 | --------------------------- | |
430 |
|
475 | |||
431 |
Functions can also be pushed and pulled using |
|
476 | Functions can also be pushed and pulled using :meth:`push_function` and | |
|
477 | :meth:`pull_function`:: | |||
|
478 | ||||
|
479 | ||||
|
480 | In [52]: mec.block=True | |||
432 |
|
481 | |||
433 | In [53]: def f(x): |
|
482 | In [53]: def f(x): | |
434 | ....: return 2.0*x**4 |
|
483 | ....: return 2.0*x**4 | |
435 | ....: |
|
484 | ....: | |
436 |
|
485 | |||
437 | In [54]: mec.push_function(dict(f=f)) |
|
486 | In [54]: mec.push_function(dict(f=f)) | |
438 | Out[54]: [None, None, None, None] |
|
487 | Out[54]: [None, None, None, None] | |
439 |
|
488 | |||
440 | In [55]: mec.execute('y = f(4.0)') |
|
489 | In [55]: mec.execute('y = f(4.0)') | |
441 | Out[55]: |
|
490 | Out[55]: | |
442 | <Results List> |
|
491 | <Results List> | |
443 | [0] In [15]: y = f(4.0) |
|
492 | [0] In [15]: y = f(4.0) | |
444 | [1] In [14]: y = f(4.0) |
|
493 | [1] In [14]: y = f(4.0) | |
445 | [2] In [15]: y = f(4.0) |
|
494 | [2] In [15]: y = f(4.0) | |
446 | [3] In [14]: y = f(4.0) |
|
495 | [3] In [14]: y = f(4.0) | |
447 |
|
496 | |||
448 |
|
497 | |||
449 | In [56]: px print y |
|
498 | In [56]: px print y | |
450 | Executing command on Controller |
|
499 | Executing command on Controller | |
451 | Out[56]: |
|
500 | Out[56]: | |
452 | <Results List> |
|
501 | <Results List> | |
453 | [0] In [16]: print y |
|
502 | [0] In [16]: print y | |
454 | [0] Out[16]: 512.0 |
|
503 | [0] Out[16]: 512.0 | |
455 |
|
504 | |||
456 | [1] In [15]: print y |
|
505 | [1] In [15]: print y | |
457 | [1] Out[15]: 512.0 |
|
506 | [1] Out[15]: 512.0 | |
458 |
|
507 | |||
459 | [2] In [16]: print y |
|
508 | [2] In [16]: print y | |
460 | [2] Out[16]: 512.0 |
|
509 | [2] Out[16]: 512.0 | |
461 |
|
510 | |||
462 | [3] In [15]: print y |
|
511 | [3] In [15]: print y | |
463 | [3] Out[15]: 512.0 |
|
512 | [3] Out[15]: 512.0 | |
464 |
|
513 | |||
465 |
|
514 | |||
466 | Dictionary interface |
|
515 | Dictionary interface | |
467 | -------------------- |
|
516 | -------------------- | |
468 |
|
517 | |||
469 | As a shorthand to ``push`` and ``pull``, the ``MultiEngineClient`` class implements some of the Python dictionary interface. This make the remote namespaces of the engines appear as a local dictionary. Underneath, this uses ``push`` and ``pull``:: |
|
518 | As a shorthand to :meth:`push` and :meth:`pull`, the | |
|
519 | :class:`MultiEngineClient` class implements some of the Python dictionary | |||
|
520 | interface. This make the remote namespaces of the engines appear as a local | |||
|
521 | dictionary. Underneath, this uses :meth:`push` and :meth:`pull`:: | |||
470 |
|
522 | |||
471 | In [50]: mec.block=True |
|
523 | In [50]: mec.block=True | |
472 |
|
524 | |||
473 | In [51]: mec['a']=['foo','bar'] |
|
525 | In [51]: mec['a']=['foo','bar'] | |
474 |
|
526 | |||
475 | In [52]: mec['a'] |
|
527 | In [52]: mec['a'] | |
476 | Out[52]: [['foo', 'bar'], ['foo', 'bar'], ['foo', 'bar'], ['foo', 'bar']] |
|
528 | Out[52]: [['foo', 'bar'], ['foo', 'bar'], ['foo', 'bar'], ['foo', 'bar']] | |
477 |
|
529 | |||
478 | Scatter and gather |
|
530 | Scatter and gather | |
479 | ------------------ |
|
531 | ------------------ | |
480 |
|
532 | |||
481 |
Sometimes it is useful to partition a sequence and push the partitions to |
|
533 | Sometimes it is useful to partition a sequence and push the partitions to | |
482 |
MPI language, this is know as scatter/gather and we |
|
534 | different engines. In MPI language, this is know as scatter/gather and we | |
483 | important to remember that in IPython ``scatter`` is from the interactive IPython session to |
|
535 | follow that terminology. However, it is important to remember that in | |
484 | the engines and ``gather`` is from the engines back to the interactive IPython session. For |
|
536 | IPython's :class:`MultiEngineClient` class, :meth:`scatter` is from the | |
485 | scatter/gather operations between engines, MPI should be used:: |
|
537 | interactive IPython session to the engines and :meth:`gather` is from the | |
|
538 | engines back to the interactive IPython session. For scatter/gather operations | |||
|
539 | between engines, MPI should be used:: | |||
486 |
|
540 | |||
487 | In [58]: mec.scatter('a',range(16)) |
|
541 | In [58]: mec.scatter('a',range(16)) | |
488 | Out[58]: [None, None, None, None] |
|
542 | Out[58]: [None, None, None, None] | |
489 |
|
543 | |||
490 | In [59]: px print a |
|
544 | In [59]: px print a | |
491 | Executing command on Controller |
|
545 | Executing command on Controller | |
492 | Out[59]: |
|
546 | Out[59]: | |
493 | <Results List> |
|
547 | <Results List> | |
494 | [0] In [17]: print a |
|
548 | [0] In [17]: print a | |
495 | [0] Out[17]: [0, 1, 2, 3] |
|
549 | [0] Out[17]: [0, 1, 2, 3] | |
496 |
|
550 | |||
497 | [1] In [16]: print a |
|
551 | [1] In [16]: print a | |
498 | [1] Out[16]: [4, 5, 6, 7] |
|
552 | [1] Out[16]: [4, 5, 6, 7] | |
499 |
|
553 | |||
500 | [2] In [17]: print a |
|
554 | [2] In [17]: print a | |
501 | [2] Out[17]: [8, 9, 10, 11] |
|
555 | [2] Out[17]: [8, 9, 10, 11] | |
502 |
|
556 | |||
503 | [3] In [16]: print a |
|
557 | [3] In [16]: print a | |
504 | [3] Out[16]: [12, 13, 14, 15] |
|
558 | [3] Out[16]: [12, 13, 14, 15] | |
505 |
|
559 | |||
506 |
|
560 | |||
507 | In [60]: mec.gather('a') |
|
561 | In [60]: mec.gather('a') | |
508 | Out[60]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] |
|
562 | Out[60]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] | |
509 |
|
563 | |||
510 | Other things to look at |
|
564 | Other things to look at | |
511 | ======================= |
|
565 | ======================= | |
512 |
|
566 | |||
513 | Parallel map |
|
|||
514 | ------------ |
|
|||
515 |
|
||||
516 | Python's builtin ``map`` functions allows a function to be applied to a sequence element-by-element. This type of code is typically trivial to parallelize. In fact, the MultiEngine interface in IPython already has a parallel version of ``map`` that works just like its serial counterpart:: |
|
|||
517 |
|
||||
518 | In [63]: serial_result = map(lambda x:x**10, range(32)) |
|
|||
519 |
|
||||
520 | In [64]: parallel_result = mec.map(lambda x:x**10, range(32)) |
|
|||
521 |
|
||||
522 | In [65]: serial_result==parallel_result |
|
|||
523 | Out[65]: True |
|
|||
524 |
|
||||
525 | As you would expect, the parallel version of ``map`` is also influenced by the ``block`` and ``targets`` keyword arguments and attributes. |
|
|||
526 |
|
||||
527 | How to do parallel list comprehensions |
|
567 | How to do parallel list comprehensions | |
528 | -------------------------------------- |
|
568 | -------------------------------------- | |
529 |
|
569 | |||
530 | In many cases list comprehensions are nicer than using the map function. While we don't have fully parallel list comprehensions, it is simple to get the basic effect using ``scatter`` and ``gather``:: |
|
570 | In many cases list comprehensions are nicer than using the map function. While | |
|
571 | we don't have fully parallel list comprehensions, it is simple to get the | |||
|
572 | basic effect using :meth:`scatter` and :meth:`gather`:: | |||
531 |
|
573 | |||
532 | In [66]: mec.scatter('x',range(64)) |
|
574 | In [66]: mec.scatter('x',range(64)) | |
533 | Out[66]: [None, None, None, None] |
|
575 | Out[66]: [None, None, None, None] | |
534 |
|
576 | |||
535 | In [67]: px y = [i**10 for i in x] |
|
577 | In [67]: px y = [i**10 for i in x] | |
536 | Executing command on Controller |
|
578 | Executing command on Controller | |
537 | Out[67]: |
|
579 | Out[67]: | |
538 | <Results List> |
|
580 | <Results List> | |
539 | [0] In [19]: y = [i**10 for i in x] |
|
581 | [0] In [19]: y = [i**10 for i in x] | |
540 | [1] In [18]: y = [i**10 for i in x] |
|
582 | [1] In [18]: y = [i**10 for i in x] | |
541 | [2] In [19]: y = [i**10 for i in x] |
|
583 | [2] In [19]: y = [i**10 for i in x] | |
542 | [3] In [18]: y = [i**10 for i in x] |
|
584 | [3] In [18]: y = [i**10 for i in x] | |
543 |
|
585 | |||
544 |
|
586 | |||
545 | In [68]: y = mec.gather('y') |
|
587 | In [68]: y = mec.gather('y') | |
546 |
|
588 | |||
547 | In [69]: print y |
|
589 | In [69]: print y | |
548 | [0, 1, 1024, 59049, 1048576, 9765625, 60466176, 282475249, 1073741824,...] |
|
590 | [0, 1, 1024, 59049, 1048576, 9765625, 60466176, 282475249, 1073741824,...] | |
549 |
|
591 | |||
550 |
Parallel |
|
592 | Parallel exceptions | |
551 | ------------------- |
|
593 | ------------------- | |
552 |
|
594 | |||
553 | In the MultiEngine interface, parallel commands can raise Python exceptions, just like serial commands. But, it is a little subtle, because a single parallel command can actually raise multiple exceptions (one for each engine the command was run on). To express this idea, the MultiEngine interface has a ``CompositeError`` exception class that will be raised in most cases. The ``CompositeError`` class is a special type of exception that wraps one or more other types of exceptions. Here is how it works:: |
|
595 | In the multiengine interface, parallel commands can raise Python exceptions, | |
|
596 | just like serial commands. But, it is a little subtle, because a single | |||
|
597 | parallel command can actually raise multiple exceptions (one for each engine | |||
|
598 | the command was run on). To express this idea, the MultiEngine interface has a | |||
|
599 | :exc:`CompositeError` exception class that will be raised in most cases. The | |||
|
600 | :exc:`CompositeError` class is a special type of exception that wraps one or | |||
|
601 | more other types of exceptions. Here is how it works:: | |||
554 |
|
602 | |||
555 | In [76]: mec.block=True |
|
603 | In [76]: mec.block=True | |
556 |
|
604 | |||
557 | In [77]: mec.execute('1/0') |
|
605 | In [77]: mec.execute('1/0') | |
558 | --------------------------------------------------------------------------- |
|
606 | --------------------------------------------------------------------------- | |
559 | CompositeError Traceback (most recent call last) |
|
607 | CompositeError Traceback (most recent call last) | |
560 |
|
608 | |||
561 | /ipython1-client-r3021/docs/examples/<ipython console> in <module>() |
|
609 | /ipython1-client-r3021/docs/examples/<ipython console> in <module>() | |
562 |
|
610 | |||
563 | /ipython1-client-r3021/ipython1/kernel/multiengineclient.pyc in execute(self, lines, targets, block) |
|
611 | /ipython1-client-r3021/ipython1/kernel/multiengineclient.pyc in execute(self, lines, targets, block) | |
564 | 432 targets, block = self._findTargetsAndBlock(targets, block) |
|
612 | 432 targets, block = self._findTargetsAndBlock(targets, block) | |
565 | 433 result = blockingCallFromThread(self.smultiengine.execute, lines, |
|
613 | 433 result = blockingCallFromThread(self.smultiengine.execute, lines, | |
566 | --> 434 targets=targets, block=block) |
|
614 | --> 434 targets=targets, block=block) | |
567 | 435 if block: |
|
615 | 435 if block: | |
568 | 436 result = ResultList(result) |
|
616 | 436 result = ResultList(result) | |
569 |
|
617 | |||
570 | /ipython1-client-r3021/ipython1/kernel/twistedutil.pyc in blockingCallFromThread(f, *a, **kw) |
|
618 | /ipython1-client-r3021/ipython1/kernel/twistedutil.pyc in blockingCallFromThread(f, *a, **kw) | |
571 | 72 result.raiseException() |
|
619 | 72 result.raiseException() | |
572 | 73 except Exception, e: |
|
620 | 73 except Exception, e: | |
573 | ---> 74 raise e |
|
621 | ---> 74 raise e | |
574 | 75 return result |
|
622 | 75 return result | |
575 | 76 |
|
623 | 76 | |
576 |
|
624 | |||
577 | CompositeError: one or more exceptions from call to method: execute |
|
625 | CompositeError: one or more exceptions from call to method: execute | |
578 | [0:execute]: ZeroDivisionError: integer division or modulo by zero |
|
626 | [0:execute]: ZeroDivisionError: integer division or modulo by zero | |
579 | [1:execute]: ZeroDivisionError: integer division or modulo by zero |
|
627 | [1:execute]: ZeroDivisionError: integer division or modulo by zero | |
580 | [2:execute]: ZeroDivisionError: integer division or modulo by zero |
|
628 | [2:execute]: ZeroDivisionError: integer division or modulo by zero | |
581 | [3:execute]: ZeroDivisionError: integer division or modulo by zero |
|
629 | [3:execute]: ZeroDivisionError: integer division or modulo by zero | |
582 |
|
630 | |||
583 |
Notice how the error message printed when |
|
631 | Notice how the error message printed when :exc:`CompositeError` is raised has information about the individual exceptions that were raised on each engine. If you want, you can even raise one of these original exceptions:: | |
584 |
|
632 | |||
585 | In [80]: try: |
|
633 | In [80]: try: | |
586 | ....: mec.execute('1/0') |
|
634 | ....: mec.execute('1/0') | |
587 | ....: except client.CompositeError, e: |
|
635 | ....: except client.CompositeError, e: | |
588 | ....: e.raise_exception() |
|
636 | ....: e.raise_exception() | |
589 | ....: |
|
637 | ....: | |
590 | ....: |
|
638 | ....: | |
591 | --------------------------------------------------------------------------- |
|
639 | --------------------------------------------------------------------------- | |
592 | ZeroDivisionError Traceback (most recent call last) |
|
640 | ZeroDivisionError Traceback (most recent call last) | |
593 |
|
641 | |||
594 | /ipython1-client-r3021/docs/examples/<ipython console> in <module>() |
|
642 | /ipython1-client-r3021/docs/examples/<ipython console> in <module>() | |
595 |
|
643 | |||
596 | /ipython1-client-r3021/ipython1/kernel/error.pyc in raise_exception(self, excid) |
|
644 | /ipython1-client-r3021/ipython1/kernel/error.pyc in raise_exception(self, excid) | |
597 | 156 raise IndexError("an exception with index %i does not exist"%excid) |
|
645 | 156 raise IndexError("an exception with index %i does not exist"%excid) | |
598 | 157 else: |
|
646 | 157 else: | |
599 | --> 158 raise et, ev, etb |
|
647 | --> 158 raise et, ev, etb | |
600 | 159 |
|
648 | 159 | |
601 | 160 def collect_exceptions(rlist, method): |
|
649 | 160 def collect_exceptions(rlist, method): | |
602 |
|
650 | |||
603 | ZeroDivisionError: integer division or modulo by zero |
|
651 | ZeroDivisionError: integer division or modulo by zero | |
604 |
|
652 | |||
605 |
If you are working in IPython, you can simple type ``%debug`` after one of |
|
653 | If you are working in IPython, you can simple type ``%debug`` after one of | |
|
654 | these :exc:`CompositeError` exceptions is raised, and inspect the exception | |||
|
655 | instance:: | |||
606 |
|
656 | |||
607 | In [81]: mec.execute('1/0') |
|
657 | In [81]: mec.execute('1/0') | |
608 | --------------------------------------------------------------------------- |
|
658 | --------------------------------------------------------------------------- | |
609 | CompositeError Traceback (most recent call last) |
|
659 | CompositeError Traceback (most recent call last) | |
610 |
|
660 | |||
611 | /ipython1-client-r3021/docs/examples/<ipython console> in <module>() |
|
661 | /ipython1-client-r3021/docs/examples/<ipython console> in <module>() | |
612 |
|
662 | |||
613 | /ipython1-client-r3021/ipython1/kernel/multiengineclient.pyc in execute(self, lines, targets, block) |
|
663 | /ipython1-client-r3021/ipython1/kernel/multiengineclient.pyc in execute(self, lines, targets, block) | |
614 | 432 targets, block = self._findTargetsAndBlock(targets, block) |
|
664 | 432 targets, block = self._findTargetsAndBlock(targets, block) | |
615 | 433 result = blockingCallFromThread(self.smultiengine.execute, lines, |
|
665 | 433 result = blockingCallFromThread(self.smultiengine.execute, lines, | |
616 | --> 434 targets=targets, block=block) |
|
666 | --> 434 targets=targets, block=block) | |
617 | 435 if block: |
|
667 | 435 if block: | |
618 | 436 result = ResultList(result) |
|
668 | 436 result = ResultList(result) | |
619 |
|
669 | |||
620 | /ipython1-client-r3021/ipython1/kernel/twistedutil.pyc in blockingCallFromThread(f, *a, **kw) |
|
670 | /ipython1-client-r3021/ipython1/kernel/twistedutil.pyc in blockingCallFromThread(f, *a, **kw) | |
621 | 72 result.raiseException() |
|
671 | 72 result.raiseException() | |
622 | 73 except Exception, e: |
|
672 | 73 except Exception, e: | |
623 | ---> 74 raise e |
|
673 | ---> 74 raise e | |
624 | 75 return result |
|
674 | 75 return result | |
625 | 76 |
|
675 | 76 | |
626 |
|
676 | |||
627 | CompositeError: one or more exceptions from call to method: execute |
|
677 | CompositeError: one or more exceptions from call to method: execute | |
628 | [0:execute]: ZeroDivisionError: integer division or modulo by zero |
|
678 | [0:execute]: ZeroDivisionError: integer division or modulo by zero | |
629 | [1:execute]: ZeroDivisionError: integer division or modulo by zero |
|
679 | [1:execute]: ZeroDivisionError: integer division or modulo by zero | |
630 | [2:execute]: ZeroDivisionError: integer division or modulo by zero |
|
680 | [2:execute]: ZeroDivisionError: integer division or modulo by zero | |
631 | [3:execute]: ZeroDivisionError: integer division or modulo by zero |
|
681 | [3:execute]: ZeroDivisionError: integer division or modulo by zero | |
632 |
|
682 | |||
633 | In [82]: %debug |
|
683 | In [82]: %debug | |
634 | > |
|
684 | > | |
635 |
|
685 | |||
636 | /ipython1-client-r3021/ipython1/kernel/twistedutil.py(74)blockingCallFromThread() |
|
686 | /ipython1-client-r3021/ipython1/kernel/twistedutil.py(74)blockingCallFromThread() | |
637 | 73 except Exception, e: |
|
687 | 73 except Exception, e: | |
638 | ---> 74 raise e |
|
688 | ---> 74 raise e | |
639 | 75 return result |
|
689 | 75 return result | |
640 |
|
690 | |||
641 | # With the debugger running, e is the exceptions instance. We can tab complete |
|
691 | # With the debugger running, e is the exceptions instance. We can tab complete | |
642 | # on it and see the extra methods that are available. |
|
692 | # on it and see the extra methods that are available. | |
643 | ipdb> e. |
|
693 | ipdb> e. | |
644 | e.__class__ e.__getitem__ e.__new__ e.__setstate__ e.args |
|
694 | e.__class__ e.__getitem__ e.__new__ e.__setstate__ e.args | |
645 | e.__delattr__ e.__getslice__ e.__reduce__ e.__str__ e.elist |
|
695 | e.__delattr__ e.__getslice__ e.__reduce__ e.__str__ e.elist | |
646 | e.__dict__ e.__hash__ e.__reduce_ex__ e.__weakref__ e.message |
|
696 | e.__dict__ e.__hash__ e.__reduce_ex__ e.__weakref__ e.message | |
647 | e.__doc__ e.__init__ e.__repr__ e._get_engine_str e.print_tracebacks |
|
697 | e.__doc__ e.__init__ e.__repr__ e._get_engine_str e.print_tracebacks | |
648 | e.__getattribute__ e.__module__ e.__setattr__ e._get_traceback e.raise_exception |
|
698 | e.__getattribute__ e.__module__ e.__setattr__ e._get_traceback e.raise_exception | |
649 | ipdb> e.print_tracebacks() |
|
699 | ipdb> e.print_tracebacks() | |
650 | [0:execute]: |
|
700 | [0:execute]: | |
651 | --------------------------------------------------------------------------- |
|
701 | --------------------------------------------------------------------------- | |
652 | ZeroDivisionError Traceback (most recent call last) |
|
702 | ZeroDivisionError Traceback (most recent call last) | |
653 |
|
703 | |||
654 | /ipython1-client-r3021/docs/examples/<string> in <module>() |
|
704 | /ipython1-client-r3021/docs/examples/<string> in <module>() | |
655 |
|
705 | |||
656 | ZeroDivisionError: integer division or modulo by zero |
|
706 | ZeroDivisionError: integer division or modulo by zero | |
657 |
|
707 | |||
658 | [1:execute]: |
|
708 | [1:execute]: | |
659 | --------------------------------------------------------------------------- |
|
709 | --------------------------------------------------------------------------- | |
660 | ZeroDivisionError Traceback (most recent call last) |
|
710 | ZeroDivisionError Traceback (most recent call last) | |
661 |
|
711 | |||
662 | /ipython1-client-r3021/docs/examples/<string> in <module>() |
|
712 | /ipython1-client-r3021/docs/examples/<string> in <module>() | |
663 |
|
713 | |||
664 | ZeroDivisionError: integer division or modulo by zero |
|
714 | ZeroDivisionError: integer division or modulo by zero | |
665 |
|
715 | |||
666 | [2:execute]: |
|
716 | [2:execute]: | |
667 | --------------------------------------------------------------------------- |
|
717 | --------------------------------------------------------------------------- | |
668 | ZeroDivisionError Traceback (most recent call last) |
|
718 | ZeroDivisionError Traceback (most recent call last) | |
669 |
|
719 | |||
670 | /ipython1-client-r3021/docs/examples/<string> in <module>() |
|
720 | /ipython1-client-r3021/docs/examples/<string> in <module>() | |
671 |
|
721 | |||
672 | ZeroDivisionError: integer division or modulo by zero |
|
722 | ZeroDivisionError: integer division or modulo by zero | |
673 |
|
723 | |||
674 | [3:execute]: |
|
724 | [3:execute]: | |
675 | --------------------------------------------------------------------------- |
|
725 | --------------------------------------------------------------------------- | |
676 | ZeroDivisionError Traceback (most recent call last) |
|
726 | ZeroDivisionError Traceback (most recent call last) | |
677 |
|
727 | |||
678 | /ipython1-client-r3021/docs/examples/<string> in <module>() |
|
728 | /ipython1-client-r3021/docs/examples/<string> in <module>() | |
679 |
|
729 | |||
680 | ZeroDivisionError: integer division or modulo by zero |
|
730 | ZeroDivisionError: integer division or modulo by zero | |
681 |
|
731 | |||
|
732 | .. note:: | |||
|
733 | ||||
|
734 | The above example appears to be broken right now because of a change in | |||
|
735 | how we are using Twisted. | |||
|
736 | ||||
682 | All of this same error handling magic even works in non-blocking mode:: |
|
737 | All of this same error handling magic even works in non-blocking mode:: | |
683 |
|
738 | |||
684 | In [83]: mec.block=False |
|
739 | In [83]: mec.block=False | |
685 |
|
740 | |||
686 | In [84]: pr = mec.execute('1/0') |
|
741 | In [84]: pr = mec.execute('1/0') | |
687 |
|
742 | |||
688 | In [85]: pr.r |
|
743 | In [85]: pr.r | |
689 | --------------------------------------------------------------------------- |
|
744 | --------------------------------------------------------------------------- | |
690 | CompositeError Traceback (most recent call last) |
|
745 | CompositeError Traceback (most recent call last) | |
691 |
|
746 | |||
692 | /ipython1-client-r3021/docs/examples/<ipython console> in <module>() |
|
747 | /ipython1-client-r3021/docs/examples/<ipython console> in <module>() | |
693 |
|
748 | |||
694 | /ipython1-client-r3021/ipython1/kernel/multiengineclient.pyc in _get_r(self) |
|
749 | /ipython1-client-r3021/ipython1/kernel/multiengineclient.pyc in _get_r(self) | |
695 | 170 |
|
750 | 170 | |
696 | 171 def _get_r(self): |
|
751 | 171 def _get_r(self): | |
697 | --> 172 return self.get_result(block=True) |
|
752 | --> 172 return self.get_result(block=True) | |
698 | 173 |
|
753 | 173 | |
699 | 174 r = property(_get_r) |
|
754 | 174 r = property(_get_r) | |
700 |
|
755 | |||
701 | /ipython1-client-r3021/ipython1/kernel/multiengineclient.pyc in get_result(self, default, block) |
|
756 | /ipython1-client-r3021/ipython1/kernel/multiengineclient.pyc in get_result(self, default, block) | |
702 | 131 return self.result |
|
757 | 131 return self.result | |
703 | 132 try: |
|
758 | 132 try: | |
704 | --> 133 result = self.client.get_pending_deferred(self.result_id, block) |
|
759 | --> 133 result = self.client.get_pending_deferred(self.result_id, block) | |
705 | 134 except error.ResultNotCompleted: |
|
760 | 134 except error.ResultNotCompleted: | |
706 | 135 return default |
|
761 | 135 return default | |
707 |
|
762 | |||
708 | /ipython1-client-r3021/ipython1/kernel/multiengineclient.pyc in get_pending_deferred(self, deferredID, block) |
|
763 | /ipython1-client-r3021/ipython1/kernel/multiengineclient.pyc in get_pending_deferred(self, deferredID, block) | |
709 | 385 |
|
764 | 385 | |
710 | 386 def get_pending_deferred(self, deferredID, block): |
|
765 | 386 def get_pending_deferred(self, deferredID, block): | |
711 | --> 387 return blockingCallFromThread(self.smultiengine.get_pending_deferred, deferredID, block) |
|
766 | --> 387 return blockingCallFromThread(self.smultiengine.get_pending_deferred, deferredID, block) | |
712 | 388 |
|
767 | 388 | |
713 | 389 def barrier(self, pendingResults): |
|
768 | 389 def barrier(self, pendingResults): | |
714 |
|
769 | |||
715 | /ipython1-client-r3021/ipython1/kernel/twistedutil.pyc in blockingCallFromThread(f, *a, **kw) |
|
770 | /ipython1-client-r3021/ipython1/kernel/twistedutil.pyc in blockingCallFromThread(f, *a, **kw) | |
716 | 72 result.raiseException() |
|
771 | 72 result.raiseException() | |
717 | 73 except Exception, e: |
|
772 | 73 except Exception, e: | |
718 | ---> 74 raise e |
|
773 | ---> 74 raise e | |
719 | 75 return result |
|
774 | 75 return result | |
720 | 76 |
|
775 | 76 | |
721 |
|
776 | |||
722 | CompositeError: one or more exceptions from call to method: execute |
|
777 | CompositeError: one or more exceptions from call to method: execute | |
723 | [0:execute]: ZeroDivisionError: integer division or modulo by zero |
|
778 | [0:execute]: ZeroDivisionError: integer division or modulo by zero | |
724 | [1:execute]: ZeroDivisionError: integer division or modulo by zero |
|
779 | [1:execute]: ZeroDivisionError: integer division or modulo by zero | |
725 | [2:execute]: ZeroDivisionError: integer division or modulo by zero |
|
780 | [2:execute]: ZeroDivisionError: integer division or modulo by zero | |
726 | [3:execute]: ZeroDivisionError: integer division or modulo by zero |
|
781 | [3:execute]: ZeroDivisionError: integer division or modulo by zero | |
727 |
|
782 | |||
728 |
|
783 |
@@ -1,240 +1,93 b'' | |||||
1 | .. _paralleltask: |
|
1 | .. _paralleltask: | |
2 |
|
2 | |||
3 |
========================== |
|
3 | ========================== | |
4 |
The IPython |
|
4 | The IPython task interface | |
5 |
========================== |
|
5 | ========================== | |
6 |
|
6 | |||
7 | .. contents:: |
|
7 | .. contents:: | |
8 |
|
8 | |||
9 | The ``Task`` interface to the controller presents the engines as a fault tolerant, dynamic load-balanced system or workers. Unlike the ``MultiEngine`` interface, in the ``Task`` interface, the user have no direct access to individual engines. In some ways, this interface is simpler, but in other ways it is more powerful. Best of all the user can use both of these interfaces at the same time to take advantage or both of their strengths. When the user can break up the user's work into segments that do not depend on previous execution, the ``Task`` interface is ideal. But it also has more power and flexibility, allowing the user to guide the distribution of jobs, without having to assign Tasks to engines explicitly. |
|
9 | The task interface to the controller presents the engines as a fault tolerant, dynamic load-balanced system or workers. Unlike the multiengine interface, in the task interface, the user have no direct access to individual engines. In some ways, this interface is simpler, but in other ways it is more powerful. | |
|
10 | ||||
|
11 | Best of all the user can use both of these interfaces running at the same time to take advantage or both of their strengths. When the user can break up the user's work into segments that do not depend on previous execution, the task interface is ideal. But it also has more power and flexibility, allowing the user to guide the distribution of jobs, without having to assign tasks to engines explicitly. | |||
10 |
|
12 | |||
11 | Starting the IPython controller and engines |
|
13 | Starting the IPython controller and engines | |
12 | =========================================== |
|
14 | =========================================== | |
13 |
|
15 | |||
14 |
To follow along with this tutorial, |
|
16 | To follow along with this tutorial, you will need to start the IPython | |
15 | controller and four IPython engines. The simplest way of doing this is to |
|
17 | controller and four IPython engines. The simplest way of doing this is to use | |
16 |
|
|
18 | the :command:`ipcluster` command:: | |
17 |
|
19 | |||
18 | $ ipcluster -n 4 |
|
20 | $ ipcluster -n 4 | |
19 |
|
21 | |||
20 |
For more detailed information about starting the controller and engines, see |
|
22 | For more detailed information about starting the controller and engines, see | |
|
23 | our :ref:`introduction <ip1par>` to using IPython for parallel computing. | |||
|
24 | ||||
|
25 | Creating a ``TaskClient`` instance | |||
|
26 | ========================================= | |||
|
27 | ||||
|
28 | The first step is to import the IPython :mod:`IPython.kernel.client` module | |||
|
29 | and then create a :class:`TaskClient` instance:: | |||
|
30 | ||||
|
31 | In [1]: from IPython.kernel import client | |||
|
32 | ||||
|
33 | In [2]: tc = client.TaskClient() | |||
|
34 | ||||
|
35 | This form assumes that the :file:`ipcontroller-tc.furl` is in the | |||
|
36 | :file:`~./ipython/security` directory on the client's host. If not, the | |||
|
37 | location of the ``.furl`` file must be given as an argument to the | |||
|
38 | constructor:: | |||
|
39 | ||||
|
40 | In[2]: mec = client.TaskClient('/path/to/my/ipcontroller-tc.furl') | |||
|
41 | ||||
|
42 | Quick and easy parallelism | |||
|
43 | ========================== | |||
|
44 | ||||
|
45 | In many cases, you simply want to apply a Python function to a sequence of objects, but *in parallel*. Like the multiengine interface, the task interface provides two simple ways of accomplishing this: a parallel version of :func:`map` and ``@parallel`` function decorator. However, the verions in the task interface have one important difference: they are dynamically load balanced. Thus, if the execution time per item varies significantly, you should use the versions in the task interface. | |||
|
46 | ||||
|
47 | Parallel map | |||
|
48 | ------------ | |||
|
49 | ||||
|
50 | The parallel :meth:`map` in the task interface is similar to that in the multiengine interface:: | |||
|
51 | ||||
|
52 | In [63]: serial_result = map(lambda x:x**10, range(32)) | |||
|
53 | ||||
|
54 | In [64]: parallel_result = tc.map(lambda x:x**10, range(32)) | |||
|
55 | ||||
|
56 | In [65]: serial_result==parallel_result | |||
|
57 | Out[65]: True | |||
|
58 | ||||
|
59 | Parallel function decorator | |||
|
60 | --------------------------- | |||
|
61 | ||||
|
62 | Parallel functions are just like normal function, but they can be called on sequences and *in parallel*. The multiengine interface provides a decorator that turns any Python function into a parallel function:: | |||
21 |
|
63 | |||
22 | The magic here is that this single controller and set of engines is running both the MultiEngine and ``Task`` interfaces simultaneously. |
|
64 | In [10]: @tc.parallel() | |
|
65 | ....: def f(x): | |||
|
66 | ....: return 10.0*x**4 | |||
|
67 | ....: | |||
23 |
|
68 | |||
24 | QuickStart Task Farming |
|
69 | In [11]: f(range(32)) # this is done in parallel | |
25 | ======================= |
|
70 | Out[11]: | |
|
71 | [0.0,10.0,160.0,...] | |||
26 |
|
72 | |||
27 | First, a quick example of how to start running the most basic Tasks. |
|
73 | More details | |
28 | The first step is to import the IPython ``client`` module and then create a ``TaskClient`` instance:: |
|
74 | ============ | |
29 |
|
||||
30 | In [1]: from IPython.kernel import client |
|
|||
31 |
|
||||
32 | In [2]: tc = client.TaskClient() |
|
|||
33 |
|
75 | |||
34 | Then the user wrap the commands the user want to run in Tasks:: |
|
76 | The :class:`TaskClient` has many more powerful features that allow quite a bit of flexibility in how tasks are defined and run. The next places to look are in the following classes: | |
35 |
|
77 | |||
36 | In [3]: tasklist = [] |
|
78 | * :class:`IPython.kernel.client.TaskClient` | |
37 | In [4]: for n in range(1000): |
|
79 | * :class:`IPython.kernel.client.StringTask` | |
38 | ... tasklist.append(client.Task("a = %i"%n, pull="a")) |
|
80 | * :class:`IPython.kernel.client.MapTask` | |
39 |
|
81 | |||
40 | The first argument of the ``Task`` constructor is a string, the command to be executed. The most important optional keyword argument is ``pull``, which can be a string or list of strings, and it specifies the variable names to be saved as results of the ``Task``. |
|
82 | The following is an overview of how to use these classes together: | |
41 |
|
83 | |||
42 | Next, the user need to submit the Tasks to the ``TaskController`` with the ``TaskClient``:: |
|
84 | 1. Create a :class:`TaskClient`. | |
|
85 | 2. Create one or more instances of :class:`StringTask` or :class:`MapTask` | |||
|
86 | to define your tasks. | |||
|
87 | 3. Submit your tasks to using the :meth:`run` method of your | |||
|
88 | :class:`TaskClient` instance. | |||
|
89 | 4. Use :meth:`TaskClient.get_task_result` to get the results of the | |||
|
90 | tasks. | |||
43 |
|
91 | |||
44 | In [5]: taskids = [ tc.run(t) for t in tasklist ] |
|
92 | We are in the process of developing more detailed information about the task interface. For now, the docstrings of the :class:`TaskClient`, :class:`StringTask` and :class:`MapTask` classes should be consulted. | |
45 |
|
93 | |||
46 | This will give the user a list of the TaskIDs used by the controller to keep track of the Tasks and their results. Now at some point the user are going to want to get those results back. The ``barrier`` method allows the user to wait for the Tasks to finish running:: |
|
|||
47 |
|
||||
48 | In [6]: tc.barrier(taskids) |
|
|||
49 |
|
||||
50 | This command will block until all the Tasks in ``taskids`` have finished. Now, the user probably want to look at the user's results:: |
|
|||
51 |
|
||||
52 | In [7]: task_results = [ tc.get_task_result(taskid) for taskid in taskids ] |
|
|||
53 |
|
||||
54 | Now the user have a list of ``TaskResult`` objects, which have the actual result as a dictionary, but also keep track of some useful metadata about the ``Task``:: |
|
|||
55 |
|
||||
56 | In [8]: tr = ``Task``_results[73] |
|
|||
57 |
|
||||
58 | In [9]: tr |
|
|||
59 | Out[9]: ``TaskResult``[ID:73]:{'a':73} |
|
|||
60 |
|
||||
61 | In [10]: tr.engineid |
|
|||
62 | Out[10]: 1 |
|
|||
63 |
|
||||
64 | In [11]: tr.submitted, tr.completed, tr.duration |
|
|||
65 | Out[11]: ("2008/03/08 03:41:42", "2008/03/08 03:41:44", 2.12345) |
|
|||
66 |
|
||||
67 | The actual results are stored in a dictionary, ``tr.results``, and a namespace object ``tr.ns`` which accesses the result keys by attribute:: |
|
|||
68 |
|
||||
69 | In [12]: tr.results['a'] |
|
|||
70 | Out[12]: 73 |
|
|||
71 |
|
||||
72 | In [13]: tr.ns.a |
|
|||
73 | Out[13]: 73 |
|
|||
74 |
|
||||
75 | That should cover the basics of running simple Tasks. There are several more powerful things the user can do with Tasks covered later. The most useful probably being using a ``MutiEngineClient`` interface to initialize all the engines with the import dependencies necessary to run the user's Tasks. |
|
|||
76 |
|
||||
77 | There are many options for running and managing Tasks. The best way to learn further about the ``Task`` interface is to study the examples in ``docs/examples``. If the user do so and learn a lots about this interface, we encourage the user to expand this documentation about the ``Task`` system. |
|
|||
78 |
|
||||
79 | Overview of the Task System |
|
|||
80 | =========================== |
|
|||
81 |
|
||||
82 | The user's view of the ``Task`` system has three basic objects: The ``TaskClient``, the ``Task``, and the ``TaskResult``. The names of these three objects well indicate their role. |
|
|||
83 |
|
||||
84 | The ``TaskClient`` is the user's ``Task`` farming connection to the IPython cluster. Unlike the ``MultiEngineClient``, the ``TaskControler`` handles all the scheduling and distribution of work, so the ``TaskClient`` has no notion of engines, it just submits Tasks and requests their results. The Tasks are described as ``Task`` objects, and their results are wrapped in ``TaskResult`` objects. Thus, there are very few necessary methods for the user to manage. |
|
|||
85 |
|
||||
86 | Inside the task system is a Scheduler object, which assigns tasks to workers. The default scheduler is a simple FIFO queue. Subclassing the Scheduler should be easy, just implementing your own priority system. |
|
|||
87 |
|
||||
88 | The TaskClient |
|
|||
89 | ============== |
|
|||
90 |
|
||||
91 | The ``TaskClient`` is the object the user use to connect to the ``Controller`` that is managing the user's Tasks. It is the analog of the ``MultiEngineClient`` for the standard IPython multiplexing interface. As with all client interfaces, the first step is to import the IPython Client Module:: |
|
|||
92 |
|
||||
93 | In [1]: from IPython.kernel import client |
|
|||
94 |
|
||||
95 | Just as with the ``MultiEngineClient``, the user create the ``TaskClient`` with a tuple, containing the ip-address and port of the ``Controller``. the ``client`` module conveniently has the default address of the ``Task`` interface of the controller. Creating a default ``TaskClient`` object would be done with this:: |
|
|||
96 |
|
||||
97 | In [2]: tc = client.TaskClient(client.default_task_address) |
|
|||
98 |
|
||||
99 | or, if the user want to specify a non default location of the ``Controller``, the user can specify explicitly:: |
|
|||
100 |
|
||||
101 | In [3]: tc = client.TaskClient(("192.168.1.1", 10113)) |
|
|||
102 |
|
||||
103 | As discussed earlier, the ``TaskClient`` only has a few basic methods. |
|
|||
104 |
|
||||
105 | * ``tc.run(task)`` |
|
|||
106 | ``run`` is the method by which the user submits Tasks. It takes exactly one argument, a ``Task`` object. All the advanced control of ``Task`` behavior is handled by properties of the ``Task`` object, rather than the submission command, so they will be discussed later in the `Task`_ section. ``run`` returns an integer, the ``Task``ID by which the ``Task`` and its results can be tracked and retrieved:: |
|
|||
107 |
|
||||
108 | In [4]: ``Task``ID = tc.run(``Task``) |
|
|||
109 |
|
||||
110 | * ``tc.get_task_result(taskid, block=``False``)`` |
|
|||
111 | ``get_task_result`` is the method by which results are retrieved. It takes a single integer argument, the ``Task``ID`` of the result the user wish to retrieve. ``get_task_result`` also takes a keyword argument ``block``. ``block`` specifies whether the user actually want to wait for the result. If ``block`` is false, as it is by default, ``get_task_result`` will return immediately. If the ``Task`` has completed, it will return the ``TaskResult`` object for that ``Task``. But if the ``Task`` has not completed, it will return ``None``. If the user specify ``block=``True``, then ``get_task_result`` will wait for the ``Task`` to complete, and always return the ``TaskResult`` for the requested ``Task``. |
|
|||
112 | * ``tc.barrier(taskid(s))`` |
|
|||
113 | ``barrier`` is a synchronization method. It takes exactly one argument, a ``Task``ID or list of taskIDs. ``barrier`` will block until all the specified Tasks have completed. In practice, a barrier is often called between the ``Task`` submission section of the code and the result gathering section:: |
|
|||
114 |
|
||||
115 | In [5]: taskIDs = [ tc.run(``Task``) for ``Task`` in myTasks ] |
|
|||
116 |
|
||||
117 | In [6]: tc.get_task_result(taskIDs[-1]) is None |
|
|||
118 | Out[6]: ``True`` |
|
|||
119 |
|
||||
120 | In [7]: tc.barrier(``Task``ID) |
|
|||
121 |
|
||||
122 | In [8]: results = [ tc.get_task_result(tid) for tid in taskIDs ] |
|
|||
123 |
|
||||
124 | * ``tc.queue_status(verbose=``False``)`` |
|
|||
125 | ``queue_status`` is a method for querying the state of the ``TaskControler``. ``queue_status`` returns a dict of the form:: |
|
|||
126 |
|
||||
127 | {'scheduled': Tasks that have been submitted but yet run |
|
|||
128 | 'pending' : Tasks that are currently running |
|
|||
129 | 'succeeded': Tasks that have completed successfully |
|
|||
130 | 'failed' : Tasks that have finished with a failure |
|
|||
131 | } |
|
|||
132 |
|
||||
133 | if @verbose is not specified (or is ``False``), then the values of the dict are integers - the number of Tasks in each state. if @verbose is ``True``, then each element in the dict is a list of the taskIDs in that state:: |
|
|||
134 |
|
||||
135 | In [8]: tc.queue_status() |
|
|||
136 | Out[8]: {'scheduled': 4, |
|
|||
137 | 'pending' : 2, |
|
|||
138 | 'succeeded': 5, |
|
|||
139 | 'failed' : 1 |
|
|||
140 | } |
|
|||
141 |
|
||||
142 | In [9]: tc.queue_status(verbose=True) |
|
|||
143 | Out[9]: {'scheduled': [8,9,10,11], |
|
|||
144 | 'pending' : [6,7], |
|
|||
145 | 'succeeded': [0,1,2,4,5], |
|
|||
146 | 'failed' : [3] |
|
|||
147 | } |
|
|||
148 |
|
||||
149 | * ``tc.abort(taskid)`` |
|
|||
150 | ``abort`` allows the user to abort Tasks that have already been submitted. ``abort`` will always return immediately. If the ``Task`` has completed, ``abort`` will raise an ``IndexError ``Task`` Already Completed``. An obvious case for ``abort`` would be where the user submits a long-running ``Task`` with a number of retries (see ``Task``_ section for how to specify retries) in an interactive session, but realizes there has been a typo. The user can then abort the ``Task``, preventing certain failures from cluttering up the queue. It can also be used for parallel search-type problems, where only one ``Task`` will give the solution, so once the user find the solution, the user would want to abort all remaining Tasks to prevent wasted work. |
|
|||
151 | * ``tc.spin()`` |
|
|||
152 | ``spin`` simply triggers the scheduler in the ``TaskControler``. Under most normal circumstances, this will do nothing. The primary known usage case involves the ``Task`` dependency (see `Dependencies`_). The dependency is a function of an Engine's ``properties``, but changing the ``properties`` via the ``MutliEngineClient`` does not trigger a reschedule event. The main example case for this requires the following event sequence: |
|
|||
153 | * ``engine`` is available, ``Task`` is submitted, but ``engine`` does not have ``Task``'s dependencies. |
|
|||
154 | * ``engine`` gets necessary dependencies while no new Tasks are submitted or completed. |
|
|||
155 | * now ``engine`` can run ``Task``, but a ``Task`` event is required for the ``TaskControler`` to try scheduling ``Task`` again. |
|
|||
156 |
|
||||
157 | ``spin`` is just an empty ping method to ensure that the Controller has scheduled all available Tasks, and should not be needed under most normal circumstances. |
|
|||
158 |
|
||||
159 | That covers the ``TaskClient``, a simple interface to the cluster. With this, the user can submit jobs (and abort if necessary), request their results, synchronize on arbitrary subsets of jobs. |
|
|||
160 |
|
||||
161 | .. _task: The Task Object |
|
|||
162 |
|
||||
163 | The Task Object |
|
|||
164 | =============== |
|
|||
165 |
|
||||
166 | The ``Task`` is the basic object for describing a job. It can be used in a very simple manner, where the user just specifies a command string to be executed as the ``Task``. The usage of this first argument is exactly the same as the ``execute`` method of the ``MultiEngine`` (in fact, ``execute`` is called to run the code):: |
|
|||
167 |
|
||||
168 | In [1]: t = client.Task("a = str(id)") |
|
|||
169 |
|
||||
170 | This ``Task`` would run, and store the string representation of the ``id`` element in ``a`` in each worker's namespace, but it is fairly useless because the user does not know anything about the state of the ``worker`` on which it ran at the time of retrieving results. It is important that each ``Task`` not expect the state of the ``worker`` to persist after the ``Task`` is completed. |
|
|||
171 | There are many different situations for using ``Task`` Farming, and the ``Task`` object has many attributes for use in customizing the ``Task`` behavior. All of a ``Task``'s attributes may be specified in the constructor, through keyword arguments, or after ``Task`` construction through attribute assignment. |
|
|||
172 |
|
||||
173 | Data Attributes |
|
|||
174 | *************** |
|
|||
175 | It is likely that the user may want to move data around before or after executing the ``Task``. We provide methods of sending data to initialize the worker's namespace, and specifying what data to bring back as the ``Task``'s results. |
|
|||
176 |
|
||||
177 | * pull = [] |
|
|||
178 | The obvious case is as above, where ``t`` would execute and store the result of ``myfunc`` in ``a``, it is likely that the user would want to bring ``a`` back to their namespace. This is done through the ``pull`` attribute. ``pull`` can be a string or list of strings, and it specifies the names of variables to be retrieved. The ``TaskResult`` object retrieved by ``get_task_result`` will have a dictionary of keys and values, and the ``Task``'s ``pull`` attribute determines what goes into it:: |
|
|||
179 |
|
||||
180 | In [2]: t = client.Task("a = str(id)", pull = "a") |
|
|||
181 |
|
||||
182 | In [3]: t = client.Task("a = str(id)", pull = ["a", "id"]) |
|
|||
183 |
|
||||
184 | * push = {} |
|
|||
185 | A user might also want to initialize some data into the namespace before the code part of the ``Task`` is run. Enter ``push``. ``push`` is a dictionary of key/value pairs to be loaded from the user's namespace into the worker's immediately before execution:: |
|
|||
186 |
|
||||
187 | In [4]: t = client.Task("a = f(submitted)", push=dict(submitted=time.time()), pull="a") |
|
|||
188 |
|
||||
189 | push and pull result directly in calling an ``engine``'s ``push`` and ``pull`` methods before and after ``Task`` execution respectively, and thus their api is the same. |
|
|||
190 |
|
||||
191 | Namespace Cleaning |
|
|||
192 | ****************** |
|
|||
193 | When a user is running a large number of Tasks, it is likely that the namespace of the worker's could become cluttered. Some Tasks might be sensitive to clutter, while others might be known to cause namespace pollution. For these reasons, Tasks have two boolean attributes for cleaning up the namespace. |
|
|||
194 |
|
||||
195 | * ``clear_after`` |
|
|||
196 | if clear_after is specified ``True``, the worker on which the ``Task`` was run will be reset (via ``engine.reset``) upon completion of the ``Task``. This can be useful for both Tasks that produce clutter or Tasks whose intermediate data one might wish to be kept private:: |
|
|||
197 |
|
||||
198 | In [5]: t = client.Task("a = range(1e10)", pull = "a",clear_after=True) |
|
|||
199 |
|
||||
200 |
|
||||
201 | * ``clear_before`` |
|
|||
202 | as one might guess, clear_before is identical to ``clear_after``, but it takes place before the ``Task`` is run. This ensures that the ``Task`` runs on a fresh worker:: |
|
|||
203 |
|
||||
204 | In [6]: t = client.Task("a = globals()", pull = "a",clear_before=True) |
|
|||
205 |
|
||||
206 | Of course, a user can both at the same time, ensuring that all workers are clear except when they are currently running a job. Both of these default to ``False``. |
|
|||
207 |
|
||||
208 | Fault Tolerance |
|
|||
209 | *************** |
|
|||
210 | It is possible that Tasks might fail, and there are a variety of reasons this could happen. One might be that the worker it was running on disconnected, and there was nothing wrong with the ``Task`` itself. With the fault tolerance attributes of the ``Task``, the user can specify how many times to resubmit the ``Task``, and what to do if it never succeeds. |
|
|||
211 |
|
||||
212 | * ``retries`` |
|
|||
213 | ``retries`` is an integer, specifying the number of times a ``Task`` is to be retried. It defaults to zero. It is often a good idea for this number to be 1 or 2, to protect the ``Task`` from disconnecting engines, but not a large number. If a ``Task`` is failing 100 times, there is probably something wrong with the ``Task``. The canonical bad example: |
|
|||
214 |
|
||||
215 | In [7]: t = client.Task("os.kill(os.getpid(), 9)", retries=99) |
|
|||
216 |
|
||||
217 | This would actually take down 100 workers. |
|
|||
218 |
|
||||
219 | * ``recovery_task`` |
|
|||
220 | ``recovery_task`` is another ``Task`` object, to be run in the event of the original ``Task`` still failing after running out of retries. Since ``recovery_task`` is another ``Task`` object, it can have its own ``recovery_task``. The chain of Tasks is limitless, except loops are not allowed (that would be bad!). |
|
|||
221 |
|
||||
222 | Dependencies |
|
|||
223 | ************ |
|
|||
224 | Dependencies are the most powerful part of the ``Task`` farming system, because it allows the user to do some classification of the workers, and guide the ``Task`` distribution without meddling with the controller directly. It makes use of two objects - the ``Task``'s ``depend`` attribute, and the engine's ``properties``. See the `MultiEngine`_ reference for how to use engine properties. The engine properties api exists for extending IPython, allowing conditional execution and new controllers that make decisions based on properties of its engines. Currently the ``Task`` dependency is the only internal use of the properties api. |
|
|||
225 |
|
||||
226 | .. _MultiEngine: ./parallel_multiengine |
|
|||
227 |
|
||||
228 | The ``depend`` attribute of a ``Task`` must be a function of exactly one argument, the worker's properties dictionary, and it should return ``True`` if the ``Task`` should be allowed to run on the worker and ``False`` if not. The usage in the controller is fault tolerant, so exceptions raised by ``Task.depend`` will be ignored and functionally equivalent to always returning ``False``. Tasks`` with invalid ``depend`` functions will never be assigned to a worker:: |
|
|||
229 |
|
||||
230 | In [8]: def dep(properties): |
|
|||
231 | ... return properties["RAM"] > 2**32 # have at least 4GB |
|
|||
232 | In [9]: t = client.Task("a = bigfunc()", depend=dep) |
|
|||
233 |
|
||||
234 | It is important to note that assignment of values to the properties dict is done entirely by the user, either locally (in the engine) using the EngineAPI, or remotely, through the ``MultiEngineClient``'s get/set_properties methods. |
|
|||
235 |
|
||||
236 |
|
||||
237 |
|
||||
238 |
|
||||
239 |
|
||||
240 |
|
@@ -1,60 +1,58 b'' | |||||
1 | #!/bin/sh |
|
1 | #!/bin/sh | |
2 | # IPython release script |
|
2 | # IPython release script | |
3 |
|
3 | |||
4 | PYVER=`python -V 2>&1 | awk '{print $2}' | awk -F '.' '{print $1$2}' ` |
|
4 | PYVER=`python -V 2>&1 | awk '{print $2}' | awk -F '.' '{print $1$2}' ` | |
5 | version=`ipython -Version` |
|
5 | version=`ipython -Version` | |
6 | ipdir=~/ipython/ipython |
|
6 | ipdir=~/ipython/ipython | |
7 | ipbackupdir=~/ipython/backup |
|
7 | ipbackupdir=~/ipython/backup | |
8 |
|
8 | |||
9 | echo |
|
9 | echo | |
10 | echo "Releasing IPython version $version" |
|
10 | echo "Releasing IPython version $version" | |
11 | echo "==================================" |
|
11 | echo "==================================" | |
12 |
|
12 | |||
13 | echo "Marking ChangeLog with release information and making NEWS file..." |
|
|||
14 |
|
||||
15 | # Clean up build/dist directories |
|
|||
16 | rm -rf $ipdir/build/* |
|
|||
17 | rm -rf $ipdir/dist/* |
|
|||
18 |
|
||||
19 | # Perform local backup |
|
13 | # Perform local backup | |
20 | cd $ipdir/tools |
|
14 | cd $ipdir/tools | |
21 | ./make_tarball.py |
|
15 | ./make_tarball.py | |
22 | mv ipython-*.tgz $ipbackupdir |
|
16 | mv ipython-*.tgz $ipbackupdir | |
23 |
|
17 | |||
|
18 | # Clean up build/dist directories | |||
|
19 | rm -rf $ipdir/build/* | |||
|
20 | rm -rf $ipdir/dist/* | |||
|
21 | ||||
24 | # Build source and binary distros |
|
22 | # Build source and binary distros | |
25 | cd $ipdir |
|
23 | cd $ipdir | |
26 | ./setup.py sdist --formats=gztar |
|
24 | ./setup.py sdist --formats=gztar | |
27 |
|
25 | |||
28 | # Build version-specific RPMs, where we must use the --python option to ensure |
|
26 | # Build version-specific RPMs, where we must use the --python option to ensure | |
29 | # that the resulting RPM is really built with the requested python version (so |
|
27 | # that the resulting RPM is really built with the requested python version (so | |
30 | # things go to lib/python2.X/...) |
|
28 | # things go to lib/python2.X/...) | |
31 | python2.4 ./setup.py bdist_rpm --binary-only --release=py24 --python=/usr/bin/python2.4 |
|
29 | #python2.4 ./setup.py bdist_rpm --binary-only --release=py24 --python=/usr/bin/python2.4 | |
32 | python2.5 ./setup.py bdist_rpm --binary-only --release=py25 --python=/usr/bin/python2.5 |
|
30 | #python2.5 ./setup.py bdist_rpm --binary-only --release=py25 --python=/usr/bin/python2.5 | |
33 |
|
31 | |||
34 | # Build eggs |
|
32 | # Build eggs | |
35 | python2.4 ./setup_bdist_egg.py |
|
33 | python2.4 ./setup_bdist_egg.py | |
36 | python2.5 ./setup_bdist_egg.py |
|
34 | python2.5 ./setup_bdist_egg.py | |
37 |
|
35 | |||
38 | # Call the windows build separately, so that the extra Windows scripts don't |
|
36 | # Call the windows build separately, so that the extra Windows scripts don't | |
39 | # get pulled into Unix builds (setup.py has code which checks for |
|
37 | # get pulled into Unix builds (setup.py has code which checks for | |
40 | # bdist_wininst) |
|
38 | # bdist_wininst) | |
41 | ./setup.py bdist_wininst --install-script=ipython_win_post_install.py |
|
39 | ./setup.py bdist_wininst --install-script=ipython_win_post_install.py | |
42 |
|
40 | |||
43 | # Change name so retarded Vista runs the installer correctly |
|
41 | # Change name so retarded Vista runs the installer correctly | |
44 | rename 's/win32/win32-setup/' $ipdir/dist/*.exe |
|
42 | rename 's/win32/win32-setup/' $ipdir/dist/*.exe | |
45 |
|
43 | |||
46 | # Register with the Python Package Index (PyPI) |
|
44 | # Register with the Python Package Index (PyPI) | |
47 | echo "Registering with PyPI..." |
|
45 | echo "Registering with PyPI..." | |
48 | cd $ipdir |
|
46 | cd $ipdir | |
49 | ./setup.py register |
|
47 | ./setup.py register | |
50 |
|
48 | |||
51 | # Upload all files |
|
49 | # Upload all files | |
52 | cd $ipdir/dist |
|
50 | cd $ipdir/dist | |
53 | echo "Uploading distribution files..." |
|
51 | echo "Uploading distribution files..." | |
54 | scp * ipython@ipython.scipy.org:www/dist/ |
|
52 | scp * ipython@ipython.scipy.org:www/dist/ | |
55 |
|
53 | |||
56 | echo "Uploading backup files..." |
|
54 | echo "Uploading backup files..." | |
57 | cd $ipbackupdir |
|
55 | cd $ipbackupdir | |
58 | scp `ls -1tr *tgz | tail -1` ipython@ipython.scipy.org:www/backup/ |
|
56 | scp `ls -1tr *tgz | tail -1` ipython@ipython.scipy.org:www/backup/ | |
59 |
|
57 | |||
60 | echo "Done!" |
|
58 | echo "Done!" |
@@ -1,31 +1,31 b'' | |||||
1 | #!/bin/sh |
|
1 | #!/bin/sh | |
2 |
|
2 | |||
3 | # release test |
|
3 | # release test | |
4 |
|
4 | |||
5 | ipdir=$PWD/.. |
|
5 | ipdir=$PWD/.. | |
6 |
|
6 | |||
7 | cd $ipdir |
|
7 | cd $ipdir | |
8 |
|
8 | |||
9 | # Clean up build/dist directories |
|
9 | # Clean up build/dist directories | |
10 | rm -rf $ipdir/build/* |
|
10 | rm -rf $ipdir/build/* | |
11 | rm -rf $ipdir/dist/* |
|
11 | rm -rf $ipdir/dist/* | |
12 |
|
12 | |||
13 | # build source distros |
|
13 | # build source distros | |
14 | cd $ipdir |
|
14 | cd $ipdir | |
15 | ./setup.py sdist --formats=gztar |
|
15 | ./setup.py sdist --formats=gztar | |
16 |
|
16 | |||
17 | # Build rpms |
|
17 | # Build rpms | |
18 |
|
|
18 | python2.4 ./setup.py bdist_rpm --binary-only --release=py24 --python=/usr/bin/python2.4 | |
19 |
|
|
19 | python2.5 ./setup.py bdist_rpm --binary-only --release=py25 --python=/usr/bin/python2.5 | |
20 |
|
20 | |||
21 | # Build eggs |
|
21 | # Build eggs | |
22 | python2.4 ./setup_bdist_egg.py |
|
22 | python2.4 ./setup_bdist_egg.py | |
23 | python2.5 ./setup_bdist_egg.py |
|
23 | python2.5 ./setup_bdist_egg.py | |
24 |
|
24 | |||
25 | # Call the windows build separately, so that the extra Windows scripts don't |
|
25 | # Call the windows build separately, so that the extra Windows scripts don't | |
26 | # get pulled into Unix builds (setup.py has code which checks for |
|
26 | # get pulled into Unix builds (setup.py has code which checks for | |
27 | # bdist_wininst) |
|
27 | # bdist_wininst) | |
28 | ./setup.py bdist_wininst --install-script=ipython_win_post_install.py |
|
28 | ./setup.py bdist_wininst --install-script=ipython_win_post_install.py | |
29 |
|
29 | |||
30 | # Change name so retarded Vista runs the installer correctly |
|
30 | # Change name so retarded Vista runs the installer correctly | |
31 | rename 's/win32/win32-setup/' $ipdir/dist/*.exe |
|
31 | rename 's/win32/win32-setup/' $ipdir/dist/*.exe |
1 | NO CONTENT: file was removed |
|
NO CONTENT: file was removed |
1 | NO CONTENT: file was removed |
|
NO CONTENT: file was removed |
1 | NO CONTENT: file was removed |
|
NO CONTENT: file was removed |
General Comments 0
You need to be logged in to leave comments.
Login now