def resolve_redirect(self, response, new_location, environ, buffered=False):
        """Resolves a single redirect and triggers the request again
        directly on this redirect client.
        """
        scheme, netloc, script_root, qs, anchor = url_parse(new_location)
        base_url = url_unparse((scheme, netloc, "", "", "")).rstrip("/") + "/"

        cur_server_name = netloc.split(":", 1)[0].split(".")
        real_server_name = get_host(environ).rsplit(":", 1)[0].split(".")

        if self.allow_subdomain_redirects:
            allowed = cur_server_name[-len(real_server_name) :] == real_server_name
        else:
            allowed = cur_server_name == real_server_name

        if not allowed:
            raise RuntimeError("%r does not support redirect to " "external targets" % self.__class__)

        # For redirect handling we temporarily disable the response
        # wrapper.  This is not threadsafe but not a real concern
        # since the test client must not be shared anyways.
        old_response_wrapper = self.response_wrapper
        self.response_wrapper = None
        try:
            return self.open(path=script_root, base_url=base_url, query_string=qs, as_tuple=True, buffered=buffered)
        finally:
            self.response_wrapper = old_response_wrapper

 def parse_redirect(self, location, parse_fragment=False):
     from werkzeug.urls import url_parse, url_decode, url_unparse
     scheme, netloc, script_root, qs, anchor = url_parse(location)
     return (
         url_unparse((scheme, netloc, script_root, '', '')),
         url_decode(anchor if parse_fragment else qs)
     )

def render_template(template_file_name, **kwargs):
    if app is None:
        raise RuntimeError("No web application registered with mailer")
    template = get_jinja_environment().get_template(template_file_name)
    base_url = url_unparse(("https" if config.web_https else "http",
                            config.web_public_host, "/", "", ""))
    with app.test_request_context(base_url=base_url):
        return template.render(**kwargs)

 def _post(self, translated_resource: dict, url: str, **kwargs):
     """Sends the resource to an agent or itself"""
     if self.config['BASE_URL_FOR_AGENTS'] in url:  # We submit the resource to ourselves
         url = url_parse(url)  # We need to remove the base path
         absolute_path_ref = url_unparse(URL('', '', url.path, url.query, url.fragment))
         response = self._post_internal(translated_resource, absolute_path_ref)
     else:
         response = self._post_external(translated_resource, url, **kwargs)
     return response

 def _rebuild(self):
     base = url_parse(self._absolute_url)
     params = base.decode_query()
     for key, value in self._params.iteritems():
         if isinstance(value, (list, tuple)):
             params.setlist(key, value)
         else:
             params[key] = value
     self._url = url_unparse(base._replace(query=url_encode(params), fragment=self.fragment))

def make_github_link(app, path, line=None, mode="blob"):
    config = app.config

    urlpath = "/{user}/{project}/{mode}/{branch}/{path}".format(
        user=config.github_user,
        project=config.github_project,
        branch=config.version or 'master',
        path=path,
        mode=mode,
    )
    return urls.url_unparse((
        'https',
        'github.com',
        urlpath,
        '',
        '' if line is None else 'L%d' % line
    ))

    def resolve_redirect(self, response, new_location, environ, buffered=False):
        """Resolves a single redirect and triggers the request again
        directly on this redirect client.
        """
        scheme, netloc, script_root, qs, anchor = url_parse(new_location)
        base_url = url_unparse((scheme, netloc, '', '', '')).rstrip('/') + '/'

        cur_server_name = netloc.split(':', 1)[0].split('.')
        real_server_name = get_host(environ).rsplit(':', 1)[0].split('.')
        if cur_server_name == ['']:
            # this is a local redirect having autocorrect_location_header=False
            cur_server_name = real_server_name
            base_url = EnvironBuilder(environ).base_url

        if self.allow_subdomain_redirects:
            allowed = cur_server_name[-len(real_server_name):] == real_server_name
        else:
            allowed = cur_server_name == real_server_name

        if not allowed:
            raise RuntimeError('%r does not support redirect to '
                               'external targets' % self.__class__)

        status_code = int(response[1].split(None, 1)[0])
        if status_code == 307:
            method = environ['REQUEST_METHOD']
        else:
            method = 'GET'

        # For redirect handling we temporarily disable the response
        # wrapper.  This is not threadsafe but not a real concern
        # since the test client must not be shared anyways.
        old_response_wrapper = self.response_wrapper
        self.response_wrapper = None
        try:
            return self.open(path=script_root, base_url=base_url,
                             query_string=qs, as_tuple=True,
                             buffered=buffered, method=method)
        finally:
            self.response_wrapper = old_response_wrapper

def parse_redirect(location, parse_fragment=False):
    scheme, netloc, script_root, qs, anchor = url_parse(location)
    return (
        url_unparse((scheme, netloc, script_root, '', '')),
        url_decode(anchor if parse_fragment else qs)
    )

 def _get_base_url(self):
     return url_unparse((self.url_scheme, self.host,
                         self.script_root, '', '')).rstrip('/') + '/'

 def _get_base_url(self):
     return url_unparse((self.url_scheme, self.host, self.script_root, "", "")).rstrip("/") + "/"