Python urllib_parse.urlunparse函数代码示例

def _remove_params_from_url(url):
    """
    Return a copy of a URL with its parameters, fragments, and query
    string removed.
    """
    parsed = urlparse.urlparse(url)
    return urlparse.urlunparse((parsed[0], parsed[1], parsed[2], '', '', ''))

    def __init__(self, value):
        if not isinstance(value, six.text_type):
            raise TypeError("value must be a unicode string")

        parsed = urllib_parse.urlparse(value)
        if not parsed.hostname:
            netloc = ""
        elif parsed.port:
            netloc = (
                idna.encode(parsed.hostname) +
                ":{0}".format(parsed.port).encode("ascii")
            ).decode("ascii")
        else:
            netloc = idna.encode(parsed.hostname).decode("ascii")

        # Note that building a URL in this fashion means it should be
        # semantically indistinguishable from the original but is not
        # guaranteed to be exactly the same.
        uri = urllib_parse.urlunparse((
            parsed.scheme,
            netloc,
            parsed.path,
            parsed.params,
            parsed.query,
            parsed.fragment
        )).encode("ascii")

        self._value = value
        self._encoded = uri

    def get_sample_data(self, meter_name, parse_url, params, cache):

        extractor = self._get_extractor(meter_name)
        if extractor is None:
            # The way to getting meter is not implemented in this driver or
            # OpenDaylight REST API has not api to getting meter.
            return None

        iter = self._get_iter(meter_name)
        if iter is None:
            # The way to getting meter is not implemented in this driver or
            # OpenDaylight REST API has not api to getting meter.
            return None

        parts = urlparse.ParseResult(params.get('scheme', ['http'])[0],
                                     parse_url.netloc,
                                     parse_url.path,
                                     None,
                                     None,
                                     None)
        endpoint = urlparse.urlunparse(parts)

        data = self._prepare_cache(endpoint, params, cache)

        samples = []
        if data:
            for sample in iter(extractor, data):
                if sample is not None:
                    # set controller name to resource_metadata
                    sample[2]['controller'] = 'OpenDaylight_V2'
                    samples.append(sample)

        return samples

def _build_network_relative_path(url):
    p = urlparse.urlparse(url)
    parse_result = urlparse.ParseResult(
        p.scheme,
        p.netloc,
        os.path.dirname(p.path),
        '', '', '')
    return urlparse.urlunparse(parse_result)

def url_add_parameters(url, params):
    """Adds parameters to URL, parameter will be repeated if already present"""
    if params:
        fragments = list(urlparse(url))
        value = parse_qs(fragments[4])
        value.update(params)
        fragments[4] = urlencode(value)
        url = urlunparse(fragments)
    return url

 def _auth1(self):
     status = 0
     reason = 'Unknown'
     attempt = 0
     while attempt < self.attempts:
         attempt += 1
         self.verbose('Attempting auth v1 with %s', self.auth_url)
         parsed, conn = self._connect(self.auth_url)
         self.verbose('> GET %s', parsed.path)
         conn.request(
             'GET', parsed.path, '',
             {'User-Agent': self.user_agent,
              'X-Auth-User': quote(self.auth_user),
              'X-Auth-Key': quote(self.auth_key)})
         try:
             resp = conn.getresponse()
             status = resp.status
             reason = resp.reason
             self.verbose('< %s %s', status, reason)
             hdrs = headers_to_dict(resp.getheaders())
             resp.read()
             resp.close()
             conn.close()
         except Exception as err:
             status = 0
             reason = str(err)
             hdrs = {}
         if status == 401:
             break
         if status // 100 == 2:
             try:
                 self.storage_url = hdrs['x-storage-url']
             except KeyError:
                 status = 0
                 reason = 'No x-storage-url header'
                 break
             if self.snet:
                 parsed = list(urlparse.urlparse(self.storage_url))
                 # Second item in the list is the netloc
                 parsed[1] = 'snet-' + parsed[1]
                 self.storage_url = urlparse.urlunparse(parsed)
             self.cdn_url = hdrs.get('x-cdn-management-url')
             self.auth_token = hdrs.get('x-auth-token')
             if not self.auth_token:
                 self.auth_token = hdrs.get('x-storage-token')
                 if not self.auth_token:
                     status = 500
                     reason = (
                         'No x-auth-token or x-storage-token header in '
                         'response')
                     break
             self._auth_save_cache()
             break
         elif status // 100 != 5:
             break
         self.client.sleep(2 ** attempt)
     return status, reason

    def __init__(self, user, password, session):
        self.user = user
        self.password = password
        self.session = session

        self.cookies = {}
        self.login_url = urllib_parse.urlunparse(
            ["https", API_DOMAIN, "/login", "", "", ""],
        )

 def _next_server(self, cause=None):
     while True:
         url = super(Client, self)._next_server(cause)
         r = urlparse(url)
         ips = self._dns_resolver.resolve(r.hostname)
         if ips:
             netloc = '{0}:{1}'.format(random.choice(ips), r.port)
             self._base_uri_unresolved = url
             return urlunparse((r.scheme, netloc, r.path, r.params, r.query, r.fragment))

def _rebase_url(url, base):
    base = list(urlparse.urlparse(base))
    url = list(urlparse.urlparse(url))
    if not url[0]:  # fix up schema
        url[0] = base[0] or "http"
    if not url[1]:  # fix up hostname
        url[1] = base[1]
        if not url[2].startswith('/'):
            url[2] = re.sub(r'/[^/]+$', '/', base[2]) + url[2]
    return urlparse.urlunparse(url)

