docs: def enqueue(self, obj, *args, **kwargs):
          """Enqueue a function call or :doc:`job` instance.
  
          :param func: Function or :doc:`job <job>`. Must be serializable and
              importable by :doc:`worker <worker>` processes.
          :type func: callable | :doc:`kq.Job <job>`
          :param args: Positional arguments for the function. Ignored if **func**
              is a :doc:`job <job>` object.
          :param kwargs: Keyword arguments for the function. Ignored if **func**
              is a :doc:`job <job>` object.
          :return: Enqueued job.
          :rtype: :doc:`kq.Job <job>`
          """
          timestamp = int(time.time() * 1000)
  
          if isinstance(obj, Job):
              job_id = uuid.uuid4().hex if obj.id is None else obj.id
              func = obj.func
              args = tuple() if obj.args is None else obj.args
              kwargs = {} if obj.kwargs is None else obj.kwargs
              timeout = self._timeout if obj.timeout is None else obj.timeout
              key = self._key if obj.key is None else obj.key
              partition = self._part if obj.partition is None else obj.partition
  
              assert is_str(job_id), 'Job.id must be a str'
              assert callable(func), 'Job.func must be a callable'
              assert is_iter(args), 'Job.args must be a list or tuple'
              assert is_dict(kwargs), 'Job.kwargs must be a dict'
              assert is_number(timeout), 'Job.timeout must be an int or float'
              assert is_none_or_bytes(key), 'Job.key must be a bytes'
              assert is_none_or_int(partition), 'Job.partition must be an int'
          else:
              assert callable(obj), 'first argument must be a callable'
              job_id = uuid.uuid4().hex
              func = obj
              args = args
              kwargs = kwargs
              timeout = self._timeout
              key = self._key
              partition = self._part
  
          job = Job(
              id=job_id,
              timestamp=timestamp,
              topic=self._topic,
              func=func,
              args=args,
              kwargs=kwargs,
              timeout=timeout,
              key=key,
              partition=partition
          )
          self._logger.info('Enqueueing {} ...'.format(job))
          self._producer.send(
              self._topic,
              value=self._serializer(job),
              key=self._serializer(key) if key else None,
              partition=partition,
              timestamp_ms=timestamp
          )
          return job