urllib Namespace Reference

Data Structures
class	URLopener
class	FancyURLopener
class	ftpwrapper
class	addbase
class	addclosehook
class	addinfo
class	addinfourl

Functions
def	url2pathname
def	pathname2url
def	urlopen
def	urlretrieve
def	urlcleanup
def	localhost
def	thishost
def	ftperrors
def	noheaders
def	basejoin
def	toBytes
def	unwrap
def	splittype
def	splithost
def	splituser
def	splitpasswd
def	splitport
def	splitnport
def	splitquery
def	splittag
def	splitattr
def	splitvalue
def	splitgophertype
def	unquote
def	unquote_plus
def	quote
def	quote_plus
def	urlencode
def	getproxies_environment
def	getproxies
def	proxy_bypass
def	getproxies_registry
def	test1
def	reporthook
def	test
def	main

Variables
list	__all__
string	__version__ = '1.15'
int	MAXFTPCACHE = 10
	_urlopener = None
dictionary	ftpcache = {}
	_localhost = None
	_thishost = None
	_ftperrors = None
	_noheaders = None
	_typeprog = None
	_hostprog = None
	_userprog = None
	_passwdprog = None
	_portprog = None
	_nportprog = None
	_queryprog = None
	_tagprog = None
	_valueprog = None
tuple	always_safe
string	_fast_safe_test = always_safe+'/'
	_fast_safe = None
	getproxies = getproxies_environment
tuple	fp = open(fn, 'rb')
	'gopher://gopher.micro.umn.edu/1/', More...
tuple	data = fp.read()
tuple	table = string.maketrans("", "")

Detailed Description

Open an arbitrary URL.

See the following document for more info on URLs:
"Names and Addresses, URIs, URLs, URNs, URCs", at
http://www.w3.org/pub/WWW/Addressing/Overview.html

See also the HTTP spec (from which the error codes are derived):
"HTTP - Hypertext Transfer Protocol", at
http://www.w3.org/pub/WWW/Protocols/

Related standards and specs:
- RFC1808: the "relative URL" spec. (authoritative status)
- RFC1738 - the "URL standard". (authoritative status)
- RFC1630 - the "URI spec". (informational status)

The object returned by URLopener().open(file) will differ per
protocol.  All you know is that is has methods read(), readline(),
readlines(), fileno(), close() and info().  The read*(), fileno()
and close() methods work like those of open files.
The info() method returns a mimetools.Message object which can be
used to query various info about the object, if available.
(mimetools.Message objects are queried with the getheader() method.)

Function Documentation

def urllib.basejoin	(		base,
			url
	)

Utility to combine a URL with a base URL to form a new URL.

Definition at line 828 of file urllib.py.

References string.rfind(), splithost(), splitquery(), splittag(), and splittype().

def basejoin(base, url):
    """Utility to combine a URL with a base URL to form a new URL."""
    type, path = splittype(url)
    if type:
        # if url is complete (i.e., it contains a type), return it
        return url
    host, path = splithost(path)
    type, basepath = splittype(base) # inherit type from base
    if host:
        # if url contains host, just inherit type
        if type: return type + '://' + host + path
        else:
            # no type inherited, so url must have started with //
            # just return it
            return url
    host, basepath = splithost(basepath) # inherit host
    basepath, basetag = splittag(basepath) # remove extraneous cruft
    basepath, basequery = splitquery(basepath) # idem
    if path[:1] != '/':
        # non-absolute path name
        if path[:1] in ('#', '?'):
            # path is just a tag or query, attach to basepath
            i = len(basepath)
        else:
            # else replace last component
            i = basepath.rfind('/')
        if i < 0:
            # basepath not absolute
            if host:
                # host present, make absolute
                basepath = '/'
            else:
                # else keep non-absolute
                basepath = ''
        else:
            # remove last file component
            basepath = basepath[:i+1]
        # Interpret ../ (important because of symlinks)
        while basepath and path[:3] == '../':
            path = path[3:]
            i = basepath[:-1].rfind('/')
            if i > 0:
                basepath = basepath[:i+1]
            elif i == 0:
                basepath = '/'
                break
            else:
                basepath = ''

        path = basepath + path
    if host and path and path[0] != '/':
        path = '/' + path
    if type and host: return type + '://' + host + path
    elif type: return type + ':' + path
    elif host: return '//' + host + path # don't know what this means
    else: return path


# Utilities to parse URLs (most of these return None for missing parts):
# unwrap('<URL:type://host/path>') --> 'type://host/path'
# splittype('type:opaquestring') --> 'type', 'opaquestring'
# splithost('//host[:port]/path') --> 'host[:port]', '/path'
# splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'
# splitpasswd('user:passwd') -> 'user', 'passwd'
# splitport('host:port') --> 'host', 'port'
# splitquery('/path?query') --> '/path', 'query'
# splittag('/path#tag') --> '/path', 'tag'
# splitattr('/path;attr1=value1;attr2=value2;...') ->
#   '/path', ['attr1=value1', 'attr2=value2', ...]
# splitvalue('attr=value') --> 'attr', 'value'
# splitgophertype('/Xselector') --> 'X', 'selector'
# unquote('abc%20def') -> 'abc def'
# quote('abc def') -> 'abc%20def')