This document describes the current stable version of Celery (3.1). For development docs, go here.

celery.backends.base

celery.backends.base

Result backend base classes.

• BaseBackend defines the interface.
• KeyValueStoreBackend is a common base class using K/V semantics like _get and _put.

class celery.backends.base.BaseBackend(app, serializer=None, max_cached_results=None, accept=None, url=None, **kwargs)

EXCEPTION_STATES = frozenset(['FAILURE', 'RETRY', 'REVOKED'])

READY_STATES = frozenset(['FAILURE', 'REVOKED', 'SUCCESS'])

exception TimeoutError

The operation timed out.

UNREADY_STATES = frozenset(['STARTED', 'RECEIVED', 'RETRY', 'PENDING'])

apply_chord(header, partial_args, group_id, body, **options)

as_uri(include_password=False)

Return the backend as an URI, sanitizing the password or not

chord_error_from_stack(callback, exc=None)

cleanup()

Backend cleanup. Is run by celery.task.DeleteExpiredTaskMetaTask.

current_task_children(request=None)

decode(payload)

decode_result(payload)

delete_group(group_id)

encode(data)

encode_result(result, status)

exception_to_python(exc)

Convert serialized exception to Python exception.

fail_from_current_stack(task_id, exc=None)

fallback_chord_unlock(group_id, body, result=None, countdown=1, **kwargs)

forget(task_id)

get_children(task_id)

Get the list of subtasks sent by a task.

get_group_meta(group_id, cache=True)

get_result(task_id)

Get the result of a task.

get_status(task_id)

Get the status of a task.

get_task_meta(task_id, cache=True)

get_traceback(task_id)

Get the traceback for a failed task.

is_cached(task_id)

mark_as_done(task_id, result, request=None)

Mark task as successfully executed.

mark_as_failure(task_id, exc, traceback=None, request=None)

Mark task as executed with failure. Stores the exception.

mark_as_retry(task_id, exc, traceback=None, request=None)

Mark task as being retries. Stores the current exception (if any).

mark_as_revoked(task_id, reason='', request=None)

mark_as_started(task_id, **meta)

Mark a task as started

meta_from_decoded(meta)

on_chord_part_return(task, state, result, propagate=False)

on_task_call(producer, task_id)

persistent = True

Set to true if the backend is peristent by default.

prepare_exception(exc, serializer=None)

Prepare exception for serialization.

prepare_expires(value, type=None)

prepare_persistent(enabled=None)

prepare_value(result)

Prepare value for storage.

process_cleanup()

Cleanup actions to do at the end of a task worker process.

reload_group_result(group_id)

Reload group result, even if it has been previously fetched.

reload_task_result(task_id)

Reload task result, even if it has been previously fetched.

restore_group(group_id, cache=True)

Get the result for a group.

retry_policy = {'interval_start': 0, 'interval_max': 1, 'max_retries': 20, 'interval_step': 1}

save_group(group_id, result)

Store the result of an executed group.

store_result(task_id, result, status, traceback=None, request=None, **kwargs)

Update task state and result.

subpolling_interval = None

Time to sleep between polling each individual item in ResultSet.iterate. as opposed to the interval argument which is for each pass.

supports_autoexpire = False

If true the backend must automatically expire results. The daily backend_cleanup periodic task will not be triggered in this case.

supports_native_join = False

If true the backend must implement get_many().

wait_for(task_id, timeout=None, interval=0.5, no_ack=True, on_interval=None)

Wait for task and return its result.

If the task raises an exception, this exception will be re-raised by wait_for().

If timeout is not None, this raises the celery.exceptions.TimeoutError exception if the operation takes longer than timeout seconds.

class celery.backends.base.KeyValueStoreBackend(*args, **kwargs)

chord_keyprefix = 'chord-unlock-'

delete(key)

expire(key, value)

get(key)

get_key_for_chord(group_id, key='')

Get the cache key for the chord waiting on group with given id.

get_key_for_group(group_id, key='')

Get the cache key for a group by id.

get_key_for_task(task_id, key='')

Get the cache key for a task by id.

get_many(task_ids, timeout=None, interval=0.5, no_ack=True, READY_STATES=frozenset(['FAILURE', 'REVOKED', 'SUCCESS']))

group_keyprefix = 'celery-taskset-meta-'

implements_incr = False

incr(key)

key_t(s)

mget(keys)

on_chord_part_return(task, state, result, propagate=None)

set(key, value)

task_keyprefix = 'celery-task-meta-'

class celery.backends.base.DisabledBackend(app, serializer=None, max_cached_results=None, accept=None, url=None, **kwargs)

as_uri(*args, **kwargs)

get_many(*args, **kwargs)

get_result(*args, **kwargs)

get_state(*args, **kwargs)

get_status(*args, **kwargs)

get_traceback(*args, **kwargs)

store_result(*args, **kwargs)

wait_for(*args, **kwargs)