Python and CASA

CASA uses Python, IPython and matplotlib within the package. IPython is an enhanced, interactive shell to Python which provides many features for efficient command line interaction, while matplotlib is a Python 2-D plotting library for publication quality figures in different hardcopy formats.

From www.python.org: "Python is an interpreted, interactive, object-oriented programming language". Python is used as the underlying command line interface/scripting language to CASA. Thus, CASA inherits the features and the annoyances of Python. For example, since Python is inherently 0-based in its indexing of arrays, vectors, etc, CASA is also 0-based; any Index inputs (e.g., start (for start channel), fieldIndex, antennaID, etc) will start with 0. Another example is that indenting of lines means something to Python, of which users will have to be aware.

Currently, CASA uses python 2.6 (2.5 for the Mac OS 10.5 version). Some key links to python are:

• http://python.org – Main Python page
• https://docs.python.org/2/reference/ – Python Reference
• https://docs.python.org/2/tutorial/ – Python Tutorial
• http://ipython.scipy.org – IPython page
• http://matplotlib.sourceforge.net – matplotlib page

Each of the features of these components behave in the standard way within CASA. In the following sections, we outline the key elements for analysis interactions; see the Python references and the IPython page for the full suite of functionality.

 

Python Packages

The following python packages are included in CASA:

• ipython
• nose
• pyfits
• pytz
• dbus
  
• numpy
• scientific python
• twisted
• zope.interface
• foolscap
• matplotlib
• scipy

Automatic parentheses

Automatic parentheses is enabled for calling functions with argument lists; this feature is intended to allow less typing for common situations. IPython will display the interpretation of the line, beneath the one typed, as indicated by the ’-------->’. Default behavior in CASA is to have automatic parentheses enabled.

 

Indentation

Python pays attention to indentation of lines in scripts or when you enter them interactively. It uses indentation to determine the level of nesting in loops. Be careful when cutting and pasting, if you get the wrong indentation, then unpredictable things can happen (usually it just gives an error).

A blank line can be used to return the indentation to a previous level. For example, expanded parameters in tasks cause indentation in subsequent lines in the interface. For example, the following snippet of inputs from clean can be cut and pasted without error due to the blank line after the indented parameters:

If the blank line were not there, an error would result if you pasted this at the CASA prompt.

 

Lists and Ranges

Sometimes, you need to give a task a list of indices. For example, some tasks and tools expect a comma-separated Python list, e.g.

You can use the Python range function to generate a list of consecutive numbers, e.g.

giving the same list as above, e.g.

Note that range starts from the first limit and goes to one below the second limit (Python is 0-based, and range is designed to work in loop functions). If only a single limit is given, the first limit is treated as 0, and the one given is used as the second, e.g.

You can also combine multiple ranges by summing lists

 

Dictionaries

 

ID	casa-python-dictionaries

Python dictionaries are data structures that contain key:value pairs, sort of like a hash array. These are useful to store mini-databases of things. In CASA, the parameter values are kept in a dictionary behind the scenes.

To initialize a dictionary, say we call it mydict, for use:

To add members:

To see its contents:

To access a specific entry:

Saving and Reading Dictionaries

To save a simple dictionary to a file:

More complex dictionaries, like those produced by imstat that contain NumPy arrays, require a different approach to save. The pickle module lets you save general data structures from Python. For example:

The dictionaries are now saved in pickle file myxstat.pickle in the current directory. To retrieve:

Thus, you can make scripts that save information and use it later, like for regressions.

 

Control Flow: Conditionals, Loops, and Exceptions

 There are a number of ways to control the flow of execution in Python, including conditionals (if), loops (for and while), and exceptions (try). We will discuss the first two below.

Conditionals

The standard if block handles conditional execution or branches in Python:

Insert a pass statement if you want no action to be taken for a particular clause. The should reduce down to True or False. For example,

chooses branches based on the value of the importmode Python variable (set previously in script).

Loops

The for loop

