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

celery.bin.base

Preload Options

These options are supported by all commands, and usually parsed before command-specific arguments.

-A, --app

app instance to use (e.g. module.attr_name)

-b, --broker

url to broker. default is ‘amqp://guest@localhost//’

--loader

name of custom loader class to use.

--config

Name of the configuration module

Daemon Options

These options are supported by commands that can detach into the background (daemon). They will be present in any command that also has a –detach option.

-f, --logfile

Path to log file. If no logfile is specified, stderr is used.

--pidfile

Optional file used to store the process pid.

The program will not start if this file already exists and the pid is still alive.

--uid

User id, or user name of the user to run as after detaching.

--gid

Group id, or group name of the main group to change to after detaching.

--umask

Effective umask (in octal) of the process after detaching. Inherits the umask of the parent process by default.

--workdir

Optional directory to change to after detaching.

--executable

Executable to use for the detached process.

exception celery.bin.base.Error(reason, status=None)

status = 1

exception celery.bin.base.UsageError(reason, status=None)

status = 64

class celery.bin.base.Extensions(namespace, register)

add(cls, name)

load()

class celery.bin.base.HelpFormatter(indent_increment=2, max_help_position=24, width=None, short_first=1)

format_description(description)

format_epilog(epilog)

class celery.bin.base.Command(app=None, get_app=None, no_color=False, stdout=None, stderr=None, quiet=False, on_error=None, on_usage_error=None)

Base class for command-line applications.

Parameters:

• app – The current app.
• get_app – Callable returning the current app if no app provided.

exception Error(reason, status=None)

status = 1

Parser

alias of OptionParser

exception UsageError(reason, status=None)

status = 64

add_append_opt(acc, opt, value)

args = u''

ask(q, choices, default=None)

Prompt user to choose from a tuple of string values.

Parameters:

• q – the question to ask (do not include questionark)
• choice – tuple of possible choices, must be lowercase.
• default – Default value if any.

If a default is not specified the question will be repeated until the user gives a valid choice.

Matching is done case insensitively.

check_args(args)

colored

create_parser(prog_name, command=None)

description = u''

die(msg, status=1)

doc = None

early_version(argv)

enable_config_from_cmdline = False

epilog = None

error(s)

execute_from_commandline(argv=None)

Execute application from command-line.

Parameters:argv – The list of command-line arguments. Defaults to sys.argv.

expanduser(value)

find_app(app)

get_cls_by_name(name, imp=<function import_from_cwd>)

get_options()

Get supported command-line options.

handle_argv(prog_name, argv, command=None)

Parse command-line arguments from argv and dispatch to run().

Parameters:

• prog_name – The program name (argv[0]).
• argv – Command arguments.

Exits with an error message if supports_args is disabled and argv contains positional arguments.

host_format(s, **extra)

leaf = True

maybe_patch_concurrency(argv=None)

namespace = u'celery'

no_color

node_format(s, nodename, **extra)

on_concurrency_setup()

on_error(exc)

on_usage_error(exc)

option_list = ()

out(s, fh=None)

parse_doc(doc)

parse_options(prog_name, arguments, command=None)

Parse the available options.

parse_preload_options(args)

preload_options = (<Option at 0x7f36c81a73f8: -A/--app>, <Option at 0x7f36c8442d40: -b/--broker>, <Option at 0x7f36c84156c8: --loader>, <Option at 0x7f36c8415b00: --config>, <Option at 0x7f36c8415560: --workdir>, <Option at 0x7f36c8415e60: -C/--no-color>, <Option at 0x7f36c8415a70: -q/--quiet>)

prepare_args(options, args)

prepare_parser(parser)

preparse_options(args, options)

pretty(n)

pretty_dict_ok_error(n)

pretty_list(n)

process_cmdline_config(argv)

prog_name = u'celery'

respects_app_option = True

run(*args, **options)

This is the body of the command called by handle_argv().

run_from_argv(prog_name, argv=None, command=None)

say_chat(direction, title, body=u'')

say_remote_command_reply(replies)

setup_app_from_commandline(argv)

show_body = True

show_reply = True

supports_args = True

symbol_by_name(name, imp=<function import_from_cwd>)

usage(command)

verify_args(given, _index=0)

version = '3.1.25 (Cipater)'

with_pool_option(argv)

Return tuple of (short_opts, long_opts) if the command supports a pool argument, and used to monkey patch eventlet/gevent environments as early as possible.

E.g::

has_pool_option = ([‘-P’], [‘–pool’])

class celery.bin.base.Option(*opts, **attrs)

Instance attributes:

_short_opts : [string] _long_opts : [string]

action : string type : string dest : string default : any nargs : int const : any choices : [string] callback : function callback_args : (any*) callback_kwargs : { string : any } help : string metavar : string

ACTIONS = ('store', 'store_const', 'store_true', 'store_false', 'append', 'append_const', 'count', 'callback', 'help', 'version')

ALWAYS_TYPED_ACTIONS = ('store', 'append')

ATTRS = ['action', 'type', 'dest', 'default', 'nargs', 'const', 'choices', 'callback', 'callback_args', 'callback_kwargs', 'help', 'metavar']

CHECK_METHODS = [<function _check_action>, <function _check_type>, <function _check_choice>, <function _check_dest>, <function _check_const>, <function _check_nargs>, <function _check_callback>]

CONST_ACTIONS = ('store_const', 'append_const')

STORE_ACTIONS = ('store', 'store_const', 'store_true', 'store_false', 'append', 'append_const', 'count')

TYPED_ACTIONS = ('store', 'append', 'callback')

TYPES = ('string', 'int', 'long', 'float', 'complex', 'choice')

TYPE_CHECKER = {'int': <function check_builtin>, 'float': <function check_builtin>, 'complex': <function check_builtin>, 'long': <function check_builtin>, 'choice': <function check_choice>}

check_value(opt, value)

convert_value(opt, value)

get_opt_string()

process(opt, value, values, parser)

take_action(action, dest, opt, value, values, parser)

takes_value()

celery.bin.base.daemon_options(default_pidfile=None, default_logfile=None)