def parse_connection_string(value):
    """Original Governor stores connection strings for each cluster members if a following format:
        postgres://{username}:{password}@{connect_address}/postgres
    Since each of our patroni instances provides own REST API endpoint it's good to store this information
    in DCS among with postgresql connection string. In order to not introduce new keys and be compatible with
    original Governor we decided to extend original connection string in a following way:
        postgres://{username}:{password}@{connect_address}/postgres?application_name={api_url}
    This way original Governor could use such connection string as it is, because of feature of `libpq` library.

    This method is able to split connection string stored in DCS into two parts, `conn_url` and `api_url`"""

    scheme, netloc, path, params, query, fragment = urlparse(value)
    conn_url = urlunparse((scheme, netloc, path, params, '', fragment))
    api_url = ([v for n, v in parse_qsl(query) if n == 'application_name'] or [None])[0]
    return conn_url, api_url

def _build_general_name(backend, gn):
    if gn.type == backend._lib.GEN_DNS:
        data = backend._ffi.buffer(gn.d.dNSName.data, gn.d.dNSName.length)[:]
        return x509.DNSName(idna.decode(data))
    elif gn.type == backend._lib.GEN_URI:
        data = backend._ffi.buffer(
            gn.d.uniformResourceIdentifier.data,
            gn.d.uniformResourceIdentifier.length
        )[:].decode("ascii")
        parsed = urllib_parse.urlparse(data)
        hostname = idna.decode(parsed.hostname)
        if parsed.port:
            netloc = hostname + u":" + six.text_type(parsed.port)
        else:
            netloc = hostname

        # Note that building a URL in this fashion means it should be
        # semantically indistinguishable from the original but is not
        # guaranteed to be exactly the same.
        uri = urllib_parse.urlunparse((
            parsed.scheme,
            netloc,
            parsed.path,
            parsed.params,
            parsed.query,
            parsed.fragment
        ))
        return x509.UniformResourceIdentifier(uri)
    elif gn.type == backend._lib.GEN_RID:
        oid = _obj2txt(backend, gn.d.registeredID)
        return x509.RegisteredID(x509.ObjectIdentifier(oid))
    elif gn.type == backend._lib.GEN_IPADD:
        return x509.IPAddress(
            ipaddress.ip_address(
                backend._ffi.buffer(
                    gn.d.iPAddress.data, gn.d.iPAddress.length
                )[:]
            )
        )
    else:
        # otherName, x400Address or ediPartyName
        raise x509.UnsupportedGeneralNameType(
            "{0} is not a supported type".format(
                x509._GENERAL_NAMES.get(gn.type, gn.type)
            ),
            gn.type
        )

def url_replace(url, **params):
    """ Replace some named parts in an url; See `urlparse.ParseResult` for the names """
    url_fields = urlparse.ParseResult._fields
    name_to_num = {field: idx for idx, field in enumerate(url_fields)}
    url_parts = list(urlparse.urlparse(url))  # Need a copy anyway
    for key, val in params.items():

        # Allow supplying various stuff as a query
        if key == 'query' and not isinstance(val, (bytes, unicode)):
            if isinstance(val, dict):
                val = val.items()
            val = [(to_bytes(query_key), to_bytes(query_val))
                   for query_key, query_val in val]
            val = urlencode(val)

        num = name_to_num[key]  # Will except here if supplied an unknown url param
        url_parts[num] = val
    return urlparse.urlunparse(url_parts)

 def info(self):
     info = {
         "active": self.active(),
         "expires": self._expires,
         "idle_time": self.idle_time,
         "ops": list(self._ops),
         "size": self._size,
         "sparse": self._sparse,
         "timeout": self._timeout,
         "url": urllib_parse.urlunparse(self._url),
         "uuid": self._uuid,
     }
     if self._transfer_id:
         info["transfer_id"] = self._transfer_id
     if self.filename:
         info["filename"] = self.filename
     transferred = self.transferred()
     if transferred is not None:
         info["transferred"] = transferred
     return info

    def _idna_encode(self, value):
        parsed = urllib_parse.urlparse(value)
        if parsed.port:
            netloc = (
                idna.encode(parsed.hostname) +
                ":{0}".format(parsed.port).encode("ascii")
            ).decode("ascii")
        else:
            netloc = idna.encode(parsed.hostname).decode("ascii")

        # Note that building a URL in this fashion means it should be
        # semantically indistinguishable from the original but is not
        # guaranteed to be exactly the same.
        return urllib_parse.urlunparse((
            parsed.scheme,
            netloc,
            parsed.path,
            parsed.params,
            parsed.query,
            parsed.fragment
        ))

def strip_netloc(url):
    """
    Strip the scheme and host from the URL, returning the
    server-absolute portion.

    Useful for wrapping an absolute-URI for which only the
    path is expected (such as in calls to getPage).

    >>> strip_netloc('https://google.com/foo/bar?bing#baz')
    '/foo/bar?bing'

    >>> strip_netloc('//google.com/foo/bar?bing#baz')
    '/foo/bar?bing'

    >>> strip_netloc('/foo/bar?bing#baz')
    '/foo/bar?bing'
    """
    parsed = urllib_parse.urlparse(url)
    scheme, netloc, path, params, query, fragment = parsed
    stripped = '', '', path, params, query, ''
    return urllib_parse.urlunparse(stripped)