flag.

synchronously

module-level functions. No changes to functionality

it blocks for

branch.

one instance, if two or more threads accessed a method at the same time.

word in python 3.7

isn't done, segfaults may sporadically occur.

featdesign.loadDesignMat function

commit 27f214ac
Author: Paul McCarthy <pauld.mccarthy@gmail.com>
Date:   Wed Apr 26 18:20:08 2017 +0100

    Version bump

commit 52f759f0
Author: Paul McCarthy <pauld.mccarthy@gmail.com>
Date:   Wed Apr 26 18:05:11 2017 +0100

    More robust unit tests for async.idle(alwaysQueue=True). Also using a single
    wx.App object for complex reasons

commit d87aae89
Author: Paul McCarthy <pauld.mccarthy@gmail.com>
Date:   Wed Apr 26 18:00:13 2017 +0100

    Adjustment to async.idle(alwaysQueue=True) - now, a second idle call is only
    necessary if the first call came before a wx.App had been created.

lock up (as thousands of TaskThreads were being created, and not destroyed)

block until queue is empty. ImageWrapper has method to access TaskThread. This
is primarily used for testing threaded access to ImageWrapper.

which is primarily for testing.

identifying reference image associated with a FIRST vtk file.

immediatelly re-run the idle loop.

initialisation. Async.idle still honours after argument, even if a
wx application is not running.

Platform.canHaveGui, can be used to tell whether we are able to create a
GUI. Async modified to use platform.haveGui instead of performing its
own test.

already queued to be dropped. More useful when used through idleWhen.

events (if user stops moving the mouse), meaning that idle tasks can get
stuck in the idle queue, and not processed until the next UI
event. Therefore, the idle loop now gets periodically called by a
wx.Timer, in addition to via EVT_IDLE events.

dictate when the actual function is called.

keyword arguments.

TaskThread also doesn't crash when an enqueued task raises an error.

  - New cache module, which implements a simple in-memory cache.
  - Async module defines a 'mutex' decorator, which allows instance
    method access to be made mutually-exclusive