Stable version is 2.5 not 2.4
Now depends on Kombu 2.1.2.  Closes #650
Cosmetics
Optimize __call__ at execution not class creation.

Moves __call__ optimization so that it happens when the task is executed,
rather than when the class is created.

This may fix a bug where custom __call__'s mysteriously disappears.
Task.type was somehow lost during merge from 3.0-devel
celery.task.chords.Chord must be importable
celeryctl shell: chord, TaskSet/group and BaseTask is now in locals
Verify that the pidfile is actually written correctly.  Closes #641

Hopefully this will crash the worker immediately if the system
is out of space to store the complete pidfile.

In addition, we now verify that existing pidfiles contain
a new line so that a partially written pidfile is detected as broken,
as before doing:

    echo -n "1" > celeryd.pid

would cause celeryd to think that an existing instance was already
running (init has pid 1 after all).

Thanks to estebistec!
Adds celery.bugreport
AsyncResult.task_id -> AsyncResult.id (also TasksetResult.taskset_id -> .id
TimeoutHandler now sleeps for one second instead of a half
Tasks can now have callbacks and errbacks, and dependencies are recorded

- The task message format have been updated with two new extension keys

    Both keys can be empty/undefined or a list of subtasks.

    - ``callbacks``

        Applied if the task exits successfully, with the result
        of the task as an argument.

    - ``errbacks``

        Applied if an error occurred while executing the task,
        with the uuid of the task as an argument.  Since it may not be possible
        to serialize the exception instance, it passes the uuid of the task
        instead.  The uuid can then be used to retrieve the exception and
        traceback of the task from the result backend.

- ``link`` and ``link_error`` keyword arguments has been added
  to ``apply_async``.

    The value passed can be either a subtask or a list of
    subtasks:

    .. code-block:: python

        add.apply_async((2, 2), link=mul.subtask())
        add.apply_async((2, 2), link=[mul.subtask(), echo.subtask()])

    Example error callback:

    .. code-block:: python

        @task
        def error_handler(uuid):
            result = AsyncResult(uuid)
            exc = result.get(propagate=False)
            print("Task %r raised exception: %r\n%r" % (
                exc, result.traceback))

        >>> add.apply_async((2, 2), link_error=error_handler)

- We now track what subtasks a task sends, and some result backends
  supports retrieving this information.

    - task.request.children

        Contains the result instances of the subtasks
        the currently executing task has applied.

    - AsyncResult.children

        Returns the tasks dependencies, as a list of
        ``AsyncResult``/``ResultSet`` instances.

    - AsyncResult.iterdeps

        Recursively iterates over the tasks dependencies,
        yielding `(parent, node)` tuples.

        Raises IncompleteStream if any of the dependencies
        has not returned yet.

    - AsyncResult.graph

        A ``DependencyGraph`` of the tasks dependencies.
        This can also be used to convert to dot format:

        .. code-block:: python

            with open("graph.dot") as fh:
                result.graph.to_dot(fh)

        which can than be used to produce an image::

            $ dot -Tpng graph.dot -o graph.png
More useful utilities for callbacks and result graphs

- chain(a, b, c):  Creates a chain of tasks so that: a then b then c,
    and returns the first task in the chain.

- AsyncResult.get_leaf()

    Waits and returns the result of the leaf subtask.
    That is the last node found when traversing the graph,
    but this means that the graph can be 1-dimensional only (in effect
    a list).

    This is useful for task chains like::

        >>> # (2 + 2) * 8 / 2
        >>> chain(add.subtask((2, 2)),
                  mul.subtask((8, ),
                  div.subtask((2, ))).get_leaf()
        16

- subtask.link(subtask) + subtask.link_error(subtask)

    Shortcut to ``s.options.setdefault("link", []).append(subtask)``

- subtask.flatten_links()

    Returns a flattened list of all dependencies (recursively)
Improvments to the celeryctl list command
Adds celery command as an entrypoint to all other commands
Moves celery.task.control -> celery.app.control

Conflicts:

	celery/app/base.py
Moves celery.log -> celery.app.log

Conflicts:

	celery/apps/beat.py
	celery/apps/worker.py
	celery/beat.py
	celery/log.py
	celery/worker/__init__.py
Bugreport now available as a command and broadcast command

- Get it from a Python repl:

    >>> import celery
    >>> print(celery.bugreport())

- Use celeryctl:

    $ celeryctl report

- Get it from remote workers:

    $ celeryctl inspect report
Use kombu.utils.encoding instead
Reorganizes utils into utils.imports, utils.text and utils.functional