class odoo.addons.queue_job.models.base.Base[source]

Bases : BaseModel

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

A new with_delay() method is added on all Odoo Models, allowing to postpone the execution of a job method in an asynchronous process.

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

Return a DelayableRecordset

The returned instance allows to enqueue any method of the recordset’s Model.


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

with_delay() accepts job properties which specify how the job will be executed.

Usage with job properties:

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
  • priority – Priority of the job, 0 being the higher priority. Default is 10.

  • eta – Heure estimée de lancement (ETA) du job. Il ne sera pas exécuté avant cette date/heure.

  • 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. It is either a string, either a function that takes the job as argument (see job.identity_exact()).


instance of a DelayableRecordset

Type renvoyé


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[source]

Model storing the jobs to be executed.

_name = 'queue.job'

the model name (in dot-notation, module namespace)

_inherit = ['mail.thread', 'mail.activity.mixin']

Python-inherited models:


str or list(str)


  • If _name is set, name(s) of parent models to inherit from

  • If _name is unset, name of a single model to extend in-place



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

Decorator for job methods.

Deprecated. Use queue.job.function XML records (details in readme/USAGE.rst).

It enables the possibility to use a Model’s method as a job function.

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.

Exemple :

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')


Voir aussi : related_action() une action connexe peut être attachée à un job

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

Attach a Related Action to a job (decorator)

Deprecated. Use queue.job.function XML records (details in readme/USAGE.rst).

Un action connexe apparaîtra comme un bouton dans la vue Odoo. Le bouton exécutera l’action, habituellement une ouverture de formulaire de l’enregistrement lié au job.

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

Exemple d’utilisation :

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

    def related_action_partner(self):
        model = self.model_name
        partner = self.records
        # 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):
        # ...

Les kwargs sont transmis à l’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)

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

This class will generally not be used directly, it is used internally by with_delay()

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. It is the in-memory representation of a job.

Jobs are stored in the queue.job Odoo Model, but they are handled through this class.


Id (UUID) du job.


État du job, peut être en attente, en queue, démarré, terminé, échoué. L’état initial est en attente et l’état final est terminé.


L’essai actuel, démarre à 0 et s’incrémente de 1 chaque fois que le job est exécuté.


Le nombre maximum d’essais permis avant que le job soit considéré comme échoué.


Arguments transmis à la fonction pendant l’exécution.


Arguments nommés transmis à la fonction pendant l’exécution.


Description du job à destination des utilisateurs.


La fonction Python elle-même.


Modèle Odoo pour lequel le job va fonctionner.


Priorité du job, 0 étant la plus haute priorité.


Date et heure de création du job.


Date et heure de mise en queue du job.


Date et heure de démarrage du job.


Date et heure d’arrêt du job.


Une description du résultat (à destination des utilisateurs).


Exception error name when the job failed.


Exception error message when the job failed.


Informations sur l”Exception (`traceback”) ayant causé l’échec du job


Id de l’utilisateur Odoo qui a créé le job


Heure estimée de lancement (ETA) du job. Il ne sera pas exécuté avant cette date/heure.


Model recordset when we are on a delayed Model method

classmethod load(env, job_uuid)[source]

Lit un job depuis la base de données


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]

Crée un job et le met en queue. Renvoie le UUID du job.

S’attend à ce que les arguments spécifiques au job soient déjà extraites de ceux à passer à la fonction du job.

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]

Exécute le job.

Le job est exécuté avec l’utilisateur qui l’a initié.


Stocke le job

property func_string
property func
property job_function_name
property identity_key
property description
property uuid

Id du job, c’est un UUID

property model_name
property user_id
property eta
property channel
property exec_time
set_pending(result=None, reset_retry=True)[source]
postpone(result=None, seconds=None)[source]

Postpone the job

Écrit un heure estimée de lancement dans n secondes. Utilisé quand une Exception non fatale souhaite relancer un job.