iterates over elements of a sequence seq, assigning each in turn to iter. The sequence is usually a list of values. For example,

As usual, blocks are closed by blank lines of the previous indentation level.

You can use the range Python function to generate a numerical loop:

There is also a while loop construct

which executes the statement block while the is True. The while loop can also take an else block. For example,

 

System shell access

For scripts, the os.system methods are the preferred way to access system shell commands.

In interactive mode, any input line beginning with a ’!’ character is passed verbatim (minus the ’!’) to the underlying operating system. Several common commands (ls,pwd,less) may be executed with or without the ’!’. Note that the cd command must be executed without the ’!’, and the cp command must use ’!’ as there is a conflict with the cp tool in CASA. For example:

Using the os.system methods 

To use this, you need the os package. This should be loaded by default by CASA, but if not you can use

in your script. For example, in our scripts we use this to clean up any existing output files:

Note that the os package has many useful methods. You can see these by using tab-completion:

Directory Navigation

In addition, filesystem navigation is aided through the use of bookmarks to simplify access to frequently-used directories:

For python scripts, there is a special command to change a directory.

os.system('cd ~/directory')

will NOT work but the following will:

os.chdir('~/directory')

Shell Command and Capture

 See also the following section for the use of the command history.

1. sx shell_command, !!shell_command - this captures the output to a list

2. sc - captures the output to a variable; options are ’-l’ and ’-v’

 

Logging

There are two components to logging within CASA. Logging of all command line inputs is done via IPython.

Upon startup, CASA will log all commands to a file called ipython-YYYYMMDD-HHMMSS.log. This file can be changed via the use of the ~/.casa/ipython/ipythonrc file. This log file can be edited and re-executed as appropriate using the execfile feature.

Logging can be turned on and off using the logon, logoff commands.

The second component is the output from applications which is directed to the file ./casa-YYYYMMDD-HHMMSS.log. See the section on the casalogger.

History and Searching

Numbered input/output history is provided natively within IPython. Command history is also maintained on-line.

Command history can be accessed via the ’hist’ command. The history is reset at the beginning of every CASA session, that is, typing ’hist’ when you first start CASA will not provide any commands from the previous session. However, all of the commands are still available at the command line and can be accessed through the up or down arrow keys, and through searching.

The history can be saved as a script or used as a macro for further use:

There are two mechanisms for searching command history:

Previous/Next: use Ctrl-p (previous,up) and Ctrl-n (next,down) to search through only the history items that match what you have typed so far (min-match completion). If you use Ctrl-p or Ctrl-n at a blank prompt, they behave just like the normal arrow keys.

Search: Ctrl-r opens a search prompt. Begin typing and the system searches your history for lines that contain what you’ve typed so far, completing what it can. For example:

Typing anything after the colon will provide you with the last command matching the characters, for example, typing ’op’ finds:

Subsequent hitting of Ctrl-r will search for the next command matching the characters.

 

Macros

Macros can be made for easy re-execution of previous commands. For example to store the commands 13-15 to the macro ’example’:

 

On-line editing

You can edit files on-line in two ways:

Using the shell access via ’!vi’
Using the ed function; this will edit the file but upon closing, it will try to execute the file; using the ’script.py’ example above:

 

Executing Python scripts

Python scripts are simple text files containing lists of commands as if typed at the keyboard.

# file is script.py
# My script to plot the observed visibilities
plotms('ngc5921.ms','uvdist') #yaxis defaults to amplitude

This can be done by using the execfile command to execute this script. execfile will execute the script as though you had typed the lines at the CASA prompt.

If you don’t want to launch CASA and execute your script from the command line, you can use the ’-c’ option:

 

How do I exit from CASA?

 You can exit CASA by using the quit command. This will bring up the query

to give you a chance in case you did not mean to exit. You can also quit using

or CTRL-D.

If you don’t want to see the question "Do you really want to exit [y]/n?", then just type Exit or exit followed by return, and CASA will stop right then and there.