## Working with angles (is surprisingly hard)

Due to the periodic nature of angles, especially the discontinuity at 2π / 360°, working with them presents some subtle issues. For example, the angles 5° and 355° are "close" to each other, but are numerically quite different. In a geographic (GIS) context, this often surfaces when working with geometries spanning Earth's date-line at -180°/+180° longitude, which often requires multiple code paths to obtain the desired result.

I've recently run into the problem of computing averages and differences of angles. The difference should increase linearly, it should be 0 if they are equal, negative if the second angle lies to one side of the first, positive if it's on the other side (whether that's left or right depends on whether the angles increase in the clockwise direction or in counter-clockwise direction). Getting that right and coming up with test cases to prove that it's correct was quite interesting. As Bishop notes in Pattern Recognition and Machine Learning, it's often simpler to perform operations on angles in a 2D (x, y) space and then back-transform to angles using the `atan2()` function. I've used that for the averaging function; the difference is calculated using modulo arithmetic.

Here's the Python version of the two functions:

```def average_angles(angles):
"""Average (mean) of angles

Return the average of an input sequence of angles. The result is between
``0`` and ``2 * math.pi``.
If the average is not defined (e.g. ``average_angles([0, math.pi]))``,
a ``ValueError`` is raised.
"""

x = sum(math.cos(a) for a in angles)
y = sum(math.sin(a) for a in angles)

if x == 0 and y == 0:
raise ValueError(
"The angle average of the inputs is undefined: %r" % angles)

# To get outputs from -pi to +pi, delete everything but math.atan2() here.
return math.fmod(math.atan2(y, x) + 2 * math.pi, 2 * math.pi)

def subtract_angles(lhs, rhs):
"""Return the signed difference between angles lhs and rhs

Return ``(lhs - rhs)``, the value will be within ``[-math.pi, math.pi)``.
Both ``lhs`` and ``rhs`` may either be zero-based (within
``[0, 2*math.pi]``), or ``-pi``-based (within ``[-math.pi, math.pi]``).
"""

return math.fmod((lhs - rhs) + math.pi * 3, 2 * math.pi) - math.pi
```

The code, along with test cases can also be found in this GitHub Gist. Translation of these functions to other languages should be straight-forward, `sin()`/`cos()`/`fmod()`/`atan2()` are pretty ubiquitous.

## Resource management with Python

There should be one – and preferably only one – obvious way to do it.

— Tim Peters in The Zen of Python

There are multiple ways to manage resources with Python, but only one of them is save, reliable and Pythonic.

Before we dive in, let's examine what resources can mean in this context. The most obvious examples are open files, but the concept is broader: it includes locked mutexes, started client processes, or a temporary directory change using `os.chdir()`. The common theme is that all of these require some sort of cleanup that must reliably be executed in the future. The file must be closed, the mutex unlocked, the process terminated, and the current directory must be changed back.

So the core question is: how to ensure that this cleanup really happens?

### Failed solutions

Manually calling the cleanup function at the end of a code block is the most obvious solution:

```f = open('file.txt', 'w')
do_something(f)
f.close()
```

The problem with this is that `f.close()` will never be executed if `do_something(f)` throws an exception. So we'll need a better solution.

C++ programmers see this and try to apply the C++ solution: RAII, where resources are acquired in an object's constructor and released in the destructor:

```class MyFile(object):
def __init__(self, fname):
self.f = open(fname, 'w')

def __del__(self):
self.f.close()

my_f = MyFile('file.txt')
do_something(my_f.f)
# my_f.__del__() automatically called once my_f goes out of scope
```

Apart from being verbose and a bit un-Pythonic, it's also not necessarily correct. `__del__()` is only called once the object's refcount reaches zero, which can be prevented by reference cycles or leaked references. Additionally, until Python 3.4 some `__del__()` methods were not called during interpreter shutdown.

### A workable solution

The way to ensure that cleanup code is called in the face of exceptions is the `try ... finally` construct:

```f = open('file.txt', 'w')
try:
do_something(f)
finally:
f.close()
```

In contrast to the previous two solutions, this ensures that the file is closed no matter what (short of an interpreter crash). It's a bit unwieldy, especially when you think about `try ... finally` statements sprinkled all over a large code base. Fortunately, Python provides a better way.

### The correct solution™

The Pythonic solution is to use the `with` statement:

```with open('file.txt', 'w') as f:
do_something(f)
```

It is concise and correct even if `do_something(f)` raises an exception. Nearly all built-in classes that manage resources can be used in this way.

Under the covers, this functionality is implemented using objects known as context managers, which provide `__enter__()` and `__exit__()` methods that are called at the beginning and end of the `with` block. While it's possible to write such classes manually, an easier way is to use the contextlib.contextmanager decorator.

```from contextlib import contextmanager

@contextmanager
def managed_resource(name):
r = acquire_resource(name)
try:
yield r
finally:
release_resource(r)

with managed_resource('file.txt') as r:
do_something(r)
```

The `contextmanager` decorator turns a generator function (a function with a `yield` statement) into a context manager. This way it is possible to make arbitrary code compatible with the `with` statement in just a few lines of Python.

Note that `try ... finally` is used as a building block here. In contrast to the previous solution, it is hidden away in a utility resource manager function, and doesn't clutter the main program flow, which is nice.

If the client code doesn't need to obtain an explicit reference to the resource, things are even simpler:

```@contextmanager
def managed_resource(name):
r = acquire_resource(name)
try:
yield
finally:
release_resource(r)

with managed_resource('file.txt'):
do_something()
```

Sometimes the argument comes up that this makes it harder to use those resources in interactive Python sessions – you can't wrap your whole session in a gigantic `with` block, after all. The solution is simple: just call `__enter__()` on the context manager manually to obtain the resource:

```cm_r = managed_resource('file.txt')
r = cm_r.__enter__()
# Work with r...
cm_r.__exit__(None, None, None)
```

The `__exit__()` method takes three arguments, passing `None` here is fine (these are used to pass exception information, where applicable). Another option in interactive sessions is to not call `__exit__()` at all, if you can live with the consequences.

### Wrap Up

Concise, correct, Pythonic. There is no reason to ever manage resources in any other way in Python. If you aren't using it yet - start now!

published tagged python

## libconf - a Python reader for libconfig files

This weekend, I uploaded my first package to PyPI: libconf, a pure-Python reader for files in libconfig format. This configuration file format is reminiscent of JSON and is mostly used in C/C++ projects through the libconfig library. It looks like this:

```version = 7;
window: {
title: "libconfig example"
position: { x: 375; y: 210; w: 800; h: 600; }
};
capabilities: {
can-do-lists: (true, 0x3A20, ("sublist"), {subgroup: "ok"})
can-do-arrays: [3, "yes", True]
};
```

There are already two Python implementations: pylibconfig2 is a pure-Python reader licensed under GPLv3 and python-libconfig provides bindings for the libconfig C++ library. The first one I didn't like because of it's licensing, the second one I didn't like because of the more involved installation procedure. Also, I kind of enjoy writing parsers.

So, I set down during the easter weekend and wrote libconf. It's a pure-Python reader for libconfig files with an interface similar to the Python `json` module. There are two main methods: `load(f)` and `loads(string)`. Both return a `dict`-like data-structure that can be indexed (`config['version']`), but supports attribute access as well (`config.version`):

```import libconf
>>> with open('example.cfg') as f:
>>> config['window']['title']
'libconfig example'
>>> config.window.title
'libconfig example'
```

It was a fun little project. Creating a recursive descent parser is pretty straightforward, especially for such a simple file format. Writing documentation, packaging and uploading to GitHub and PyPI took longer than coding up the implementation itself.

published tagged Python

## Plotting maps with Folium

Data visualization in Python is a well solved problem by now. Matplotlib and it's prettier cousin Seaborn are widely used to generate static graphs. Bokeh generates HTML files with interactive, JavaScript-based graphs. It's a great way of sharing data with other people who don't have a Python development environment ready. Several other libraries exist for more specialized purposes.

What has been missing for a long time was good map libraries. Plotting capabilities were fine, but basemap support of the existing libraries was very limited. For example, the popular Matplotlib-basemap has great plot types (contour maps, heatmaps, ...) but can't show any high-resolution maps: it only has country/state shapes or whole-world images. Consequently, it's useless for drawing city or street level maps, unless you want to set up your own tile server (you don't).

Along comes Folium, a library that generates interactive maps in HTML format based on Leaflet.js. It supports, among others, OpenStreetMap and MapBox base layers which look great and provide enough details for large-scale maps.

Here is an example that shows some GPS data I cleaned up with a Kalman filter:

```def plot(points, center):
map_osm = folium.Map(location=center, zoom_start=16, max_zoom=23)
map_osm.line(locations=points)
map_osm.create_map(path='folium-example.html')
```

Here's what it looks like. I find it pretty neat, especially given that it took only 3 lines of code to create:

## Returning generators from with statements

Recently, an interesting issue came up at work that involved a subtle interaction between context managers and generator functions. Here is some example code demonstrating the problem:

```@contextlib.contextmanager
def resource():
"""Context manager for some resource"""

print("Resource setup")
yield
print("Resource teardown")

"""Load a list of values (requires resource to be held)"""

for i in range(3):
print("Generating value %d" % i)
yield i

"""Load values while holding the required resource"""

with resource():
```

This is the output when run:

```>>> for val in load_values(): pass
Resource setup
Resource teardown
Generating value 0
Generating value 1
Generating value 2
```

Whoops. The resource is destroyed before the values are actually generated. This is obviously a problem if the generator depends on the existence of the resource.

When you think about it, it's pretty clear what's going on. Calling `_load_values()` produces a generator object, whose code is only executed when values are requested. `load_values()` returns that generator, exiting the `with` statement and leading to the destruction of the resource. When the outer `for` loop (`for val`) comes around to iterating over the generator, the resource is long gone.

How do you solve this problem? In Python 3.3 and newer, you can use the ```yield from``` syntax to turn `load_values()` into a generator as well. The execution of `load_values()` is halted at the `yield from` point until the child generator is exhausted, at which point it is safe to dispose of the resource:

```def load_values():
"""Load values while holding the required resource"""

with resource():
```

In older Python versions, an explicit for loop over the child generator is required:

```def load_values():
"""Load values while holding the required resource"""

with resource():
yield val
```

Still another method would be to turn the result of `_load_values()` into a `list` and returning that instead. This incurs higher memory overhead since all values have to be held in memory at the same time, so it's only appropriate for relatively short lists.

To sum up, it's a bad idea to return generators from under `with` statements. While it's not terribly confusing what's going on, it's a whee bit subtle and not many people think about this until they ran into the issue. Hope this heads-up helps.

published tagged python

## A better way for deleting Docker images and containers

In one of my last posts, I described the current (sad) state of managing Docker container and image expiration. Briefly, Docker creates new containers and images for many tasks, but there is no good way to automatically remove them. The best practice seems to be a rather hack-ish bash one-liner.

Since this wasn't particularly satisfying, I decided to do something about it. Here, I present docker-cleanup, a Python application for removing containers and images based on a configurable set of rules.

This is a rules file example:

```# Keep currently running containers, delete others if they last finished
# more than a week ago.
KEEP CONTAINER IF Container.State.Running;
DELETE CONTAINER IF Container.State.FinishedAt.before('1 week ago');

# Delete dangling (unnamed and not used by containers) images.
DELETE IMAGE IF Image.Dangling;
```

Clear, expressive, straight-forward. The rule language can do a whole lot more and provides a readable and intuitive way to define removal policies for images and containers.

Head over to GitHub, give it a try, and let me know what you think!

## Using Python slice objects for fun and profit

Just a quick tip about the hardly known `slice` objects in Python. They are used to implement the slicing syntax for sequence types (lists, strings):

```s = "The quick brown fox jumps over the lazy dog"

# s[4:9] is internally converted (and equivalent) to s[slice(4, 9)].
assert s[4:9] == s[slice(4, 9)]

# 'Not present' is encoded as 'None'
assert s[20:] == s[slice(20, None)]
```

`slice` object can be used in normal code too, for example for tracking regions in strings: instead of having separate `start_idx` and `end_idx` variables (or writing a custom class/`namedtuple`) simply roll the indices into a `slice`.

```# A column-aligned table:
table = ('REPOSITORY   TAG      IMAGE ID       CREATED       VIRTUAL SIZE',
'<none>       <none>   0987654321AB   2 hours ago   385.8 MB',
'chris/web    latest   0123456789AB   2 hours ago   385.8 MB',
)

# Compute the column slices by parsing the header. Gives a list of slices.

for entry in entries:
repo, tag, id, created, size = [entry[sl].strip() for sl in slices]
...
```

This is mostly useful when the indices are computed at runtime and applied to more than one string.

More generally, `slice` objects encapsulate regions of strings/lists/tuples, and are an appropriate tool for simplifying code that operates on start/end indices. They provide a clean abstraction, make the code more straight-forward and save a bit of typing.

published tagged python

## A neat Python debugger command

`pdb` is a console-mode debugger built into Python. Out of the box, it has basic features like variable inspection, breakpoints, and stack frame walking, but it lacks more advanced capabilities.

Fortunately, it can be customized with a `.pdbrc` file in the user's home directory. Ned Batchelder has several helpful commands in his `.pdbrc` file:

• `pl`: print local variables
• `pi obj`: print the instance variables of `obj`
• `ps`: print the instance variables of `self`

Printing instance variables is great for quickly inspecting objects, but it shows only one half of the picture. What about the class-side of objects? Properties and methods are crucial for understanding what can actually be done with an object, in contrast to what data it encapsulates.

Since I couldn't find a readily available pdb command for listing class contents, I wrote my own:

```# Print contents of an object's class (including bases).
alias pc for k,v in sorted({k:v for cls in reversed(%1.__class__.__mro__) for k,v in cls.__dict__.items() if cls is not object}.items()): print("%s%-20s= %-80.80s" % ("%1.",k,repr(v)))
```

`pc` lists the contents of an object's class and its base classes. Typically, these are the properties and methods supported by the object. It is used like this:

```# 'proc' is a multiprocessing.Process() instance.
(Pdb) pc proc
...
proc.daemon              = <property object at 0x036B9A20>
proc.exitcode            = <property object at 0x036B99C0>
proc.ident               = <property object at 0x036B9A50>
proc.is_alive            = <function BaseProcess.is_alive at 0x033E4618>
proc.join                = <function BaseProcess.join at 0x033E45D0>
proc.name                = <property object at 0x036B99F0>
proc.pid                 = <property object at 0x036B9A50>
proc.run                 = <function BaseProcess.run at 0x033E4A98>
proc.start               = <function BaseProcess.start at 0x033E4DB0>
proc.terminate           = <function BaseProcess.terminate at 0x033E4DF8>
```

Note the difference to `pi`, which lists the contents of the `proc` instance:

```(Pdb) pi proc       # In contrast, here is the image dictionary.
proc._args          = ()
proc._config        = {'authkey': b'\xd0\xc8\xbd\xd6\xcf\x7fo\xab\x19_A6\xf8M\xd4\xef\x88\xa9;\x99c\x9
proc._identity      = (2,)
proc._kwargs        = {}
proc._name          = 'Process-2'
proc._parent_pid    = 1308
proc._popen         = None
proc._target        = None
```

In general, `pc` focuses on the interface while `pi` examines the state of the object. The two complement each other nicely. Especially when working with an unfamiliar codebase, `pc` is helpful for quickly figuring out how to use a specific class.

`pc` works with both Python 2 and Python 3 (on Python 2 it only shows new-style classes). Add it to your `.pdbrc` and give it a try. Let me know what you think!

published tagged python

## Python's GIL and atomic reference counting

I love Python because it's an incredibly fun, expressive and productive language. However, it's often criticised for being slow. I think the correct answer to that is two-fold:

• Use an alternative Python implementation for impressive speed-ups. For example, PyPy is on average 7 times faster than the standard CPython.
• Not all parts of a program have to be blazingly fast. Use Python for all non-performance-critical areas, such as the UI and database access, and drop to C or C++ only when it's required for for CPU intensive tasks. This is easy to achieve with language binding generators such as CFFI, SWIG or SIP.

A further performance-related issue is Python's Global Interpreter Lock (GIL), which ensures that only one Python thread can run at a single time. This is a bit problematic, because it affects PyPy as well, unless you want to use its experimental software transactional memory support.

Why is this such a big deal? With the rise of multi-core processors, multithreading is becoming more important as well. This not only affects performance on large servers, it impacts desktop programs and is crucial for battery life on mobile phones (race to idle). Further, other programming languages make multi-threaded programming easier and easier. C, C++, and Java have all moved to a common memory model for multithreading. C++ has gained `std::atomic`, futures, and first-class thread support. C# has `async` and `await`, which is proposed for inclusion in C++ as well. This trend will only accelerate in the future.

With this in mind, I decided to investigate the CPython GIL. Previous proposals for its removal have failed, but I thought it's worth a look — especially since I couldn't find any recent attempts.

The results were not encouraging. Changing the reference count used by Python objects from a normal `int` to an atomic type resulted in a ~23% slowdown on my machine. This is without actually changing any of the locking. This penalty could be moderated for single-threaded programs by only using atomic instructions once a second thread is started. This requires a function call and an `if` statement to check whether to use atomics or not in the refcount hot path. Doing this still results in an 11% slowdown in the single-threaded case. If hot-patching was used instead of the `if`, a 6% slowdown remained.

The last result looks promising, but is deceiving. Hot-patching would rely on having a single function to patch. Alas, the compiler decided to mostly inline the `Py_INCREF`/`Py_DECREF` function calls. Disabling inlining of these functions gives a 16% slowdown, which is worse than the "call + `if`" method. Furthermore, hot-patching is probably not something that could be merged in CPython anyway.

So what's the conclusion? Maybe turning `Py_INCREF` and `Py_DECREF` into functions and living with the 11% slowdown of the single-threaded case would be sell-able, if compelling speed-ups of multithreaded workloads could be shown. It should be possible to convert one module at a time from the GIL to fine-grained locking, but performance increases would only be expected once at least a couple of core modules are converted. That would take a substantial amount of work, especially given the high risk that the resulting patches wouldn't be accepted upstream.

Where does this leave Python as a language in the multi-threaded world? I'm not sure. Since PyPy is already the solution to Python's performance issue, perhaps it can solve the concurrency problem as well with its software transactional memory mode.

PS: My profiling showed that the reference counting in Python (`Py_INCREF()` and `Py_DECREF()`) takes up to about 5–10% of the execution time of benchmarks (not including actual object destruction), crazy!

published tagged python

## Subclassing C++ in Python with SIP

I use SIP in MapsEvolved to generate bindings for interfacing Python with C++. I really like SIP due to its straight-forward syntax that mostly allows just copying class definitions over from C++. Further, it's really well thought out and contains support for a number of advanced use cases.

One such feature is implementing a C++ interface in Python. The resulting class can then even be passed back to C++, and any methods called on it will be forwarded to the Python implementation. Sweet!

Here is an example I originally wrote for this Stack Overflow question. It illustrates how ridiculously easy it is to get this working:

visitor.h:

```class EXPORT Node {
public:
int getN() const;
...
};
struct EXPORT NodeVisitor {
virtual void OnNode(Node *n) = 0;
};
void visit_graph_nodes(NodeVisitor *nv);
```

visitor.sip:

```%Module pyvisit

#include "visitor.h"
%End

class Node {
public:
int getN() const;
...
};

struct NodeVisitor {
virtual void OnNode(Node* n) = 0;
};

void visit_graph_nodes(NodeVisitor *nv);
```

Using it from Python:

```>>> import pyvisit
>>> class PyNodeVisitor(pyvisit.NodeVisitor):
>>>     def OnNode(self, node):
>>>         print(node.getN())
>>> pnv = PyNodeVisitor()
>>> visit_graph_nodes(pnv)
1
2
3
...
```

Here, the C++ function `visit_graph_nodes()` calls the Python method `pnv.OnNode()` for every node in its (internal) graph. A zip file with the full working source code of this example can be downloaded here.

The subclassing capabilities of SIP don't stop at interfaces, either. It's possible to derive from any C++ class, abstract or not, inheriting (or overriding) existing method implementations as needed. This gives a lot of flexibility and makes it easy to have classes with some parts implemented in C++, and others being in Python.

published tagged python