docs: def build(self, endpoint, values=None, method=None, force_external=False,
                append_unknown=True):
          """Building URLs works pretty much the other way round.  Instead of
          `match` you call `build` and pass it the endpoint and a dict of
          arguments for the placeholders.
  
          The `build` function also accepts an argument called `force_external`
          which, if you set it to `True` will force external URLs. Per default
          external URLs (include the server name) will only be used if the
          target URL is on a different subdomain.
  
          >>> m = Map([
          ...     Rule('/', endpoint='index'),
          ...     Rule('/downloads/', endpoint='downloads/index'),
          ...     Rule('/downloads/<int:id>', endpoint='downloads/show')
          ... ])
          >>> urls = m.bind("example.com", "/")
          >>> urls.build("index", {})
          '/'
          >>> urls.build("downloads/show", {'id': 42})
          '/downloads/42'
          >>> urls.build("downloads/show", {'id': 42}, force_external=True)
          'http://example.com/downloads/42'
  
          Because URLs cannot contain non ASCII data you will always get
          bytestrings back.  Non ASCII characters are urlencoded with the
          charset defined on the map instance.
  
          Additional values are converted to unicode and appended to the URL as
          URL querystring parameters:
  
          >>> urls.build("index", {'q': 'My Searchstring'})
          '/?q=My+Searchstring'
  
          If a rule does not exist when building a `BuildError` exception is
          raised.
  
          The build method accepts an argument called `method` which allows you
          to specify the method you want to have an URL built for if you have
          different methods for the same endpoint specified.
  
          .. versionadded:: 0.6
             the `append_unknown` parameter was added.
  
          :param endpoint: the endpoint of the URL to build.
          :param values: the values for the URL to build.  Unhandled values are
                         appended to the URL as query parameters.
          :param method: the HTTP method for the rule if there are different
                         URLs for different methods on the same endpoint.
          :param force_external: enforce full canonical external URLs.
          :param append_unknown: unknown parameters are appended to the generated
                                 URL as query string argument.  Disable this
                                 if you want the builder to ignore those.
          """
          self.map.update()
          if values:
              if isinstance(values, MultiDict):
                  valueiter = values.iteritems(multi=True)
              else:
                  valueiter = iteritems(values)
              values = dict((k, v) for k, v in valueiter if v is not None)
          else:
              values = {}
  
          rv = self._partial_build(endpoint, values, method, append_unknown)
          if rv is None:
              raise BuildError(endpoint, values, method)
          domain_part, path = rv
  
          host = self.get_host(domain_part)
  
          # shortcut this.
          if not force_external and (
              (self.map.host_matching and host == self.server_name) or
              (not self.map.host_matching and domain_part == self.subdomain)):
              return str(urljoin(self.script_name, './' + path.lstrip('/')))
          return str('%s://%s%s/%s' % (
              self.url_scheme,
              host,
              self.script_name[:-1],
              path.lstrip('/')
          ))