1:mod:`urllib.parse` --- Parse URLs into components 2================================================== 3 4.. module:: urllib.parse 5 :synopsis: Parse URLs into or assemble them from components. 6 7**Source code:** :source:`Lib/urllib/parse.py` 8 9.. index:: 10 single: WWW 11 single: World Wide Web 12 single: URL 13 pair: URL; parsing 14 pair: relative; URL 15 16-------------- 17 18This module defines a standard interface to break Uniform Resource Locator (URL) 19strings up in components (addressing scheme, network location, path etc.), to 20combine the components back into a URL string, and to convert a "relative URL" 21to an absolute URL given a "base URL." 22 23The module has been designed to match the Internet RFC on Relative Uniform 24Resource Locators. It supports the following URL schemes: ``file``, ``ftp``, 25``gopher``, ``hdl``, ``http``, ``https``, ``imap``, ``mailto``, ``mms``, 26``news``, ``nntp``, ``prospero``, ``rsync``, ``rtsp``, ``rtspu``, ``sftp``, 27``shttp``, ``sip``, ``sips``, ``snews``, ``svn``, ``svn+ssh``, ``telnet``, 28``wais``, ``ws``, ``wss``. 29 30The :mod:`urllib.parse` module defines functions that fall into two broad 31categories: URL parsing and URL quoting. These are covered in detail in 32the following sections. 33 34URL Parsing 35----------- 36 37The URL parsing functions focus on splitting a URL string into its components, 38or on combining URL components into a URL string. 39 40.. function:: urlparse(urlstring, scheme='', allow_fragments=True) 41 42 Parse a URL into six components, returning a 6-tuple. This corresponds to the 43 general structure of a URL: ``scheme://netloc/path;parameters?query#fragment``. 44 Each tuple item is a string, possibly empty. The components are not broken up in 45 smaller parts (for example, the network location is a single string), and % 46 escapes are not expanded. The delimiters as shown above are not part of the 47 result, except for a leading slash in the *path* component, which is retained if 48 present. For example: 49 50 >>> from urllib.parse import urlparse 51 >>> o = urlparse('http://www.cwi.nl:80/%7Eguido/Python.html') 52 >>> o # doctest: +NORMALIZE_WHITESPACE 53 ParseResult(scheme='http', netloc='www.cwi.nl:80', path='/%7Eguido/Python.html', 54 params='', query='', fragment='') 55 >>> o.scheme 56 'http' 57 >>> o.port 58 80 59 >>> o.geturl() 60 'http://www.cwi.nl:80/%7Eguido/Python.html' 61 62 Following the syntax specifications in :rfc:`1808`, urlparse recognizes 63 a netloc only if it is properly introduced by '//'. Otherwise the 64 input is presumed to be a relative URL and thus to start with 65 a path component. 66 67 >>> from urllib.parse import urlparse 68 >>> urlparse('//www.cwi.nl:80/%7Eguido/Python.html') 69 ParseResult(scheme='', netloc='www.cwi.nl:80', path='/%7Eguido/Python.html', 70 params='', query='', fragment='') 71 >>> urlparse('www.cwi.nl/%7Eguido/Python.html') 72 ParseResult(scheme='', netloc='', path='www.cwi.nl/%7Eguido/Python.html', 73 params='', query='', fragment='') 74 >>> urlparse('help/Python.html') 75 ParseResult(scheme='', netloc='', path='help/Python.html', params='', 76 query='', fragment='') 77 78 The *scheme* argument gives the default addressing scheme, to be 79 used only if the URL does not specify one. It should be the same type 80 (text or bytes) as *urlstring*, except that the default value ``''`` is 81 always allowed, and is automatically converted to ``b''`` if appropriate. 82 83 If the *allow_fragments* argument is false, fragment identifiers are not 84 recognized. Instead, they are parsed as part of the path, parameters 85 or query component, and :attr:`fragment` is set to the empty string in 86 the return value. 87 88 The return value is actually an instance of a subclass of :class:`tuple`. This 89 class has the following additional read-only convenience attributes: 90 91 +------------------+-------+--------------------------+----------------------+ 92 | Attribute | Index | Value | Value if not present | 93 +==================+=======+==========================+======================+ 94 | :attr:`scheme` | 0 | URL scheme specifier | *scheme* parameter | 95 +------------------+-------+--------------------------+----------------------+ 96 | :attr:`netloc` | 1 | Network location part | empty string | 97 +------------------+-------+--------------------------+----------------------+ 98 | :attr:`path` | 2 | Hierarchical path | empty string | 99 +------------------+-------+--------------------------+----------------------+ 100 | :attr:`params` | 3 | Parameters for last path | empty string | 101 | | | element | | 102 +------------------+-------+--------------------------+----------------------+ 103 | :attr:`query` | 4 | Query component | empty string | 104 +------------------+-------+--------------------------+----------------------+ 105 | :attr:`fragment` | 5 | Fragment identifier | empty string | 106 +------------------+-------+--------------------------+----------------------+ 107 | :attr:`username` | | User name | :const:`None` | 108 +------------------+-------+--------------------------+----------------------+ 109 | :attr:`password` | | Password | :const:`None` | 110 +------------------+-------+--------------------------+----------------------+ 111 | :attr:`hostname` | | Host name (lower case) | :const:`None` | 112 +------------------+-------+--------------------------+----------------------+ 113 | :attr:`port` | | Port number as integer, | :const:`None` | 114 | | | if present | | 115 +------------------+-------+--------------------------+----------------------+ 116 117 Reading the :attr:`port` attribute will raise a :exc:`ValueError` if 118 an invalid port is specified in the URL. See section 119 :ref:`urlparse-result-object` for more information on the result object. 120 121 .. versionchanged:: 3.2 122 Added IPv6 URL parsing capabilities. 123 124 .. versionchanged:: 3.3 125 The fragment is now parsed for all URL schemes (unless *allow_fragment* is 126 false), in accordance with :rfc:`3986`. Previously, a whitelist of 127 schemes that support fragments existed. 128 129 .. versionchanged:: 3.6 130 Out-of-range port numbers now raise :exc:`ValueError`, instead of 131 returning :const:`None`. 132 133 134.. function:: parse_qs(qs, keep_blank_values=False, strict_parsing=False, encoding='utf-8', errors='replace') 135 136 Parse a query string given as a string argument (data of type 137 :mimetype:`application/x-www-form-urlencoded`). Data are returned as a 138 dictionary. The dictionary keys are the unique query variable names and the 139 values are lists of values for each name. 140 141 The optional argument *keep_blank_values* is a flag indicating whether blank 142 values in percent-encoded queries should be treated as blank strings. A true value 143 indicates that blanks should be retained as blank strings. The default false 144 value indicates that blank values are to be ignored and treated as if they were 145 not included. 146 147 The optional argument *strict_parsing* is a flag indicating what to do with 148 parsing errors. If false (the default), errors are silently ignored. If true, 149 errors raise a :exc:`ValueError` exception. 150 151 The optional *encoding* and *errors* parameters specify how to decode 152 percent-encoded sequences into Unicode characters, as accepted by the 153 :meth:`bytes.decode` method. 154 155 Use the :func:`urllib.parse.urlencode` function (with the ``doseq`` 156 parameter set to ``True``) to convert such dictionaries into query 157 strings. 158 159 160 .. versionchanged:: 3.2 161 Add *encoding* and *errors* parameters. 162 163 164.. function:: parse_qsl(qs, keep_blank_values=False, strict_parsing=False, encoding='utf-8', errors='replace') 165 166 Parse a query string given as a string argument (data of type 167 :mimetype:`application/x-www-form-urlencoded`). Data are returned as a list of 168 name, value pairs. 169 170 The optional argument *keep_blank_values* is a flag indicating whether blank 171 values in percent-encoded queries should be treated as blank strings. A true value 172 indicates that blanks should be retained as blank strings. The default false 173 value indicates that blank values are to be ignored and treated as if they were 174 not included. 175 176 The optional argument *strict_parsing* is a flag indicating what to do with 177 parsing errors. If false (the default), errors are silently ignored. If true, 178 errors raise a :exc:`ValueError` exception. 179 180 The optional *encoding* and *errors* parameters specify how to decode 181 percent-encoded sequences into Unicode characters, as accepted by the 182 :meth:`bytes.decode` method. 183 184 Use the :func:`urllib.parse.urlencode` function to convert such lists of pairs into 185 query strings. 186 187 .. versionchanged:: 3.2 188 Add *encoding* and *errors* parameters. 189 190 191.. function:: urlunparse(parts) 192 193 Construct a URL from a tuple as returned by ``urlparse()``. The *parts* 194 argument can be any six-item iterable. This may result in a slightly 195 different, but equivalent URL, if the URL that was parsed originally had 196 unnecessary delimiters (for example, a ``?`` with an empty query; the RFC 197 states that these are equivalent). 198 199 200.. function:: urlsplit(urlstring, scheme='', allow_fragments=True) 201 202 This is similar to :func:`urlparse`, but does not split the params from the URL. 203 This should generally be used instead of :func:`urlparse` if the more recent URL 204 syntax allowing parameters to be applied to each segment of the *path* portion 205 of the URL (see :rfc:`2396`) is wanted. A separate function is needed to 206 separate the path segments and parameters. This function returns a 5-tuple: 207 (addressing scheme, network location, path, query, fragment identifier). 208 209 The return value is actually an instance of a subclass of :class:`tuple`. This 210 class has the following additional read-only convenience attributes: 211 212 +------------------+-------+-------------------------+----------------------+ 213 | Attribute | Index | Value | Value if not present | 214 +==================+=======+=========================+======================+ 215 | :attr:`scheme` | 0 | URL scheme specifier | *scheme* parameter | 216 +------------------+-------+-------------------------+----------------------+ 217 | :attr:`netloc` | 1 | Network location part | empty string | 218 +------------------+-------+-------------------------+----------------------+ 219 | :attr:`path` | 2 | Hierarchical path | empty string | 220 +------------------+-------+-------------------------+----------------------+ 221 | :attr:`query` | 3 | Query component | empty string | 222 +------------------+-------+-------------------------+----------------------+ 223 | :attr:`fragment` | 4 | Fragment identifier | empty string | 224 +------------------+-------+-------------------------+----------------------+ 225 | :attr:`username` | | User name | :const:`None` | 226 +------------------+-------+-------------------------+----------------------+ 227 | :attr:`password` | | Password | :const:`None` | 228 +------------------+-------+-------------------------+----------------------+ 229 | :attr:`hostname` | | Host name (lower case) | :const:`None` | 230 +------------------+-------+-------------------------+----------------------+ 231 | :attr:`port` | | Port number as integer, | :const:`None` | 232 | | | if present | | 233 +------------------+-------+-------------------------+----------------------+ 234 235 Reading the :attr:`port` attribute will raise a :exc:`ValueError` if 236 an invalid port is specified in the URL. See section 237 :ref:`urlparse-result-object` for more information on the result object. 238 239 .. versionchanged:: 3.6 240 Out-of-range port numbers now raise :exc:`ValueError`, instead of 241 returning :const:`None`. 242 243 244.. function:: urlunsplit(parts) 245 246 Combine the elements of a tuple as returned by :func:`urlsplit` into a 247 complete URL as a string. The *parts* argument can be any five-item 248 iterable. This may result in a slightly different, but equivalent URL, if the 249 URL that was parsed originally had unnecessary delimiters (for example, a ? 250 with an empty query; the RFC states that these are equivalent). 251 252 253.. function:: urljoin(base, url, allow_fragments=True) 254 255 Construct a full ("absolute") URL by combining a "base URL" (*base*) with 256 another URL (*url*). Informally, this uses components of the base URL, in 257 particular the addressing scheme, the network location and (part of) the 258 path, to provide missing components in the relative URL. For example: 259 260 >>> from urllib.parse import urljoin 261 >>> urljoin('http://www.cwi.nl/%7Eguido/Python.html', 'FAQ.html') 262 'http://www.cwi.nl/%7Eguido/FAQ.html' 263 264 The *allow_fragments* argument has the same meaning and default as for 265 :func:`urlparse`. 266 267 .. note:: 268 269 If *url* is an absolute URL (that is, starting with ``//`` or ``scheme://``), 270 the *url*'s host name and/or scheme will be present in the result. For example: 271 272 .. doctest:: 273 274 >>> urljoin('http://www.cwi.nl/%7Eguido/Python.html', 275 ... '//www.python.org/%7Eguido') 276 'http://www.python.org/%7Eguido' 277 278 If you do not want that behavior, preprocess the *url* with :func:`urlsplit` and 279 :func:`urlunsplit`, removing possible *scheme* and *netloc* parts. 280 281 282 .. versionchanged:: 3.5 283 284 Behaviour updated to match the semantics defined in :rfc:`3986`. 285 286 287.. function:: urldefrag(url) 288 289 If *url* contains a fragment identifier, return a modified version of *url* 290 with no fragment identifier, and the fragment identifier as a separate 291 string. If there is no fragment identifier in *url*, return *url* unmodified 292 and an empty string. 293 294 The return value is actually an instance of a subclass of :class:`tuple`. This 295 class has the following additional read-only convenience attributes: 296 297 +------------------+-------+-------------------------+----------------------+ 298 | Attribute | Index | Value | Value if not present | 299 +==================+=======+=========================+======================+ 300 | :attr:`url` | 0 | URL with no fragment | empty string | 301 +------------------+-------+-------------------------+----------------------+ 302 | :attr:`fragment` | 1 | Fragment identifier | empty string | 303 +------------------+-------+-------------------------+----------------------+ 304 305 See section :ref:`urlparse-result-object` for more information on the result 306 object. 307 308 .. versionchanged:: 3.2 309 Result is a structured object rather than a simple 2-tuple. 310 311.. _parsing-ascii-encoded-bytes: 312 313Parsing ASCII Encoded Bytes 314--------------------------- 315 316The URL parsing functions were originally designed to operate on character 317strings only. In practice, it is useful to be able to manipulate properly 318quoted and encoded URLs as sequences of ASCII bytes. Accordingly, the 319URL parsing functions in this module all operate on :class:`bytes` and 320:class:`bytearray` objects in addition to :class:`str` objects. 321 322If :class:`str` data is passed in, the result will also contain only 323:class:`str` data. If :class:`bytes` or :class:`bytearray` data is 324passed in, the result will contain only :class:`bytes` data. 325 326Attempting to mix :class:`str` data with :class:`bytes` or 327:class:`bytearray` in a single function call will result in a 328:exc:`TypeError` being raised, while attempting to pass in non-ASCII 329byte values will trigger :exc:`UnicodeDecodeError`. 330 331To support easier conversion of result objects between :class:`str` and 332:class:`bytes`, all return values from URL parsing functions provide 333either an :meth:`encode` method (when the result contains :class:`str` 334data) or a :meth:`decode` method (when the result contains :class:`bytes` 335data). The signatures of these methods match those of the corresponding 336:class:`str` and :class:`bytes` methods (except that the default encoding 337is ``'ascii'`` rather than ``'utf-8'``). Each produces a value of a 338corresponding type that contains either :class:`bytes` data (for 339:meth:`encode` methods) or :class:`str` data (for 340:meth:`decode` methods). 341 342Applications that need to operate on potentially improperly quoted URLs 343that may contain non-ASCII data will need to do their own decoding from 344bytes to characters before invoking the URL parsing methods. 345 346The behaviour described in this section applies only to the URL parsing 347functions. The URL quoting functions use their own rules when producing 348or consuming byte sequences as detailed in the documentation of the 349individual URL quoting functions. 350 351.. versionchanged:: 3.2 352 URL parsing functions now accept ASCII encoded byte sequences 353 354 355.. _urlparse-result-object: 356 357Structured Parse Results 358------------------------ 359 360The result objects from the :func:`urlparse`, :func:`urlsplit` and 361:func:`urldefrag` functions are subclasses of the :class:`tuple` type. 362These subclasses add the attributes listed in the documentation for 363those functions, the encoding and decoding support described in the 364previous section, as well as an additional method: 365 366.. method:: urllib.parse.SplitResult.geturl() 367 368 Return the re-combined version of the original URL as a string. This may 369 differ from the original URL in that the scheme may be normalized to lower 370 case and empty components may be dropped. Specifically, empty parameters, 371 queries, and fragment identifiers will be removed. 372 373 For :func:`urldefrag` results, only empty fragment identifiers will be removed. 374 For :func:`urlsplit` and :func:`urlparse` results, all noted changes will be 375 made to the URL returned by this method. 376 377 The result of this method remains unchanged if passed back through the original 378 parsing function: 379 380 >>> from urllib.parse import urlsplit 381 >>> url = 'HTTP://www.Python.org/doc/#' 382 >>> r1 = urlsplit(url) 383 >>> r1.geturl() 384 'http://www.Python.org/doc/' 385 >>> r2 = urlsplit(r1.geturl()) 386 >>> r2.geturl() 387 'http://www.Python.org/doc/' 388 389 390The following classes provide the implementations of the structured parse 391results when operating on :class:`str` objects: 392 393.. class:: DefragResult(url, fragment) 394 395 Concrete class for :func:`urldefrag` results containing :class:`str` 396 data. The :meth:`encode` method returns a :class:`DefragResultBytes` 397 instance. 398 399 .. versionadded:: 3.2 400 401.. class:: ParseResult(scheme, netloc, path, params, query, fragment) 402 403 Concrete class for :func:`urlparse` results containing :class:`str` 404 data. The :meth:`encode` method returns a :class:`ParseResultBytes` 405 instance. 406 407.. class:: SplitResult(scheme, netloc, path, query, fragment) 408 409 Concrete class for :func:`urlsplit` results containing :class:`str` 410 data. The :meth:`encode` method returns a :class:`SplitResultBytes` 411 instance. 412 413 414The following classes provide the implementations of the parse results when 415operating on :class:`bytes` or :class:`bytearray` objects: 416 417.. class:: DefragResultBytes(url, fragment) 418 419 Concrete class for :func:`urldefrag` results containing :class:`bytes` 420 data. The :meth:`decode` method returns a :class:`DefragResult` 421 instance. 422 423 .. versionadded:: 3.2 424 425.. class:: ParseResultBytes(scheme, netloc, path, params, query, fragment) 426 427 Concrete class for :func:`urlparse` results containing :class:`bytes` 428 data. The :meth:`decode` method returns a :class:`ParseResult` 429 instance. 430 431 .. versionadded:: 3.2 432 433.. class:: SplitResultBytes(scheme, netloc, path, query, fragment) 434 435 Concrete class for :func:`urlsplit` results containing :class:`bytes` 436 data. The :meth:`decode` method returns a :class:`SplitResult` 437 instance. 438 439 .. versionadded:: 3.2 440 441 442URL Quoting 443----------- 444 445The URL quoting functions focus on taking program data and making it safe 446for use as URL components by quoting special characters and appropriately 447encoding non-ASCII text. They also support reversing these operations to 448recreate the original data from the contents of a URL component if that 449task isn't already covered by the URL parsing functions above. 450 451.. function:: quote(string, safe='/', encoding=None, errors=None) 452 453 Replace special characters in *string* using the ``%xx`` escape. Letters, 454 digits, and the characters ``'_.-'`` are never quoted. By default, this 455 function is intended for quoting the path section of URL. The optional *safe* 456 parameter specifies additional ASCII characters that should not be quoted 457 --- its default value is ``'/'``. 458 459 *string* may be either a :class:`str` or a :class:`bytes`. 460 461 The optional *encoding* and *errors* parameters specify how to deal with 462 non-ASCII characters, as accepted by the :meth:`str.encode` method. 463 *encoding* defaults to ``'utf-8'``. 464 *errors* defaults to ``'strict'``, meaning unsupported characters raise a 465 :class:`UnicodeEncodeError`. 466 *encoding* and *errors* must not be supplied if *string* is a 467 :class:`bytes`, or a :class:`TypeError` is raised. 468 469 Note that ``quote(string, safe, encoding, errors)`` is equivalent to 470 ``quote_from_bytes(string.encode(encoding, errors), safe)``. 471 472 Example: ``quote('/El Niño/')`` yields ``'/El%20Ni%C3%B1o/'``. 473 474 475.. function:: quote_plus(string, safe='', encoding=None, errors=None) 476 477 Like :func:`quote`, but also replace spaces by plus signs, as required for 478 quoting HTML form values when building up a query string to go into a URL. 479 Plus signs in the original string are escaped unless they are included in 480 *safe*. It also does not have *safe* default to ``'/'``. 481 482 Example: ``quote_plus('/El Niño/')`` yields ``'%2FEl+Ni%C3%B1o%2F'``. 483 484 485.. function:: quote_from_bytes(bytes, safe='/') 486 487 Like :func:`quote`, but accepts a :class:`bytes` object rather than a 488 :class:`str`, and does not perform string-to-bytes encoding. 489 490 Example: ``quote_from_bytes(b'a&\xef')`` yields 491 ``'a%26%EF'``. 492 493 494.. function:: unquote(string, encoding='utf-8', errors='replace') 495 496 Replace ``%xx`` escapes by their single-character equivalent. 497 The optional *encoding* and *errors* parameters specify how to decode 498 percent-encoded sequences into Unicode characters, as accepted by the 499 :meth:`bytes.decode` method. 500 501 *string* must be a :class:`str`. 502 503 *encoding* defaults to ``'utf-8'``. 504 *errors* defaults to ``'replace'``, meaning invalid sequences are replaced 505 by a placeholder character. 506 507 Example: ``unquote('/El%20Ni%C3%B1o/')`` yields ``'/El Niño/'``. 508 509 510.. function:: unquote_plus(string, encoding='utf-8', errors='replace') 511 512 Like :func:`unquote`, but also replace plus signs by spaces, as required for 513 unquoting HTML form values. 514 515 *string* must be a :class:`str`. 516 517 Example: ``unquote_plus('/El+Ni%C3%B1o/')`` yields ``'/El Niño/'``. 518 519 520.. function:: unquote_to_bytes(string) 521 522 Replace ``%xx`` escapes by their single-octet equivalent, and return a 523 :class:`bytes` object. 524 525 *string* may be either a :class:`str` or a :class:`bytes`. 526 527 If it is a :class:`str`, unescaped non-ASCII characters in *string* 528 are encoded into UTF-8 bytes. 529 530 Example: ``unquote_to_bytes('a%26%EF')`` yields ``b'a&\xef'``. 531 532 533.. function:: urlencode(query, doseq=False, safe='', encoding=None, \ 534 errors=None, quote_via=quote_plus) 535 536 Convert a mapping object or a sequence of two-element tuples, which may 537 contain :class:`str` or :class:`bytes` objects, to a percent-encoded ASCII 538 text string. If the resultant string is to be used as a *data* for POST 539 operation with the :func:`~urllib.request.urlopen` function, then 540 it should be encoded to bytes, otherwise it would result in a 541 :exc:`TypeError`. 542 543 The resulting string is a series of ``key=value`` pairs separated by ``'&'`` 544 characters, where both *key* and *value* are quoted using the *quote_via* 545 function. By default, :func:`quote_plus` is used to quote the values, which 546 means spaces are quoted as a ``'+'`` character and '/' characters are 547 encoded as ``%2F``, which follows the standard for GET requests 548 (``application/x-www-form-urlencoded``). An alternate function that can be 549 passed as *quote_via* is :func:`quote`, which will encode spaces as ``%20`` 550 and not encode '/' characters. For maximum control of what is quoted, use 551 ``quote`` and specify a value for *safe*. 552 553 When a sequence of two-element tuples is used as the *query* 554 argument, the first element of each tuple is a key and the second is a 555 value. The value element in itself can be a sequence and in that case, if 556 the optional parameter *doseq* is evaluates to ``True``, individual 557 ``key=value`` pairs separated by ``'&'`` are generated for each element of 558 the value sequence for the key. The order of parameters in the encoded 559 string will match the order of parameter tuples in the sequence. 560 561 The *safe*, *encoding*, and *errors* parameters are passed down to 562 *quote_via* (the *encoding* and *errors* parameters are only passed 563 when a query element is a :class:`str`). 564 565 To reverse this encoding process, :func:`parse_qs` and :func:`parse_qsl` are 566 provided in this module to parse query strings into Python data structures. 567 568 Refer to :ref:`urllib examples <urllib-examples>` to find out how urlencode 569 method can be used for generating query string for a URL or data for POST. 570 571 .. versionchanged:: 3.2 572 Query parameter supports bytes and string objects. 573 574 .. versionadded:: 3.5 575 *quote_via* parameter. 576 577 578.. seealso:: 579 580 :rfc:`3986` - Uniform Resource Identifiers 581 This is the current standard (STD66). Any changes to urllib.parse module 582 should conform to this. Certain deviations could be observed, which are 583 mostly for backward compatibility purposes and for certain de-facto 584 parsing requirements as commonly observed in major browsers. 585 586 :rfc:`2732` - Format for Literal IPv6 Addresses in URL's. 587 This specifies the parsing requirements of IPv6 URLs. 588 589 :rfc:`2396` - Uniform Resource Identifiers (URI): Generic Syntax 590 Document describing the generic syntactic requirements for both Uniform Resource 591 Names (URNs) and Uniform Resource Locators (URLs). 592 593 :rfc:`2368` - The mailto URL scheme. 594 Parsing requirements for mailto URL schemes. 595 596 :rfc:`1808` - Relative Uniform Resource Locators 597 This Request For Comments includes the rules for joining an absolute and a 598 relative URL, including a fair number of "Abnormal Examples" which govern the 599 treatment of border cases. 600 601 :rfc:`1738` - Uniform Resource Locators (URL) 602 This specifies the formal syntax and semantics of absolute URLs. 603