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, 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, **options): """Send task by name. :param name: Name of task to call (e.g. `"tasks.add"`). :keyword result_cls: Specify custom result class. Default is using :meth:`AsyncResult`. Otherwise supports the same arguments as :meth:`@-Task.apply_async`. """ 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) options = router.route(options, route_name or name, args, kwargs) if root_id is None: parent, have_parent = get_current_worker_task(), True if parent: root_id = parent.request.root_id or parent.request.id if parent_id is None: if not have_parent: parent, have_parent = get_current_worker_task(), True if parent: parent_id = parent.request.id message = amqp.create_task_message( task_id, name, args, kwargs, countdown, eta, group_id, expires, retries, chord, maybe_list(link), maybe_list(link_error), reply_to or self.oid, time_limit, soft_time_limit, self.conf.task_send_sent_event, root_id, parent_id, shadow, chain, ) if connection: producer = amqp.Producer(connection) with self.producer_or_acquire(producer) as P: self.backend.on_task_call(P, task_id) amqp.send_task_message(P, name, message, **options) result = (result_cls or self.AsyncResult)(task_id) if add_to_parent: if not have_parent: parent, have_parent = get_current_worker_task(), True if parent: parent.add_trail(result) return result
def apply_async(self, args=(), kwargs=None, add_to_parent=True, producer=None, **options): app = self.app if app.conf.task_always_eager: return self.apply(args, kwargs, **options) if not self.tasks: return self.freeze() options, group_id, root_id = self._freeze_gid(options) tasks = self._prepared(self.tasks, args, group_id, root_id, app) result = self.app.GroupResult( group_id, list(self._apply_tasks(tasks, producer, app, **options)), ) # - Special case of group(A.s() | group(B.s(), C.s())) # That is, group with single item that is a chain but the # last task in that chain is a group. # # We cannot actually support arbitrary GroupResults in chains, # but this special case we can. if len(result) == 1 and isinstance(result[0], GroupResult): result = result[0] parent_task = get_current_worker_task() if add_to_parent and parent_task: parent_task.add_trail(result) return result
def current_worker_task(self): """The task currently being executed by a worker or :const:`None`. Differs from :data:`current_task` in that it's not affected by tasks calling other tasks directly, or eagerly. """ return get_current_worker_task()
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, reply_to=None, **options): task_id = task_id or uuid() producer = producer or publisher # XXX compat router = router or self.amqp.router conf = self.conf if conf.CELERY_ALWAYS_EAGER: # pragma: no cover warnings.warn(AlwaysEagerIgnored( 'CELERY_ALWAYS_EAGER has no effect on send_task', ), stacklevel=2) options = router.route(options, name, args, kwargs) if connection: producer = self.amqp.TaskProducer(connection) with self.producer_or_acquire(producer) as P: self.backend.on_task_call(P, task_id) task_id = P.publish_task( name, args, kwargs, countdown=countdown, eta=eta, task_id=task_id, expires=expires, callbacks=maybe_list(link), errbacks=maybe_list(link_error), reply_to=reply_to or self.oid, **options ) result = (result_cls or self.AsyncResult)(task_id) if add_to_parent: parent = get_current_worker_task() if parent: parent.add_trail(result) return result
def run(self, tasks, result, group_id, partial_args, add_to_parent=True): app = self.app result = result_from_tuple(result, app) # any partial args are added to all tasks in the group taskit = (signature(task, app=app).clone(partial_args) for i, task in enumerate(tasks)) if self.request.is_eager or app.conf.CELERY_ALWAYS_EAGER: return app.GroupResult( result.id, [stask.apply(group_id=group_id) for stask in taskit], ) with app.producer_or_acquire() as pub: [ stask.apply_async(group_id=group_id, producer=pub, add_to_parent=False) for stask in taskit ] parent = get_current_worker_task() if add_to_parent and parent: parent.add_trail(result) return result
def group(self, tasks, result, group_id, partial_args, add_to_parent=True): app = self.app result = result_from_tuple(result, app) # any partial args are added to all tasks in the group taskit = (maybe_signature(task, app=app).clone(partial_args) for i, task in enumerate(tasks)) with app.producer_or_acquire() as producer: [stask.apply_async(group_id=group_id, producer=producer, add_to_parent=False) for stask in taskit] parent = get_current_worker_task() if add_to_parent and parent: parent.add_trail(result) return result
def run(self, tasks, result, group_id, partial_args, add_to_parent=True): app = self.app result = result_from_tuple(result, app) # any partial args are added to all tasks in the group taskit = (signature(task, app=app).clone(partial_args) for i, task in enumerate(tasks)) if self.request.is_eager or app.conf.CELERY_ALWAYS_EAGER: return app.GroupResult(result.id, [stask.apply(group_id=group_id) for stask in taskit]) with app.producer_or_acquire() as pub: [stask.apply_async(group_id=group_id, producer=pub, add_to_parent=False) for stask in taskit] parent = get_current_worker_task() if add_to_parent and parent: parent.add_trail(result) return result
def run(self, tasks, result, group_id, partial_args): app = self.app result = from_serializable(result, app) # any partial args are added to all tasks in the group taskit = (subtask(task).clone(partial_args) for i, task in enumerate(tasks)) if self.request.is_eager or app.conf.CELERY_ALWAYS_EAGER: return app.GroupResult(result.id, [stask.apply(group_id=group_id) for stask in taskit]) with app.producer_or_acquire() as pub: [stask.apply_async(group_id=group_id, publisher=pub, add_to_parent=False) for stask in taskit] parent = get_current_worker_task() if parent: parent.request.children.append(result) return result
def apply_async(self, args=(), kwargs=None, add_to_parent=True, producer=None, **options): app = self.app if app.conf.CELERY_ALWAYS_EAGER: return self.apply(args, kwargs, **options) if not self.tasks: return self.freeze() options, group_id, root_id = self._freeze_gid(options) tasks = self._prepared(self.tasks, args, group_id, root_id) result = self.app.GroupResult(group_id, list(self._apply_tasks(tasks, producer, app, **options))) parent_task = get_current_worker_task() if add_to_parent and parent_task: parent_task.add_trail(result) return result
def run(self, tasks, result, group_id): app = self.app result = from_serializable(result) if self.request.is_eager or app.conf.CELERY_ALWAYS_EAGER: return app.GroupResult(result.id, [subtask(task).apply(group_id=group_id) for task in tasks]) with app.default_producer() as pub: [subtask(task).apply_async(group_id=group_id, publisher=pub, add_to_parent=False) for task in tasks] parent = get_current_worker_task() if parent: parent.request.children.append(result) return result
def run(self, tasks, result, group_id, partial_args): app = self.app result = from_serializable(result) # any partial args are added to all tasks in the group taskit = (subtask(task).clone(partial_args) for i, task in enumerate(tasks)) if self.request.is_eager or app.conf.CELERY_ALWAYS_EAGER: return app.GroupResult(result.id, [task.apply(group_id=group_id) for task in taskit]) with app.producer_or_acquire() as pub: [task.apply_async(group_id=group_id, publisher=pub, add_to_parent=False) for task in taskit] parent = get_current_worker_task() if parent: parent.request.children.append(result) return result
def apply_async(self, connection=None, publisher=None, taskset_id=None): """Apply TaskSet.""" app = self.app if app.conf.CELERY_ALWAYS_EAGER: return self.apply(taskset_id=taskset_id) with app.connection_or_acquire(connection) as conn: setid = taskset_id or uuid() pub = publisher or self.Publisher(conn) results = self._async_results(setid, pub) result = app.TaskSetResult(setid, results) parent = get_current_worker_task() if parent: parent.add_trail(result) return result
def apply_async(self, connection=None, connect_timeout=None, publisher=None, taskset_id=None): """Apply TaskSet.""" app = self.app if app.conf.CELERY_ALWAYS_EAGER: return self.apply(taskset_id=taskset_id) with app.default_connection(connection, connect_timeout) as conn: setid = taskset_id or uuid() pub = publisher or self.Publisher(conn) results = self._async_results(setid, pub) result = app.TaskSetResult(setid, results) parent = get_current_worker_task() if parent: parent.request.children.append(result) return result
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, 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, **options): 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.CELERY_ALWAYS_EAGER: # pragma: no cover warnings.warn(AlwaysEagerIgnored( 'CELERY_ALWAYS_EAGER has no effect on send_task', ), stacklevel=2) options = router.route(options, route_name or name, args, kwargs) message = amqp.create_task_message( task_id, name, args, kwargs, countdown, eta, group_id, expires, retries, chord, maybe_list(link), maybe_list(link_error), reply_to or self.oid, time_limit, soft_time_limit, self.conf.CELERY_SEND_TASK_SENT_EVENT, root_id, parent_id, shadow, ) if connection: producer = amqp.Producer(connection) with self.producer_or_acquire(producer) as P: self.backend.on_task_call(P, task_id) amqp.send_task_message(P, name, message, **options) result = (result_cls or self.AsyncResult)(task_id) if add_to_parent: parent = get_current_worker_task() if parent: parent.add_trail(result) return result
def apply_async(self, args=(), kwargs=None, add_to_parent=True, producer=None, **options): app = self.app if app.conf.CELERY_ALWAYS_EAGER: return self.apply(args, kwargs, **options) if not self.tasks: return self.freeze() options, group_id, root_id = self._freeze_gid(options) tasks = self._prepared(self.tasks, args, group_id, root_id) result = self.app.GroupResult( group_id, list(self._apply_tasks(tasks, producer, app, **options)), ) parent_task = get_current_worker_task() if add_to_parent and parent_task: parent_task.add_trail(result) return result
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, retries=0, chord=None, reply_to=None, time_limit=None, soft_time_limit=None, root_id=None, parent_id=None, **options): 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.CELERY_ALWAYS_EAGER: # pragma: no cover warnings.warn(AlwaysEagerIgnored( 'CELERY_ALWAYS_EAGER has no effect on send_task', ), stacklevel=2) options = router.route(options, name, args, kwargs) message = amqp.create_task_message( task_id, name, args, kwargs, countdown, eta, group_id, expires, retries, chord, maybe_list(link), maybe_list(link_error), reply_to or self.oid, time_limit, soft_time_limit, self.conf.CELERY_SEND_TASK_SENT_EVENT, root_id, parent_id, ) if connection: producer = amqp.Producer(connection) with self.producer_or_acquire(producer) as P: self.backend.on_task_call(P, task_id) amqp.send_task_message(P, name, message, **options) result = (result_cls or self.AsyncResult)(task_id) if add_to_parent: parent = get_current_worker_task() if parent: parent.add_trail(result) return result
def apply_async(self, args=None, kwargs=None, task_id=None, producer=None, connection=None, router=None, link=None, link_error=None, publisher=None, add_to_parent=True, **options): """Apply tasks asynchronously by sending a message. :keyword args: The positional arguments to pass on to the task (a :class:`list` or :class:`tuple`). :keyword kwargs: The keyword arguments to pass on to the task (a :class:`dict`) :keyword countdown: Number of seconds into the future that the task should execute. Defaults to immediate execution (do not confuse with the `immediate` flag, as they are unrelated). :keyword eta: A :class:`~datetime.datetime` object describing the absolute time and date of when the task should be executed. May not be specified if `countdown` is also supplied. (Do not confuse this with the `immediate` flag, as they are unrelated). :keyword expires: Either a :class:`int`, describing the number of seconds, or a :class:`~datetime.datetime` object that describes the absolute time and date of when the task should expire. The task will not be executed after the expiration time. :keyword connection: Re-use existing broker connection instead of establishing a new one. :keyword retry: If enabled sending of the task message will be retried in the event of connection loss or failure. Default is taken from the :setting:`CELERY_TASK_PUBLISH_RETRY` setting. Note you need to handle the producer/connection manually for this to work. :keyword retry_policy: Override the retry policy used. See the :setting:`CELERY_TASK_PUBLISH_RETRY` setting. :keyword routing_key: Custom routing key used to route the task to a worker server. If in combination with a ``queue`` argument only used to specify custom routing keys to topic exchanges. :keyword queue: The queue to route the task to. This must be a key present in :setting:`CELERY_QUEUES`, or :setting:`CELERY_CREATE_MISSING_QUEUES` must be enabled. See :ref:`guide-routing` for more information. :keyword exchange: Named custom exchange to send the task to. Usually not used in combination with the ``queue`` argument. :keyword priority: The task priority, a number between 0 and 9. Defaults to the :attr:`priority` attribute. :keyword serializer: A string identifying the default serialization method to use. Can be `pickle`, `json`, `yaml`, `msgpack` or any custom serialization method that has been registered with :mod:`kombu.serialization.registry`. Defaults to the :attr:`serializer` attribute. :keyword compression: A string identifying the compression method to use. Can be one of ``zlib``, ``bzip2``, or any custom compression methods registered with :func:`kombu.compression.register`. Defaults to the :setting:`CELERY_MESSAGE_COMPRESSION` setting. :keyword link: A single, or a list of subtasks to apply if the task exits successfully. :keyword link_error: A single, or a list of subtasks to apply if an error occurs while executing the task. :keyword producer: :class:[email protected]` instance to use. :keyword add_to_parent: If set to True (default) and the task is applied while executing another task, then the result will be appended to the parent tasks ``request.children`` attribute. :keyword publisher: Deprecated alias to ``producer``. Also supports all keyword arguments supported by :meth:`kombu.messaging.Producer.publish`. .. note:: If the :setting:`CELERY_ALWAYS_EAGER` setting is set, it will be replaced by a local :func:`apply` call instead. """ producer = producer or publisher app = self._get_app() router = router or self.app.amqp.router conf = app.conf # add 'self' if this is a bound method. if self.__self__ is not None: args = (self.__self__, ) + tuple(args) if conf.CELERY_ALWAYS_EAGER: return self.apply(args, kwargs, task_id=task_id, link=link, link_error=link_error, **options) options = dict(extract_exec_options(self), **options) options = router.route(options, self.name, args, kwargs) if connection: producer = app.amqp.TaskProducer(connection) with app.producer_or_acquire(producer) as P: task_id = P.publish_task(self.name, args, kwargs, task_id=task_id, callbacks=maybe_list(link), errbacks=maybe_list(link_error), **options) result = self.AsyncResult(task_id) if add_to_parent: parent = get_current_worker_task() if parent: parent.request.children.append(result) return result
def apply_async(self, args=None, kwargs=None, task_id=None, producer=None, connection=None, router=None, link=None, link_error=None, publisher=None, add_to_parent=True, **options): """Apply tasks asynchronously by sending a message. :keyword args: The positional arguments to pass on to the task (a :class:`list` or :class:`tuple`). :keyword kwargs: The keyword arguments to pass on to the task (a :class:`dict`) :keyword countdown: Number of seconds into the future that the task should execute. Defaults to immediate execution (do not confuse with the `immediate` flag, as they are unrelated). :keyword eta: A :class:`~datetime.datetime` object describing the absolute time and date of when the task should be executed. May not be specified if `countdown` is also supplied. (Do not confuse this with the `immediate` flag, as they are unrelated). :keyword expires: Either a :class:`int`, describing the number of seconds, or a :class:`~datetime.datetime` object that describes the absolute time and date of when the task should expire. The task will not be executed after the expiration time. :keyword connection: Re-use existing broker connection instead of establishing a new one. :keyword retry: If enabled sending of the task message will be retried in the event of connection loss or failure. Default is taken from the :setting:`CELERY_TASK_PUBLISH_RETRY` setting. Note you need to handle the producer/connection manually for this to work. :keyword retry_policy: Override the retry policy used. See the :setting:`CELERY_TASK_PUBLISH_RETRY` setting. :keyword routing_key: The routing key used to route the task to a worker server. Defaults to the :attr:`routing_key` attribute. :keyword exchange: The named exchange to send the task to. Defaults to the :attr:`exchange` attribute. :keyword exchange_type: The exchange type to initialize the exchange if not already declared. Defaults to the :attr:`exchange_type` attribute. :keyword immediate: Request immediate delivery. Will raise an exception if the task cannot be routed to a worker immediately. (Do not confuse this parameter with the `countdown` and `eta` settings, as they are unrelated). Defaults to the :attr:`immediate` attribute. :keyword mandatory: Mandatory routing. Raises an exception if there's no running workers able to take on this task. Defaults to the :attr:`mandatory` attribute. :keyword priority: The task priority, a number between 0 and 9. Defaults to the :attr:`priority` attribute. :keyword serializer: A string identifying the default serialization method to use. Can be `pickle`, `json`, `yaml`, `msgpack` or any custom serialization method that has been registered with :mod:`kombu.serialization.registry`. Defaults to the :attr:`serializer` attribute. :keyword compression: A string identifying the compression method to use. Can be one of ``zlib``, ``bzip2``, or any custom compression methods registered with :func:`kombu.compression.register`. Defaults to the :setting:`CELERY_MESSAGE_COMPRESSION` setting. :keyword link: A single, or a list of subtasks to apply if the task exits successfully. :keyword link_error: A single, or a list of subtasks to apply if an error occurs while executing the task. :keyword producer: :class:[email protected]` instance to use. :keyword add_to_parent: If set to True (default) and the task is applied while executing another task, then the result will be appended to the parent tasks ``request.children`` attribute. :keyword publisher: Deprecated alias to ``producer``. .. note:: If the :setting:`CELERY_ALWAYS_EAGER` setting is set, it will be replaced by a local :func:`apply` call instead. """ producer = producer or publisher app = self._get_app() router = router or self.app.amqp.router conf = app.conf # add 'self' if this is a bound method. if self.__self__ is not None: args = (self.__self__, ) + tuple(args) if conf.CELERY_ALWAYS_EAGER: return self.apply(args, kwargs, task_id=task_id, **options) options = dict(extract_exec_options(self), **options) options = router.route(options, self.name, args, kwargs) if connection: producer = app.amqp.TaskProducer(connection) with app.producer_or_acquire(producer) as P: evd = None if conf.CELERY_SEND_TASK_SENT_EVENT: evd = app.events.Dispatcher(channel=P.channel, buffer_while_offline=False) task_id = P.publish_task(self.name, args, kwargs, task_id=task_id, event_dispatcher=evd, callbacks=maybe_list(link), errbacks=maybe_list(link_error), **options) result = self.AsyncResult(task_id) if add_to_parent: parent = get_current_worker_task() if parent: parent.request.children.append(result) return result
def current_worker_task(self): return get_current_worker_task()
def apply_async(self, args=None, kwargs=None, task_id=None, producer=None, connection=None, router=None, link=None, link_error=None, publisher=None, add_to_parent=True, **options): """Apply tasks asynchronously by sending a message. :keyword args: The positional arguments to pass on to the task (a :class:`list` or :class:`tuple`). :keyword kwargs: The keyword arguments to pass on to the task (a :class:`dict`) :keyword countdown: Number of seconds into the future that the task should execute. Defaults to immediate execution (do not confuse with the `immediate` flag, as they are unrelated). :keyword eta: A :class:`~datetime.datetime` object describing the absolute time and date of when the task should be executed. May not be specified if `countdown` is also supplied. (Do not confuse this with the `immediate` flag, as they are unrelated). :keyword expires: Either a :class:`int`, describing the number of seconds, or a :class:`~datetime.datetime` object that describes the absolute time and date of when the task should expire. The task will not be executed after the expiration time. :keyword connection: Re-use existing broker connection instead of establishing a new one. :keyword retry: If enabled sending of the task message will be retried in the event of connection loss or failure. Default is taken from the :setting:`CELERY_TASK_PUBLISH_RETRY` setting. Note you need to handle the producer/connection manually for this to work. :keyword retry_policy: Override the retry policy used. See the :setting:`CELERY_TASK_PUBLISH_RETRY` setting. :keyword routing_key: The routing key used to route the task to a worker server. Defaults to the :attr:`routing_key` attribute. :keyword exchange: The named exchange to send the task to. Defaults to the :attr:`exchange` attribute. :keyword exchange_type: The exchange type to initialize the exchange if not already declared. Defaults to the :attr:`exchange_type` attribute. :keyword immediate: Request immediate delivery. Will raise an exception if the task cannot be routed to a worker immediately. (Do not confuse this parameter with the `countdown` and `eta` settings, as they are unrelated). Defaults to the :attr:`immediate` attribute. :keyword mandatory: Mandatory routing. Raises an exception if there's no running workers able to take on this task. Defaults to the :attr:`mandatory` attribute. :keyword priority: The task priority, a number between 0 and 9. Defaults to the :attr:`priority` attribute. :keyword serializer: A string identifying the default serialization method to use. Can be `pickle`, `json`, `yaml`, `msgpack` or any custom serialization method that has been registered with :mod:`kombu.serialization.registry`. Defaults to the :attr:`serializer` attribute. :keyword compression: A string identifying the compression method to use. Can be one of ``zlib``, ``bzip2``, or any custom compression methods registered with :func:`kombu.compression.register`. Defaults to the :setting:`CELERY_MESSAGE_COMPRESSION` setting. :keyword link: A single, or a list of subtasks to apply if the task exits successfully. :keyword link_error: A single, or a list of subtasks to apply if an error occurs while executing the task. :keyword producer: :class:[email protected]` instance to use. :keyword add_to_parent: If set to True (default) and the task is applied while executing another task, then the result will be appended to the parent tasks ``request.children`` attribute. :keyword publisher: Deprecated alias to ``producer``. .. note:: If the :setting:`CELERY_ALWAYS_EAGER` setting is set, it will be replaced by a local :func:`apply` call instead. """ producer = producer or publisher app = self._get_app() router = router or self.app.amqp.router conf = app.conf # add 'self' if this is a bound method. if self.__self__ is not None: args = (self.__self__, ) + tuple(args) if conf.CELERY_ALWAYS_EAGER: return self.apply(args, kwargs, task_id=task_id, **options) options = dict(extract_exec_options(self), **options) options = router.route(options, self.name, args, kwargs) if connection: producer = app.amqp.TaskProducer(connection) with app.default_producer(producer) as P: evd = None if conf.CELERY_SEND_TASK_SENT_EVENT: evd = app.events.Dispatcher(channel=P.channel, buffer_while_offline=False) task_id = P.publish_task(self.name, args, kwargs, task_id=task_id, event_dispatcher=evd, callbacks=maybe_list(link), errbacks=maybe_list(link_error), **options) result = self.AsyncResult(task_id) if add_to_parent: parent = get_current_worker_task() if parent: parent.request.children.append(result) return result
def apply_async(self, args=None, kwargs=None, task_id=None, producer=None, connection=None, router=None, link=None, link_error=None, publisher=None, add_to_parent=True, **options): """Apply tasks asynchronously by sending a message. :keyword args: The positional arguments to pass on to the task (a :class:`list` or :class:`tuple`). :keyword kwargs: The keyword arguments to pass on to the task (a :class:`dict`) :keyword countdown: Number of seconds into the future that the task should execute. Defaults to immediate execution (do not confuse with the `immediate` flag, as they are unrelated). :keyword eta: A :class:`~datetime.datetime` object describing the absolute time and date of when the task should be executed. May not be specified if `countdown` is also supplied. (Do not confuse this with the `immediate` flag, as they are unrelated). :keyword expires: Either a :class:`int`, describing the number of seconds, or a :class:`~datetime.datetime` object that describes the absolute time and date of when the task should expire. The task will not be executed after the expiration time. :keyword connection: Re-use existing broker connection instead of establishing a new one. :keyword retry: If enabled sending of the task message will be retried in the event of connection loss or failure. Default is taken from the :setting:`CELERY_TASK_PUBLISH_RETRY` setting. Note you need to handle the producer/connection manually for this to work. :keyword retry_policy: Override the retry policy used. See the :setting:`CELERY_TASK_PUBLISH_RETRY` setting. :keyword routing_key: Custom routing key used to route the task to a worker server. If in combination with a ``queue`` argument only used to specify custom routing keys to topic exchanges. :keyword queue: The queue to route the task to. This must be a key present in :setting:`CELERY_QUEUES`, or :setting:`CELERY_CREATE_MISSING_QUEUES` must be enabled. See :ref:`guide-routing` for more information. :keyword exchange: Named custom exchange to send the task to. Usually not used in combination with the ``queue`` argument. :keyword priority: The task priority, a number between 0 and 9. Defaults to the :attr:`priority` attribute. :keyword serializer: A string identifying the default serialization method to use. Can be `pickle`, `json`, `yaml`, `msgpack` or any custom serialization method that has been registered with :mod:`kombu.serialization.registry`. Defaults to the :attr:`serializer` attribute. :keyword compression: A string identifying the compression method to use. Can be one of ``zlib``, ``bzip2``, or any custom compression methods registered with :func:`kombu.compression.register`. Defaults to the :setting:`CELERY_MESSAGE_COMPRESSION` setting. :keyword link: A single, or a list of subtasks to apply if the task exits successfully. :keyword link_error: A single, or a list of subtasks to apply if an error occurs while executing the task. :keyword producer: :class:[email protected]` instance to use. :keyword add_to_parent: If set to True (default) and the task is applied while executing another task, then the result will be appended to the parent tasks ``request.children`` attribute. :keyword publisher: Deprecated alias to ``producer``. Also supports all keyword arguments supported by :meth:`kombu.messaging.Producer.publish`. .. note:: If the :setting:`CELERY_ALWAYS_EAGER` setting is set, it will be replaced by a local :func:`apply` call instead. """ producer = producer or publisher app = self._get_app() router = router or self.app.amqp.router conf = app.conf if conf.CELERY_ALWAYS_EAGER: return self.apply(args, kwargs, task_id=task_id, link=link, link_error=link_error, **options) # add 'self' if this is a bound method. if self.__self__ is not None: args = (self.__self__, ) + tuple(args) options = dict(extract_exec_options(self), **options) options = router.route(options, self.name, args, kwargs) if connection: producer = app.amqp.TaskProducer(connection) with app.producer_or_acquire(producer) as P: task_id = P.publish_task(self.name, args, kwargs, task_id=task_id, callbacks=maybe_list(link), errbacks=maybe_list(link_error), **options) result = self.AsyncResult(task_id) if add_to_parent: parent = get_current_worker_task() if parent: parent.request.children.append(result) return result