class odoo.addons.queue_job.models.base.Base(pool, cr)[source]

Bases: odoo.models.BaseModel

The base model, which is implicitly inherited by all models.

with_delay(priority=None, eta=None, max_retries=None, description=None, channel=None, identity_key=None)[source]

Return a DelayableRecordset

The returned instance allow to enqueue any method of the recordset’s Model which is decorated by job().


self.env['res.users'].with_delay().write({'name': 'test'})

In the line above, in so far write is allowed to be delayed with @job, the write will be executed in an asynchronous job.

  • priority – Priority of the job, 0 being the higher priority. Default is 10.
  • eta – Estimated Time of Arrival of the job. It will not be executed before this date/time.
  • max_retries – maximum number of retries before giving up and set the job state to ‘failed’. A value of 0 means infinite retries. Default is 5.
  • description – human description of the job. If None, description is computed from the function doc or name
  • channel – the complete name of the channel to use to process the function. If specified it overrides the one defined on the function
  • identity_key – key uniquely identifying the job, if specified and a job with the same key has not yet been run, the new job will not be added.

instance of a DelayableRecordset

Return type:


Note for developers: if you want to run tests or simply disable jobs queueing for debugging purposes, you can:

  1. set the env var TEST_QUEUE_JOB_NO_DELAY=1
  2. pass a ctx key test_queue_job_no_delay=1

In tests you’ll have to mute the logger like:

class odoo.addons.queue_job.models.queue_job.QueueJob(pool, cr)[source]

Job status and result

_name = 'queue.job'
_inherit = ['mail.thread', 'ir.needaction_mixin']



odoo.addons.queue_job.job.job(func=None, default_channel='root', retry_pattern=None)[source]

Decorator for jobs.

Optional argument:

  • default_channel – the channel wherein the job will be assigned. This channel is set at the installation of the module and can be manually changed later using the views.
  • retry_pattern (dict(retry_count,retry_eta_seconds)) – The retry pattern to use for postponing a job. If a job is postponed and there is no eta specified, the eta will be determined from the dict in retry_pattern. When no retry pattern is provided, jobs will be retried after RETRY_INTERVAL seconds.

Indicates that a method of a Model can be delayed in the Job Queue.

When a method has the @job decorator, its calls can then be delayed with:

recordset.with_delay(priority=10).the_method(args, **kwargs)

Where the_method is the method decorated with @job. Its arguments and keyword arguments will be kept in the Job Queue for its asynchronous execution.

default_channel indicates in which channel the job must be executed

retry_pattern is a dict where keys are the count of retries and the values are the delay to postpone a job.


class ProductProduct(models.Model):
    _inherit = 'product.product'

    def export_one_thing(self, one_thing):
        # work
        # export one_thing

# [...]

# => normal and synchronous function call

# => the job will be executed as soon as possible

delayable = env['a.model'].with_delay(priority=30, eta=60*60*5)
# => the job will be executed with a low priority and not before a
# delay of 5 hours from now

def export_one_thing(one_thing):
    # work
    # export one_thing

@job(retry_pattern={1: 10 * 60,
                    5: 20 * 60,
                    10: 30 * 60,
                    15: 12 * 60 * 60})
def retryable_example():
    # 5 first retries postponed 10 minutes later
    # retries 5 to 10 postponed 20 minutes later
    # retries 10 to 15 postponed 30 minutes later
    # all subsequent retries postponed 12 hours later
    raise RetryableJobError('Must be retried later')


See also: related_action() a related action can be attached to a job

odoo.addons.queue_job.job.related_action(action=None, **kwargs)[source]

Attach a Related Action to a job.

A Related Action will appear as a button on the Odoo view. The button will execute the action, usually it will open the form view of the record related to the job.

The action must be a method on the queue.job model.

Example usage:

class QueueJob(models.Model):
    _inherit = 'queue.job'

    def related_action_partner(self):
        model = self.model_name
        partner = self.env[model].browse(self.record_ids)
        # possibly get the real ID if partner_id is a binding ID
        action = {
            'name': _("Partner"),
            'type': 'ir.actions.act_window',
            'res_model': model,
            'view_type': 'form',
            'view_mode': 'form',
            'res_id': partner.id,
        return action

class ResPartner(models.Model):
    _inherit = 'res.partner'

    def export_partner(self):
        # ...

The kwargs are transmitted to the action:

class QueueJob(models.Model):
    _inherit = 'queue.job'

    def related_action_product(self, extra_arg=1):
        assert extra_arg == 2
        model = self.model_name

class ProductProduct(models.Model):
    _inherit = 'product.product'

    @related_action(action='related_action_product', extra_arg=2)
    def export_product(self):
        # ...


class odoo.addons.queue_job.job.DelayableRecordset(recordset, priority=None, eta=None, max_retries=None, description=None, channel=None, identity_key=None)[source]

Bases: object

Allow to delay a method for a recordset


delayable = DelayableRecordset(recordset, priority=20)
delayable.method(args, kwargs)

method must be a method of the recordset’s Model, decorated with job().

The method call will be processed asynchronously in the job queue, with the passed arguments.

class odoo.addons.queue_job.job.Job(func, args=None, kwargs=None, priority=None, eta=None, job_uuid=None, max_retries=None, description=None, channel=None, identity_key=None)[source]

Bases: object

A Job is a task to execute.


Id (UUID) of the job.


State of the job, can pending, enqueued, started, done or failed. The start state is pending and the final state is done.


The current try, starts at 0 and each time the job is executed, it increases by 1.


The maximum number of retries allowed before the job is considered as failed.


Arguments passed to the function when executed.


Keyword arguments passed to the function when executed.


Human description of the job.


The python function itself.


Odoo model on which the job will run.


Priority of the job, 0 being the higher priority.


Date and time when the job was created.


Date and time when the job was enqueued.


Date and time when the job was started.


Date and time when the job was done.


A description of the result (for humans).


Exception information (traceback) when the job failed.


Odoo user id which created the job


Estimated Time of Arrival of the job. It will not be executed before this date/time.


Model recordset when we are on a delayed Model method

classmethod load(env, job_uuid)[source]

Read a job from the Database


Check if a job to be executed with the same key exists.

classmethod enqueue(func, args=None, kwargs=None, priority=None, eta=None, max_retries=None, description=None, channel=None, identity_key=None)[source]

Create a Job and enqueue it in the queue. Return the job.

This expects the arguments specific to the job to be already extracted from the ones to pass to the job function.

If the identity key is the same than the one in a pending job, no job is created and the existing job is returned

static db_record_from_uuid(env, job_uuid)[source]

Execute the job.

The job is executed with the user which has initiated it.


Store the Job


Job ID, this is an UUID

set_pending(result=None, reset_retry=True)[source]
postpone(result=None, seconds=None)[source]

Write an estimated time arrival to n seconds later than now. Used when an retryable exception want to retry a job later.