OpenQuizz
Une application de gestion des contenus pédagogiques
|
Public Member Functions | |
def | replace (self, **kwargs) |
def | host (self) |
def | ascii_host (self) |
def | port (self) |
def | auth (self) |
def | username (self) |
def | raw_username (self) |
def | password (self) |
def | raw_password (self) |
def | decode_query (self, *args, **kwargs) |
def | join (self, *args, **kwargs) |
def | to_url (self) |
def | decode_netloc (self) |
def | to_uri_tuple (self) |
def | to_iri_tuple (self) |
def | get_file_location (self, pathformat=None) |
Superclass of :py:class:`URL` and :py:class:`BytesURL`.
def ascii_host | ( | self | ) |
Works exactly like :attr:`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.
def auth | ( | self | ) |
The authentication part in the URL if available, `None` otherwise.
def decode_netloc | ( | self | ) |
Decodes the netloc part into a string.
def decode_query | ( | self, | |
* | args, | ||
** | kwargs | ||
) |
Decodes the query part of the URL. Ths is a shortcut for calling :func:`url_decode` on the query argument. The arguments and keyword arguments are forwarded to :func:`url_decode` unchanged.
def get_file_location | ( | self, | |
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``. :param pathformat: The expected format of the path component. Currently ``'windows'`` and ``'posix'`` are supported. Defaults to ``None`` which is autodetect.
def host | ( | self | ) |
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.
def join | ( | self, | |
* | args, | ||
** | kwargs | ||
) |
Joins this URL with another one. This is just a convenience function for calling into :meth:`url_join` and then parsing the return value again.
def password | ( | self | ) |
The password if it was part of the URL, `None` otherwise. This undergoes URL decoding and will always be a unicode string.
def port | ( | self | ) |
The port in the URL as an integer if it was present, `None` otherwise. This does not fill in default ports.
def raw_password | ( | self | ) |
The password if it was part of the URL, `None` otherwise. Unlike :attr:`password` this one is not being decoded.
def raw_username | ( | self | ) |
The username if it was part of the URL, `None` otherwise. Unlike :attr:`username` this one is not being decoded.
def replace | ( | self, | |
** | kwargs | ||
) |
Return an URL with the same values, except for those parameters given new values by whichever keyword arguments are specified.
def to_iri_tuple | ( | self | ) |
Returns a :class:`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 :meth:`uri_to_iri` which will return a string.
def to_uri_tuple | ( | self | ) |
Returns a :class:`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 :meth:`iri_to_uri` which will return a string.
def to_url | ( | self | ) |
Returns a URL string or bytes depending on the type of the information stored. This is just a convenience function for calling :meth:`url_unparse` for this URL.
def username | ( | self | ) |
The username if it was part of the URL, `None` otherwise. This undergoes URL decoding and will always be a unicode string.