docs: def lookup_url(self, url, klass, module=None):
          '''
          Gets a proxy reference to the actor indicated by the URL in the
          parameters. It can be a local reference or a remote direction to
          another host.
  
          This method can be called remotely synchronously.
  
          :param srt. url: address that identifies an actor.
          :param class klass: the class of the actor.
          :param srt. module: if the actor class is not in the calling module,
              you need to specify the module where it is here. Also, the *klass*
              parameter change to be a string.
          :return: :class:`~.Proxy` of the actor requested.
          :raises: :class:`NotFoundError`, if the URL specified do not
              correspond to any actor in the host.
          :raises: :class:`HostDownError`  if the host is down.
          :raises: :class:`HostError`  if there is an error looking for
              the actor in another server.
          '''
          if not self.alive:
              raise HostDownError()
          aurl = urlparse(url)
          if self.is_local(aurl):
              if url not in self.actors.keys():
                  raise NotFoundError(url)
              else:
                  return Proxy(self.actors[url])
          else:
              try:
                  dispatcher = self.actors[aurl.scheme]
                  if module is not None:
                      try:
                          module_ = __import__(module, globals(), locals(),
                                               [klass], -1)
                          klass_ = getattr(module_, klass)
                      except Exception, e:
                          raise HostError("At lookup_url: " +
                                          "Import failed for module " + module +
                                          ", class " + klass +
                                          ". Check this values for the lookup." +
                                          " ERROR: " + str(e))
                  elif isinstance(klass, (types.TypeType, types.ClassType)):
                      klass_ = klass
                  else:
                      raise HostError("The class specified to look up is" +
                                      " not a class.")
                  remote_actor = actor.ActorRef(url, klass_, dispatcher.channel)
                  return Proxy(remote_actor)
              except HostError:
                  raise
              except Exception, e:
                  raise HostError("ERROR looking for the actor on another " +
                                  "server. Hosts must " +
                                  "be in http to work properly. " + str(e))