werkzeug.urls
used to provide several wrapper functions for Python 2 urlparse, whose main purpose were to work around the behavior of the Py2 stdlib and its lack of unicode support. While this was already a somewhat inconvenient situation, it got even more complicated because Python 3’s urllib.parse
actually does handle unicode properly. In other words, this module would wrap two libraries with completely different behavior. So now this module contains a 2-and-3-compatible backport of Python 3’s urllib.parse
, which is mostly API-compatible.
class werkzeug.urls.BaseURL
Superclass of URL
and BytesURL
.
ascii_host
Works exactly like host
but will return a result that is restricted to ASCII. If it finds a netloc that is not ASCII it will attempt to idna decode it. This is useful for socket operations when the URL might include internationalized characters.
auth
The authentication part in the URL if available, None
otherwise.
decode_netloc()
Decodes the netloc part into a string.
decode_query(*args, **kwargs)
Decodes the query part of the URL. Ths is a shortcut for calling url_decode()
on the query argument. The arguments and keyword arguments are forwarded to url_decode()
unchanged.
get_file_location(pathformat=None)
Returns a tuple with the location of the file in the form (server, location)
. If the netloc is empty in the URL or points to localhost, it’s represented as None
.
The pathformat
by default is autodetection but needs to be set when working with URLs of a specific system. The supported values are 'windows'
when working with Windows or DOS paths and 'posix'
when working with posix paths.
If the URL does not point to a local file, the server and location are both represented as None
.
Parameters: |
pathformat – The expected format of the path component. Currently 'windows' and 'posix' are supported. Defaults to None which is autodetect. |
---|
host
The host part of the URL if available, otherwise None
. The host is either the hostname or the IP address mentioned in the URL. It will not contain the port.
join(*args, **kwargs)
Joins this URL with another one. This is just a convenience function for calling into url_join()
and then parsing the return value again.
password
The password if it was part of the URL, None
otherwise. This undergoes URL decoding and will always be a unicode string.
port
The port in the URL as an integer if it was present, None
otherwise. This does not fill in default ports.
raw_password
The password if it was part of the URL, None
otherwise. Unlike password
this one is not being decoded.
raw_username
The username if it was part of the URL, None
otherwise. Unlike username
this one is not being decoded.
replace(**kwargs)
Return an URL with the same values, except for those parameters given new values by whichever keyword arguments are specified.
to_iri_tuple()
Returns a URL
tuple that holds a IRI. This will try to decode as much information as possible in the URL without losing information similar to how a web browser does it for the URL bar.
It’s usually more interesting to directly call uri_to_iri()
which will return a string.
to_uri_tuple()
Returns a BytesURL
tuple that holds a URI. This will encode all the information in the URL properly to ASCII using the rules a web browser would follow.
It’s usually more interesting to directly call iri_to_uri()
which will return a string.
to_url()
Returns a URL string or bytes depending on the type of the information stored. This is just a convenience function for calling url_unparse()
for this URL.
username
The username if it was part of the URL, None
otherwise. This undergoes URL decoding and will always be a unicode string.
class werkzeug.urls.BytesURL
Represents a parsed URL in bytes.
decode(charset='utf-8', errors='replace')
Decodes the URL to a tuple made out of strings. The charset is only being used for the path, query and fragment.
encode_netloc()
Returns the netloc unchanged as bytes.
class werkzeug.urls.Href(base='./', charset='utf-8', sort=False, key=None)
Implements a callable that constructs URLs with the given base. The function can be called with any number of positional and keyword arguments which than are used to assemble the URL. Works with URLs and posix paths.
Positional arguments are appended as individual segments to the path of the URL:
>>> href = Href('/foo') >>> href('bar', 23) '/foo/bar/23' >>> href('foo', bar=23) '/foo/foo?bar=23'
If any of the arguments (positional or keyword) evaluates to None
it will be skipped. If no keyword arguments are given the last argument can be a dict
or MultiDict
(or any other dict subclass), otherwise the keyword arguments are used for the query parameters, cutting off the first trailing underscore of the parameter name:
>>> href(is_=42) '/foo?is=42' >>> href({'foo': 'bar'}) '/foo?foo=bar'
Combining of both methods is not allowed:
>>> href({'foo': 'bar'}, bar=42) Traceback (most recent call last): ... TypeError: keyword arguments and query-dicts can't be combined
Accessing attributes on the href object creates a new href object with the attribute name as prefix:
>>> bar_href = href.bar >>> bar_href("blub") '/foo/bar/blub'
If sort
is set to True
the items are sorted by key
or the default sorting algorithm:
>>> href = Href("/", sort=True) >>> href(a=1, b=2, c=3) '/?a=1&b=2&c=3'
New in version 0.5: sort
and key
were added.
class werkzeug.urls.URL
Represents a parsed URL. This behaves like a regular tuple but also has some extra attributes that give further insight into the URL.
encode(charset='utf-8', errors='replace')
Encodes the URL to a tuple made out of bytes. The charset is only being used for the path, query and fragment.
encode_netloc()
Encodes the netloc part to an ASCII safe URL as bytes.
werkzeug.urls.iri_to_uri(iri, charset='utf-8', errors='strict', safe_conversion=False)
Convert an IRI to a URI. All non-ASCII and unsafe characters are quoted. If the URL has a domain, it is encoded to Punycode.
>>> iri_to_uri('http://\u2603.net/p\xe5th?q=\xe8ry%DF') 'http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF'
Parameters: |
|
---|
There is a general problem with IRI conversion with some protocols that are in violation of the URI specification. Consider the following two IRIs:
magnet:?xt=uri:whatever itms-services://?action=download-manifest
After parsing, we don’t know if the scheme requires the //
, which is dropped if empty, but conveys different meanings in the final URL if it’s present or not. In this case, you can use safe_conversion
, which will return the URL unchanged if it only contains ASCII characters and no whitespace. This can result in a URI with unquoted characters if it was not already quoted correctly, but preserves the URL’s semantics. Werkzeug uses this for the Location
header for redirects.
Changed in version 0.15: All reserved characters remain unquoted. Previously, only some reserved characters were left unquoted.
Changed in version 0.9.6: The safe_conversion
parameter was added.
New in version 0.6.
werkzeug.urls.uri_to_iri(uri, charset='utf-8', errors='werkzeug.url_quote')
Convert a URI to an IRI. All valid UTF-8 characters are unquoted, leaving all reserved and invalid characters quoted. If the URL has a domain, it is decoded from Punycode.
>>> uri_to_iri("http://xn--n3h.net/p%C3%A5th?q=%C3%A8ry%DF") 'http://\u2603.net/p\xe5th?q=\xe8ry%DF'
Parameters: |
|
---|
Changed in version 0.15: All reserved and invalid characters remain quoted. Previously, only some reserved characters were preserved, and invalid bytes were replaced instead of left quoted.
New in version 0.6.
werkzeug.urls.url_decode(s, charset='utf-8', decode_keys=False, include_empty=True, errors='replace', separator='&', cls=None)
Parse a querystring and return it as MultiDict
. There is a difference in key decoding on different Python versions. On Python 3 keys will always be fully decoded whereas on Python 2, keys will remain bytestrings if they fit into ASCII. On 2.x keys can be forced to be unicode by setting decode_keys
to True
.
If the charset is set to None
no unicode decoding will happen and raw bytes will be returned.
Per default a missing value for a key will default to an empty key. If you don’t want that behavior you can set include_empty
to False
.
Per default encoding errors are ignored. If you want a different behavior you can set errors
to 'replace'
or 'strict'
. In strict mode a HTTPUnicodeError
is raised.
Changed in version 0.5: In previous versions “;” and “&” could be used for url decoding. This changed in 0.5 where only “&” is supported. If you want to use “;” instead a different separator
can be provided.
The cls
parameter was added.
Parameters: |
|
---|
werkzeug.urls.url_decode_stream(stream, charset='utf-8', decode_keys=False, include_empty=True, errors='replace', separator='&', cls=None, limit=None, return_iterator=False)
Works like url_decode()
but decodes a stream. The behavior of stream and limit follows functions like make_line_iter()
. The generator of pairs is directly fed to the cls
so you can consume the data while it’s parsed.
New in version 0.8.
Parameters: |
|
---|
werkzeug.urls.url_encode(obj, charset='utf-8', encode_keys=False, sort=False, key=None, separator=b'&')
URL encode a dict/MultiDict
. If a value is None
it will not appear in the result string. Per default only values are encoded into the target charset strings. If encode_keys
is set to True
unicode keys are supported too.
If sort
is set to True
the items are sorted by key
or the default sorting algorithm.
New in version 0.5: sort
, key
, and separator
were added.
Parameters: |
|
---|
werkzeug.urls.url_encode_stream(obj, stream=None, charset='utf-8', encode_keys=False, sort=False, key=None, separator=b'&')
Like url_encode()
but writes the results to a stream object. If the stream is None
a generator over all encoded pairs is returned.
New in version 0.8.
Parameters: |
|
---|
werkzeug.urls.url_fix(s, charset='utf-8')
Sometimes you get an URL by a user that just isn’t a real URL because it contains unsafe characters like ‘ ‘ and so on. This function can fix some of the problems in a similar way browsers handle data entered by the user:
>>> url_fix(u'http://de.wikipedia.org/wiki/Elf (Begriffskl\xe4rung)') 'http://de.wikipedia.org/wiki/Elf%20(Begriffskl%C3%A4rung)'
Parameters: |
|
---|
werkzeug.urls.url_join(base, url, allow_fragments=True)
Join a base URL and a possibly relative URL to form an absolute interpretation of the latter.
Parameters: |
|
---|
werkzeug.urls.url_parse(url, scheme=None, allow_fragments=True)
Parses a URL from a string into a URL
tuple. If the URL is lacking a scheme it can be provided as second argument. Otherwise, it is ignored. Optionally fragments can be stripped from the URL by setting allow_fragments
to False
.
The inverse of this function is url_unparse()
.
Parameters: |
|
---|
werkzeug.urls.url_quote(string, charset='utf-8', errors='strict', safe='/:', unsafe='')
URL encode a single string with a given encoding.
Parameters: |
|
---|
New in version 0.9.2: The unsafe
parameter was added.
werkzeug.urls.url_quote_plus(string, charset='utf-8', errors='strict', safe='')
URL encode a single string with the given encoding and convert whitespace to “+”.
Parameters: |
|
---|
werkzeug.urls.url_unparse(components)
The reverse operation to url_parse()
. This accepts arbitrary as well as URL
tuples and returns a URL as a string.
Parameters: | components – the parsed URL as tuple which should be converted into a URL string. |
---|
werkzeug.urls.url_unquote(string, charset='utf-8', errors='replace', unsafe='')
URL decode a single string with a given encoding. If the charset is set to None
no unicode decoding is performed and raw bytes are returned.
Parameters: |
|
---|
werkzeug.urls.url_unquote_plus(s, charset='utf-8', errors='replace')
URL decode a single string with the given charset
and decode “+” to whitespace.
Per default encoding errors are ignored. If you want a different behavior you can set errors
to 'replace'
or 'strict'
. In strict mode a HTTPUnicodeError
is raised.
Parameters: |
|
---|
© 2007–2020 Pallets
Licensed under the BSD 3-clause License.
https://werkzeug.palletsprojects.com/en/1.0.x/urls/