URL Helpers

This module implements various URL related functions.

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)

Converts any unicode based IRI to an acceptable ASCII URI. Werkzeug always uses utf-8 URLs internally because this is what browsers and HTTP do as well. In some places where it accepts an URL it also accepts a unicode IRI and converts it into a URI.

Examples for IRI versus URI:

>>> iri_to_uri(u'http://☃.net/')
'http://xn--n3h.net/'
>>> iri_to_uri(u'http://üser:pässword@☃.net/påth')
'http://%C3%BCser:p%C3%A4ssword@xn--n3h.net/p%C3%A5th'

There is a general problem with IRI and URI conversion with some protocols that appear in the wild that are in violation of the URI specification. In places where Werkzeug goes through a forced IRI to URI conversion it will set the safe_conversion flag which will not perform a conversion if the end result is already ASCII. This can mean that the return value is not an entirely correct URI but it will not destroy such invalid URLs in the process.

As an example consider the following two IRIs:

magnet:?xt=uri:whatever
itms-services://?action=download-manifest

The internal representation after parsing of those URLs is the same and there is no way to reconstruct the original one. If safe conversion is enabled however this function becomes a noop for both of those strings as they both can be considered URIs.

New in version 0.6.

Changed in version 0.9.6: The safe_conversion parameter was added.

Parameters:

• iri – The IRI to convert.
• charset – The charset for the URI.
• safe_conversion – indicates if a safe conversion should take place. For more information see the explanation above.

werkzeug.urls.uri_to_iri(uri, charset='utf-8', errors='replace')

Converts a URI in a given charset to a IRI.

Examples for URI versus IRI:

>>> uri_to_iri(b'http://xn--n3h.net/')
u'http://\u2603.net/'
>>> uri_to_iri(b'http://%C3%BCser:p%C3%A4ssword@xn--n3h.net/p%C3%A5th')
u'http://\xfcser:p\xe4ssword@\u2603.net/p\xe5th'

Query strings are left unchanged:

>>> uri_to_iri('/?foo=24&x=%26%2f')
u'/?foo=24&x=%26%2f'

New in version 0.6.

Parameters:

• uri – The URI to convert.
• charset – The charset of the URI.
• errors – The error handling on decode.

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:

• s – a string with the query string to decode.
• charset – the charset of the query string. If set to None no unicode decoding will take place.
• decode_keys – Used on Python 2.x to control whether keys should be forced to be unicode objects. If set to True then keys will be unicode in all cases. Otherwise, they remain str if they fit into ASCII.
• include_empty – Set to False if you don’t want empty values to appear in the dict.
• errors – the decoding error behavior.
• separator – the pair separator to be used, defaults to &
• cls – an optional dict class to use. If this is not specified or None the default MultiDict is used.

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:

• stream – a stream with the encoded querystring
• charset – the charset of the query string. If set to None no unicode decoding will take place.
• decode_keys – Used on Python 2.x to control whether keys should be forced to be unicode objects. If set to True, keys will be unicode in all cases. Otherwise, they remain str if they fit into ASCII.
• include_empty – Set to False if you don’t want empty values to appear in the dict.
• errors – the decoding error behavior.
• separator – the pair separator to be used, defaults to &
• cls – an optional dict class to use. If this is not specified or None the default MultiDict is used.
• limit – the content length of the URL data. Not necessary if a limited stream is provided.
• return_iterator – if set to True the cls argument is ignored and an iterator over all decoded pairs is returned

werkzeug.urls.url_encode(obj, charset='utf-8', encode_keys=False, sort=False, key=None, separator='&')

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:

• obj – the object to encode into a query string.
• charset – the charset of the query string.
• encode_keys – set to True if you have unicode keys. (Ignored on Python 3.x)
• sort – set to True if you want parameters to be sorted by key.
• separator – the separator to be used for the pairs.
• key – an optional function to be used for sorting. For more details check out the sorted() documentation.

werkzeug.urls.url_encode_stream(obj, stream=None, charset='utf-8', encode_keys=False, sort=False, key=None, separator='&')

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:

• obj – the object to encode into a query string.
• stream – a stream to write the encoded object into or None if an iterator over the encoded pairs should be returned. In that case the separator argument is ignored.
• charset – the charset of the query string.
• encode_keys – set to True if you have unicode keys. (Ignored on Python 3.x)
• sort – set to True if you want parameters to be sorted by key.
• separator – the separator to be used for the pairs.
• key – an optional function to be used for sorting. For more details check out the sorted() documentation.

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:

• s – the string with the URL to fix.
• charset – The target charset for the URL if the url was given as unicode string.

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:

• base – the base URL for the join operation.
• url – the URL to join.
• allow_fragments – indicates whether fragments should be allowed.

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:

• url – the URL to parse.
• scheme – the default schema to use if the URL is schemaless.
• allow_fragments – if set to False a fragment will be removed from the URL.

werkzeug.urls.url_quote(string, charset='utf-8', errors='strict', safe='/:', unsafe='')

URL encode a single string with a given encoding.

Parameters:

• s – the string to quote.
• charset – the charset to be used.
• safe – an optional sequence of safe characters.
• unsafe – an optional sequence of unsafe characters.

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:

• s – The string to quote.
• charset – The charset to be used.
• safe – An optional sequence of safe characters.

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:

• s – the string to unquote.
• charset – the charset of the query string. If set to None no unicode decoding will take place.
• errors – the error handling for the charset decoding.

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:

• s – The string to unquote.
• charset – the charset of the query string. If set to None no unicode decoding will take place.
• errors – The error handling for the charset decoding.