code: def run_forever(self, *args, **kwargs):
          
          collectloop = CollectLoop(self._handle)
          updatesloop = GetUpdatesLoop(self._bot,
                                       lambda update:
                                           collectloop.input_queue.put(_extract_message(update)[1]))
                                           # feed messages to collect loop
          # feed events to collect loop
          self._bot.scheduler.on_event(collectloop.input_queue.put)
          self._bot.scheduler.run_as_thread()
  
          updatesloop.run_as_thread(*args, **kwargs)
          collectloop.run_forever()
docs: :type relax: float
          :param relax: seconds between each :meth:`.getUpdates`
  
          :type offset: int
          :param offset:
              initial ``offset`` parameter supplied to :meth:`.getUpdates`
  
          :type timeout: int
          :param timeout:
              ``timeout`` parameter supplied to :meth:`.getUpdates`, controlling
              how long to poll.
  
          :type allowed_updates: array of string
          :param allowed_updates:
              ``allowed_updates`` parameter supplied to :meth:`.getUpdates`,
              controlling which types of updates to receive.
  
          Calling this method will block forever. Use :meth:`.run_as_thread` to
          run it non-blockingly.