docs: def interval(host, time, actor, method, *args, **kwargs):
      '''Creates an Event attached to the host for management that will
      execute the *method* of the *actor* every *time* seconds.
  
      See example in :ref:`sample_inter`
  
      :param Proxy host: host that will manage the interval, commonly the
          host of the actor.
      :param int time: seconds for the intervals.
      :param Proxy actor: actor to which make the call every *time* seconds.
      :param Str. method: method of the *actor* to be called.
      :param list args: arguments for *method*.
      :return: :class:`Event` instance of the interval.
      '''
      call = getattr(actor, method, None)
      if not callable(call):
          raise IntervalError("The actor %s does not have the method %s."
                              % (actor.get_id(), method))
      if call.__class__.__name__ in ["TellWrapper", "TellRefWrapper"]:
          # If the method is a normal tell, the interval thread can send
          # the calls normally.
          # It it is a Ref Tell, the proxies in the args would be parsed
          # during the call to this very method. So the call can be made
          # as a normall Tell. The actor will do the loads normally on the
          # receive as it has its methods marked as ref.
          if call.__class__.__name__ is "TellRefWrapper":
              call.__call__ = TellWrapper.__call__
  
          return intervals.interval_host(host, time, call, *args, **kwargs)
      else:
          raise IntervalError("The callable for the interval must be a tell \
              method of the actor.")