Furious

166 Update processors.py
- This seems of little use and is in every non-completion furious task. Minor but could just be removed.

167 Update examples to have the correct furious handler
- The examples should work now. I'm not sure why the queue base URL change affected the handling of the tasks but backing up to the commit prior to that one and the URL handling is fine. I did this little tweak to get it working. I suspected that the \* in the app yaml routing before the change was being handled differently but after a bunch of searching I was not able to find what actually was handling the furious calls (to my chagrin). Was hacking on some completion stuff and couldn't get the examples to work so I carved this off to get it looked at first.

170 encode / decode _process_results option
- currently, the _process_results option is not correctly encoded/decoded with the rest of the async options. passing in a callable will result in a json error. this change handles _process_results exactly like _context_checker is currently handled.

162 insert_tasks_ignore_duplicates - New _insert_tasks_ignore_duplicate_name
- ...s to gracefully handle DuplicateTaskNameError exceptions raised by inserts.

1) Let me know if you guys would prefer to just modify the existing _insert_tasks function, and add another option.
2) Should we add an options that just selects the _insert_tasks_ignore_duplicate_names automatically, which shields the implementation from the user.

Right now a typical usage would be:


with context.new(batch_size=100,
insert_tasks=insert_tasks_ignore_duplicate_names) as ctx:
ctx.add(...)


163 Add info needed to add Furious to the public pypi
- Since Furious is open source we should be good people and add our lib to pypi so
others can easily use it via pip/easy_install and not be required to build from
source.

I've added the required info to setup.py and setup.cfg. Wasn't much. Also added
the generated pypi files to the .gitignore so we don't push those up.

164 Mounting furious on /_queue/async instead of /_ah/queue/async
- This includes a new furious version that moved furious URIs from `/_ah/queue/async` -> `/_queue/async`. All the yaml files now map the old and new URIs to the furious router with the following regex: `url: /_(ah/queue|queue)/async.*`. Testing needs to ensure that tasks that are inflight with the old URIs are able to drain successfully with a new deploy.

158 Fix the error callback example
- This fixes the example to show how you can assign an async to be executed if there is an unhanded exception in your own async. Due to changes with how we handle results this example no longer work and was throwing its own exceptions trying to access properties that no longer existed. This fixes that.

I think the expected behavior of the error callback example is to re-raise the exception that was found in the other task.

159 add an extra_task_info async option which is logged before task execution
- If an extra_task_info option is present on the Async, it will be logged immediately before task execution, with the rest of the task info.

160 Transient error retry on start
- Re-opened PR against Workiva/furious

Original PR here: markshaule-wf1
Async Changes:
Async.start() now sleeps before attempting to re-add task on a TransientError.
Add option retry_transient_errors to override the retry behaviour in Async.start(). False can be specified to just re-raise the TransientError, and not attempt a retry.

Context Changes:
Context _insert_tasks now re-raises TransientError if retry option has been set to False.
Renamed parameter 'retry_errors' to 'retry_transient_errors' in _insert_tasks function.
_insert_tasks - retry_transient_errors parameter is now passed onto recursive calls correctly.

Notes on compatibility:
Since I've renamed the parameter for _insert_tasks, that could potentially break someone's custom implementation of that function.

147 Add parent id and request id to Async
- Add a parent id and request id to the Async object. The parent id will be passed
down to "children" asyncs. This will allow us to track the chain/graph of asyncs
without developer intervention.

149 Small doc-related improvements
- Bump docutils requirement to 0.12; 0.10 is not available on PyPI.
Correct and expand .pth file instructions, and improve doc building instructions while I'm at it.

155 transient_error_retry - Retry transient errors when attempting to insert_tasks, and re-raise if the reinsert fails
- Instead of silently failing on a TransientError on task inserts, we check the options to see if we should retry the failure (after a delay). If the retry fails, we re-raise.

Currently, the default option is to retry. I can't think of a scenario that the called would not want to have the errors retry, or at least trigger an error.
As a side effect, this may break custom implementations of _insert_tasks since we have added a parameter.

156 Only reinsert tasks which were not enqueued
- Addresses issue 154.

If a list of more than one Tasks is given, a raised exception does not
guarantee that no tasks were added to the queue (unless transactional is set
to True). To determine which tasks were successfully added when an exception
is raised, check the Task.was_enqueued property.

157 Inherit Queue for completion check
- Addresses concerns over completion checks and cleanup tasks occurring in the default queue in BigSky.

Three configurable options were added

cleanupqueue - where cleanup tasks for completion markers should be run
cleanupdelay - how long should cleanup tasks be delayed
defaultqueue - what is the default queue for completion and cleanup tasks (if no cleanupqueue is defined)

Completion checks will now inherit which queue they will run in from the tasks that kick them off. There is a new example of how this works added to the examples folder called context_inherit.

This pattern of inheritance allows greater freedom to shard async's across different queues and balance out their own performance (completion performance included).

142 Ensure correct Async type is used for callbacks
- This addresses issue 141 where get_current_async returns a base Async from within a callback even if a subclass was used.

145 Raise exception with correct traceback
- This corrects issue 143 where exceptions are raised in the results
processor with the incorrect traceback.

146 completion_retry - If a marker/context is already complete, re-execute the completion tasks, in case they failed to execute on the first attempt
- This address issue 144 where a BulkAdd() error when executing the completion handler will retry, but won't execute the completion handler.

121 Absolute Imports
- Convert imports from relative to absolute to be consistent within codebase and "Python standards."

122 In persist mode, call _persist_result when result set
- When persist_result is set in an Async's options, Async._persist_result will
be called when the result is set one the Async. The persistence engine
must be specified, either in the Async's options or in furious config, or an
exception will be raised.

123 Make Async id work right and test persist result
- This PR will correct the behavior of Async.id so that consistent ids are used and returned. It also adds some tests for persist result.

124 Add retries to test runner
- Add retries to test runner.

When running tests, use app engine sdk to track retry count, set it in os.environ, and stop retrying at the maximum. Still ignores task delay (countdown) when running tests.

126 Context completion
- Framework is in the core now. This should be a decent first-pass. There are items throughout that could use some tweaks and tuning, but example/context_events (trigger) is functional.

130 Switch the context id on an Async to be passed in via the options or be pulled from the current context
- This allows the context to pass its id down to the context. This will be used by the completion logic.

131 Completion callback being called multiple times fix WIP
- Handles having multiple things complete at a single time via a transaction.

132 Context completion persist results
- Add initial persistence logic

133 Completion integration
- This PR has everything from Robert, Beau and myself with some merge conflict resolution and some minor improvements. IAPI will be code review off this PR so they can see everything in one place.

134 Completion tweaks and integration

136 Add get_async_with_context method
- Add a method to load the current executing async with its triggering context

138 Add limits example
- This is not so much an example as a testbed for testing queue runtime characteristics as related to task runtime.

139 Allow AutoContexts to be created from context.new()
- This adds a batch_size kwarg to context.new which results in an
AutoContext being registered instead of a regular Context. Aside from
being more convenient, this allows the AutoContext behavior to be
abstracted from the client. This helps in the event that we decide to
bring AutoContext's batching functionality into Context, removing the
need for the subclass.

140 Switch furious to use _pkg_meta for version