index
int64 0
731k
| package
stringlengths 2
98
⌀ | name
stringlengths 1
76
| docstring
stringlengths 0
281k
⌀ | code
stringlengths 4
1.07M
⌀ | signature
stringlengths 2
42.8k
⌀ |
|---|---|---|---|---|---|
711,281
|
celery.app.base
|
_autodiscover_tasks_from_names
| null |
def _autodiscover_tasks_from_names(self, packages, related_name):
# packages argument can be lazy
return self.loader.autodiscover_tasks(
packages() if callable(packages) else packages, related_name,
)
|
(self, packages, related_name)
|
711,282
|
celery.app.base
|
_connection
| null |
def _connection(self, url, userid=None, password=None,
virtual_host=None, port=None, ssl=None,
connect_timeout=None, transport=None,
transport_options=None, heartbeat=None,
login_method=None, failover_strategy=None, **kwargs):
conf = self.conf
return self.amqp.Connection(
url,
userid or conf.broker_user,
password or conf.broker_password,
virtual_host or conf.broker_vhost,
port or conf.broker_port,
transport=transport or conf.broker_transport,
ssl=self.either('broker_use_ssl', ssl),
heartbeat=heartbeat,
login_method=login_method or conf.broker_login_method,
failover_strategy=(
failover_strategy or conf.broker_failover_strategy
),
transport_options=dict(
conf.broker_transport_options, **transport_options or {}
),
connect_timeout=self.either(
'broker_connection_timeout', connect_timeout
),
)
|
(self, url, userid=None, password=None, virtual_host=None, port=None, ssl=None, connect_timeout=None, transport=None, transport_options=None, heartbeat=None, login_method=None, failover_strategy=None, **kwargs)
|
711,283
|
celery.app.base
|
_ensure_after_fork
| null |
def _ensure_after_fork(self):
if not self._after_fork_registered:
self._after_fork_registered = True
if register_after_fork is not None:
register_after_fork(self, _after_fork_cleanup_app)
|
(self)
|
711,284
|
celery.app.base
|
_finalize_pending_conf
|
Get config value by key and finalize loading the configuration.
Note:
This is used by PendingConfiguration:
as soon as you access a key the configuration is read.
|
def _finalize_pending_conf(self):
"""Get config value by key and finalize loading the configuration.
Note:
This is used by PendingConfiguration:
as soon as you access a key the configuration is read.
"""
try:
conf = self._conf = self._load_config()
except AttributeError as err:
# AttributeError is not propagated, it is "handled" by
# PendingConfiguration parent class. This causes
# confusing RecursionError.
raise ModuleNotFoundError(*err.args) from err
return conf
|
(self)
|
711,285
|
celery.app.base
|
_get_backend
| null |
def _get_backend(self):
backend, url = backends.by_url(
self.backend_cls or self.conf.result_backend,
self.loader)
return backend(app=self, url=url)
|
(self)
|
711,286
|
celery.app.base
|
_get_default_loader
| null |
def _get_default_loader(self):
# the --loader command-line argument sets the environment variable.
return (
os.environ.get('CELERY_LOADER') or
self.loader_cls or
'celery.loaders.app:AppLoader'
)
|
(self)
|
711,287
|
celery.app.base
|
_load_config
| null |
def _load_config(self):
if isinstance(self.on_configure, Signal):
self.on_configure.send(sender=self)
else:
# used to be a method pre 4.0
self.on_configure()
if self._config_source:
self.loader.config_from_object(self._config_source)
self.configured = True
settings = detect_settings(
self.prepare_config(self.loader.conf), self._preconf,
ignore_keys=self._preconf_set_by_auto, prefix=self.namespace,
)
if self._conf is not None:
# replace in place, as someone may have referenced app.conf,
# done some changes, accessed a key, and then try to make more
# changes to the reference and not the finalized value.
self._conf.swap_with(settings)
else:
self._conf = settings
# load lazy config dict initializers.
pending_def = self._pending_defaults
while pending_def:
self._conf.add_defaults(maybe_evaluate(pending_def.popleft()()))
# load lazy periodic tasks
pending_beat = self._pending_periodic_tasks
while pending_beat:
periodic_task_args, periodic_task_kwargs = pending_beat.popleft()
self._add_periodic_task(*periodic_task_args, **periodic_task_kwargs)
self.on_after_configure.send(sender=self, source=self._conf)
return self._conf
|
(self)
|
711,288
|
celery.app.base
|
_rgetattr
| null |
def _rgetattr(self, path):
return attrgetter(path)(self)
|
(self, path)
|
711,289
|
celery.app.base
|
_sig_to_periodic_task_entry
| null |
def _sig_to_periodic_task_entry(self, schedule, sig,
args=(), kwargs=None, name=None, **opts):
kwargs = {} if not kwargs else kwargs
sig = (sig.clone(args, kwargs)
if isinstance(sig, abstract.CallableSignature)
else self.signature(sig.name, args, kwargs))
return name or repr(sig), {
'schedule': schedule,
'task': sig.name,
'args': sig.args,
'kwargs': sig.kwargs,
'options': dict(sig.options, **opts),
}
|
(self, schedule, sig, args=(), kwargs=None, name=None, **opts)
|
711,290
|
celery.app.base
|
_task_from_fun
| null |
def _task_from_fun(self, fun, name=None, base=None, bind=False, **options):
if not self.finalized and not self.autofinalize:
raise RuntimeError('Contract breach: app not finalized')
name = name or self.gen_task_name(fun.__name__, fun.__module__)
base = base or self.Task
if name not in self._tasks:
run = fun if bind else staticmethod(fun)
task = type(fun.__name__, (base,), dict({
'app': self,
'name': name,
'run': run,
'_decorated': True,
'__doc__': fun.__doc__,
'__module__': fun.__module__,
'__annotations__': fun.__annotations__,
'__header__': self.type_checker(fun, bound=bind),
'__wrapped__': run}, **options))()
# for some reason __qualname__ cannot be set in type()
# so we have to set it here.
try:
task.__qualname__ = fun.__qualname__
except AttributeError:
pass
self._tasks[task.name] = task
task.bind(self) # connects task to this app
add_autoretry_behaviour(task, **options)
else:
task = self._tasks[name]
return task
|
(self, fun, name=None, base=None, bind=False, **options)
|
711,291
|
celery.app.base
|
add_defaults
|
Add default configuration from dict ``d``.
If the argument is a callable function then it will be regarded
as a promise, and it won't be loaded until the configuration is
actually needed.
This method can be compared to:
.. code-block:: pycon
>>> celery.conf.update(d)
with a difference that 1) no copy will be made and 2) the dict will
not be transferred when the worker spawns child processes, so
it's important that the same configuration happens at import time
when pickle restores the object on the other side.
|
def add_defaults(self, fun):
"""Add default configuration from dict ``d``.
If the argument is a callable function then it will be regarded
as a promise, and it won't be loaded until the configuration is
actually needed.
This method can be compared to:
.. code-block:: pycon
>>> celery.conf.update(d)
with a difference that 1) no copy will be made and 2) the dict will
not be transferred when the worker spawns child processes, so
it's important that the same configuration happens at import time
when pickle restores the object on the other side.
"""
if not callable(fun):
d, fun = fun, lambda: d
if self.configured:
return self._conf.add_defaults(fun())
self._pending_defaults.append(fun)
|
(self, fun)
|
711,292
|
celery.app.base
|
add_periodic_task
|
Add a periodic task to beat schedule.
Celery beat store tasks based on `sig` or `name` if provided. Adding the
same signature twice make the second task override the first one. To
avoid the override, use distinct `name` for them.
|
def add_periodic_task(self, schedule, sig,
args=(), kwargs=(), name=None, **opts):
"""
Add a periodic task to beat schedule.
Celery beat store tasks based on `sig` or `name` if provided. Adding the
same signature twice make the second task override the first one. To
avoid the override, use distinct `name` for them.
"""
key, entry = self._sig_to_periodic_task_entry(
schedule, sig, args, kwargs, name, **opts)
if self.configured:
self._add_periodic_task(key, entry, name=name)
else:
self._pending_periodic_tasks.append([(key, entry), {"name": name}])
return key
|
(self, schedule, sig, args=(), kwargs=(), name=None, **opts)
|
711,293
|
celery.app.base
|
autodiscover_tasks
|
Auto-discover task modules.
Searches a list of packages for a "tasks.py" module (or use
related_name argument).
If the name is empty, this will be delegated to fix-ups (e.g., Django).
For example if you have a directory layout like this:
.. code-block:: text
foo/__init__.py
tasks.py
models.py
bar/__init__.py
tasks.py
models.py
baz/__init__.py
models.py
Then calling ``app.autodiscover_tasks(['foo', 'bar', 'baz'])`` will
result in the modules ``foo.tasks`` and ``bar.tasks`` being imported.
Arguments:
packages (List[str]): List of packages to search.
This argument may also be a callable, in which case the
value returned is used (for lazy evaluation).
related_name (Optional[str]): The name of the module to find. Defaults
to "tasks": meaning "look for 'module.tasks' for every
module in ``packages``.". If ``None`` will only try to import
the package, i.e. "look for 'module'".
force (bool): By default this call is lazy so that the actual
auto-discovery won't happen until an application imports
the default modules. Forcing will cause the auto-discovery
to happen immediately.
|
def autodiscover_tasks(self, packages=None,
related_name='tasks', force=False):
"""Auto-discover task modules.
Searches a list of packages for a "tasks.py" module (or use
related_name argument).
If the name is empty, this will be delegated to fix-ups (e.g., Django).
For example if you have a directory layout like this:
.. code-block:: text
foo/__init__.py
tasks.py
models.py
bar/__init__.py
tasks.py
models.py
baz/__init__.py
models.py
Then calling ``app.autodiscover_tasks(['foo', 'bar', 'baz'])`` will
result in the modules ``foo.tasks`` and ``bar.tasks`` being imported.
Arguments:
packages (List[str]): List of packages to search.
This argument may also be a callable, in which case the
value returned is used (for lazy evaluation).
related_name (Optional[str]): The name of the module to find. Defaults
to "tasks": meaning "look for 'module.tasks' for every
module in ``packages``.". If ``None`` will only try to import
the package, i.e. "look for 'module'".
force (bool): By default this call is lazy so that the actual
auto-discovery won't happen until an application imports
the default modules. Forcing will cause the auto-discovery
to happen immediately.
"""
if force:
return self._autodiscover_tasks(packages, related_name)
signals.import_modules.connect(starpromise(
self._autodiscover_tasks, packages, related_name,
), weak=False, sender=self)
|
(self, packages=None, related_name='tasks', force=False)
|
711,294
|
celery.app.base
|
connection
|
Establish a connection to the message broker.
Please use :meth:`connection_for_read` and
:meth:`connection_for_write` instead, to convey the intent
of use for this connection.
Arguments:
url: Either the URL or the hostname of the broker to use.
hostname (str): URL, Hostname/IP-address of the broker.
If a URL is used, then the other argument below will
be taken from the URL instead.
userid (str): Username to authenticate as.
password (str): Password to authenticate with
virtual_host (str): Virtual host to use (domain).
port (int): Port to connect to.
ssl (bool, Dict): Defaults to the :setting:`broker_use_ssl`
setting.
transport (str): defaults to the :setting:`broker_transport`
setting.
transport_options (Dict): Dictionary of transport specific options.
heartbeat (int): AMQP Heartbeat in seconds (``pyamqp`` only).
login_method (str): Custom login method to use (AMQP only).
failover_strategy (str, Callable): Custom failover strategy.
**kwargs: Additional arguments to :class:`kombu.Connection`.
Returns:
kombu.Connection: the lazy connection instance.
|
def connection(self, hostname=None, userid=None, password=None,
virtual_host=None, port=None, ssl=None,
connect_timeout=None, transport=None,
transport_options=None, heartbeat=None,
login_method=None, failover_strategy=None, **kwargs):
"""Establish a connection to the message broker.
Please use :meth:`connection_for_read` and
:meth:`connection_for_write` instead, to convey the intent
of use for this connection.
Arguments:
url: Either the URL or the hostname of the broker to use.
hostname (str): URL, Hostname/IP-address of the broker.
If a URL is used, then the other argument below will
be taken from the URL instead.
userid (str): Username to authenticate as.
password (str): Password to authenticate with
virtual_host (str): Virtual host to use (domain).
port (int): Port to connect to.
ssl (bool, Dict): Defaults to the :setting:`broker_use_ssl`
setting.
transport (str): defaults to the :setting:`broker_transport`
setting.
transport_options (Dict): Dictionary of transport specific options.
heartbeat (int): AMQP Heartbeat in seconds (``pyamqp`` only).
login_method (str): Custom login method to use (AMQP only).
failover_strategy (str, Callable): Custom failover strategy.
**kwargs: Additional arguments to :class:`kombu.Connection`.
Returns:
kombu.Connection: the lazy connection instance.
"""
return self.connection_for_write(
hostname or self.conf.broker_write_url,
userid=userid, password=password,
virtual_host=virtual_host, port=port, ssl=ssl,
connect_timeout=connect_timeout, transport=transport,
transport_options=transport_options, heartbeat=heartbeat,
login_method=login_method, failover_strategy=failover_strategy,
**kwargs
)
|
(self, hostname=None, userid=None, password=None, virtual_host=None, port=None, ssl=None, connect_timeout=None, transport=None, transport_options=None, heartbeat=None, login_method=None, failover_strategy=None, **kwargs)
|
711,295
|
celery.app.base
|
bugreport
|
Return information useful in bug reports.
|
def bugreport(self):
"""Return information useful in bug reports."""
return bugreport(self)
|
(self)
|
711,296
|
celery.app.base
|
close
|
Clean up after the application.
Only necessary for dynamically created apps, and you should
probably use the :keyword:`with` statement instead.
Example:
>>> with Celery(set_as_current=False) as app:
... with app.connection_for_write() as conn:
... pass
|
def close(self):
"""Clean up after the application.
Only necessary for dynamically created apps, and you should
probably use the :keyword:`with` statement instead.
Example:
>>> with Celery(set_as_current=False) as app:
... with app.connection_for_write() as conn:
... pass
"""
self._pool = None
_deregister_app(self)
|
(self)
|
711,297
|
celery.app.base
|
config_from_cmdline
| null |
def config_from_cmdline(self, argv, namespace='celery'):
self._conf.update(
self.loader.cmdline_config_parser(argv, namespace)
)
|
(self, argv, namespace='celery')
|
711,298
|
celery.app.base
|
config_from_envvar
|
Read configuration from environment variable.
The value of the environment variable must be the name
of a module to import.
Example:
>>> os.environ['CELERY_CONFIG_MODULE'] = 'myapp.celeryconfig'
>>> celery.config_from_envvar('CELERY_CONFIG_MODULE')
|
def config_from_envvar(self, variable_name, silent=False, force=False):
"""Read configuration from environment variable.
The value of the environment variable must be the name
of a module to import.
Example:
>>> os.environ['CELERY_CONFIG_MODULE'] = 'myapp.celeryconfig'
>>> celery.config_from_envvar('CELERY_CONFIG_MODULE')
"""
module_name = os.environ.get(variable_name)
if not module_name:
if silent:
return False
raise ImproperlyConfigured(
ERR_ENVVAR_NOT_SET.strip().format(variable_name))
return self.config_from_object(module_name, silent=silent, force=force)
|
(self, variable_name, silent=False, force=False)
|
711,299
|
celery.app.base
|
config_from_object
|
Read configuration from object.
Object is either an actual object or the name of a module to import.
Example:
>>> celery.config_from_object('myapp.celeryconfig')
>>> from myapp import celeryconfig
>>> celery.config_from_object(celeryconfig)
Arguments:
silent (bool): If true then import errors will be ignored.
force (bool): Force reading configuration immediately.
By default the configuration will be read only when required.
|
def config_from_object(self, obj,
silent=False, force=False, namespace=None):
"""Read configuration from object.
Object is either an actual object or the name of a module to import.
Example:
>>> celery.config_from_object('myapp.celeryconfig')
>>> from myapp import celeryconfig
>>> celery.config_from_object(celeryconfig)
Arguments:
silent (bool): If true then import errors will be ignored.
force (bool): Force reading configuration immediately.
By default the configuration will be read only when required.
"""
self._config_source = obj
self.namespace = namespace or self.namespace
if force or self.configured:
self._conf = None
if self.loader.config_from_object(obj, silent=silent):
return self.conf
|
(self, obj, silent=False, force=False, namespace=None)
|
711,301
|
celery.app.base
|
connection_for_read
|
Establish connection used for consuming.
See Also:
:meth:`connection` for supported arguments.
|
def connection_for_read(self, url=None, **kwargs):
"""Establish connection used for consuming.
See Also:
:meth:`connection` for supported arguments.
"""
return self._connection(url or self.conf.broker_read_url, **kwargs)
|
(self, url=None, **kwargs)
|
711,302
|
celery.app.base
|
connection_for_write
|
Establish connection used for producing.
See Also:
:meth:`connection` for supported arguments.
|
def connection_for_write(self, url=None, **kwargs):
"""Establish connection used for producing.
See Also:
:meth:`connection` for supported arguments.
"""
return self._connection(url or self.conf.broker_write_url, **kwargs)
|
(self, url=None, **kwargs)
|
711,303
|
celery.app.base
|
connection_or_acquire
|
Context used to acquire a connection from the pool.
For use within a :keyword:`with` statement to get a connection
from the pool if one is not already provided.
Arguments:
connection (kombu.Connection): If not provided, a connection
will be acquired from the connection pool.
|
def connection_or_acquire(self, connection=None, pool=True, *_, **__):
"""Context used to acquire a connection from the pool.
For use within a :keyword:`with` statement to get a connection
from the pool if one is not already provided.
Arguments:
connection (kombu.Connection): If not provided, a connection
will be acquired from the connection pool.
"""
return FallbackContext(connection, self._acquire_connection, pool=pool)
|
(self, connection=None, pool=True, *_, **__)
|
711,304
|
celery.app.base
|
create_task_cls
|
Create a base task class bound to this app.
|
def create_task_cls(self):
"""Create a base task class bound to this app."""
return self.subclass_with_self(
self.task_cls, name='Task', attribute='_app',
keep_reduce=True, abstract=True,
)
|
(self)
|
711,306
|
celery.app.base
|
producer_or_acquire
|
Context used to acquire a producer from the pool.
For use within a :keyword:`with` statement to get a producer
from the pool if one is not already provided
Arguments:
producer (kombu.Producer): If not provided, a producer
will be acquired from the producer pool.
|
def producer_or_acquire(self, producer=None):
"""Context used to acquire a producer from the pool.
For use within a :keyword:`with` statement to get a producer
from the pool if one is not already provided
Arguments:
producer (kombu.Producer): If not provided, a producer
will be acquired from the producer pool.
"""
return FallbackContext(
producer, self.producer_pool.acquire, block=True,
)
|
(self, producer=None)
|
711,307
|
celery.app.base
|
either
|
Get key from configuration or use default values.
Fallback to the value of a configuration key if none of the
`*values` are true.
|
def either(self, default_key, *defaults):
"""Get key from configuration or use default values.
Fallback to the value of a configuration key if none of the
`*values` are true.
"""
return first(None, [
first(None, defaults), starpromise(self.conf.get, default_key),
])
|
(self, default_key, *defaults)
|
711,308
|
celery.app.base
|
finalize
|
Finalize the app.
This loads built-in tasks, evaluates pending task decorators,
reads configuration, etc.
|
def finalize(self, auto=False):
"""Finalize the app.
This loads built-in tasks, evaluates pending task decorators,
reads configuration, etc.
"""
with self._finalize_mutex:
if not self.finalized:
if auto and not self.autofinalize:
raise RuntimeError('Contract breach: app not finalized')
self.finalized = True
_announce_app_finalized(self)
pending = self._pending
while pending:
maybe_evaluate(pending.popleft())
for task in self._tasks.values():
task.bind(self)
self.on_after_finalize.send(sender=self)
|
(self, auto=False)
|
711,309
|
celery.app.base
|
gen_task_name
| null |
def gen_task_name(self, name, module):
return gen_task_name(self, name, module)
|
(self, name, module)
|
711,310
|
celery.app.base
|
now
|
Return the current time and date as a datetime.
|
def now(self):
"""Return the current time and date as a datetime."""
now_in_utc = to_utc(datetime.now(datetime_timezone.utc))
return now_in_utc.astimezone(self.timezone)
|
(self)
|
711,311
|
celery.app.base
|
on_init
|
Optional callback called at init.
|
def on_init(self):
"""Optional callback called at init."""
|
(self)
|
711,312
|
celery.app.base
|
prepare_config
|
Prepare configuration before it is merged with the defaults.
|
def prepare_config(self, c):
"""Prepare configuration before it is merged with the defaults."""
return find_deprecated_settings(c)
|
(self, c)
|
711,314
|
celery.app.base
|
register_task
|
Utility for registering a task-based class.
Note:
This is here for compatibility with old Celery 1.0
style task classes, you should not need to use this for
new projects.
|
def register_task(self, task, **options):
"""Utility for registering a task-based class.
Note:
This is here for compatibility with old Celery 1.0
style task classes, you should not need to use this for
new projects.
"""
task = inspect.isclass(task) and task() or task
if not task.name:
task_cls = type(task)
task.name = self.gen_task_name(
task_cls.__name__, task_cls.__module__)
add_autoretry_behaviour(task, **options)
self.tasks[task.name] = task
task._app = self
task.bind(self)
return task
|
(self, task, **options)
|
711,315
|
celery.app.base
|
select_queues
|
Select subset of queues.
Arguments:
queues (Sequence[str]): a list of queue names to keep.
|
def select_queues(self, queues=None):
"""Select subset of queues.
Arguments:
queues (Sequence[str]): a list of queue names to keep.
"""
return self.amqp.queues.select(queues)
|
(self, queues=None)
|
711,316
|
celery.app.base
|
send_task
|
Send task by name.
Supports the same arguments as :meth:`@-Task.apply_async`.
Arguments:
name (str): Name of task to call (e.g., `"tasks.add"`).
result_cls (AsyncResult): Specify custom result class.
|
def send_task(self, name, args=None, kwargs=None, countdown=None,
eta=None, task_id=None, producer=None, connection=None,
router=None, result_cls=None, expires=None,
publisher=None, link=None, link_error=None,
add_to_parent=True, group_id=None, group_index=None,
retries=0, chord=None,
reply_to=None, time_limit=None, soft_time_limit=None,
root_id=None, parent_id=None, route_name=None,
shadow=None, chain=None, task_type=None, replaced_task_nesting=0, **options):
"""Send task by name.
Supports the same arguments as :meth:`@-Task.apply_async`.
Arguments:
name (str): Name of task to call (e.g., `"tasks.add"`).
result_cls (AsyncResult): Specify custom result class.
"""
parent = have_parent = None
amqp = self.amqp
task_id = task_id or uuid()
producer = producer or publisher # XXX compat
router = router or amqp.router
conf = self.conf
if conf.task_always_eager: # pragma: no cover
warnings.warn(AlwaysEagerIgnored(
'task_always_eager has no effect on send_task',
), stacklevel=2)
ignore_result = options.pop('ignore_result', False)
options = router.route(
options, route_name or name, args, kwargs, task_type)
if expires is not None:
if isinstance(expires, datetime):
expires_s = (maybe_make_aware(
expires) - self.now()).total_seconds()
elif isinstance(expires, str):
expires_s = (maybe_make_aware(
isoparse(expires)) - self.now()).total_seconds()
else:
expires_s = expires
if expires_s < 0:
logger.warning(
f"{task_id} has an expiration date in the past ({-expires_s}s ago).\n"
"We assume this is intended and so we have set the "
"expiration date to 0 instead.\n"
"According to RabbitMQ's documentation:\n"
"\"Setting the TTL to 0 causes messages to be expired upon "
"reaching a queue unless they can be delivered to a "
"consumer immediately.\"\n"
"If this was unintended, please check the code which "
"published this task."
)
expires_s = 0
options["expiration"] = expires_s
if not root_id or not parent_id:
parent = self.current_worker_task
if parent:
if not root_id:
root_id = parent.request.root_id or parent.request.id
if not parent_id:
parent_id = parent.request.id
if conf.task_inherit_parent_priority:
options.setdefault('priority',
parent.request.delivery_info.get('priority'))
# alias for 'task_as_v2'
message = amqp.create_task_message(
task_id, name, args, kwargs, countdown, eta, group_id, group_index,
expires, retries, chord,
maybe_list(link), maybe_list(link_error),
reply_to or self.thread_oid, time_limit, soft_time_limit,
self.conf.task_send_sent_event,
root_id, parent_id, shadow, chain,
ignore_result=ignore_result,
replaced_task_nesting=replaced_task_nesting, **options
)
stamped_headers = options.pop('stamped_headers', [])
for stamp in stamped_headers:
options.pop(stamp)
if connection:
producer = amqp.Producer(connection, auto_declare=False)
with self.producer_or_acquire(producer) as P:
with P.connection._reraise_as_library_errors():
if not ignore_result:
self.backend.on_task_call(P, task_id)
amqp.send_task_message(P, name, message, **options)
result = (result_cls or self.AsyncResult)(task_id)
# We avoid using the constructor since a custom result class
# can be used, in which case the constructor may still use
# the old signature.
result.ignored = ignore_result
if add_to_parent:
if not have_parent:
parent, have_parent = self.current_worker_task, True
if parent:
parent.add_trail(result)
return result
|
(self, name, args=None, kwargs=None, countdown=None, eta=None, task_id=None, producer=None, connection=None, router=None, result_cls=None, expires=None, publisher=None, link=None, link_error=None, add_to_parent=True, group_id=None, group_index=None, retries=0, chord=None, reply_to=None, time_limit=None, soft_time_limit=None, root_id=None, parent_id=None, route_name=None, shadow=None, chain=None, task_type=None, replaced_task_nesting=0, **options)
|
711,317
|
celery.app.base
|
set_current
|
Make this the current app for this thread.
|
def set_current(self):
"""Make this the current app for this thread."""
_set_current_app(self)
|
(self)
|
711,318
|
celery.app.base
|
set_default
|
Make this the default app for all threads.
|
def set_default(self):
"""Make this the default app for all threads."""
set_default_app(self)
|
(self)
|
711,319
|
celery.app.base
|
setup_security
|
Setup the message-signing serializer.
This will affect all application instances (a global operation).
Disables untrusted serializers and if configured to use the ``auth``
serializer will register the ``auth`` serializer with the provided
settings into the Kombu serializer registry.
Arguments:
allowed_serializers (Set[str]): List of serializer names, or
content_types that should be exempt from being disabled.
key (str): Name of private key file to use.
Defaults to the :setting:`security_key` setting.
key_password (bytes): Password to decrypt the private key.
Defaults to the :setting:`security_key_password` setting.
cert (str): Name of certificate file to use.
Defaults to the :setting:`security_certificate` setting.
store (str): Directory containing certificates.
Defaults to the :setting:`security_cert_store` setting.
digest (str): Digest algorithm used when signing messages.
Default is ``sha256``.
serializer (str): Serializer used to encode messages after
they've been signed. See :setting:`task_serializer` for
the serializers supported. Default is ``json``.
|
def setup_security(self, allowed_serializers=None, key=None, key_password=None, cert=None,
store=None, digest=DEFAULT_SECURITY_DIGEST,
serializer='json'):
"""Setup the message-signing serializer.
This will affect all application instances (a global operation).
Disables untrusted serializers and if configured to use the ``auth``
serializer will register the ``auth`` serializer with the provided
settings into the Kombu serializer registry.
Arguments:
allowed_serializers (Set[str]): List of serializer names, or
content_types that should be exempt from being disabled.
key (str): Name of private key file to use.
Defaults to the :setting:`security_key` setting.
key_password (bytes): Password to decrypt the private key.
Defaults to the :setting:`security_key_password` setting.
cert (str): Name of certificate file to use.
Defaults to the :setting:`security_certificate` setting.
store (str): Directory containing certificates.
Defaults to the :setting:`security_cert_store` setting.
digest (str): Digest algorithm used when signing messages.
Default is ``sha256``.
serializer (str): Serializer used to encode messages after
they've been signed. See :setting:`task_serializer` for
the serializers supported. Default is ``json``.
"""
from celery.security import setup_security
return setup_security(allowed_serializers, key, key_password, cert,
store, digest, serializer, app=self)
|
(self, allowed_serializers=None, key=None, key_password=None, cert=None, store=None, digest='sha256', serializer='json')
|
711,320
|
celery.app.base
|
signature
|
Return a new :class:`~celery.Signature` bound to this app.
|
def signature(self, *args, **kwargs):
"""Return a new :class:`~celery.Signature` bound to this app."""
kwargs['app'] = self
return self._canvas.signature(*args, **kwargs)
|
(self, *args, **kwargs)
|
711,321
|
celery.app.base
|
start
|
Run :program:`celery` using `argv`.
Uses :data:`sys.argv` if `argv` is not specified.
|
def start(self, argv=None):
"""Run :program:`celery` using `argv`.
Uses :data:`sys.argv` if `argv` is not specified.
"""
from celery.bin.celery import celery
celery.params[0].default = self
if argv is None:
argv = sys.argv
try:
celery.main(args=argv, standalone_mode=False)
except Exit as e:
return e.exit_code
finally:
celery.params[0].default = None
|
(self, argv=None)
|
711,322
|
celery.app.base
|
subclass_with_self
|
Subclass an app-compatible class.
App-compatible means that the class has a class attribute that
provides the default app it should use, for example:
``class Foo: app = None``.
Arguments:
Class (type): The app-compatible class to subclass.
name (str): Custom name for the target class.
attribute (str): Name of the attribute holding the app,
Default is 'app'.
reverse (str): Reverse path to this object used for pickling
purposes. For example, to get ``app.AsyncResult``,
use ``"AsyncResult"``.
keep_reduce (bool): If enabled a custom ``__reduce__``
implementation won't be provided.
|
def subclass_with_self(self, Class, name=None, attribute='app',
reverse=None, keep_reduce=False, **kw):
"""Subclass an app-compatible class.
App-compatible means that the class has a class attribute that
provides the default app it should use, for example:
``class Foo: app = None``.
Arguments:
Class (type): The app-compatible class to subclass.
name (str): Custom name for the target class.
attribute (str): Name of the attribute holding the app,
Default is 'app'.
reverse (str): Reverse path to this object used for pickling
purposes. For example, to get ``app.AsyncResult``,
use ``"AsyncResult"``.
keep_reduce (bool): If enabled a custom ``__reduce__``
implementation won't be provided.
"""
Class = symbol_by_name(Class)
reverse = reverse if reverse else Class.__name__
def __reduce__(self):
return _unpickle_appattr, (reverse, self.__reduce_args__())
attrs = dict(
{attribute: self},
__module__=Class.__module__,
__doc__=Class.__doc__,
**kw)
if not keep_reduce:
attrs['__reduce__'] = __reduce__
return type(name or Class.__name__, (Class,), attrs)
|
(self, Class, name=None, attribute='app', reverse=None, keep_reduce=False, **kw)
|
711,323
|
celery.app.base
|
task
|
Decorator to create a task class out of any callable.
See :ref:`Task options<task-options>` for a list of the
arguments that can be passed to this decorator.
Examples:
.. code-block:: python
@app.task
def refresh_feed(url):
store_feed(feedparser.parse(url))
with setting extra options:
.. code-block:: python
@app.task(exchange='feeds')
def refresh_feed(url):
return store_feed(feedparser.parse(url))
Note:
App Binding: For custom apps the task decorator will return
a proxy object, so that the act of creating the task is not
performed until the task is used or the task registry is accessed.
If you're depending on binding to be deferred, then you must
not access any attributes on the returned object until the
application is fully set up (finalized).
|
def task(self, *args, **opts):
"""Decorator to create a task class out of any callable.
See :ref:`Task options<task-options>` for a list of the
arguments that can be passed to this decorator.
Examples:
.. code-block:: python
@app.task
def refresh_feed(url):
store_feed(feedparser.parse(url))
with setting extra options:
.. code-block:: python
@app.task(exchange='feeds')
def refresh_feed(url):
return store_feed(feedparser.parse(url))
Note:
App Binding: For custom apps the task decorator will return
a proxy object, so that the act of creating the task is not
performed until the task is used or the task registry is accessed.
If you're depending on binding to be deferred, then you must
not access any attributes on the returned object until the
application is fully set up (finalized).
"""
if USING_EXECV and opts.get('lazy', True):
# When using execv the task in the original module will point to a
# different app, so doing things like 'add.request' will point to
# a different task instance. This makes sure it will always use
# the task instance from the current app.
# Really need a better solution for this :(
from . import shared_task
return shared_task(*args, lazy=False, **opts)
def inner_create_task_cls(shared=True, filter=None, lazy=True, **opts):
_filt = filter
def _create_task_cls(fun):
if shared:
def cons(app):
return app._task_from_fun(fun, **opts)
cons.__name__ = fun.__name__
connect_on_app_finalize(cons)
if not lazy or self.finalized:
ret = self._task_from_fun(fun, **opts)
else:
# return a proxy object that evaluates on first use
ret = PromiseProxy(self._task_from_fun, (fun,), opts,
__doc__=fun.__doc__)
self._pending.append(ret)
if _filt:
return _filt(ret)
return ret
return _create_task_cls
if len(args) == 1:
if callable(args[0]):
return inner_create_task_cls(**opts)(*args)
raise TypeError('argument 1 to @task() must be a callable')
if args:
raise TypeError(
'@task() takes exactly 1 argument ({} given)'.format(
sum([len(args), len(opts)])))
return inner_create_task_cls(**opts)
|
(self, *args, **opts)
|
711,324
|
celery.app.base
|
type_checker
| null |
def type_checker(self, fun, bound=False):
return staticmethod(head_from_fun(fun, bound=bound))
|
(self, fun, bound=False)
|
711,325
|
celery.app.base
|
uses_utc_timezone
|
Check if the application uses the UTC timezone.
|
def uses_utc_timezone(self):
"""Check if the application uses the UTC timezone."""
return self.timezone == timezone.utc
|
(self)
|
711,326
|
celery.app.base
|
worker_main
|
Run :program:`celery worker` using `argv`.
Uses :data:`sys.argv` if `argv` is not specified.
|
def worker_main(self, argv=None):
"""Run :program:`celery worker` using `argv`.
Uses :data:`sys.argv` if `argv` is not specified.
"""
if argv is None:
argv = sys.argv
if 'worker' not in argv:
raise ValueError(
"The worker sub-command must be specified in argv.\n"
"Use app.start() to programmatically start other commands."
)
self.start(argv=argv)
|
(self, argv=None)
|
711,327
|
celery.canvas
|
Signature
|
Task Signature.
Class that wraps the arguments and execution options
for a single task invocation.
Used as the parts in a :class:`group` and other constructs,
or to pass tasks around as callbacks while being compatible
with serializers with a strict type subset.
Signatures can also be created from tasks:
- Using the ``.signature()`` method that has the same signature
as ``Task.apply_async``:
.. code-block:: pycon
>>> add.signature(args=(1,), kwargs={'kw': 2}, options={})
- or the ``.s()`` shortcut that works for star arguments:
.. code-block:: pycon
>>> add.s(1, kw=2)
- the ``.s()`` shortcut does not allow you to specify execution options
but there's a chaining `.set` method that returns the signature:
.. code-block:: pycon
>>> add.s(2, 2).set(countdown=10).set(expires=30).delay()
Note:
You should use :func:`~celery.signature` to create new signatures.
The ``Signature`` class is the type returned by that function and
should be used for ``isinstance`` checks for signatures.
See Also:
:ref:`guide-canvas` for the complete guide.
Arguments:
task (Union[Type[celery.app.task.Task], str]): Either a task
class/instance, or the name of a task.
args (Tuple): Positional arguments to apply.
kwargs (Dict): Keyword arguments to apply.
options (Dict): Additional options to :meth:`Task.apply_async`.
Note:
If the first argument is a :class:`dict`, the other
arguments will be ignored and the values in the dict will be used
instead::
>>> s = signature('tasks.add', args=(2, 2))
>>> signature(s)
{'task': 'tasks.add', args=(2, 2), kwargs={}, options={}}
|
class Signature(dict):
"""Task Signature.
Class that wraps the arguments and execution options
for a single task invocation.
Used as the parts in a :class:`group` and other constructs,
or to pass tasks around as callbacks while being compatible
with serializers with a strict type subset.
Signatures can also be created from tasks:
- Using the ``.signature()`` method that has the same signature
as ``Task.apply_async``:
.. code-block:: pycon
>>> add.signature(args=(1,), kwargs={'kw': 2}, options={})
- or the ``.s()`` shortcut that works for star arguments:
.. code-block:: pycon
>>> add.s(1, kw=2)
- the ``.s()`` shortcut does not allow you to specify execution options
but there's a chaining `.set` method that returns the signature:
.. code-block:: pycon
>>> add.s(2, 2).set(countdown=10).set(expires=30).delay()
Note:
You should use :func:`~celery.signature` to create new signatures.
The ``Signature`` class is the type returned by that function and
should be used for ``isinstance`` checks for signatures.
See Also:
:ref:`guide-canvas` for the complete guide.
Arguments:
task (Union[Type[celery.app.task.Task], str]): Either a task
class/instance, or the name of a task.
args (Tuple): Positional arguments to apply.
kwargs (Dict): Keyword arguments to apply.
options (Dict): Additional options to :meth:`Task.apply_async`.
Note:
If the first argument is a :class:`dict`, the other
arguments will be ignored and the values in the dict will be used
instead::
>>> s = signature('tasks.add', args=(2, 2))
>>> signature(s)
{'task': 'tasks.add', args=(2, 2), kwargs={}, options={}}
"""
TYPES = {}
_app = _type = None
# The following fields must not be changed during freezing/merging because
# to do so would disrupt completion of parent tasks
_IMMUTABLE_OPTIONS = {"group_id", "stamped_headers"}
@classmethod
def register_type(cls, name=None):
"""Register a new type of signature.
Used as a class decorator, for example:
>>> @Signature.register_type()
>>> class mysig(Signature):
>>> pass
"""
def _inner(subclass):
cls.TYPES[name or subclass.__name__] = subclass
return subclass
return _inner
@classmethod
def from_dict(cls, d, app=None):
"""Create a new signature from a dict.
Subclasses can override this method to customize how are
they created from a dict.
"""
typ = d.get('subtask_type')
if typ:
target_cls = cls.TYPES[typ]
if target_cls is not cls:
return target_cls.from_dict(d, app=app)
return Signature(d, app=app)
def __init__(self, task=None, args=None, kwargs=None, options=None,
type=None, subtask_type=None, immutable=False,
app=None, **ex):
self._app = app
if isinstance(task, dict):
super().__init__(task) # works like dict(d)
else:
# Also supports using task class/instance instead of string name.
try:
task_name = task.name
except AttributeError:
task_name = task
else:
self._type = task
super().__init__(
task=task_name, args=tuple(args or ()),
kwargs=kwargs or {},
options=dict(options or {}, **ex),
subtask_type=subtask_type,
immutable=immutable,
)
def __call__(self, *partial_args, **partial_kwargs):
"""Call the task directly (in the current process)."""
args, kwargs, _ = self._merge(partial_args, partial_kwargs, None)
return self.type(*args, **kwargs)
def delay(self, *partial_args, **partial_kwargs):
"""Shortcut to :meth:`apply_async` using star arguments."""
return self.apply_async(partial_args, partial_kwargs)
def apply(self, args=None, kwargs=None, **options):
"""Call task locally.
Same as :meth:`apply_async` but executed the task inline instead
of sending a task message.
"""
args = args if args else ()
kwargs = kwargs if kwargs else {}
# Extra options set to None are dismissed
options = {k: v for k, v in options.items() if v is not None}
# For callbacks: extra args are prepended to the stored args.
args, kwargs, options = self._merge(args, kwargs, options)
return self.type.apply(args, kwargs, **options)
def apply_async(self, args=None, kwargs=None, route_name=None, **options):
"""Apply this task asynchronously.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
options (Dict): Partial options to be merged
with existing options.
Returns:
~@AsyncResult: promise of future evaluation.
See also:
:meth:`~@Task.apply_async` and the :ref:`guide-calling` guide.
"""
args = args if args else ()
kwargs = kwargs if kwargs else {}
# Extra options set to None are dismissed
options = {k: v for k, v in options.items() if v is not None}
try:
_apply = self._apply_async
except IndexError: # pragma: no cover
# no tasks for chain, etc to find type
return
# For callbacks: extra args are prepended to the stored args.
if args or kwargs or options:
args, kwargs, options = self._merge(args, kwargs, options)
else:
args, kwargs, options = self.args, self.kwargs, self.options
# pylint: disable=too-many-function-args
# Works on this, as it's a property
return _apply(args, kwargs, **options)
def _merge(self, args=None, kwargs=None, options=None, force=False):
"""Merge partial args/kwargs/options with existing ones.
If the signature is immutable and ``force`` is False, the existing
args/kwargs will be returned as-is and only the options will be merged.
Stamped headers are considered immutable and will not be merged regardless.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
options (Dict): Partial options to be merged with existing options.
force (bool): If True, the args/kwargs will be merged even if the signature is
immutable. The stamped headers are not affected by this option and will not
be merged regardless.
Returns:
Tuple: (args, kwargs, options)
"""
args = args if args else ()
kwargs = kwargs if kwargs else {}
if options is not None:
# We build a new options dictionary where values in `options`
# override values in `self.options` except for keys which are
# noted as being immutable (unrelated to signature immutability)
# implying that allowing their value to change would stall tasks
immutable_options = self._IMMUTABLE_OPTIONS
if "stamped_headers" in self.options:
immutable_options = self._IMMUTABLE_OPTIONS.union(set(self.options.get("stamped_headers", [])))
# merge self.options with options without overriding stamped headers from self.options
new_options = {**self.options, **{
k: v for k, v in options.items()
if k not in immutable_options or k not in self.options
}}
else:
new_options = self.options
if self.immutable and not force:
return (self.args, self.kwargs, new_options)
return (tuple(args) + tuple(self.args) if args else self.args,
dict(self.kwargs, **kwargs) if kwargs else self.kwargs,
new_options)
def clone(self, args=None, kwargs=None, **opts):
"""Create a copy of this signature.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
options (Dict): Partial options to be merged with
existing options.
"""
args = args if args else ()
kwargs = kwargs if kwargs else {}
# need to deepcopy options so origins links etc. is not modified.
if args or kwargs or opts:
args, kwargs, opts = self._merge(args, kwargs, opts)
else:
args, kwargs, opts = self.args, self.kwargs, self.options
signature = Signature.from_dict({'task': self.task,
'args': tuple(args),
'kwargs': kwargs,
'options': deepcopy(opts),
'subtask_type': self.subtask_type,
'immutable': self.immutable},
app=self._app)
signature._type = self._type
return signature
partial = clone
def freeze(self, _id=None, group_id=None, chord=None,
root_id=None, parent_id=None, group_index=None):
"""Finalize the signature by adding a concrete task id.
The task won't be called and you shouldn't call the signature
twice after freezing it as that'll result in two task messages
using the same task id.
The arguments are used to override the signature's headers during
freezing.
Arguments:
_id (str): Task id to use if it didn't already have one.
New UUID is generated if not provided.
group_id (str): Group id to use if it didn't already have one.
chord (Signature): Chord body when freezing a chord header.
root_id (str): Root id to use.
parent_id (str): Parent id to use.
group_index (int): Group index to use.
Returns:
~@AsyncResult: promise of future evaluation.
"""
# pylint: disable=redefined-outer-name
# XXX chord is also a class in outer scope.
opts = self.options
try:
# if there is already an id for this task, return it
tid = opts['task_id']
except KeyError:
# otherwise, use the _id sent to this function, falling back on a generated UUID
tid = opts['task_id'] = _id or uuid()
if root_id:
opts['root_id'] = root_id
if parent_id:
opts['parent_id'] = parent_id
if 'reply_to' not in opts:
# fall back on unique ID for this thread in the app
opts['reply_to'] = self.app.thread_oid
if group_id and "group_id" not in opts:
opts['group_id'] = group_id
if chord:
opts['chord'] = chord
if group_index is not None:
opts['group_index'] = group_index
# pylint: disable=too-many-function-args
# Works on this, as it's a property.
return self.AsyncResult(tid)
_freeze = freeze
def replace(self, args=None, kwargs=None, options=None):
"""Replace the args, kwargs or options set for this signature.
These are only replaced if the argument for the section is
not :const:`None`.
"""
signature = self.clone()
if args is not None:
signature.args = args
if kwargs is not None:
signature.kwargs = kwargs
if options is not None:
signature.options = options
return signature
def set(self, immutable=None, **options):
"""Set arbitrary execution options (same as ``.options.update(…)``).
Returns:
Signature: This is a chaining method call
(i.e., it will return ``self``).
"""
if immutable is not None:
self.set_immutable(immutable)
self.options.update(options)
return self
def set_immutable(self, immutable):
self.immutable = immutable
def _stamp_headers(self, visitor_headers=None, append_stamps=False, self_headers=True, **headers):
"""Collect all stamps from visitor, headers and self,
and return an idempotent dictionary of stamps.
.. versionadded:: 5.3
Arguments:
visitor_headers (Dict): Stamps from a visitor method.
append_stamps (bool):
If True, duplicated stamps will be appended to a list.
If False, duplicated stamps will be replaced by the last stamp.
self_headers (bool):
If True, stamps from self.options will be added.
If False, stamps from self.options will be ignored.
headers (Dict): Stamps that should be added to headers.
Returns:
Dict: Merged stamps.
"""
# Use append_stamps=False to prioritize visitor_headers over headers in case of duplicated stamps.
# This will lose duplicated headers from the headers argument, but that is the best effort solution
# to avoid implicitly casting the duplicated stamp into a list of both stamps from headers and
# visitor_headers of the same key.
# Example:
# headers = {"foo": "bar1"}
# visitor_headers = {"foo": "bar2"}
# _merge_dictionaries(headers, visitor_headers, aggregate_duplicates=True)
# headers["foo"] == ["bar1", "bar2"] -> The stamp is now a list
# _merge_dictionaries(headers, visitor_headers, aggregate_duplicates=False)
# headers["foo"] == "bar2" -> "bar1" is lost, but the stamp is according to the visitor
headers = headers.copy()
if "stamped_headers" not in headers:
headers["stamped_headers"] = list(headers.keys())
# Merge headers with visitor headers
if visitor_headers is not None:
visitor_headers = visitor_headers or {}
if "stamped_headers" not in visitor_headers:
visitor_headers["stamped_headers"] = list(visitor_headers.keys())
# Sync from visitor
_merge_dictionaries(headers, visitor_headers, aggregate_duplicates=append_stamps)
headers["stamped_headers"] = list(set(headers["stamped_headers"]))
# Merge headers with self.options
if self_headers:
stamped_headers = set(headers.get("stamped_headers", []))
stamped_headers.update(self.options.get("stamped_headers", []))
headers["stamped_headers"] = list(stamped_headers)
# Only merge stamps that are in stamped_headers from self.options
redacted_options = {k: v for k, v in self.options.items() if k in headers["stamped_headers"]}
# Sync from self.options
_merge_dictionaries(headers, redacted_options, aggregate_duplicates=append_stamps)
headers["stamped_headers"] = list(set(headers["stamped_headers"]))
return headers
def stamp(self, visitor=None, append_stamps=False, **headers):
"""Stamp this signature with additional custom headers.
Using a visitor will pass on responsibility for the stamping
to the visitor.
.. versionadded:: 5.3
Arguments:
visitor (StampingVisitor): Visitor API object.
append_stamps (bool):
If True, duplicated stamps will be appended to a list.
If False, duplicated stamps will be replaced by the last stamp.
headers (Dict): Stamps that should be added to headers.
"""
self.stamp_links(visitor, append_stamps, **headers)
headers = headers.copy()
visitor_headers = None
if visitor is not None:
visitor_headers = visitor.on_signature(self, **headers) or {}
headers = self._stamp_headers(visitor_headers, append_stamps, **headers)
return self.set(**headers)
def stamp_links(self, visitor, append_stamps=False, **headers):
"""Stamp this signature links (callbacks and errbacks).
Using a visitor will pass on responsibility for the stamping
to the visitor.
Arguments:
visitor (StampingVisitor): Visitor API object.
append_stamps (bool):
If True, duplicated stamps will be appended to a list.
If False, duplicated stamps will be replaced by the last stamp.
headers (Dict): Stamps that should be added to headers.
"""
non_visitor_headers = headers.copy()
# When we are stamping links, we want to avoid adding stamps from the linked signature itself
# so we turn off self_headers to stamp the link only with the visitor and the headers.
# If it's enabled, the link copies the stamps of the linked signature, and we don't want that.
self_headers = False
# Stamp all of the callbacks of this signature
headers = deepcopy(non_visitor_headers)
for link in maybe_list(self.options.get('link')) or []:
link = maybe_signature(link, app=self.app)
visitor_headers = None
if visitor is not None:
visitor_headers = visitor.on_callback(link, **headers) or {}
headers = self._stamp_headers(
visitor_headers=visitor_headers,
append_stamps=append_stamps,
self_headers=self_headers,
**headers
)
link.stamp(visitor, append_stamps, **headers)
# Stamp all of the errbacks of this signature
headers = deepcopy(non_visitor_headers)
for link in maybe_list(self.options.get('link_error')) or []:
link = maybe_signature(link, app=self.app)
visitor_headers = None
if visitor is not None:
visitor_headers = visitor.on_errback(link, **headers) or {}
headers = self._stamp_headers(
visitor_headers=visitor_headers,
append_stamps=append_stamps,
self_headers=self_headers,
**headers
)
link.stamp(visitor, append_stamps, **headers)
def _with_list_option(self, key):
"""Gets the value at the given self.options[key] as a list.
If the value is not a list, it will be converted to one and saved in self.options.
If the key does not exist, an empty list will be set and returned instead.
Arguments:
key (str): The key to get the value for.
Returns:
List: The value at the given key as a list or an empty list if the key does not exist.
"""
items = self.options.setdefault(key, [])
if not isinstance(items, MutableSequence):
items = self.options[key] = [items]
return items
def append_to_list_option(self, key, value):
"""Appends the given value to the list at the given key in self.options."""
items = self._with_list_option(key)
if value not in items:
items.append(value)
return value
def extend_list_option(self, key, value):
"""Extends the list at the given key in self.options with the given value.
If the value is not a list, it will be converted to one.
"""
items = self._with_list_option(key)
items.extend(maybe_list(value))
def link(self, callback):
"""Add callback task to be applied if this task succeeds.
Returns:
Signature: the argument passed, for chaining
or use with :func:`~functools.reduce`.
"""
return self.append_to_list_option('link', callback)
def link_error(self, errback):
"""Add callback task to be applied on error in task execution.
Returns:
Signature: the argument passed, for chaining
or use with :func:`~functools.reduce`.
"""
return self.append_to_list_option('link_error', errback)
def on_error(self, errback):
"""Version of :meth:`link_error` that supports chaining.
on_error chains the original signature, not the errback so::
>>> add.s(2, 2).on_error(errback.s()).delay()
calls the ``add`` task, not the ``errback`` task, but the
reverse is true for :meth:`link_error`.
"""
self.link_error(errback)
return self
def flatten_links(self):
"""Return a recursive list of dependencies.
"unchain" if you will, but with links intact.
"""
return list(itertools.chain.from_iterable(itertools.chain(
[[self]],
(link.flatten_links()
for link in maybe_list(self.options.get('link')) or [])
)))
def __or__(self, other):
"""Chaining operator.
Example:
>>> add.s(2, 2) | add.s(4) | add.s(8)
Returns:
chain: Constructs a :class:`~celery.canvas.chain` of the given signatures.
"""
if isinstance(other, _chain):
# task | chain -> chain
return _chain(seq_concat_seq(
(self,), other.unchain_tasks()), app=self._app)
elif isinstance(other, group):
# unroll group with one member
other = maybe_unroll_group(other)
# task | group() -> chain
return _chain(self, other, app=self.app)
elif isinstance(other, Signature):
# task | task -> chain
return _chain(self, other, app=self._app)
return NotImplemented
def __ior__(self, other):
# Python 3.9 introduces | as the merge operator for dicts.
# We override the in-place version of that operator
# so that canvases continue to work as they did before.
return self.__or__(other)
def election(self):
type = self.type
app = type.app
tid = self.options.get('task_id') or uuid()
with app.producer_or_acquire(None) as producer:
props = type.backend.on_task_call(producer, tid)
app.control.election(tid, 'task',
self.clone(task_id=tid, **props),
connection=producer.connection)
return type.AsyncResult(tid)
def reprcall(self, *args, **kwargs):
"""Return a string representation of the signature.
Merges the given arguments with the signature's arguments
only for the purpose of generating the string representation.
The signature itself is not modified.
Example:
>>> add.s(2, 2).reprcall()
'add(2, 2)'
"""
args, kwargs, _ = self._merge(args, kwargs, {}, force=True)
return reprcall(self['task'], args, kwargs)
def __deepcopy__(self, memo):
memo[id(self)] = self
return dict(self) # TODO: Potential bug of being a shallow copy
def __invert__(self):
return self.apply_async().get()
def __reduce__(self):
# for serialization, the task type is lazily loaded,
# and not stored in the dict itself.
return signature, (dict(self),)
def __json__(self):
return dict(self)
def __repr__(self):
return self.reprcall()
def items(self):
for k, v in super().items():
yield k.decode() if isinstance(k, bytes) else k, v
@property
def name(self):
# for duck typing compatibility with Task.name
return self.task
@cached_property
def type(self):
return self._type or self.app.tasks[self['task']]
@cached_property
def app(self):
return self._app or current_app
@cached_property
def AsyncResult(self):
try:
return self.type.AsyncResult
except KeyError: # task not registered
return self.app.AsyncResult
@cached_property
def _apply_async(self):
try:
return self.type.apply_async
except KeyError:
return _partial(self.app.send_task, self['task'])
id = getitem_property('options.task_id', 'Task UUID')
parent_id = getitem_property('options.parent_id', 'Task parent UUID.')
root_id = getitem_property('options.root_id', 'Task root UUID.')
task = getitem_property('task', 'Name of task.')
args = getitem_property('args', 'Positional arguments to task.')
kwargs = getitem_property('kwargs', 'Keyword arguments to task.')
options = getitem_property('options', 'Task execution options.')
subtask_type = getitem_property('subtask_type', 'Type of signature')
immutable = getitem_property(
'immutable', 'Flag set if no longer accepts new arguments')
|
(task=None, args=None, kwargs=None, options=None, type=None, subtask_type=None, immutable=False, app=None, **ex)
|
711,328
|
celery.canvas
|
__call__
|
Call the task directly (in the current process).
|
def __call__(self, *partial_args, **partial_kwargs):
"""Call the task directly (in the current process)."""
args, kwargs, _ = self._merge(partial_args, partial_kwargs, None)
return self.type(*args, **kwargs)
|
(self, *partial_args, **partial_kwargs)
|
711,329
|
celery.canvas
|
__deepcopy__
| null |
def __deepcopy__(self, memo):
memo[id(self)] = self
return dict(self) # TODO: Potential bug of being a shallow copy
|
(self, memo)
|
711,330
|
celery.canvas
|
__init__
| null |
def __init__(self, task=None, args=None, kwargs=None, options=None,
type=None, subtask_type=None, immutable=False,
app=None, **ex):
self._app = app
if isinstance(task, dict):
super().__init__(task) # works like dict(d)
else:
# Also supports using task class/instance instead of string name.
try:
task_name = task.name
except AttributeError:
task_name = task
else:
self._type = task
super().__init__(
task=task_name, args=tuple(args or ()),
kwargs=kwargs or {},
options=dict(options or {}, **ex),
subtask_type=subtask_type,
immutable=immutable,
)
|
(self, task=None, args=None, kwargs=None, options=None, type=None, subtask_type=None, immutable=False, app=None, **ex)
|
711,331
|
celery.canvas
|
__invert__
| null |
def __invert__(self):
return self.apply_async().get()
|
(self)
|
711,332
|
celery.canvas
|
__ior__
| null |
def __ior__(self, other):
# Python 3.9 introduces | as the merge operator for dicts.
# We override the in-place version of that operator
# so that canvases continue to work as they did before.
return self.__or__(other)
|
(self, other)
|
711,333
|
celery.canvas
|
__json__
| null |
def __json__(self):
return dict(self)
|
(self)
|
711,334
|
celery.canvas
|
__or__
|
Chaining operator.
Example:
>>> add.s(2, 2) | add.s(4) | add.s(8)
Returns:
chain: Constructs a :class:`~celery.canvas.chain` of the given signatures.
|
def __or__(self, other):
"""Chaining operator.
Example:
>>> add.s(2, 2) | add.s(4) | add.s(8)
Returns:
chain: Constructs a :class:`~celery.canvas.chain` of the given signatures.
"""
if isinstance(other, _chain):
# task | chain -> chain
return _chain(seq_concat_seq(
(self,), other.unchain_tasks()), app=self._app)
elif isinstance(other, group):
# unroll group with one member
other = maybe_unroll_group(other)
# task | group() -> chain
return _chain(self, other, app=self.app)
elif isinstance(other, Signature):
# task | task -> chain
return _chain(self, other, app=self._app)
return NotImplemented
|
(self, other)
|
711,335
|
celery.canvas
|
__reduce__
| null |
def __reduce__(self):
# for serialization, the task type is lazily loaded,
# and not stored in the dict itself.
return signature, (dict(self),)
|
(self)
|
711,336
|
celery.canvas
|
__repr__
| null |
def __repr__(self):
return self.reprcall()
|
(self)
|
711,337
|
celery.canvas
|
freeze
|
Finalize the signature by adding a concrete task id.
The task won't be called and you shouldn't call the signature
twice after freezing it as that'll result in two task messages
using the same task id.
The arguments are used to override the signature's headers during
freezing.
Arguments:
_id (str): Task id to use if it didn't already have one.
New UUID is generated if not provided.
group_id (str): Group id to use if it didn't already have one.
chord (Signature): Chord body when freezing a chord header.
root_id (str): Root id to use.
parent_id (str): Parent id to use.
group_index (int): Group index to use.
Returns:
~@AsyncResult: promise of future evaluation.
|
def freeze(self, _id=None, group_id=None, chord=None,
root_id=None, parent_id=None, group_index=None):
"""Finalize the signature by adding a concrete task id.
The task won't be called and you shouldn't call the signature
twice after freezing it as that'll result in two task messages
using the same task id.
The arguments are used to override the signature's headers during
freezing.
Arguments:
_id (str): Task id to use if it didn't already have one.
New UUID is generated if not provided.
group_id (str): Group id to use if it didn't already have one.
chord (Signature): Chord body when freezing a chord header.
root_id (str): Root id to use.
parent_id (str): Parent id to use.
group_index (int): Group index to use.
Returns:
~@AsyncResult: promise of future evaluation.
"""
# pylint: disable=redefined-outer-name
# XXX chord is also a class in outer scope.
opts = self.options
try:
# if there is already an id for this task, return it
tid = opts['task_id']
except KeyError:
# otherwise, use the _id sent to this function, falling back on a generated UUID
tid = opts['task_id'] = _id or uuid()
if root_id:
opts['root_id'] = root_id
if parent_id:
opts['parent_id'] = parent_id
if 'reply_to' not in opts:
# fall back on unique ID for this thread in the app
opts['reply_to'] = self.app.thread_oid
if group_id and "group_id" not in opts:
opts['group_id'] = group_id
if chord:
opts['chord'] = chord
if group_index is not None:
opts['group_index'] = group_index
# pylint: disable=too-many-function-args
# Works on this, as it's a property.
return self.AsyncResult(tid)
|
(self, _id=None, group_id=None, chord=None, root_id=None, parent_id=None, group_index=None)
|
711,338
|
celery.canvas
|
_merge
|
Merge partial args/kwargs/options with existing ones.
If the signature is immutable and ``force`` is False, the existing
args/kwargs will be returned as-is and only the options will be merged.
Stamped headers are considered immutable and will not be merged regardless.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
options (Dict): Partial options to be merged with existing options.
force (bool): If True, the args/kwargs will be merged even if the signature is
immutable. The stamped headers are not affected by this option and will not
be merged regardless.
Returns:
Tuple: (args, kwargs, options)
|
def _merge(self, args=None, kwargs=None, options=None, force=False):
"""Merge partial args/kwargs/options with existing ones.
If the signature is immutable and ``force`` is False, the existing
args/kwargs will be returned as-is and only the options will be merged.
Stamped headers are considered immutable and will not be merged regardless.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
options (Dict): Partial options to be merged with existing options.
force (bool): If True, the args/kwargs will be merged even if the signature is
immutable. The stamped headers are not affected by this option and will not
be merged regardless.
Returns:
Tuple: (args, kwargs, options)
"""
args = args if args else ()
kwargs = kwargs if kwargs else {}
if options is not None:
# We build a new options dictionary where values in `options`
# override values in `self.options` except for keys which are
# noted as being immutable (unrelated to signature immutability)
# implying that allowing their value to change would stall tasks
immutable_options = self._IMMUTABLE_OPTIONS
if "stamped_headers" in self.options:
immutable_options = self._IMMUTABLE_OPTIONS.union(set(self.options.get("stamped_headers", [])))
# merge self.options with options without overriding stamped headers from self.options
new_options = {**self.options, **{
k: v for k, v in options.items()
if k not in immutable_options or k not in self.options
}}
else:
new_options = self.options
if self.immutable and not force:
return (self.args, self.kwargs, new_options)
return (tuple(args) + tuple(self.args) if args else self.args,
dict(self.kwargs, **kwargs) if kwargs else self.kwargs,
new_options)
|
(self, args=None, kwargs=None, options=None, force=False)
|
711,339
|
celery.canvas
|
_stamp_headers
|
Collect all stamps from visitor, headers and self,
and return an idempotent dictionary of stamps.
.. versionadded:: 5.3
Arguments:
visitor_headers (Dict): Stamps from a visitor method.
append_stamps (bool):
If True, duplicated stamps will be appended to a list.
If False, duplicated stamps will be replaced by the last stamp.
self_headers (bool):
If True, stamps from self.options will be added.
If False, stamps from self.options will be ignored.
headers (Dict): Stamps that should be added to headers.
Returns:
Dict: Merged stamps.
|
def _stamp_headers(self, visitor_headers=None, append_stamps=False, self_headers=True, **headers):
"""Collect all stamps from visitor, headers and self,
and return an idempotent dictionary of stamps.
.. versionadded:: 5.3
Arguments:
visitor_headers (Dict): Stamps from a visitor method.
append_stamps (bool):
If True, duplicated stamps will be appended to a list.
If False, duplicated stamps will be replaced by the last stamp.
self_headers (bool):
If True, stamps from self.options will be added.
If False, stamps from self.options will be ignored.
headers (Dict): Stamps that should be added to headers.
Returns:
Dict: Merged stamps.
"""
# Use append_stamps=False to prioritize visitor_headers over headers in case of duplicated stamps.
# This will lose duplicated headers from the headers argument, but that is the best effort solution
# to avoid implicitly casting the duplicated stamp into a list of both stamps from headers and
# visitor_headers of the same key.
# Example:
# headers = {"foo": "bar1"}
# visitor_headers = {"foo": "bar2"}
# _merge_dictionaries(headers, visitor_headers, aggregate_duplicates=True)
# headers["foo"] == ["bar1", "bar2"] -> The stamp is now a list
# _merge_dictionaries(headers, visitor_headers, aggregate_duplicates=False)
# headers["foo"] == "bar2" -> "bar1" is lost, but the stamp is according to the visitor
headers = headers.copy()
if "stamped_headers" not in headers:
headers["stamped_headers"] = list(headers.keys())
# Merge headers with visitor headers
if visitor_headers is not None:
visitor_headers = visitor_headers or {}
if "stamped_headers" not in visitor_headers:
visitor_headers["stamped_headers"] = list(visitor_headers.keys())
# Sync from visitor
_merge_dictionaries(headers, visitor_headers, aggregate_duplicates=append_stamps)
headers["stamped_headers"] = list(set(headers["stamped_headers"]))
# Merge headers with self.options
if self_headers:
stamped_headers = set(headers.get("stamped_headers", []))
stamped_headers.update(self.options.get("stamped_headers", []))
headers["stamped_headers"] = list(stamped_headers)
# Only merge stamps that are in stamped_headers from self.options
redacted_options = {k: v for k, v in self.options.items() if k in headers["stamped_headers"]}
# Sync from self.options
_merge_dictionaries(headers, redacted_options, aggregate_duplicates=append_stamps)
headers["stamped_headers"] = list(set(headers["stamped_headers"]))
return headers
|
(self, visitor_headers=None, append_stamps=False, self_headers=True, **headers)
|
711,340
|
celery.canvas
|
_with_list_option
|
Gets the value at the given self.options[key] as a list.
If the value is not a list, it will be converted to one and saved in self.options.
If the key does not exist, an empty list will be set and returned instead.
Arguments:
key (str): The key to get the value for.
Returns:
List: The value at the given key as a list or an empty list if the key does not exist.
|
def _with_list_option(self, key):
"""Gets the value at the given self.options[key] as a list.
If the value is not a list, it will be converted to one and saved in self.options.
If the key does not exist, an empty list will be set and returned instead.
Arguments:
key (str): The key to get the value for.
Returns:
List: The value at the given key as a list or an empty list if the key does not exist.
"""
items = self.options.setdefault(key, [])
if not isinstance(items, MutableSequence):
items = self.options[key] = [items]
return items
|
(self, key)
|
711,341
|
celery.canvas
|
append_to_list_option
|
Appends the given value to the list at the given key in self.options.
|
def append_to_list_option(self, key, value):
"""Appends the given value to the list at the given key in self.options."""
items = self._with_list_option(key)
if value not in items:
items.append(value)
return value
|
(self, key, value)
|
711,342
|
celery.canvas
|
apply
|
Call task locally.
Same as :meth:`apply_async` but executed the task inline instead
of sending a task message.
|
def apply(self, args=None, kwargs=None, **options):
"""Call task locally.
Same as :meth:`apply_async` but executed the task inline instead
of sending a task message.
"""
args = args if args else ()
kwargs = kwargs if kwargs else {}
# Extra options set to None are dismissed
options = {k: v for k, v in options.items() if v is not None}
# For callbacks: extra args are prepended to the stored args.
args, kwargs, options = self._merge(args, kwargs, options)
return self.type.apply(args, kwargs, **options)
|
(self, args=None, kwargs=None, **options)
|
711,343
|
celery.canvas
|
apply_async
|
Apply this task asynchronously.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
options (Dict): Partial options to be merged
with existing options.
Returns:
~@AsyncResult: promise of future evaluation.
See also:
:meth:`~@Task.apply_async` and the :ref:`guide-calling` guide.
|
def apply_async(self, args=None, kwargs=None, route_name=None, **options):
"""Apply this task asynchronously.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
options (Dict): Partial options to be merged
with existing options.
Returns:
~@AsyncResult: promise of future evaluation.
See also:
:meth:`~@Task.apply_async` and the :ref:`guide-calling` guide.
"""
args = args if args else ()
kwargs = kwargs if kwargs else {}
# Extra options set to None are dismissed
options = {k: v for k, v in options.items() if v is not None}
try:
_apply = self._apply_async
except IndexError: # pragma: no cover
# no tasks for chain, etc to find type
return
# For callbacks: extra args are prepended to the stored args.
if args or kwargs or options:
args, kwargs, options = self._merge(args, kwargs, options)
else:
args, kwargs, options = self.args, self.kwargs, self.options
# pylint: disable=too-many-function-args
# Works on this, as it's a property
return _apply(args, kwargs, **options)
|
(self, args=None, kwargs=None, route_name=None, **options)
|
711,344
|
celery.canvas
|
clone
|
Create a copy of this signature.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
options (Dict): Partial options to be merged with
existing options.
|
def clone(self, args=None, kwargs=None, **opts):
"""Create a copy of this signature.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
options (Dict): Partial options to be merged with
existing options.
"""
args = args if args else ()
kwargs = kwargs if kwargs else {}
# need to deepcopy options so origins links etc. is not modified.
if args or kwargs or opts:
args, kwargs, opts = self._merge(args, kwargs, opts)
else:
args, kwargs, opts = self.args, self.kwargs, self.options
signature = Signature.from_dict({'task': self.task,
'args': tuple(args),
'kwargs': kwargs,
'options': deepcopy(opts),
'subtask_type': self.subtask_type,
'immutable': self.immutable},
app=self._app)
signature._type = self._type
return signature
|
(self, args=None, kwargs=None, **opts)
|
711,345
|
celery.canvas
|
delay
|
Shortcut to :meth:`apply_async` using star arguments.
|
def delay(self, *partial_args, **partial_kwargs):
"""Shortcut to :meth:`apply_async` using star arguments."""
return self.apply_async(partial_args, partial_kwargs)
|
(self, *partial_args, **partial_kwargs)
|
711,346
|
celery.canvas
|
election
| null |
def election(self):
type = self.type
app = type.app
tid = self.options.get('task_id') or uuid()
with app.producer_or_acquire(None) as producer:
props = type.backend.on_task_call(producer, tid)
app.control.election(tid, 'task',
self.clone(task_id=tid, **props),
connection=producer.connection)
return type.AsyncResult(tid)
|
(self)
|
711,347
|
celery.canvas
|
extend_list_option
|
Extends the list at the given key in self.options with the given value.
If the value is not a list, it will be converted to one.
|
def extend_list_option(self, key, value):
"""Extends the list at the given key in self.options with the given value.
If the value is not a list, it will be converted to one.
"""
items = self._with_list_option(key)
items.extend(maybe_list(value))
|
(self, key, value)
|
711,348
|
celery.canvas
|
flatten_links
|
Return a recursive list of dependencies.
"unchain" if you will, but with links intact.
|
def flatten_links(self):
"""Return a recursive list of dependencies.
"unchain" if you will, but with links intact.
"""
return list(itertools.chain.from_iterable(itertools.chain(
[[self]],
(link.flatten_links()
for link in maybe_list(self.options.get('link')) or [])
)))
|
(self)
|
711,350
|
celery.canvas
|
items
| null |
def items(self):
for k, v in super().items():
yield k.decode() if isinstance(k, bytes) else k, v
|
(self)
|
711,351
|
celery.canvas
|
link
|
Add callback task to be applied if this task succeeds.
Returns:
Signature: the argument passed, for chaining
or use with :func:`~functools.reduce`.
|
def link(self, callback):
"""Add callback task to be applied if this task succeeds.
Returns:
Signature: the argument passed, for chaining
or use with :func:`~functools.reduce`.
"""
return self.append_to_list_option('link', callback)
|
(self, callback)
|
711,352
|
celery.canvas
|
link_error
|
Add callback task to be applied on error in task execution.
Returns:
Signature: the argument passed, for chaining
or use with :func:`~functools.reduce`.
|
def link_error(self, errback):
"""Add callback task to be applied on error in task execution.
Returns:
Signature: the argument passed, for chaining
or use with :func:`~functools.reduce`.
"""
return self.append_to_list_option('link_error', errback)
|
(self, errback)
|
711,353
|
celery.canvas
|
on_error
|
Version of :meth:`link_error` that supports chaining.
on_error chains the original signature, not the errback so::
>>> add.s(2, 2).on_error(errback.s()).delay()
calls the ``add`` task, not the ``errback`` task, but the
reverse is true for :meth:`link_error`.
|
def on_error(self, errback):
"""Version of :meth:`link_error` that supports chaining.
on_error chains the original signature, not the errback so::
>>> add.s(2, 2).on_error(errback.s()).delay()
calls the ``add`` task, not the ``errback`` task, but the
reverse is true for :meth:`link_error`.
"""
self.link_error(errback)
return self
|
(self, errback)
|
711,355
|
celery.canvas
|
replace
|
Replace the args, kwargs or options set for this signature.
These are only replaced if the argument for the section is
not :const:`None`.
|
def replace(self, args=None, kwargs=None, options=None):
"""Replace the args, kwargs or options set for this signature.
These are only replaced if the argument for the section is
not :const:`None`.
"""
signature = self.clone()
if args is not None:
signature.args = args
if kwargs is not None:
signature.kwargs = kwargs
if options is not None:
signature.options = options
return signature
|
(self, args=None, kwargs=None, options=None)
|
711,356
|
celery.canvas
|
reprcall
|
Return a string representation of the signature.
Merges the given arguments with the signature's arguments
only for the purpose of generating the string representation.
The signature itself is not modified.
Example:
>>> add.s(2, 2).reprcall()
'add(2, 2)'
|
def reprcall(self, *args, **kwargs):
"""Return a string representation of the signature.
Merges the given arguments with the signature's arguments
only for the purpose of generating the string representation.
The signature itself is not modified.
Example:
>>> add.s(2, 2).reprcall()
'add(2, 2)'
"""
args, kwargs, _ = self._merge(args, kwargs, {}, force=True)
return reprcall(self['task'], args, kwargs)
|
(self, *args, **kwargs)
|
711,357
|
celery.canvas
|
set
|
Set arbitrary execution options (same as ``.options.update(…)``).
Returns:
Signature: This is a chaining method call
(i.e., it will return ``self``).
|
def set(self, immutable=None, **options):
"""Set arbitrary execution options (same as ``.options.update(…)``).
Returns:
Signature: This is a chaining method call
(i.e., it will return ``self``).
"""
if immutable is not None:
self.set_immutable(immutable)
self.options.update(options)
return self
|
(self, immutable=None, **options)
|
711,358
|
celery.canvas
|
set_immutable
| null |
def set_immutable(self, immutable):
self.immutable = immutable
|
(self, immutable)
|
711,359
|
celery.canvas
|
stamp
|
Stamp this signature with additional custom headers.
Using a visitor will pass on responsibility for the stamping
to the visitor.
.. versionadded:: 5.3
Arguments:
visitor (StampingVisitor): Visitor API object.
append_stamps (bool):
If True, duplicated stamps will be appended to a list.
If False, duplicated stamps will be replaced by the last stamp.
headers (Dict): Stamps that should be added to headers.
|
def stamp(self, visitor=None, append_stamps=False, **headers):
"""Stamp this signature with additional custom headers.
Using a visitor will pass on responsibility for the stamping
to the visitor.
.. versionadded:: 5.3
Arguments:
visitor (StampingVisitor): Visitor API object.
append_stamps (bool):
If True, duplicated stamps will be appended to a list.
If False, duplicated stamps will be replaced by the last stamp.
headers (Dict): Stamps that should be added to headers.
"""
self.stamp_links(visitor, append_stamps, **headers)
headers = headers.copy()
visitor_headers = None
if visitor is not None:
visitor_headers = visitor.on_signature(self, **headers) or {}
headers = self._stamp_headers(visitor_headers, append_stamps, **headers)
return self.set(**headers)
|
(self, visitor=None, append_stamps=False, **headers)
|
711,360
|
celery.canvas
|
stamp_links
|
Stamp this signature links (callbacks and errbacks).
Using a visitor will pass on responsibility for the stamping
to the visitor.
Arguments:
visitor (StampingVisitor): Visitor API object.
append_stamps (bool):
If True, duplicated stamps will be appended to a list.
If False, duplicated stamps will be replaced by the last stamp.
headers (Dict): Stamps that should be added to headers.
|
def stamp_links(self, visitor, append_stamps=False, **headers):
"""Stamp this signature links (callbacks and errbacks).
Using a visitor will pass on responsibility for the stamping
to the visitor.
Arguments:
visitor (StampingVisitor): Visitor API object.
append_stamps (bool):
If True, duplicated stamps will be appended to a list.
If False, duplicated stamps will be replaced by the last stamp.
headers (Dict): Stamps that should be added to headers.
"""
non_visitor_headers = headers.copy()
# When we are stamping links, we want to avoid adding stamps from the linked signature itself
# so we turn off self_headers to stamp the link only with the visitor and the headers.
# If it's enabled, the link copies the stamps of the linked signature, and we don't want that.
self_headers = False
# Stamp all of the callbacks of this signature
headers = deepcopy(non_visitor_headers)
for link in maybe_list(self.options.get('link')) or []:
link = maybe_signature(link, app=self.app)
visitor_headers = None
if visitor is not None:
visitor_headers = visitor.on_callback(link, **headers) or {}
headers = self._stamp_headers(
visitor_headers=visitor_headers,
append_stamps=append_stamps,
self_headers=self_headers,
**headers
)
link.stamp(visitor, append_stamps, **headers)
# Stamp all of the errbacks of this signature
headers = deepcopy(non_visitor_headers)
for link in maybe_list(self.options.get('link_error')) or []:
link = maybe_signature(link, app=self.app)
visitor_headers = None
if visitor is not None:
visitor_headers = visitor.on_errback(link, **headers) or {}
headers = self._stamp_headers(
visitor_headers=visitor_headers,
append_stamps=append_stamps,
self_headers=self_headers,
**headers
)
link.stamp(visitor, append_stamps, **headers)
|
(self, visitor, append_stamps=False, **headers)
|
711,397
|
celery
|
_find_option_with_arg
|
Search argv for options specifying short and longopt alternatives.
Returns:
str: value for option found
Raises:
KeyError: if option not found.
|
def _find_option_with_arg(argv, short_opts=None, long_opts=None):
"""Search argv for options specifying short and longopt alternatives.
Returns:
str: value for option found
Raises:
KeyError: if option not found.
"""
for i, arg in enumerate(argv):
if arg.startswith('-'):
if long_opts and arg.startswith('--'):
name, sep, val = arg.partition('=')
if name in long_opts:
return val if sep else argv[i + 1]
if short_opts and arg in short_opts:
return argv[i + 1]
raise KeyError('|'.join(short_opts or [] + long_opts or []))
|
(argv, short_opts=None, long_opts=None)
|
711,398
|
celery.app
|
bugreport
|
Return information useful in bug reports.
|
def bugreport(app=None):
"""Return information useful in bug reports."""
return (app or _state.get_current_app()).bugreport()
|
(app=None)
|
711,399
|
celery.canvas
|
chain
|
Chain tasks together.
Each tasks follows one another,
by being applied as a callback of the previous task.
Note:
If called with only one argument, then that argument must
be an iterable of tasks to chain: this allows us
to use generator expressions.
Example:
This is effectively :math:`((2 + 2) + 4)`:
.. code-block:: pycon
>>> res = chain(add.s(2, 2), add.s(4))()
>>> res.get()
8
Calling a chain will return the result of the last task in the chain.
You can get to the other tasks by following the ``result.parent``'s:
.. code-block:: pycon
>>> res.parent.get()
4
Using a generator expression:
.. code-block:: pycon
>>> lazy_chain = chain(add.s(i) for i in range(10))
>>> res = lazy_chain(3)
Arguments:
*tasks (Signature): List of task signatures to chain.
If only one argument is passed and that argument is
an iterable, then that'll be used as the list of signatures
to chain instead. This means that you can use a generator
expression.
Returns:
~celery.chain: A lazy signature that can be called to apply the first
task in the chain. When that task succeeds the next task in the
chain is applied, and so on.
|
class chain(_chain):
"""Chain tasks together.
Each tasks follows one another,
by being applied as a callback of the previous task.
Note:
If called with only one argument, then that argument must
be an iterable of tasks to chain: this allows us
to use generator expressions.
Example:
This is effectively :math:`((2 + 2) + 4)`:
.. code-block:: pycon
>>> res = chain(add.s(2, 2), add.s(4))()
>>> res.get()
8
Calling a chain will return the result of the last task in the chain.
You can get to the other tasks by following the ``result.parent``'s:
.. code-block:: pycon
>>> res.parent.get()
4
Using a generator expression:
.. code-block:: pycon
>>> lazy_chain = chain(add.s(i) for i in range(10))
>>> res = lazy_chain(3)
Arguments:
*tasks (Signature): List of task signatures to chain.
If only one argument is passed and that argument is
an iterable, then that'll be used as the list of signatures
to chain instead. This means that you can use a generator
expression.
Returns:
~celery.chain: A lazy signature that can be called to apply the first
task in the chain. When that task succeeds the next task in the
chain is applied, and so on.
"""
# could be function, but must be able to reference as :class:`chain`.
def __new__(cls, *tasks, **kwargs):
# This forces `chain(X, Y, Z)` to work the same way as `X | Y | Z`
if not kwargs and tasks:
if len(tasks) != 1 or is_list(tasks[0]):
tasks = tasks[0] if len(tasks) == 1 else tasks
# if is_list(tasks) and len(tasks) == 1:
# return super(chain, cls).__new__(cls, tasks, **kwargs)
new_instance = reduce(operator.or_, tasks, _chain())
if cls != chain and isinstance(new_instance, _chain) and not isinstance(new_instance, cls):
return super().__new__(cls, new_instance.tasks, **kwargs)
return new_instance
return super().__new__(cls, *tasks, **kwargs)
|
(*tasks, **kwargs)
|
711,400
|
celery.canvas
|
__call__
| null |
def __call__(self, *args, **kwargs):
if self.tasks:
return self.apply_async(args, kwargs)
|
(self, *args, **kwargs)
|
711,402
|
celery.canvas
|
__init__
| null |
def __init__(self, *tasks, **options):
tasks = (regen(tasks[0]) if len(tasks) == 1 and is_list(tasks[0])
else tasks)
super().__init__('celery.chain', (), {'tasks': tasks}, **options
)
self._use_link = options.pop('use_link', None)
self.subtask_type = 'chain'
self._frozen = None
|
(self, *tasks, **options)
|
711,406
|
celery.canvas
|
__new__
| null |
def __new__(cls, *tasks, **kwargs):
# This forces `chain(X, Y, Z)` to work the same way as `X | Y | Z`
if not kwargs and tasks:
if len(tasks) != 1 or is_list(tasks[0]):
tasks = tasks[0] if len(tasks) == 1 else tasks
# if is_list(tasks) and len(tasks) == 1:
# return super(chain, cls).__new__(cls, tasks, **kwargs)
new_instance = reduce(operator.or_, tasks, _chain())
if cls != chain and isinstance(new_instance, _chain) and not isinstance(new_instance, cls):
return super().__new__(cls, new_instance.tasks, **kwargs)
return new_instance
return super().__new__(cls, *tasks, **kwargs)
|
(cls, *tasks, **kwargs)
|
711,407
|
celery.canvas
|
__or__
| null |
def __or__(self, other):
if isinstance(other, group):
# unroll group with one member
other = maybe_unroll_group(other)
if not isinstance(other, group):
return self.__or__(other)
# chain | group() -> chain
tasks = self.unchain_tasks()
if not tasks:
# If the chain is empty, return the group
return other
if isinstance(tasks[-1], chord):
# CHAIN [last item is chord] | GROUP -> chain with chord body.
tasks[-1].body = tasks[-1].body | other
return type(self)(tasks, app=self.app)
# use type(self) for _chain subclasses
return type(self)(seq_concat_item(
tasks, other), app=self._app)
elif isinstance(other, _chain):
# chain | chain -> chain
# use type(self) for _chain subclasses
return type(self)(seq_concat_seq(
self.unchain_tasks(), other.unchain_tasks()), app=self._app)
elif isinstance(other, Signature):
if self.tasks and isinstance(self.tasks[-1], group):
# CHAIN [last item is group] | TASK -> chord
sig = self.clone()
sig.tasks[-1] = chord(
sig.tasks[-1], other, app=self._app)
# In the scenario where the second-to-last item in a chain is a chord,
# it leads to a situation where two consecutive chords are formed.
# In such cases, a further upgrade can be considered.
# This would involve chaining the body of the second-to-last chord with the last chord."
if len(sig.tasks) > 1 and isinstance(sig.tasks[-2], chord):
sig.tasks[-2].body = sig.tasks[-2].body | sig.tasks[-1]
sig.tasks = sig.tasks[:-1]
return sig
elif self.tasks and isinstance(self.tasks[-1], chord):
# CHAIN [last item is chord] -> chain with chord body.
sig = self.clone()
sig.tasks[-1].body = sig.tasks[-1].body | other
return sig
else:
# chain | task -> chain
# use type(self) for _chain subclasses
return type(self)(seq_concat_item(
self.unchain_tasks(), other), app=self._app)
else:
return NotImplemented
|
(self, other)
|
711,409
|
celery.canvas
|
__repr__
| null |
def __repr__(self):
if not self.tasks:
return f'<{type(self).__name__}@{id(self):#x}: empty>'
return remove_repeating_from_task(
self.tasks[0]['task'],
' | '.join(repr(t) for t in self.tasks))
|
(self)
|
711,415
|
celery.canvas
|
apply
| null |
def apply(self, args=None, kwargs=None, **options):
args = args if args else ()
kwargs = kwargs if kwargs else {}
last, (fargs, fkwargs) = None, (args, kwargs)
for task in self.tasks:
res = task.clone(fargs, fkwargs).apply(
last and (last.get(),), **dict(self.options, **options))
res.parent, last, (fargs, fkwargs) = last, res, (None, None)
return last
|
(self, args=None, kwargs=None, **options)
|
711,416
|
celery.canvas
|
apply_async
| null |
def apply_async(self, args=None, kwargs=None, **options):
# python is best at unpacking kwargs, so .run is here to do that.
args = args if args else ()
kwargs = kwargs if kwargs else []
app = self.app
if app.conf.task_always_eager:
with allow_join_result():
return self.apply(args, kwargs, **options)
return self.run(args, kwargs, app=app, **(
dict(self.options, **options) if options else self.options))
|
(self, args=None, kwargs=None, **options)
|
711,417
|
celery.canvas
|
clone
| null |
def clone(self, *args, **kwargs):
to_signature = maybe_signature
signature = super().clone(*args, **kwargs)
signature.kwargs['tasks'] = [
to_signature(sig, app=self._app, clone=True)
for sig in signature.kwargs['tasks']
]
return signature
|
(self, *args, **kwargs)
|
711,422
|
celery.canvas
|
freeze
| null |
def freeze(self, _id=None, group_id=None, chord=None,
root_id=None, parent_id=None, group_index=None):
# pylint: disable=redefined-outer-name
# XXX chord is also a class in outer scope.
_, results = self._frozen = self.prepare_steps(
self.args, self.kwargs, self.tasks, root_id, parent_id, None,
self.app, _id, group_id, chord, clone=False,
group_index=group_index,
)
return results[0]
|
(self, _id=None, group_id=None, chord=None, root_id=None, parent_id=None, group_index=None)
|
711,428
|
celery.canvas
|
prepare_steps
|
Prepare the chain for execution.
To execute a chain, we first need to unpack it correctly.
During the unpacking, we might encounter other chains, groups, or chords
which we need to unpack as well.
For example:
chain(signature1, chain(signature2, signature3)) --> Upgrades to chain(signature1, signature2, signature3)
chain(group(signature1, signature2), signature3) --> Upgrades to chord([signature1, signature2], signature3)
The responsibility of this method is to ensure that the chain is
correctly unpacked, and then the correct callbacks are set up along the way.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
tasks (List[Signature]): The tasks of the chain.
root_id (str): The id of the root task.
parent_id (str): The id of the parent task.
link_error (Union[List[Signature], Signature]): The error callback.
will be set for all tasks in the chain.
app (Celery): The Celery app instance.
last_task_id (str): The id of the last task in the chain.
group_id (str): The id of the group that the chain is a part of.
chord_body (Signature): The body of the chord, used to synchronize with the chain's
last task and the chord's body when used together.
clone (bool): Whether to clone the chain's tasks before modifying them.
from_dict (Callable): A function that takes a dict and returns a Signature.
Returns:
Tuple[List[Signature], List[AsyncResult]]: The frozen tasks of the chain, and the async results
|
def prepare_steps(self, args, kwargs, tasks,
root_id=None, parent_id=None, link_error=None, app=None,
last_task_id=None, group_id=None, chord_body=None,
clone=True, from_dict=Signature.from_dict,
group_index=None):
"""Prepare the chain for execution.
To execute a chain, we first need to unpack it correctly.
During the unpacking, we might encounter other chains, groups, or chords
which we need to unpack as well.
For example:
chain(signature1, chain(signature2, signature3)) --> Upgrades to chain(signature1, signature2, signature3)
chain(group(signature1, signature2), signature3) --> Upgrades to chord([signature1, signature2], signature3)
The responsibility of this method is to ensure that the chain is
correctly unpacked, and then the correct callbacks are set up along the way.
Arguments:
args (Tuple): Partial args to be prepended to the existing args.
kwargs (Dict): Partial kwargs to be merged with existing kwargs.
tasks (List[Signature]): The tasks of the chain.
root_id (str): The id of the root task.
parent_id (str): The id of the parent task.
link_error (Union[List[Signature], Signature]): The error callback.
will be set for all tasks in the chain.
app (Celery): The Celery app instance.
last_task_id (str): The id of the last task in the chain.
group_id (str): The id of the group that the chain is a part of.
chord_body (Signature): The body of the chord, used to synchronize with the chain's
last task and the chord's body when used together.
clone (bool): Whether to clone the chain's tasks before modifying them.
from_dict (Callable): A function that takes a dict and returns a Signature.
Returns:
Tuple[List[Signature], List[AsyncResult]]: The frozen tasks of the chain, and the async results
"""
app = app or self.app
# use chain message field for protocol 2 and later.
# this avoids pickle blowing the stack on the recursion
# required by linking task together in a tree structure.
# (why is pickle using recursion? or better yet why cannot python
# do tail call optimization making recursion actually useful?)
use_link = self._use_link
if use_link is None and app.conf.task_protocol == 1:
use_link = True
steps = deque(tasks)
# optimization: now the pop func is a local variable
steps_pop = steps.pop
steps_extend = steps.extend
prev_task = None
prev_res = None
tasks, results = [], []
i = 0
# NOTE: We are doing this in reverse order.
# The result is a list of tasks in reverse order, that is
# passed as the ``chain`` message field.
# As it's reversed the worker can just do ``chain.pop()`` to
# get the next task in the chain.
while steps:
task = steps_pop()
# if steps is not empty, this is the first task - reverse order
# if i = 0, this is the last task - again, because we're reversed
is_first_task, is_last_task = not steps, not i
if not isinstance(task, abstract.CallableSignature):
task = from_dict(task, app=app)
if isinstance(task, group):
# when groups are nested, they are unrolled - all tasks within
# groups should be called in parallel
task = maybe_unroll_group(task)
# first task gets partial args from chain
if clone:
if is_first_task:
task = task.clone(args, kwargs)
else:
task = task.clone()
elif is_first_task:
task.args = tuple(args) + tuple(task.args)
if isinstance(task, _chain):
# splice (unroll) the chain
steps_extend(task.tasks)
continue
# TODO why isn't this asserting is_last_task == False?
if isinstance(task, group) and prev_task:
# automatically upgrade group(...) | s to chord(group, s)
# for chords we freeze by pretending it's a normal
# signature instead of a group.
tasks.pop()
results.pop()
try:
task = chord(
task, body=prev_task,
task_id=prev_res.task_id, root_id=root_id, app=app,
)
except AttributeError:
# A GroupResult does not have a task_id since it consists
# of multiple tasks.
# We therefore, have to construct the chord without it.
# Issues #5467, #3585.
task = chord(
task, body=prev_task,
root_id=root_id, app=app,
)
if tasks:
prev_task = tasks[-1]
prev_res = results[-1]
else:
prev_task = None
prev_res = None
if is_last_task:
# chain(task_id=id) means task id is set for the last task
# in the chain. If the chord is part of a chord/group
# then that chord/group must synchronize based on the
# last task in the chain, so we only set the group_id and
# chord callback for the last task.
res = task.freeze(
last_task_id,
root_id=root_id, group_id=group_id, chord=chord_body,
group_index=group_index,
)
else:
res = task.freeze(root_id=root_id)
i += 1
if prev_task:
if use_link:
# link previous task to this task.
task.link(prev_task)
if prev_res and not prev_res.parent:
prev_res.parent = res
if link_error:
for errback in maybe_list(link_error):
task.link_error(errback)
tasks.append(task)
results.append(res)
prev_task, prev_res = task, res
if isinstance(task, chord):
app.backend.ensure_chords_allowed()
# If the task is a chord, and the body is a chain
# the chain has already been prepared, and res is
# set to the last task in the callback chain.
# We need to change that so that it points to the
# group result object.
node = res
while node.parent:
node = node.parent
prev_res = node
self.id = last_task_id
return tasks, results
|
(self, args, kwargs, tasks, root_id=None, parent_id=None, link_error=None, app=None, last_task_id=None, group_id=None, chord_body=None, clone=True, from_dict=<bound method Signature.from_dict of <class 'celery.canvas.Signature'>>, group_index=None)
|
711,431
|
celery.canvas
|
run
|
Executes the chain.
Responsible for executing the chain in the correct order.
In a case of a chain of a single task, the task is executed directly
and the result is returned for that task specifically.
|
def run(self, args=None, kwargs=None, group_id=None, chord=None,
task_id=None, link=None, link_error=None, publisher=None,
producer=None, root_id=None, parent_id=None, app=None,
group_index=None, **options):
"""Executes the chain.
Responsible for executing the chain in the correct order.
In a case of a chain of a single task, the task is executed directly
and the result is returned for that task specifically.
"""
# pylint: disable=redefined-outer-name
# XXX chord is also a class in outer scope.
args = args if args else ()
kwargs = kwargs if kwargs else []
app = app or self.app
use_link = self._use_link
if use_link is None and app.conf.task_protocol == 1:
use_link = True
args = (tuple(args) + tuple(self.args)
if args and not self.immutable else self.args)
# Unpack nested chains/groups/chords
tasks, results_from_prepare = self.prepare_steps(
args, kwargs, self.tasks, root_id, parent_id, link_error, app,
task_id, group_id, chord, group_index=group_index,
)
# For a chain of single task, execute the task directly and return the result for that task
# For a chain of multiple tasks, execute all of the tasks and return the AsyncResult for the chain
if results_from_prepare:
if link:
tasks[0].extend_list_option('link', link)
first_task = tasks.pop()
options = _prepare_chain_from_options(options, tasks, use_link)
result_from_apply = first_task.apply_async(**options)
# If we only have a single task, it may be important that we pass
# the real result object rather than the one obtained via freezing.
# e.g. For `GroupResult`s, we need to pass back the result object
# which will actually have its promise fulfilled by the subtasks,
# something that will never occur for the frozen result.
if not tasks:
return result_from_apply
else:
return results_from_prepare[0]
|
(self, args=None, kwargs=None, group_id=None, chord=None, task_id=None, link=None, link_error=None, publisher=None, producer=None, root_id=None, parent_id=None, app=None, group_index=None, **options)
|
711,434
|
celery.canvas
|
stamp
| null |
def stamp(self, visitor=None, append_stamps=False, **headers):
visitor_headers = None
if visitor is not None:
visitor_headers = visitor.on_chain_start(self, **headers) or {}
headers = self._stamp_headers(visitor_headers, append_stamps, **headers)
self.stamp_links(visitor, **headers)
for task in self.tasks:
task.stamp(visitor, append_stamps, **headers)
if visitor is not None:
visitor.on_chain_end(self, **headers)
|
(self, visitor=None, append_stamps=False, **headers)
|
711,436
|
celery.canvas
|
unchain_tasks
|
Return a list of tasks in the chain.
The tasks list would be cloned from the chain's tasks.
All of the chain callbacks would be added to the last task in the (cloned) chain.
All of the tasks would be linked to the same error callback
as the chain itself, to ensure that the correct error callback is called
if any of the (cloned) tasks of the chain fail.
|
def unchain_tasks(self):
"""Return a list of tasks in the chain.
The tasks list would be cloned from the chain's tasks.
All of the chain callbacks would be added to the last task in the (cloned) chain.
All of the tasks would be linked to the same error callback
as the chain itself, to ensure that the correct error callback is called
if any of the (cloned) tasks of the chain fail.
"""
# Clone chain's tasks assigning signatures from link_error
# to each task and adding the chain's links to the last task.
tasks = [t.clone() for t in self.tasks]
for sig in maybe_list(self.options.get('link')) or []:
tasks[-1].link(sig)
for sig in maybe_list(self.options.get('link_error')) or []:
for task in tasks:
task.link_error(sig)
return tasks
|
(self)
|
711,437
|
celery.canvas
|
_chord
|
Barrier synchronization primitive.
A chord consists of a header and a body.
The header is a group of tasks that must complete before the callback is
called. A chord is essentially a callback for a group of tasks.
The body is applied with the return values of all the header
tasks as a list.
Example:
The chord:
.. code-block:: pycon
>>> res = chord([add.s(2, 2), add.s(4, 4)])(sum_task.s())
is effectively :math:`\Sigma ((2 + 2) + (4 + 4))`:
.. code-block:: pycon
>>> res.get()
12
|
class _chord(Signature):
r"""Barrier synchronization primitive.
A chord consists of a header and a body.
The header is a group of tasks that must complete before the callback is
called. A chord is essentially a callback for a group of tasks.
The body is applied with the return values of all the header
tasks as a list.
Example:
The chord:
.. code-block:: pycon
>>> res = chord([add.s(2, 2), add.s(4, 4)])(sum_task.s())
is effectively :math:`\Sigma ((2 + 2) + (4 + 4))`:
.. code-block:: pycon
>>> res.get()
12
"""
@classmethod
def from_dict(cls, d, app=None):
"""Create a chord signature from a dictionary that represents a chord.
Example:
>>> chord_dict = {
"task": "celery.chord",
"args": [],
"kwargs": {
"kwargs": {},
"header": [
{
"task": "add",
"args": [
1,
2
],
"kwargs": {},
"options": {},
"subtask_type": None,
"immutable": False
},
{
"task": "add",
"args": [
3,
4
],
"kwargs": {},
"options": {},
"subtask_type": None,
"immutable": False
}
],
"body": {
"task": "xsum",
"args": [],
"kwargs": {},
"options": {},
"subtask_type": None,
"immutable": False
}
},
"options": {},
"subtask_type": "chord",
"immutable": False
}
>>> chord_sig = chord.from_dict(chord_dict)
Iterates over the given tasks in the dictionary and convert them to signatures.
Chord header needs to be defined in d['kwargs']['header'] as a sequence
of tasks.
Chord body needs to be defined in d['kwargs']['body'] as a single task.
The tasks themselves can be dictionaries or signatures (or both).
"""
options = d.copy()
args, options['kwargs'] = cls._unpack_args(**options['kwargs'])
return cls(*args, app=app, **options)
@staticmethod
def _unpack_args(header=None, body=None, **kwargs):
# Python signatures are better at extracting keys from dicts
# than manually popping things off.
return (header, body), kwargs
def __init__(self, header, body=None, task='celery.chord',
args=None, kwargs=None, app=None, **options):
args = args if args else ()
kwargs = kwargs if kwargs else {'kwargs': {}}
super().__init__(task, args,
{**kwargs, 'header': _maybe_group(header, app),
'body': maybe_signature(body, app=app)}, app=app, **options
)
self.subtask_type = 'chord'
def __call__(self, body=None, **options):
return self.apply_async((), {'body': body} if body else {}, **options)
def __or__(self, other):
if (not isinstance(other, (group, _chain)) and
isinstance(other, Signature)):
# chord | task -> attach to body
sig = self.clone()
sig.body = sig.body | other
return sig
elif isinstance(other, group) and len(other.tasks) == 1:
# chord | group -> chain with chord body.
# unroll group with one member
other = maybe_unroll_group(other)
sig = self.clone()
sig.body = sig.body | other
return sig
else:
return super().__or__(other)
def freeze(self, _id=None, group_id=None, chord=None,
root_id=None, parent_id=None, group_index=None):
# pylint: disable=redefined-outer-name
# XXX chord is also a class in outer scope.
if not isinstance(self.tasks, group):
self.tasks = group(self.tasks, app=self.app)
# first freeze all tasks in the header
header_result = self.tasks.freeze(
parent_id=parent_id, root_id=root_id, chord=self.body)
self.id = self.tasks.id
# secondly freeze all tasks in the body: those that should be called after the header
body_result = None
if self.body:
body_result = self.body.freeze(
_id, root_id=root_id, chord=chord, group_id=group_id,
group_index=group_index)
# we need to link the body result back to the group result,
# but the body may actually be a chain,
# so find the first result without a parent
node = body_result
seen = set()
while node:
if node.id in seen:
raise RuntimeError('Recursive result parents')
seen.add(node.id)
if node.parent is None:
node.parent = header_result
break
node = node.parent
return body_result
def stamp(self, visitor=None, append_stamps=False, **headers):
tasks = self.tasks
if isinstance(tasks, group):
tasks = tasks.tasks
visitor_headers = None
if visitor is not None:
visitor_headers = visitor.on_chord_header_start(self, **headers) or {}
headers = self._stamp_headers(visitor_headers, append_stamps, **headers)
self.stamp_links(visitor, append_stamps, **headers)
if isinstance(tasks, _regen):
tasks.map(_partial(_stamp_regen_task, visitor=visitor, append_stamps=append_stamps, **headers))
else:
stamps = headers.copy()
for task in tasks:
task.stamp(visitor, append_stamps, **stamps)
if visitor is not None:
visitor.on_chord_header_end(self, **headers)
if visitor is not None and self.body is not None:
visitor_headers = visitor.on_chord_body(self, **headers) or {}
headers = self._stamp_headers(visitor_headers, append_stamps, **headers)
self.body.stamp(visitor, append_stamps, **headers)
def apply_async(self, args=None, kwargs=None, task_id=None,
producer=None, publisher=None, connection=None,
router=None, result_cls=None, **options):
args = args if args else ()
kwargs = kwargs if kwargs else {}
args = (tuple(args) + tuple(self.args)
if args and not self.immutable else self.args)
body = kwargs.pop('body', None) or self.kwargs['body']
kwargs = dict(self.kwargs['kwargs'], **kwargs)
body = body.clone(**options)
app = self._get_app(body)
tasks = (self.tasks.clone() if isinstance(self.tasks, group)
else group(self.tasks, app=app, task_id=self.options.get('task_id', uuid())))
if app.conf.task_always_eager:
with allow_join_result():
return self.apply(args, kwargs,
body=body, task_id=task_id, **options)
merged_options = dict(self.options, **options) if options else self.options
option_task_id = merged_options.pop("task_id", None)
if task_id is None:
task_id = option_task_id
# chord([A, B, ...], C)
return self.run(tasks, body, args, task_id=task_id, kwargs=kwargs, **merged_options)
def apply(self, args=None, kwargs=None,
propagate=True, body=None, **options):
args = args if args else ()
kwargs = kwargs if kwargs else {}
body = self.body if body is None else body
tasks = (self.tasks.clone() if isinstance(self.tasks, group)
else group(self.tasks, app=self.app))
return body.apply(
args=(tasks.apply(args, kwargs).get(propagate=propagate),),
)
@classmethod
def _descend(cls, sig_obj):
"""Count the number of tasks in the given signature recursively.
Descend into the signature object and return the amount of tasks it contains.
"""
# Sometimes serialized signatures might make their way here
if not isinstance(sig_obj, Signature) and isinstance(sig_obj, dict):
sig_obj = Signature.from_dict(sig_obj)
if isinstance(sig_obj, group):
# Each task in a group counts toward this chord
subtasks = getattr(sig_obj.tasks, "tasks", sig_obj.tasks)
return sum(cls._descend(task) for task in subtasks)
elif isinstance(sig_obj, _chain):
# The last non-empty element in a chain counts toward this chord
for child_sig in sig_obj.tasks[-1::-1]:
child_size = cls._descend(child_sig)
if child_size > 0:
return child_size
# We have to just hope this chain is part of some encapsulating
# signature which is valid and can fire the chord body
return 0
elif isinstance(sig_obj, chord):
# The child chord's body counts toward this chord
return cls._descend(sig_obj.body)
elif isinstance(sig_obj, Signature):
# Each simple signature counts as 1 completion for this chord
return 1
# Any other types are assumed to be iterables of simple signatures
return len(sig_obj)
def __length_hint__(self):
"""Return the number of tasks in this chord's header (recursively)."""
tasks = getattr(self.tasks, "tasks", self.tasks)
return sum(self._descend(task) for task in tasks)
def run(self, header, body, partial_args, app=None, interval=None,
countdown=1, max_retries=None, eager=False,
task_id=None, kwargs=None, **options):
"""Execute the chord.
Executing the chord means executing the header and sending the
result to the body. In case of an empty header, the body is
executed immediately.
Arguments:
header (group): The header to execute.
body (Signature): The body to execute.
partial_args (tuple): Arguments to pass to the header.
app (Celery): The Celery app instance.
interval (float): The interval between retries.
countdown (int): The countdown between retries.
max_retries (int): The maximum number of retries.
task_id (str): The task id to use for the body.
kwargs (dict): Keyword arguments to pass to the header.
options (dict): Options to pass to the header.
Returns:
AsyncResult: The result of the body (with the result of the header in the parent of the body).
"""
app = app or self._get_app(body)
group_id = header.options.get('task_id') or uuid()
root_id = body.options.get('root_id')
options = dict(self.options, **options) if options else self.options
if options:
options.pop('task_id', None)
body.options.update(options)
bodyres = body.freeze(task_id, root_id=root_id)
# Chains should not be passed to the header tasks. See #3771
options.pop('chain', None)
# Neither should chords, for deeply nested chords to work
options.pop('chord', None)
options.pop('task_id', None)
header_result_args = header._freeze_group_tasks(group_id=group_id, chord=body, root_id=root_id)
if header.tasks:
app.backend.apply_chord(
header_result_args,
body,
interval=interval,
countdown=countdown,
max_retries=max_retries,
)
header_result = header.apply_async(partial_args, kwargs, task_id=group_id, **options)
# The execution of a chord body is normally triggered by its header's
# tasks completing. If the header is empty this will never happen, so
# we execute the body manually here.
else:
body.delay([])
header_result = self.app.GroupResult(*header_result_args)
bodyres.parent = header_result
return bodyres
def clone(self, *args, **kwargs):
signature = super().clone(*args, **kwargs)
# need to make copy of body
try:
signature.kwargs['body'] = maybe_signature(
signature.kwargs['body'], clone=True)
except (AttributeError, KeyError):
pass
return signature
def link(self, callback):
"""Links a callback to the chord body only."""
self.body.link(callback)
return callback
def link_error(self, errback):
"""Links an error callback to the chord body, and potentially the header as well.
Note:
The ``task_allow_error_cb_on_chord_header`` setting controls whether
error callbacks are allowed on the header. If this setting is
``False`` (the current default), then the error callback will only be
applied to the body.
"""
errback = maybe_signature(errback)
if self.app.conf.task_allow_error_cb_on_chord_header:
for task in maybe_list(self.tasks) or []:
task.link_error(errback.clone(immutable=True))
else:
# Once this warning is removed, the whole method needs to be refactored to:
# 1. link the error callback to each task in the header
# 2. link the error callback to the body
# 3. return the error callback
# In summary, up to 4 lines of code + updating the method docstring.
warnings.warn(
"task_allow_error_cb_on_chord_header=False is pending deprecation in "
"a future release of Celery.\n"
"Please test the new behavior by setting task_allow_error_cb_on_chord_header to True "
"and report any concerns you might have in our issue tracker before we make a final decision "
"regarding how errbacks should behave when used with chords.",
CPendingDeprecationWarning
)
self.body.link_error(errback)
return errback
def set_immutable(self, immutable):
"""Sets the immutable flag on the chord header only.
Note:
Does not affect the chord body.
Arguments:
immutable (bool): The new mutability value for chord header.
"""
for task in self.tasks:
task.set_immutable(immutable)
def __repr__(self):
if self.body:
if isinstance(self.body, _chain):
return remove_repeating_from_task(
self.body.tasks[0]['task'],
'%({} | {!r})'.format(
self.body.tasks[0].reprcall(self.tasks),
chain(self.body.tasks[1:], app=self._app),
),
)
return '%' + remove_repeating_from_task(
self.body['task'], self.body.reprcall(self.tasks))
return f'<chord without body: {self.tasks!r}>'
@cached_property
def app(self):
return self._get_app(self.body)
def _get_app(self, body=None):
app = self._app
if app is None:
try:
tasks = self.tasks.tasks # is a group
except AttributeError:
tasks = self.tasks
if tasks:
app = tasks[0]._app
if app is None and body is not None:
app = body._app
return app if app is not None else current_app
tasks = getitem_property('kwargs.header', 'Tasks in chord header.')
body = getitem_property('kwargs.body', 'Body task of chord.')
|
(header, body=None, task='celery.chord', args=None, kwargs=None, app=None, **options)
|
711,438
|
celery.canvas
|
__call__
| null |
def __call__(self, body=None, **options):
return self.apply_async((), {'body': body} if body else {}, **options)
|
(self, body=None, **options)
|
711,440
|
celery.canvas
|
__init__
| null |
def __init__(self, header, body=None, task='celery.chord',
args=None, kwargs=None, app=None, **options):
args = args if args else ()
kwargs = kwargs if kwargs else {'kwargs': {}}
super().__init__(task, args,
{**kwargs, 'header': _maybe_group(header, app),
'body': maybe_signature(body, app=app)}, app=app, **options
)
self.subtask_type = 'chord'
|
(self, header, body=None, task='celery.chord', args=None, kwargs=None, app=None, **options)
|
711,444
|
celery.canvas
|
__length_hint__
|
Return the number of tasks in this chord's header (recursively).
|
def __length_hint__(self):
"""Return the number of tasks in this chord's header (recursively)."""
tasks = getattr(self.tasks, "tasks", self.tasks)
return sum(self._descend(task) for task in tasks)
|
(self)
|
711,445
|
celery.canvas
|
__or__
| null |
def __or__(self, other):
if (not isinstance(other, (group, _chain)) and
isinstance(other, Signature)):
# chord | task -> attach to body
sig = self.clone()
sig.body = sig.body | other
return sig
elif isinstance(other, group) and len(other.tasks) == 1:
# chord | group -> chain with chord body.
# unroll group with one member
other = maybe_unroll_group(other)
sig = self.clone()
sig.body = sig.body | other
return sig
else:
return super().__or__(other)
|
(self, other)
|
711,447
|
celery.canvas
|
__repr__
| null |
def __repr__(self):
if self.body:
if isinstance(self.body, _chain):
return remove_repeating_from_task(
self.body.tasks[0]['task'],
'%({} | {!r})'.format(
self.body.tasks[0].reprcall(self.tasks),
chain(self.body.tasks[1:], app=self._app),
),
)
return '%' + remove_repeating_from_task(
self.body['task'], self.body.reprcall(self.tasks))
return f'<chord without body: {self.tasks!r}>'
|
(self)
|
711,449
|
celery.canvas
|
_get_app
| null |
def _get_app(self, body=None):
app = self._app
if app is None:
try:
tasks = self.tasks.tasks # is a group
except AttributeError:
tasks = self.tasks
if tasks:
app = tasks[0]._app
if app is None and body is not None:
app = body._app
return app if app is not None else current_app
|
(self, body=None)
|
711,452
|
celery.canvas
|
_unpack_args
| null |
@staticmethod
def _unpack_args(header=None, body=None, **kwargs):
# Python signatures are better at extracting keys from dicts
# than manually popping things off.
return (header, body), kwargs
|
(header=None, body=None, **kwargs)
|
711,455
|
celery.canvas
|
apply
| null |
def apply(self, args=None, kwargs=None,
propagate=True, body=None, **options):
args = args if args else ()
kwargs = kwargs if kwargs else {}
body = self.body if body is None else body
tasks = (self.tasks.clone() if isinstance(self.tasks, group)
else group(self.tasks, app=self.app))
return body.apply(
args=(tasks.apply(args, kwargs).get(propagate=propagate),),
)
|
(self, args=None, kwargs=None, propagate=True, body=None, **options)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.