|
OpenQuizz
Une application de gestion des contenus pédagogiques
|
Data Structures | |
| class | BaseURL |
| class | BytesURL |
| class | Href |
| class | URL |
Functions | |
| def | url_parse (url, scheme=None, allow_fragments=True) |
| def | url_quote (string, charset="utf-8", errors="strict", safe="/:", unsafe="") |
| def | url_quote_plus (string, charset="utf-8", errors="strict", safe="") |
| def | url_unparse (components) |
| def | url_unquote (string, charset="utf-8", errors="replace", unsafe="") |
| def | url_unquote_plus (s, charset="utf-8", errors="replace") |
| def | url_fix (s, charset="utf-8") |
| def | uri_to_iri (uri, charset="utf-8", errors="werkzeug.url_quote") |
| def | iri_to_uri (iri, charset="utf-8", errors="strict", safe_conversion=False) |
| def | url_decode (s, charset="utf-8", decode_keys=False, include_empty=True, errors="replace", separator="&", cls=None) |
| def | url_decode_stream (stream, charset="utf-8", decode_keys=False, include_empty=True, errors="replace", separator="&", cls=None, limit=None, return_iterator=False) |
| def | url_encode (obj, charset="utf-8", encode_keys=False, sort=False, key=None, separator=b"&") |
| def | url_encode_stream (obj, stream=None, charset="utf-8", encode_keys=False, sort=False, key=None, separator=b"&") |
| def | url_join (base, url, allow_fragments=True) |
Variables | |
| safe | |
| unsafe | |
| def 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'
:param iri: The IRI to convert.
:param charset: The encoding of the IRI.
:param errors: Error handler to use during ``bytes.encode``.
:param safe_conversion: Return the URL unchanged if it only contains
ASCII characters and no whitespace. See the explanation below.
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.
.. versionchanged:: 0.15
All reserved characters remain unquoted. Previously, only some
reserved characters were left unquoted.
.. versionchanged:: 0.9.6
The ``safe_conversion`` parameter was added.
.. versionadded:: 0.6
| def 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'
:param uri: The URI to convert.
:param charset: The encoding to encode unquoted bytes with.
:param errors: Error handler to use during ``bytes.encode``. By
default, invalid bytes are left quoted.
.. versionchanged:: 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.
.. versionadded:: 0.6
| def 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 :class:`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.
.. versionchanged:: 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.
:param s: a string with the query string to decode.
:param charset: the charset of the query string. If set to `None`
no unicode decoding will take place.
:param 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.
:param include_empty: Set to `False` if you don't want empty values to
appear in the dict.
:param errors: the decoding error behavior.
:param separator: the pair separator to be used, defaults to ``&``
:param cls: an optional dict class to use. If this is not specified
or `None` the default :class:`MultiDict` is used.
| def 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 :func:`url_decode` but decodes a stream. The behavior
of stream and limit follows functions like
:func:`~werkzeug.wsgi.make_line_iter`. The generator of pairs is
directly fed to the `cls` so you can consume the data while it's
parsed.
.. versionadded:: 0.8
:param stream: a stream with the encoded querystring
:param charset: the charset of the query string. If set to `None`
no unicode decoding will take place.
:param 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.
:param include_empty: Set to `False` if you don't want empty values to
appear in the dict.
:param errors: the decoding error behavior.
:param separator: the pair separator to be used, defaults to ``&``
:param cls: an optional dict class to use. If this is not specified
or `None` the default :class:`MultiDict` is used.
:param limit: the content length of the URL data. Not necessary if
a limited stream is provided.
:param return_iterator: if set to `True` the `cls` argument is ignored
and an iterator over all decoded pairs is
returned
| def 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.
.. versionadded:: 0.5
`sort`, `key`, and `separator` were added.
:param obj: the object to encode into a query string.
:param charset: the charset of the query string.
:param encode_keys: set to `True` if you have unicode keys. (Ignored on
Python 3.x)
:param sort: set to `True` if you want parameters to be sorted by `key`.
:param separator: the separator to be used for the pairs.
:param key: an optional function to be used for sorting. For more details
check out the :func:`sorted` documentation.
| def werkzeug.urls.url_encode_stream | ( | obj, | |
stream = None, |
|||
charset = "utf-8", |
|||
encode_keys = False, |
|||
sort = False, |
|||
key = None, |
|||
separator = b"&" |
|||
| ) |
Like :meth:`url_encode` but writes the results to a stream
object. If the stream is `None` a generator over all encoded
pairs is returned.
.. versionadded:: 0.8
:param obj: the object to encode into a query string.
:param 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.
:param charset: the charset of the query string.
:param encode_keys: set to `True` if you have unicode keys. (Ignored on
Python 3.x)
:param sort: set to `True` if you want parameters to be sorted by `key`.
:param separator: the separator to be used for the pairs.
:param key: an optional function to be used for sorting. For more details
check out the :func:`sorted` documentation.
| def 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)'
:param s: the string with the URL to fix.
:param charset: The target charset for the URL if the url was given as
unicode string.
| def 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. :param base: the base URL for the join operation. :param url: the URL to join. :param allow_fragments: indicates whether fragments should be allowed.
| def werkzeug.urls.url_parse | ( | url, | |
scheme = None, |
|||
allow_fragments = True |
|||
| ) |
Parses a URL from a string into a :class:`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 :func:`url_unparse`.
:param url: the URL to parse.
:param scheme: the default schema to use if the URL is schemaless.
:param allow_fragments: if set to `False` a fragment will be removed
from the URL.
| def werkzeug.urls.url_quote | ( | string, | |
charset = "utf-8", |
|||
errors = "strict", |
|||
safe = "/:", |
|||
unsafe = "" |
|||
| ) |
URL encode a single string with a given encoding. :param s: the string to quote. :param charset: the charset to be used. :param safe: an optional sequence of safe characters. :param unsafe: an optional sequence of unsafe characters. .. versionadded:: 0.9.2 The `unsafe` parameter was added.
| def 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 "+". :param s: The string to quote. :param charset: The charset to be used. :param safe: An optional sequence of safe characters.
| def werkzeug.urls.url_unparse | ( | components | ) |
The reverse operation to :meth:`url_parse`. This accepts arbitrary
as well as :class:`URL` tuples and returns a URL as a string.
:param components: the parsed URL as tuple which should be converted
into a URL string.
| def 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.
:param s: the string to unquote.
:param charset: the charset of the query string. If set to `None`
no unicode decoding will take place.
:param errors: the error handling for the charset decoding.
| def 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
:exc:`HTTPUnicodeError` is raised.
:param s: The string to unquote.
:param charset: the charset of the query string. If set to `None`
no unicode decoding will take place.
:param errors: The error handling for the `charset` decoding.
| safe |
| unsafe |