docs: def job(self, func_or_queue=None, timeout=None, result_ttl=None, ttl=None,
              depends_on=None, at_front=None, meta=None, description=None):
          """
          Decorator to mark functions for queuing via RQ, e.g.::
  
              rq = RQ()
  
              @rq.job
              def add(x, y):
                  return x + y
  
          or::
  
              @rq.job(timeout=60, result_ttl=60 * 60)
              def add(x, y):
                  return x + y
  
          Adds various functions to the job as documented in
          :class:`~flask_rq2.functions.JobFunctions`.
  
  
          .. versionchanged:: 18.0
              Adds ``depends_on``, ``at_front``, ``meta`` and ``description``
              parameters.
  
          :param queue: Name of the queue to add job to, defaults to
                        :attr:`flask_rq2.app.RQ.default_queue`.
          :type queue: str
          :param timeout: The maximum runtime in seconds of the job before it's
                          considered 'lost', defaults to 180.
          :type timeout: int
          :param result_ttl: Time to persist the job results in Redis,
                             in seconds.
          :type result_ttl: int
          :param ttl: The maximum queued time of the job before it'll be
                      cancelled.
          :type ttl: int
  
          :param depends_on: A job instance or id that the new job depends on.
          :type depends_on: ~flask_rq2.job.FlaskJob or str
  
          :param at_front: Whether or not the job is queued in front of all other
                           enqueued jobs.
          :type at_front: bool
  
          :param meta: Additional meta data about the job.
          :type meta: dict
  
          :param description: Description of the job.
          :type description: str
  
          """
          if callable(func_or_queue):
              func = func_or_queue
              queue_name = None
          else:
              func = None
              queue_name = func_or_queue
  
          def wrapper(wrapped):
              self._jobs.append(wrapped)
              helper = self._functions_cls(
                  rq=self,
                  wrapped=wrapped,
                  queue_name=queue_name,
                  timeout=timeout,
                  result_ttl=result_ttl,
                  ttl=ttl,
                  depends_on=depends_on,
                  at_front=at_front,
                  meta=meta,
                  description=description,
              )
              wrapped.helper = helper
              for function in helper.functions:
                  callback = getattr(helper, function, None)
                  setattr(wrapped, function, callback)
              return wrapped
  
          if func is None:
              return wrapper
          else:
              return wrapper(func)