Taskgraph

------------------
* Fixed an issue that would cause a deadlock if two tasks were added that had
the same function signature except different target paths.

------------------
* Fixed a race condition that would sometimes cause an exception when multiple
threads attempted to read or write to the completed Task Database.
* Fixed an issue that could cause an exception in ``__del__`` to print to
stderr during Python interpreter shutdown.
* Added a ``hash_algorithm`` parameter to ``add_task`` that is a string of
either 'sizetimestamp' or anything in ``hashlib.algorithms_available``. This
option tells TaskGraph how to fingerprint input and target files to
determine the need for recomputation.
* Added a ``copy_duplicate_artifact`` parameter to ``add_task`` that when True
tells TaskGraph to copy duplicate target results to a new target so long as
all the parameters and base/target files fingerprint to the same value.
This can save significant computation time when use in scenarios where
there are small changes in a workflow, but otherwise significant changes
in filenames. This often occurs when putting timestamps or other suffixes
on files that otherwise have identical content.

------------------
* TaskGraph now stores all task completion information in a single SQLite
database stored in its cache directory. In previous versions
TaskGraph would write a small text file for each task in a highly branching
directory tree. This structure made removal of those directory trees
computationally difficult.
* Fixed an issue that would cause TaskGraph to reexecute if the target path
was included in the argument list and that path was not normalized to the
operating system's path style.
* Fixed a deadlock in some cases where Tasks failed while other tasks checked
for pre-execution clauses.

------------------
* Fixed an issue where very long strings might be interpreted as paths and
Windows crashes because the path is too long.
* Fixed a deadlock issue where a Task might raise an unhandled exception as a
new task was added to the TaskGraph.
* Fixed the occasional ``BrokenPipeError`` that could occur when a Task
encountered an unhandled exception.
* Added an ``n_retries`` parameter to ``add_task`` that lets TaskGraph attempt
to reexecute a failing Task up to ``n_retries`` times before terminating
the TaskGraph.
* Removed the ``delayed_start`` option.

------------------
* Resolving an issue with duplicate logging being printed to stdout when
``n_workers > 0``. Logging is now only handled in the process that contains
the TaskGraph instance.
* Updated main logging message to indicate which tasks, by task name, are
currently active and how many tasks are ready to execute but can't because
there is not an open worker.
* Attempted to fix an issue where processes in the process pool were not
terminating on a Linux system by aggressively joining all threads and
processes when possible.
* Fixed an issue that would cause tasks that had been previously calculated to
prematurely trigger children tasks even if the parent tasks of the current
task needed to be reexecuted.

------------------
* Added a ``delayed_start`` flag to TaskGraph to allow for delayed execution
of taskgraph tasks. If enabled on threaded or multiprocess mode, calls to
``add_task`` will not execute tasks until the ``join`` method is invoked on
``taskgraph``. This allows for finer control over execution order when tasks
are passed non-equivalent ``priority`` levels.
* Fixing an issue where a non-JSON serializeable object would cause
``add_task`` to crash. Now TaskGraph is more tolerant of non-JSON
serializeable objects and will log warnings when parameters cannot be
serialized.
* TaskGraph constructor has an option to report a ongoing logging message
at a set interval. The message reports how many tasks have been committed
and completed.
* Fixed a bug that would cause TaskGraph to needlessly reexecute a task if
the only change was the order of the ``target_path_list`` or
``dependent_task_list`` variables.
* Fixed a bug that would cause a task to reexecute between runs if input
argument was a file that would be generated by a task that had not yet
executed.
* Made a code change that makes it very likely that tasks will be executed in
priority order if added to a TaskGraph in delayed execution mode.
* Refactored internal TaskGraph scheduling to fix a design error that made it
likely tasks would be needlessly reexecuted. This also simplified TaskGraph
flow control and cause slight performance improvements.
* Fixed an issue discovered when a ``scipy.sparse`` matrix was passed as an
argument and ``add_task`` crashed on infinite recursion. Type checking of
arguments has been simplified and now iteration only occurs on the Python
``set``, ``dict``, ``list``, and ``tuple`` types.
* Fixed an issue where the ``TaskGraph`` was not ``join``\ing the worker
process pool on a closed/join TaskGraph, or when the ``TaskGraph`` object
was being deconstructed. This would occasionally cause a race condition
where the TaskGraph may still have a cache ``.json`` file open. Discovered
through a flaky build test.
* Added functionality to the ``TaskGraph`` object to propagate log messages
from workers back to the parent process. This only applies for cases where
a ``TaskGraph`` instance is started with ``n_workers > 0``.
* Fixed an issue where a function that was passed as an argument would cause
a reexecution on a separate run because the ``__repr__`` of a function
includes its pointer address.
* Adjusted logging levels so that detailed task information is shown on DEBUG
but basic status updates are shown in INFO.