"> Note that the `decode` call in the middle line converts the string from a byte string to a normal string. In Python 3 there is a distinction between strings (sequences of characters, possibly using multiple bytes to store each character) and bytes (sequences of bytes). The world has moved on from ASCII, so in this day and age, this distinction is absolutely necessary, and Python does a fairly good job of it.\n",
"> shlex.split and shlex.quote are functions designed to break up and quote\n",
"> (respectively) shell command lines and arguments. Quoting of user provided\n",
"> arguments helps to prevent unintended consequences from inappropriate inputs.\n",
">\n",
"> Note that the `decode` call in the middle line converts the string from a byte\n",
"> string to a normal string. In Python 3 there is a distinction between strings\n",
"> (sequences of characters, possibly using multiple bytes to store each\n",
"> character) and bytes (sequences of bytes). The world has moved on from ASCII,\n",
"> so in this day and age, this distinction is absolutely necessary, and Python\n",
"> does a fairly good job of it.\n",
"\n",
"If the output is numerical then this can be extracted like this:"
"print('Volumes are: ', vol_vox, ' in voxels and ', vol_mm, ' in mm')"
]
},
...
...
@@ -275,25 +320,7 @@
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.5.2"
}
},
"metadata": {},
"nbformat": 4,
"nbformat_minor": 2
}
%% Cell type:markdown id: tags:
# Callable scripts in python
In this tutorial we will cover how to write simple stand-alone scripts in python that can be used as alternatives to bash scripts.
In this tutorial we will cover how to write simple stand-alone scripts in
python that can be used as alternatives to bash scripts.
There are some code blocks within this webpage, but for this practical we _**strongly
recommend that you write the code in an IDE or editor**_ instead and then run the scripts from a terminal.
**Important**: Throughout this series of practicals we have been working
entirely within the Jupyter notebook environment. But it's now time to
graduate to writing *real* Python scripts, and running them within a
*real* enviromnent.
So within this practical there are some code blocks, but instead of running
them inside the notebook we **strongly recommend that you write the code in
an IDE or editor**,and then run the scripts from a terminal. [Don't
panic](https://www.youtube.com/watch?v=KojYatpLPSE), we're right here,
ready to help.
## Contents
*[Basic script](#basic-script)
*[Calling other executables](#calling-other-executables)
*[Command line arguments](#command-line-arguments)
*[Example script](#example-script)
*[Exercise](#exercise)
---
<aclass="anchor"id="basic-script"></a>
## Basic script
The first line of a python script is usually:
%% Cell type:code id: tags:
```python
```
#!/usr/bin/env python
```
%% Cell type:markdown id: tags:
which invokes whichever version of python can be found by `/usr/bin/env` since python can be located in many different places.
For FSL scripts we use an alternative, to ensure that we pick up the version of python (and associated packages) that we ship with FSL. To do this we use the line:
%% Cell type:code id: tags:
```python
```
#!/usr/bin/env fslpython
```
%% Cell type:markdown id: tags:
After this line the rest of the file just uses regular python syntax, as in the other tutorials. Make sure you make the file executable - just like a bash script.
The most essential call that you need to use to replicate the way a bash script calls executables is `subprocess.run()`. A simple call looks like this:
%% Cell type:code id: tags:
```python
```
import subprocess as sp
import shlex
sp.run(['ls', '-la'])
```
%% Cell type:markdown id: tags:
> Passing the arguments as a list is good practice and improves the safety of
> Note that the `decode` call in the middle line converts the string from a byte string to a normal string. In Python 3 there is a distinction between strings (sequences of characters, possibly using multiple bytes to store each character) and bytes (sequences of bytes). The world has moved on from ASCII, so in this day and age, this distinction is absolutely necessary, and Python does a fairly good job of it.
> shlex.split and shlex.quote are functions designed to break up and quote
> (respectively) shell command lines and arguments. Quoting of user provided
> arguments helps to prevent unintended consequences from inappropriate inputs.
>
> Note that the `decode` call in the middle line converts the string from a byte
> string to a normal string. In Python 3 there is a distinction between strings
> (sequences of characters, possibly using multiple bytes to store each
> character) and bytes (sequences of bytes). The world has moved on from ASCII,
> so in this day and age, this distinction is absolutely necessary, and Python
> does a fairly good job of it.
If the output is numerical then this can be extracted like this:
> Don't be tempted to use the shell=True argument to subprocess.run, especially
> if you are dealing with user input - if the user gave
> *myfile; rm -f ~*
> as a file name and you called the command with shell=True **and** you
> passed the command in as a string then bad things happen!
>
> The safe way to use these kinds of inputs is to pass them through shlex.quote()
> before sending.
>
> ```a = shlex.quote('myfile; rm -f ~')
> cmd = "ls {}".format(a)
> sp.run(shlex.split(cmd))```
> If you're calling lots of FSL tools, the `fslpy` library has a number of
> *wrapper* functions, which can be used to call an FSL command directly
> from Python - check out `advanced_topics/08_fslpy.ipynb`.
<aclass="anchor"id="command-line-arguments"></a>
## Command line arguments
The simplest way of dealing with command line arguments is use the module `sys`, which gives access to an `argv` list:
%% Cell type:code id: tags:
```python
```
import sys
print(len(sys.argv))
print(sys.argv[0])
```
%% Cell type:markdown id: tags:
For more sophisticated argument parsing you can use `argparse` - good documentation and examples of this can be found on the web.
> argparse can automatically produce help text for the user, validate input etc., so it is strongly recommended.
---
<aclass="anchor"id="example-script"></a>
## Example script
Here is a simple bash script (it masks an image and calculates volumes - just as a random example). DO NOT execute the code blocks here within the notebook/webpage:
