home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / urllib.py < prev    next >
Encoding:
Python Source  |  2009-04-18  |  63.3 KB  |  1,777 lines
  1. """Open an arbitrary URL.
  2.  
  3. See the following document for more info on URLs:
  4. "Names and Addresses, URIs, URLs, URNs, URCs", at
  5. http://www.w3.org/pub/WWW/Addressing/Overview.html
  6.  
  7. See also the HTTP spec (from which the error codes are derived):
  8. "HTTP - Hypertext Transfer Protocol", at
  9. http://www.w3.org/pub/WWW/Protocols/
  10.  
  11. Related standards and specs:
  12. - RFC1808: the "relative URL" spec. (authoritative status)
  13. - RFC1738 - the "URL standard". (authoritative status)
  14. - RFC1630 - the "URI spec". (informational status)
  15.  
  16. The object returned by URLopener().open(file) will differ per
  17. protocol.  All you know is that is has methods read(), readline(),
  18. readlines(), fileno(), close() and info().  The read*(), fileno()
  19. and close() methods work like those of open files.
  20. The info() method returns a mimetools.Message object which can be
  21. used to query various info about the object, if available.
  22. (mimetools.Message objects are queried with the getheader() method.)
  23. """
  24.  
  25. import string
  26. import socket
  27. import os
  28. import time
  29. import sys
  30. from urlparse import urljoin as basejoin
  31. import warnings
  32.  
  33. __all__ = ["urlopen", "URLopener", "FancyURLopener", "urlretrieve",
  34.            "urlcleanup", "quote", "quote_plus", "unquote", "unquote_plus",
  35.            "urlencode", "url2pathname", "pathname2url", "splittag",
  36.            "localhost", "thishost", "ftperrors", "basejoin", "unwrap",
  37.            "splittype", "splithost", "splituser", "splitpasswd", "splitport",
  38.            "splitnport", "splitquery", "splitattr", "splitvalue",
  39.            "getproxies"]
  40.  
  41. __version__ = '1.17'    # XXX This version is not always updated :-(
  42.  
  43. MAXFTPCACHE = 10        # Trim the ftp cache beyond this size
  44.  
  45. # Helper for non-unix systems
  46. if os.name == 'mac':
  47.     from macurl2path import url2pathname, pathname2url
  48. elif os.name == 'nt':
  49.     from nturl2path import url2pathname, pathname2url
  50. elif os.name == 'riscos':
  51.     from rourl2path import url2pathname, pathname2url
  52. else:
  53.     def url2pathname(pathname):
  54.         """OS-specific conversion from a relative URL of the 'file' scheme
  55.         to a file system path; not recommended for general use."""
  56.         return unquote(pathname)
  57.  
  58.     def pathname2url(pathname):
  59.         """OS-specific conversion from a file system path to a relative URL
  60.         of the 'file' scheme; not recommended for general use."""
  61.         return quote(pathname)
  62.  
  63. # This really consists of two pieces:
  64. # (1) a class which handles opening of all sorts of URLs
  65. #     (plus assorted utilities etc.)
  66. # (2) a set of functions for parsing URLs
  67. # XXX Should these be separated out into different modules?
  68.  
  69.  
  70. # Shortcut for basic usage
  71. _urlopener = None
  72. def urlopen(url, data=None, proxies=None):
  73.     """Create a file-like object for the specified URL to read from."""
  74.     from warnings import warnpy3k
  75.     warnings.warnpy3k("urllib.urlopen() has been removed in Python 3.0 in "
  76.                         "favor of urllib2.urlopen()", stacklevel=2)
  77.  
  78.     global _urlopener
  79.     if proxies is not None:
  80.         opener = FancyURLopener(proxies=proxies)
  81.     elif not _urlopener:
  82.         opener = FancyURLopener()
  83.         _urlopener = opener
  84.     else:
  85.         opener = _urlopener
  86.     if data is None:
  87.         return opener.open(url)
  88.     else:
  89.         return opener.open(url, data)
  90. def urlretrieve(url, filename=None, reporthook=None, data=None):
  91.     global _urlopener
  92.     if not _urlopener:
  93.         _urlopener = FancyURLopener()
  94.     return _urlopener.retrieve(url, filename, reporthook, data)
  95. def urlcleanup():
  96.     if _urlopener:
  97.         _urlopener.cleanup()
  98.  
  99. # check for SSL
  100. try:
  101.     import ssl
  102. except:
  103.     _have_ssl = False
  104. else:
  105.     _have_ssl = True
  106.  
  107. # exception raised when downloaded size does not match content-length
  108. class ContentTooShortError(IOError):
  109.     def __init__(self, message, content):
  110.         IOError.__init__(self, message)
  111.         self.content = content
  112.  
  113. ftpcache = {}
  114. class URLopener:
  115.     """Class to open URLs.
  116.     This is a class rather than just a subroutine because we may need
  117.     more than one set of global protocol-specific options.
  118.     Note -- this is a base class for those who don't want the
  119.     automatic handling of errors type 302 (relocated) and 401
  120.     (authorization needed)."""
  121.  
  122.     __tempfiles = None
  123.  
  124.     version = "Python-urllib/%s" % __version__
  125.  
  126.     # Constructor
  127.     def __init__(self, proxies=None, **x509):
  128.         if proxies is None:
  129.             proxies = getproxies()
  130.         assert hasattr(proxies, 'has_key'), "proxies must be a mapping"
  131.         self.proxies = proxies
  132.         self.key_file = x509.get('key_file')
  133.         self.cert_file = x509.get('cert_file')
  134.         self.addheaders = [('User-Agent', self.version)]
  135.         self.__tempfiles = []
  136.         self.__unlink = os.unlink # See cleanup()
  137.         self.tempcache = None
  138.         # Undocumented feature: if you assign {} to tempcache,
  139.         # it is used to cache files retrieved with
  140.         # self.retrieve().  This is not enabled by default
  141.         # since it does not work for changing documents (and I
  142.         # haven't got the logic to check expiration headers
  143.         # yet).
  144.         self.ftpcache = ftpcache
  145.         # Undocumented feature: you can use a different
  146.         # ftp cache by assigning to the .ftpcache member;
  147.         # in case you want logically independent URL openers
  148.         # XXX This is not threadsafe.  Bah.
  149.  
  150.     def __del__(self):
  151.         self.close()
  152.  
  153.     def close(self):
  154.         self.cleanup()
  155.  
  156.     def cleanup(self):
  157.         # This code sometimes runs when the rest of this module
  158.         # has already been deleted, so it can't use any globals
  159.         # or import anything.
  160.         if self.__tempfiles:
  161.             for file in self.__tempfiles:
  162.                 try:
  163.                     self.__unlink(file)
  164.                 except OSError:
  165.                     pass
  166.             del self.__tempfiles[:]
  167.         if self.tempcache:
  168.             self.tempcache.clear()
  169.  
  170.     def addheader(self, *args):
  171.         """Add a header to be used by the HTTP interface only
  172.         e.g. u.addheader('Accept', 'sound/basic')"""
  173.         self.addheaders.append(args)
  174.  
  175.     # External interface
  176.     def open(self, fullurl, data=None):
  177.         """Use URLopener().open(file) instead of open(file, 'r')."""
  178.         fullurl = unwrap(toBytes(fullurl))
  179.         if self.tempcache and fullurl in self.tempcache:
  180.             filename, headers = self.tempcache[fullurl]
  181.             fp = open(filename, 'rb')
  182.             return addinfourl(fp, headers, fullurl)
  183.         urltype, url = splittype(fullurl)
  184.         if not urltype:
  185.             urltype = 'file'
  186.         if urltype in self.proxies:
  187.             proxy = self.proxies[urltype]
  188.             urltype, proxyhost = splittype(proxy)
  189.             host, selector = splithost(proxyhost)
  190.             url = (host, fullurl) # Signal special case to open_*()
  191.         else:
  192.             proxy = None
  193.         name = 'open_' + urltype
  194.         self.type = urltype
  195.         name = name.replace('-', '_')
  196.         if not hasattr(self, name):
  197.             if proxy:
  198.                 return self.open_unknown_proxy(proxy, fullurl, data)
  199.             else:
  200.                 return self.open_unknown(fullurl, data)
  201.         try:
  202.             if data is None:
  203.                 return getattr(self, name)(url)
  204.             else:
  205.                 return getattr(self, name)(url, data)
  206.         except socket.error, msg:
  207.             raise IOError, ('socket error', msg), sys.exc_info()[2]
  208.  
  209.     def open_unknown(self, fullurl, data=None):
  210.         """Overridable interface to open unknown URL type."""
  211.         type, url = splittype(fullurl)
  212.         raise IOError, ('url error', 'unknown url type', type)
  213.  
  214.     def open_unknown_proxy(self, proxy, fullurl, data=None):
  215.         """Overridable interface to open unknown URL type."""
  216.         type, url = splittype(fullurl)
  217.         raise IOError, ('url error', 'invalid proxy for %s' % type, proxy)
  218.  
  219.     # External interface
  220.     def retrieve(self, url, filename=None, reporthook=None, data=None):
  221.         """retrieve(url) returns (filename, headers) for a local object
  222.         or (tempfilename, headers) for a remote object."""
  223.         url = unwrap(toBytes(url))
  224.         if self.tempcache and url in self.tempcache:
  225.             return self.tempcache[url]
  226.         type, url1 = splittype(url)
  227.         if filename is None and (not type or type == 'file'):
  228.             try:
  229.                 fp = self.open_local_file(url1)
  230.                 hdrs = fp.info()
  231.                 del fp
  232.                 return url2pathname(splithost(url1)[1]), hdrs
  233.             except IOError, msg:
  234.                 pass
  235.         fp = self.open(url, data)
  236.         try:
  237.             headers = fp.info()
  238.             if filename:
  239.                 tfp = open(filename, 'wb')
  240.             else:
  241.                 import tempfile
  242.                 garbage, path = splittype(url)
  243.                 garbage, path = splithost(path or "")
  244.                 path, garbage = splitquery(path or "")
  245.                 path, garbage = splitattr(path or "")
  246.                 suffix = os.path.splitext(path)[1]
  247.                 (fd, filename) = tempfile.mkstemp(suffix)
  248.                 self.__tempfiles.append(filename)
  249.                 tfp = os.fdopen(fd, 'wb')
  250.             try:
  251.                 result = filename, headers
  252.                 if self.tempcache is not None:
  253.                     self.tempcache[url] = result
  254.                 bs = 1024*8
  255.                 size = -1
  256.                 read = 0
  257.                 blocknum = 0
  258.                 if reporthook:
  259.                     if "content-length" in headers:
  260.                         size = int(headers["Content-Length"])
  261.                     reporthook(blocknum, bs, size)
  262.                 while 1:
  263.                     block = fp.read(bs)
  264.                     if block == "":
  265.                         break
  266.                     read += len(block)
  267.                     tfp.write(block)
  268.                     blocknum += 1
  269.                     if reporthook:
  270.                         reporthook(blocknum, bs, size)
  271.             finally:
  272.                 tfp.close()
  273.         finally:
  274.             fp.close()
  275.         del fp
  276.         del tfp
  277.  
  278.         # raise exception if actual size does not match content-length header
  279.         if size >= 0 and read < size:
  280.             raise ContentTooShortError("retrieval incomplete: got only %i out "
  281.                                        "of %i bytes" % (read, size), result)
  282.  
  283.         return result
  284.  
  285.     # Each method named open_<type> knows how to open that type of URL
  286.  
  287.     def open_http(self, url, data=None):
  288.         """Use HTTP protocol."""
  289.         import httplib
  290.         user_passwd = None
  291.         proxy_passwd= None
  292.         if isinstance(url, str):
  293.             host, selector = splithost(url)
  294.             if host:
  295.                 user_passwd, host = splituser(host)
  296.                 host = unquote(host)
  297.             realhost = host
  298.         else:
  299.             host, selector = url
  300.             # check whether the proxy contains authorization information
  301.             proxy_passwd, host = splituser(host)
  302.             # now we proceed with the url we want to obtain
  303.             urltype, rest = splittype(selector)
  304.             url = rest
  305.             user_passwd = None
  306.             if urltype.lower() != 'http':
  307.                 realhost = None
  308.             else:
  309.                 realhost, rest = splithost(rest)
  310.                 if realhost:
  311.                     user_passwd, realhost = splituser(realhost)
  312.                 if user_passwd:
  313.                     selector = "%s://%s%s" % (urltype, realhost, rest)
  314.                 if proxy_bypass(realhost):
  315.                     host = realhost
  316.  
  317.             #print "proxy via http:", host, selector
  318.         if not host: raise IOError, ('http error', 'no host given')
  319.  
  320.         if proxy_passwd:
  321.             import base64
  322.             proxy_auth = base64.b64encode(proxy_passwd).strip()
  323.         else:
  324.             proxy_auth = None
  325.  
  326.         if user_passwd:
  327.             import base64
  328.             auth = base64.b64encode(user_passwd).strip()
  329.         else:
  330.             auth = None
  331.         h = httplib.HTTP(host)
  332.         if data is not None:
  333.             h.putrequest('POST', selector)
  334.             h.putheader('Content-Type', 'application/x-www-form-urlencoded')
  335.             h.putheader('Content-Length', '%d' % len(data))
  336.         else:
  337.             h.putrequest('GET', selector)
  338.         if proxy_auth: h.putheader('Proxy-Authorization', 'Basic %s' % proxy_auth)
  339.         if auth: h.putheader('Authorization', 'Basic %s' % auth)
  340.         if realhost: h.putheader('Host', realhost)
  341.         for args in self.addheaders: h.putheader(*args)
  342.         h.endheaders()
  343.         if data is not None:
  344.             h.send(data)
  345.         errcode, errmsg, headers = h.getreply()
  346.         fp = h.getfile()
  347.         if errcode == -1:
  348.             if fp: fp.close()
  349.             # something went wrong with the HTTP status line
  350.             raise IOError, ('http protocol error', 0,
  351.                             'got a bad status line', None)
  352.         # According to RFC 2616, "2xx" code indicates that the client's
  353.         # request was successfully received, understood, and accepted.
  354.         if (200 <= errcode < 300):
  355.             return addinfourl(fp, headers, "http:" + url, errcode)
  356.         else:
  357.             if data is None:
  358.                 return self.http_error(url, fp, errcode, errmsg, headers)
  359.             else:
  360.                 return self.http_error(url, fp, errcode, errmsg, headers, data)
  361.  
  362.     def http_error(self, url, fp, errcode, errmsg, headers, data=None):
  363.         """Handle http errors.
  364.         Derived class can override this, or provide specific handlers
  365.         named http_error_DDD where DDD is the 3-digit error code."""
  366.         # First check if there's a specific handler for this error
  367.         name = 'http_error_%d' % errcode
  368.         if hasattr(self, name):
  369.             method = getattr(self, name)
  370.             if data is None:
  371.                 result = method(url, fp, errcode, errmsg, headers)
  372.             else:
  373.                 result = method(url, fp, errcode, errmsg, headers, data)
  374.             if result: return result
  375.         return self.http_error_default(url, fp, errcode, errmsg, headers)
  376.  
  377.     def http_error_default(self, url, fp, errcode, errmsg, headers):
  378.         """Default error handler: close the connection and raise IOError."""
  379.         void = fp.read()
  380.         fp.close()
  381.         raise IOError, ('http error', errcode, errmsg, headers)
  382.  
  383.     if _have_ssl:
  384.         def open_https(self, url, data=None):
  385.             """Use HTTPS protocol."""
  386.  
  387.             import httplib
  388.             user_passwd = None
  389.             proxy_passwd = None
  390.             if isinstance(url, str):
  391.                 host, selector = splithost(url)
  392.                 if host:
  393.                     user_passwd, host = splituser(host)
  394.                     host = unquote(host)
  395.                 realhost = host
  396.             else:
  397.                 host, selector = url
  398.                 # here, we determine, whether the proxy contains authorization information
  399.                 proxy_passwd, host = splituser(host)
  400.                 urltype, rest = splittype(selector)
  401.                 url = rest
  402.                 user_passwd = None
  403.                 if urltype.lower() != 'https':
  404.                     realhost = None
  405.                 else:
  406.                     realhost, rest = splithost(rest)
  407.                     if realhost:
  408.                         user_passwd, realhost = splituser(realhost)
  409.                     if user_passwd:
  410.                         selector = "%s://%s%s" % (urltype, realhost, rest)
  411.                 #print "proxy via https:", host, selector
  412.             if not host: raise IOError, ('https error', 'no host given')
  413.             if proxy_passwd:
  414.                 import base64
  415.                 proxy_auth = base64.b64encode(proxy_passwd).strip()
  416.             else:
  417.                 proxy_auth = None
  418.             if user_passwd:
  419.                 import base64
  420.                 auth = base64.b64encode(user_passwd).strip()
  421.             else:
  422.                 auth = None
  423.             h = httplib.HTTPS(host, 0,
  424.                               key_file=self.key_file,
  425.                               cert_file=self.cert_file)
  426.             if data is not None:
  427.                 h.putrequest('POST', selector)
  428.                 h.putheader('Content-Type',
  429.                             'application/x-www-form-urlencoded')
  430.                 h.putheader('Content-Length', '%d' % len(data))
  431.             else:
  432.                 h.putrequest('GET', selector)
  433.             if proxy_auth: h.putheader('Proxy-Authorization', 'Basic %s' % proxy_auth)
  434.             if auth: h.putheader('Authorization', 'Basic %s' % auth)
  435.             if realhost: h.putheader('Host', realhost)
  436.             for args in self.addheaders: h.putheader(*args)
  437.             h.endheaders()
  438.             if data is not None:
  439.                 h.send(data)
  440.             errcode, errmsg, headers = h.getreply()
  441.             fp = h.getfile()
  442.             if errcode == -1:
  443.                 if fp: fp.close()
  444.                 # something went wrong with the HTTP status line
  445.                 raise IOError, ('http protocol error', 0,
  446.                                 'got a bad status line', None)
  447.             # According to RFC 2616, "2xx" code indicates that the client's
  448.             # request was successfully received, understood, and accepted.
  449.             if (200 <= errcode < 300):
  450.                 return addinfourl(fp, headers, "https:" + url, errcode)
  451.             else:
  452.                 if data is None:
  453.                     return self.http_error(url, fp, errcode, errmsg, headers)
  454.                 else:
  455.                     return self.http_error(url, fp, errcode, errmsg, headers,
  456.                                            data)
  457.  
  458.     def open_file(self, url):
  459.         """Use local file or FTP depending on form of URL."""
  460.         if not isinstance(url, str):
  461.             raise IOError, ('file error', 'proxy support for file protocol currently not implemented')
  462.         if url[:2] == '//' and url[2:3] != '/' and url[2:12].lower() != 'localhost/':
  463.             return self.open_ftp(url)
  464.         else:
  465.             return self.open_local_file(url)
  466.  
  467.     def open_local_file(self, url):
  468.         """Use local file."""
  469.         import mimetypes, mimetools, email.utils
  470.         try:
  471.             from cStringIO import StringIO
  472.         except ImportError:
  473.             from StringIO import StringIO
  474.         host, file = splithost(url)
  475.         localname = url2pathname(file)
  476.         try:
  477.             stats = os.stat(localname)
  478.         except OSError, e:
  479.             raise IOError(e.errno, e.strerror, e.filename)
  480.         size = stats.st_size
  481.         modified = email.utils.formatdate(stats.st_mtime, usegmt=True)
  482.         mtype = mimetypes.guess_type(url)[0]
  483.         headers = mimetools.Message(StringIO(
  484.             'Content-Type: %s\nContent-Length: %d\nLast-modified: %s\n' %
  485.             (mtype or 'text/plain', size, modified)))
  486.         if not host:
  487.             urlfile = file
  488.             if file[:1] == '/':
  489.                 urlfile = 'file://' + file
  490.             return addinfourl(open(localname, 'rb'),
  491.                               headers, urlfile)
  492.         host, port = splitport(host)
  493.         if not port \
  494.            and socket.gethostbyname(host) in (localhost(), thishost()):
  495.             urlfile = file
  496.             if file[:1] == '/':
  497.                 urlfile = 'file://' + file
  498.             return addinfourl(open(localname, 'rb'),
  499.                               headers, urlfile)
  500.         raise IOError, ('local file error', 'not on local host')
  501.  
  502.     def open_ftp(self, url):
  503.         """Use FTP protocol."""
  504.         if not isinstance(url, str):
  505.             raise IOError, ('ftp error', 'proxy support for ftp protocol currently not implemented')
  506.         import mimetypes, mimetools
  507.         try:
  508.             from cStringIO import StringIO
  509.         except ImportError:
  510.             from StringIO import StringIO
  511.         host, path = splithost(url)
  512.         if not host: raise IOError, ('ftp error', 'no host given')
  513.         host, port = splitport(host)
  514.         user, host = splituser(host)
  515.         if user: user, passwd = splitpasswd(user)
  516.         else: passwd = None
  517.         host = unquote(host)
  518.         user = unquote(user or '')
  519.         passwd = unquote(passwd or '')
  520.         host = socket.gethostbyname(host)
  521.         if not port:
  522.             import ftplib
  523.             port = ftplib.FTP_PORT
  524.         else:
  525.             port = int(port)
  526.         path, attrs = splitattr(path)
  527.         path = unquote(path)
  528.         dirs = path.split('/')
  529.         dirs, file = dirs[:-1], dirs[-1]
  530.         if dirs and not dirs[0]: dirs = dirs[1:]
  531.         if dirs and not dirs[0]: dirs[0] = '/'
  532.         key = user, host, port, '/'.join(dirs)
  533.         # XXX thread unsafe!
  534.         if len(self.ftpcache) > MAXFTPCACHE:
  535.             # Prune the cache, rather arbitrarily
  536.             for k in self.ftpcache.keys():
  537.                 if k != key:
  538.                     v = self.ftpcache[k]
  539.                     del self.ftpcache[k]
  540.                     v.close()
  541.         try:
  542.             if not key in self.ftpcache:
  543.                 self.ftpcache[key] = \
  544.                     ftpwrapper(user, passwd, host, port, dirs)
  545.             if not file: type = 'D'
  546.             else: type = 'I'
  547.             for attr in attrs:
  548.                 attr, value = splitvalue(attr)
  549.                 if attr.lower() == 'type' and \
  550.                    value in ('a', 'A', 'i', 'I', 'd', 'D'):
  551.                     type = value.upper()
  552.             (fp, retrlen) = self.ftpcache[key].retrfile(file, type)
  553.             mtype = mimetypes.guess_type("ftp:" + url)[0]
  554.             headers = ""
  555.             if mtype:
  556.                 headers += "Content-Type: %s\n" % mtype
  557.             if retrlen is not None and retrlen >= 0:
  558.                 headers += "Content-Length: %d\n" % retrlen
  559.             headers = mimetools.Message(StringIO(headers))
  560.             return addinfourl(fp, headers, "ftp:" + url)
  561.         except ftperrors(), msg:
  562.             raise IOError, ('ftp error', msg), sys.exc_info()[2]
  563.  
  564.     def open_data(self, url, data=None):
  565.         """Use "data" URL."""
  566.         if not isinstance(url, str):
  567.             raise IOError, ('data error', 'proxy support for data protocol currently not implemented')
  568.         # ignore POSTed data
  569.         #
  570.         # syntax of data URLs:
  571.         # dataurl   := "data:" [ mediatype ] [ ";base64" ] "," data
  572.         # mediatype := [ type "/" subtype ] *( ";" parameter )
  573.         # data      := *urlchar
  574.         # parameter := attribute "=" value
  575.         import mimetools
  576.         try:
  577.             from cStringIO import StringIO
  578.         except ImportError:
  579.             from StringIO import StringIO
  580.         try:
  581.             [type, data] = url.split(',', 1)
  582.         except ValueError:
  583.             raise IOError, ('data error', 'bad data URL')
  584.         if not type:
  585.             type = 'text/plain;charset=US-ASCII'
  586.         semi = type.rfind(';')
  587.         if semi >= 0 and '=' not in type[semi:]:
  588.             encoding = type[semi+1:]
  589.             type = type[:semi]
  590.         else:
  591.             encoding = ''
  592.         msg = []
  593.         msg.append('Date: %s'%time.strftime('%a, %d %b %Y %T GMT',
  594.                                             time.gmtime(time.time())))
  595.         msg.append('Content-type: %s' % type)
  596.         if encoding == 'base64':
  597.             import base64
  598.             data = base64.decodestring(data)
  599.         else:
  600.             data = unquote(data)
  601.         msg.append('Content-Length: %d' % len(data))
  602.         msg.append('')
  603.         msg.append(data)
  604.         msg = '\n'.join(msg)
  605.         f = StringIO(msg)
  606.         headers = mimetools.Message(f, 0)
  607.         #f.fileno = None     # needed for addinfourl
  608.         return addinfourl(f, headers, url)
  609.  
  610.  
  611. class FancyURLopener(URLopener):
  612.     """Derived class with handlers for errors we can handle (perhaps)."""
  613.  
  614.     def __init__(self, *args, **kwargs):
  615.         URLopener.__init__(self, *args, **kwargs)
  616.         self.auth_cache = {}
  617.         self.tries = 0
  618.         self.maxtries = 10
  619.  
  620.     def http_error_default(self, url, fp, errcode, errmsg, headers):
  621.         """Default error handling -- don't raise an exception."""
  622.         return addinfourl(fp, headers, "http:" + url, errcode)
  623.  
  624.     def http_error_302(self, url, fp, errcode, errmsg, headers, data=None):
  625.         """Error 302 -- relocated (temporarily)."""
  626.         self.tries += 1
  627.         if self.maxtries and self.tries >= self.maxtries:
  628.             if hasattr(self, "http_error_500"):
  629.                 meth = self.http_error_500
  630.             else:
  631.                 meth = self.http_error_default
  632.             self.tries = 0
  633.             return meth(url, fp, 500,
  634.                         "Internal Server Error: Redirect Recursion", headers)
  635.         result = self.redirect_internal(url, fp, errcode, errmsg, headers,
  636.                                         data)
  637.         self.tries = 0
  638.         return result
  639.  
  640.     def redirect_internal(self, url, fp, errcode, errmsg, headers, data):
  641.         if 'location' in headers:
  642.             newurl = headers['location']
  643.         elif 'uri' in headers:
  644.             newurl = headers['uri']
  645.         else:
  646.             return
  647.         void = fp.read()
  648.         fp.close()
  649.         # In case the server sent a relative URL, join with original:
  650.         newurl = basejoin(self.type + ":" + url, newurl)
  651.         return self.open(newurl)
  652.  
  653.     def http_error_301(self, url, fp, errcode, errmsg, headers, data=None):
  654.         """Error 301 -- also relocated (permanently)."""
  655.         return self.http_error_302(url, fp, errcode, errmsg, headers, data)
  656.  
  657.     def http_error_303(self, url, fp, errcode, errmsg, headers, data=None):
  658.         """Error 303 -- also relocated (essentially identical to 302)."""
  659.         return self.http_error_302(url, fp, errcode, errmsg, headers, data)
  660.  
  661.     def http_error_307(self, url, fp, errcode, errmsg, headers, data=None):
  662.         """Error 307 -- relocated, but turn POST into error."""
  663.         if data is None:
  664.             return self.http_error_302(url, fp, errcode, errmsg, headers, data)
  665.         else:
  666.             return self.http_error_default(url, fp, errcode, errmsg, headers)
  667.  
  668.     def http_error_401(self, url, fp, errcode, errmsg, headers, data=None):
  669.         """Error 401 -- authentication required.
  670.         This function supports Basic authentication only."""
  671.         if not 'www-authenticate' in headers:
  672.             URLopener.http_error_default(self, url, fp,
  673.                                          errcode, errmsg, headers)
  674.         stuff = headers['www-authenticate']
  675.         import re
  676.         match = re.match('[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', stuff)
  677.         if not match:
  678.             URLopener.http_error_default(self, url, fp,
  679.                                          errcode, errmsg, headers)
  680.         scheme, realm = match.groups()
  681.         if scheme.lower() != 'basic':
  682.             URLopener.http_error_default(self, url, fp,
  683.                                          errcode, errmsg, headers)
  684.         name = 'retry_' + self.type + '_basic_auth'
  685.         if data is None:
  686.             return getattr(self,name)(url, realm)
  687.         else:
  688.             return getattr(self,name)(url, realm, data)
  689.  
  690.     def http_error_407(self, url, fp, errcode, errmsg, headers, data=None):
  691.         """Error 407 -- proxy authentication required.
  692.         This function supports Basic authentication only."""
  693.         if not 'proxy-authenticate' in headers:
  694.             URLopener.http_error_default(self, url, fp,
  695.                                          errcode, errmsg, headers)
  696.         stuff = headers['proxy-authenticate']
  697.         import re
  698.         match = re.match('[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', stuff)
  699.         if not match:
  700.             URLopener.http_error_default(self, url, fp,
  701.                                          errcode, errmsg, headers)
  702.         scheme, realm = match.groups()
  703.         if scheme.lower() != 'basic':
  704.             URLopener.http_error_default(self, url, fp,
  705.                                          errcode, errmsg, headers)
  706.         name = 'retry_proxy_' + self.type + '_basic_auth'
  707.         if data is None:
  708.             return getattr(self,name)(url, realm)
  709.         else:
  710.             return getattr(self,name)(url, realm, data)
  711.  
  712.     def retry_proxy_http_basic_auth(self, url, realm, data=None):
  713.         host, selector = splithost(url)
  714.         newurl = 'http://' + host + selector
  715.         proxy = self.proxies['http']
  716.         urltype, proxyhost = splittype(proxy)
  717.         proxyhost, proxyselector = splithost(proxyhost)
  718.         i = proxyhost.find('@') + 1
  719.         proxyhost = proxyhost[i:]
  720.         user, passwd = self.get_user_passwd(proxyhost, realm, i)
  721.         if not (user or passwd): return None
  722.         proxyhost = quote(user, safe='') + ':' + quote(passwd, safe='') + '@' + proxyhost
  723.         self.proxies['http'] = 'http://' + proxyhost + proxyselector
  724.         if data is None:
  725.             return self.open(newurl)
  726.         else:
  727.             return self.open(newurl, data)
  728.  
  729.     def retry_proxy_https_basic_auth(self, url, realm, data=None):
  730.         host, selector = splithost(url)
  731.         newurl = 'https://' + host + selector
  732.         proxy = self.proxies['https']
  733.         urltype, proxyhost = splittype(proxy)
  734.         proxyhost, proxyselector = splithost(proxyhost)
  735.         i = proxyhost.find('@') + 1
  736.         proxyhost = proxyhost[i:]
  737.         user, passwd = self.get_user_passwd(proxyhost, realm, i)
  738.         if not (user or passwd): return None
  739.         proxyhost = quote(user, safe='') + ':' + quote(passwd, safe='') + '@' + proxyhost
  740.         self.proxies['https'] = 'https://' + proxyhost + proxyselector
  741.         if data is None:
  742.             return self.open(newurl)
  743.         else:
  744.             return self.open(newurl, data)
  745.  
  746.     def retry_http_basic_auth(self, url, realm, data=None):
  747.         host, selector = splithost(url)
  748.         i = host.find('@') + 1
  749.         host = host[i:]
  750.         user, passwd = self.get_user_passwd(host, realm, i)
  751.         if not (user or passwd): return None
  752.         host = quote(user, safe='') + ':' + quote(passwd, safe='') + '@' + host
  753.         newurl = 'http://' + host + selector
  754.         if data is None:
  755.             return self.open(newurl)
  756.         else:
  757.             return self.open(newurl, data)
  758.  
  759.     def retry_https_basic_auth(self, url, realm, data=None):
  760.         host, selector = splithost(url)
  761.         i = host.find('@') + 1
  762.         host = host[i:]
  763.         user, passwd = self.get_user_passwd(host, realm, i)
  764.         if not (user or passwd): return None
  765.         host = quote(user, safe='') + ':' + quote(passwd, safe='') + '@' + host
  766.         newurl = 'https://' + host + selector
  767.         if data is None:
  768.             return self.open(newurl)
  769.         else:
  770.             return self.open(newurl, data)
  771.  
  772.     def get_user_passwd(self, host, realm, clear_cache = 0):
  773.         key = realm + '@' + host.lower()
  774.         if key in self.auth_cache:
  775.             if clear_cache:
  776.                 del self.auth_cache[key]
  777.             else:
  778.                 return self.auth_cache[key]
  779.         user, passwd = self.prompt_user_passwd(host, realm)
  780.         if user or passwd: self.auth_cache[key] = (user, passwd)
  781.         return user, passwd
  782.  
  783.     def prompt_user_passwd(self, host, realm):
  784.         """Override this in a GUI environment!"""
  785.         import getpass
  786.         try:
  787.             user = raw_input("Enter username for %s at %s: " % (realm,
  788.                                                                 host))
  789.             passwd = getpass.getpass("Enter password for %s in %s at %s: " %
  790.                 (user, realm, host))
  791.             return user, passwd
  792.         except KeyboardInterrupt:
  793.             print
  794.             return None, None
  795.  
  796.  
  797. # Utility functions
  798.  
  799. _localhost = None
  800. def localhost():
  801.     """Return the IP address of the magic hostname 'localhost'."""
  802.     global _localhost
  803.     if _localhost is None:
  804.         _localhost = socket.gethostbyname('localhost')
  805.     return _localhost
  806.  
  807. _thishost = None
  808. def thishost():
  809.     """Return the IP address of the current host."""
  810.     global _thishost
  811.     if _thishost is None:
  812.         _thishost = socket.gethostbyname(socket.gethostname())
  813.     return _thishost
  814.  
  815. _ftperrors = None
  816. def ftperrors():
  817.     """Return the set of errors raised by the FTP class."""
  818.     global _ftperrors
  819.     if _ftperrors is None:
  820.         import ftplib
  821.         _ftperrors = ftplib.all_errors
  822.     return _ftperrors
  823.  
  824. _noheaders = None
  825. def noheaders():
  826.     """Return an empty mimetools.Message object."""
  827.     global _noheaders
  828.     if _noheaders is None:
  829.         import mimetools
  830.         try:
  831.             from cStringIO import StringIO
  832.         except ImportError:
  833.             from StringIO import StringIO
  834.         _noheaders = mimetools.Message(StringIO(), 0)
  835.         _noheaders.fp.close()   # Recycle file descriptor
  836.     return _noheaders
  837.  
  838.  
  839. # Utility classes
  840.  
  841. class ftpwrapper:
  842.     """Class used by open_ftp() for cache of open FTP connections."""
  843.  
  844.     def __init__(self, user, passwd, host, port, dirs,
  845.                  timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
  846.         self.user = user
  847.         self.passwd = passwd
  848.         self.host = host
  849.         self.port = port
  850.         self.dirs = dirs
  851.         self.timeout = timeout
  852.         self.init()
  853.  
  854.     def init(self):
  855.         import ftplib
  856.         self.busy = 0
  857.         self.ftp = ftplib.FTP()
  858.         self.ftp.connect(self.host, self.port, self.timeout)
  859.         self.ftp.login(self.user, self.passwd)
  860.         for dir in self.dirs:
  861.             self.ftp.cwd(dir)
  862.  
  863.     def retrfile(self, file, type):
  864.         import ftplib
  865.         self.endtransfer()
  866.         if type in ('d', 'D'): cmd = 'TYPE A'; isdir = 1
  867.         else: cmd = 'TYPE ' + type; isdir = 0
  868.         try:
  869.             self.ftp.voidcmd(cmd)
  870.         except ftplib.all_errors:
  871.             self.init()
  872.             self.ftp.voidcmd(cmd)
  873.         conn = None
  874.         if file and not isdir:
  875.             # Try to retrieve as a file
  876.             try:
  877.                 cmd = 'RETR ' + file
  878.                 conn = self.ftp.ntransfercmd(cmd)
  879.             except ftplib.error_perm, reason:
  880.                 if str(reason)[:3] != '550':
  881.                     raise IOError, ('ftp error', reason), sys.exc_info()[2]
  882.         if not conn:
  883.             # Set transfer mode to ASCII!
  884.             self.ftp.voidcmd('TYPE A')
  885.             # Try a directory listing. Verify that directory exists.
  886.             if file:
  887.                 pwd = self.ftp.pwd()
  888.                 try:
  889.                     try:
  890.                         self.ftp.cwd(file)
  891.                     except ftplib.error_perm, reason:
  892.                         raise IOError, ('ftp error', reason), sys.exc_info()[2]
  893.                 finally:
  894.                     self.ftp.cwd(pwd)
  895.                 cmd = 'LIST ' + file
  896.             else:
  897.                 cmd = 'LIST'
  898.             conn = self.ftp.ntransfercmd(cmd)
  899.         self.busy = 1
  900.         # Pass back both a suitably decorated object and a retrieval length
  901.         return (addclosehook(conn[0].makefile('rb'),
  902.                              self.endtransfer), conn[1])
  903.     def endtransfer(self):
  904.         if not self.busy:
  905.             return
  906.         self.busy = 0
  907.         try:
  908.             self.ftp.voidresp()
  909.         except ftperrors():
  910.             pass
  911.  
  912.     def close(self):
  913.         self.endtransfer()
  914.         try:
  915.             self.ftp.close()
  916.         except ftperrors():
  917.             pass
  918.  
  919. class addbase:
  920.     """Base class for addinfo and addclosehook."""
  921.  
  922.     def __init__(self, fp):
  923.         self.fp = fp
  924.         self.read = self.fp.read
  925.         self.readline = self.fp.readline
  926.         if hasattr(self.fp, "readlines"): self.readlines = self.fp.readlines
  927.         if hasattr(self.fp, "fileno"):
  928.             self.fileno = self.fp.fileno
  929.         else:
  930.             self.fileno = lambda: None
  931.         if hasattr(self.fp, "__iter__"):
  932.             self.__iter__ = self.fp.__iter__
  933.             if hasattr(self.fp, "next"):
  934.                 self.next = self.fp.next
  935.  
  936.     def __repr__(self):
  937.         return '<%s at %r whose fp = %r>' % (self.__class__.__name__,
  938.                                              id(self), self.fp)
  939.  
  940.     def close(self):
  941.         self.read = None
  942.         self.readline = None
  943.         self.readlines = None
  944.         self.fileno = None
  945.         if self.fp: self.fp.close()
  946.         self.fp = None
  947.  
  948. class addclosehook(addbase):
  949.     """Class to add a close hook to an open file."""
  950.  
  951.     def __init__(self, fp, closehook, *hookargs):
  952.         addbase.__init__(self, fp)
  953.         self.closehook = closehook
  954.         self.hookargs = hookargs
  955.  
  956.     def close(self):
  957.         addbase.close(self)
  958.         if self.closehook:
  959.             self.closehook(*self.hookargs)
  960.             self.closehook = None
  961.             self.hookargs = None
  962.  
  963. class addinfo(addbase):
  964.     """class to add an info() method to an open file."""
  965.  
  966.     def __init__(self, fp, headers):
  967.         addbase.__init__(self, fp)
  968.         self.headers = headers
  969.  
  970.     def info(self):
  971.         return self.headers
  972.  
  973. class addinfourl(addbase):
  974.     """class to add info() and geturl() methods to an open file."""
  975.  
  976.     def __init__(self, fp, headers, url, code=None):
  977.         addbase.__init__(self, fp)
  978.         self.headers = headers
  979.         self.url = url
  980.         self.code = code
  981.  
  982.     def info(self):
  983.         return self.headers
  984.  
  985.     def getcode(self):
  986.         return self.code
  987.  
  988.     def geturl(self):
  989.         return self.url
  990.  
  991.  
  992. # Utilities to parse URLs (most of these return None for missing parts):
  993. # unwrap('<URL:type://host/path>') --> 'type://host/path'
  994. # splittype('type:opaquestring') --> 'type', 'opaquestring'
  995. # splithost('//host[:port]/path') --> 'host[:port]', '/path'
  996. # splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'
  997. # splitpasswd('user:passwd') -> 'user', 'passwd'
  998. # splitport('host:port') --> 'host', 'port'
  999. # splitquery('/path?query') --> '/path', 'query'
  1000. # splittag('/path#tag') --> '/path', 'tag'
  1001. # splitattr('/path;attr1=value1;attr2=value2;...') ->
  1002. #   '/path', ['attr1=value1', 'attr2=value2', ...]
  1003. # splitvalue('attr=value') --> 'attr', 'value'
  1004. # unquote('abc%20def') -> 'abc def'
  1005. # quote('abc def') -> 'abc%20def')
  1006.  
  1007. try:
  1008.     unicode
  1009. except NameError:
  1010.     def _is_unicode(x):
  1011.         return 0
  1012. else:
  1013.     def _is_unicode(x):
  1014.         return isinstance(x, unicode)
  1015.  
  1016. def toBytes(url):
  1017.     """toBytes(u"URL") --> 'URL'."""
  1018.     # Most URL schemes require ASCII. If that changes, the conversion
  1019.     # can be relaxed
  1020.     if _is_unicode(url):
  1021.         try:
  1022.             url = url.encode("ASCII")
  1023.         except UnicodeError:
  1024.             raise UnicodeError("URL " + repr(url) +
  1025.                                " contains non-ASCII characters")
  1026.     return url
  1027.  
  1028. def unwrap(url):
  1029.     """unwrap('<URL:type://host/path>') --> 'type://host/path'."""
  1030.     url = url.strip()
  1031.     if url[:1] == '<' and url[-1:] == '>':
  1032.         url = url[1:-1].strip()
  1033.     if url[:4] == 'URL:': url = url[4:].strip()
  1034.     return url
  1035.  
  1036. _typeprog = None
  1037. def splittype(url):
  1038.     """splittype('type:opaquestring') --> 'type', 'opaquestring'."""
  1039.     global _typeprog
  1040.     if _typeprog is None:
  1041.         import re
  1042.         _typeprog = re.compile('^([^/:]+):')
  1043.  
  1044.     match = _typeprog.match(url)
  1045.     if match:
  1046.         scheme = match.group(1)
  1047.         return scheme.lower(), url[len(scheme) + 1:]
  1048.     return None, url
  1049.  
  1050. _hostprog = None
  1051. def splithost(url):
  1052.     """splithost('//host[:port]/path') --> 'host[:port]', '/path'."""
  1053.     global _hostprog
  1054.     if _hostprog is None:
  1055.         import re
  1056.         _hostprog = re.compile('^//([^/?]*)(.*)$')
  1057.  
  1058.     match = _hostprog.match(url)
  1059.     if match: return match.group(1, 2)
  1060.     return None, url
  1061.  
  1062. _userprog = None
  1063. def splituser(host):
  1064.     """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'."""
  1065.     global _userprog
  1066.     if _userprog is None:
  1067.         import re
  1068.         _userprog = re.compile('^(.*)@(.*)$')
  1069.  
  1070.     match = _userprog.match(host)
  1071.     if match: return map(unquote, match.group(1, 2))
  1072.     return None, host
  1073.  
  1074. _passwdprog = None
  1075. def splitpasswd(user):
  1076.     """splitpasswd('user:passwd') -> 'user', 'passwd'."""
  1077.     global _passwdprog
  1078.     if _passwdprog is None:
  1079.         import re
  1080.         _passwdprog = re.compile('^([^:]*):(.*)$')
  1081.  
  1082.     match = _passwdprog.match(user)
  1083.     if match: return match.group(1, 2)
  1084.     return user, None
  1085.  
  1086. # splittag('/path#tag') --> '/path', 'tag'
  1087. _portprog = None
  1088. def splitport(host):
  1089.     """splitport('host:port') --> 'host', 'port'."""
  1090.     global _portprog
  1091.     if _portprog is None:
  1092.         import re
  1093.         _portprog = re.compile('^(.*):([0-9]+)$')
  1094.  
  1095.     match = _portprog.match(host)
  1096.     if match: return match.group(1, 2)
  1097.     return host, None
  1098.  
  1099. _nportprog = None
  1100. def splitnport(host, defport=-1):
  1101.     """Split host and port, returning numeric port.
  1102.     Return given default port if no ':' found; defaults to -1.
  1103.     Return numerical port if a valid number are found after ':'.
  1104.     Return None if ':' but not a valid number."""
  1105.     global _nportprog
  1106.     if _nportprog is None:
  1107.         import re
  1108.         _nportprog = re.compile('^(.*):(.*)$')
  1109.  
  1110.     match = _nportprog.match(host)
  1111.     if match:
  1112.         host, port = match.group(1, 2)
  1113.         try:
  1114.             if not port: raise ValueError, "no digits"
  1115.             nport = int(port)
  1116.         except ValueError:
  1117.             nport = None
  1118.         return host, nport
  1119.     return host, defport
  1120.  
  1121. _queryprog = None
  1122. def splitquery(url):
  1123.     """splitquery('/path?query') --> '/path', 'query'."""
  1124.     global _queryprog
  1125.     if _queryprog is None:
  1126.         import re
  1127.         _queryprog = re.compile('^(.*)\?([^?]*)$')
  1128.  
  1129.     match = _queryprog.match(url)
  1130.     if match: return match.group(1, 2)
  1131.     return url, None
  1132.  
  1133. _tagprog = None
  1134. def splittag(url):
  1135.     """splittag('/path#tag') --> '/path', 'tag'."""
  1136.     global _tagprog
  1137.     if _tagprog is None:
  1138.         import re
  1139.         _tagprog = re.compile('^(.*)#([^#]*)$')
  1140.  
  1141.     match = _tagprog.match(url)
  1142.     if match: return match.group(1, 2)
  1143.     return url, None
  1144.  
  1145. def splitattr(url):
  1146.     """splitattr('/path;attr1=value1;attr2=value2;...') ->
  1147.         '/path', ['attr1=value1', 'attr2=value2', ...]."""
  1148.     words = url.split(';')
  1149.     return words[0], words[1:]
  1150.  
  1151. _valueprog = None
  1152. def splitvalue(attr):
  1153.     """splitvalue('attr=value') --> 'attr', 'value'."""
  1154.     global _valueprog
  1155.     if _valueprog is None:
  1156.         import re
  1157.         _valueprog = re.compile('^([^=]*)=(.*)$')
  1158.  
  1159.     match = _valueprog.match(attr)
  1160.     if match: return match.group(1, 2)
  1161.     return attr, None
  1162.  
  1163. _hextochr = dict(('%02x' % i, chr(i)) for i in range(256))
  1164. _hextochr.update(('%02X' % i, chr(i)) for i in range(256))
  1165.  
  1166. def unquote(s):
  1167.     """unquote('abc%20def') -> 'abc def'."""
  1168.     res = s.split('%')
  1169.     for i in xrange(1, len(res)):
  1170.         item = res[i]
  1171.         try:
  1172.             res[i] = _hextochr[item[:2]] + item[2:]
  1173.         except KeyError:
  1174.             res[i] = '%' + item
  1175.         except UnicodeDecodeError:
  1176.             res[i] = unichr(int(item[:2], 16)) + item[2:]
  1177.     return "".join(res)
  1178.  
  1179. def unquote_plus(s):
  1180.     """unquote('%7e/abc+def') -> '~/abc def'"""
  1181.     s = s.replace('+', ' ')
  1182.     return unquote(s)
  1183.  
  1184. always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  1185.                'abcdefghijklmnopqrstuvwxyz'
  1186.                '0123456789' '_.-')
  1187. _safemaps = {}
  1188.  
  1189. def quote(s, safe = '/'):
  1190.     """quote('abc def') -> 'abc%20def'
  1191.  
  1192.     Each part of a URL, e.g. the path info, the query, etc., has a
  1193.     different set of reserved characters that must be quoted.
  1194.  
  1195.     RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
  1196.     the following reserved characters.
  1197.  
  1198.     reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
  1199.                   "$" | ","
  1200.  
  1201.     Each of these characters is reserved in some component of a URL,
  1202.     but not necessarily in all of them.
  1203.  
  1204.     By default, the quote function is intended for quoting the path
  1205.     section of a URL.  Thus, it will not encode '/'.  This character
  1206.     is reserved, but in typical usage the quote function is being
  1207.     called on a path where the existing slash characters are used as
  1208.     reserved characters.
  1209.     """
  1210.     cachekey = (safe, always_safe)
  1211.     try:
  1212.         safe_map = _safemaps[cachekey]
  1213.     except KeyError:
  1214.         safe += always_safe
  1215.         safe_map = {}
  1216.         for i in range(256):
  1217.             c = chr(i)
  1218.             safe_map[c] = (c in safe) and c or ('%%%02X' % i)
  1219.         _safemaps[cachekey] = safe_map
  1220.     res = map(safe_map.__getitem__, s)
  1221.     return ''.join(res)
  1222.  
  1223. def quote_plus(s, safe = ''):
  1224.     """Quote the query fragment of a URL; replacing ' ' with '+'"""
  1225.     if ' ' in s:
  1226.         s = quote(s, safe + ' ')
  1227.         return s.replace(' ', '+')
  1228.     return quote(s, safe)
  1229.  
  1230. def urlencode(query,doseq=0):
  1231.     """Encode a sequence of two-element tuples or dictionary into a URL query string.
  1232.  
  1233.     If any values in the query arg are sequences and doseq is true, each
  1234.     sequence element is converted to a separate parameter.
  1235.  
  1236.     If the query arg is a sequence of two-element tuples, the order of the
  1237.     parameters in the output will match the order of parameters in the
  1238.     input.
  1239.     """
  1240.  
  1241.     if hasattr(query,"items"):
  1242.         # mapping objects
  1243.         query = query.items()
  1244.     else:
  1245.         # it's a bother at times that strings and string-like objects are
  1246.         # sequences...
  1247.         try:
  1248.             # non-sequence items should not work with len()
  1249.             # non-empty strings will fail this
  1250.             if len(query) and not isinstance(query[0], tuple):
  1251.                 raise TypeError
  1252.             # zero-length sequences of all types will get here and succeed,
  1253.             # but that's a minor nit - since the original implementation
  1254.             # allowed empty dicts that type of behavior probably should be
  1255.             # preserved for consistency
  1256.         except TypeError:
  1257.             ty,va,tb = sys.exc_info()
  1258.             raise TypeError, "not a valid non-string sequence or mapping object", tb
  1259.  
  1260.     l = []
  1261.     if not doseq:
  1262.         # preserve old behavior
  1263.         for k, v in query:
  1264.             k = quote_plus(str(k))
  1265.             v = quote_plus(str(v))
  1266.             l.append(k + '=' + v)
  1267.     else:
  1268.         for k, v in query:
  1269.             k = quote_plus(str(k))
  1270.             if isinstance(v, str):
  1271.                 v = quote_plus(v)
  1272.                 l.append(k + '=' + v)
  1273.             elif _is_unicode(v):
  1274.                 # is there a reasonable way to convert to ASCII?
  1275.                 # encode generates a string, but "replace" or "ignore"
  1276.                 # lose information and "strict" can raise UnicodeError
  1277.                 v = quote_plus(v.encode("ASCII","replace"))
  1278.                 l.append(k + '=' + v)
  1279.             else:
  1280.                 try:
  1281.                     # is this a sufficient test for sequence-ness?
  1282.                     x = len(v)
  1283.                 except TypeError:
  1284.                     # not a sequence
  1285.                     v = quote_plus(str(v))
  1286.                     l.append(k + '=' + v)
  1287.                 else:
  1288.                     # loop over the sequence
  1289.                     for elt in v:
  1290.                         l.append(k + '=' + quote_plus(str(elt)))
  1291.     return '&'.join(l)
  1292.  
  1293. # Proxy handling
  1294. def getproxies_environment():
  1295.     """Return a dictionary of scheme -> proxy server URL mappings.
  1296.  
  1297.     Scan the environment for variables named <scheme>_proxy;
  1298.     this seems to be the standard convention.  If you need a
  1299.     different way, you can pass a proxies dictionary to the
  1300.     [Fancy]URLopener constructor.
  1301.  
  1302.     """
  1303.     proxies = {}
  1304.     for name, value in os.environ.items():
  1305.         name = name.lower()
  1306.         if value and name[-6:] == '_proxy':
  1307.             proxies[name[:-6]] = value
  1308.     return proxies
  1309.  
  1310. def proxy_bypass_environment(host):
  1311.     """Test if proxies should not be used for a particular host.
  1312.  
  1313.     Checks the environment for a variable named no_proxy, which should
  1314.     be a list of DNS suffixes separated by commas, or '*' for all hosts.
  1315.     """
  1316.     no_proxy = os.environ.get('no_proxy', '') or os.environ.get('NO_PROXY', '')
  1317.     # '*' is special case for always bypass
  1318.     if no_proxy == '*':
  1319.         return 1
  1320.     # strip port off host
  1321.     hostonly, port = splitport(host)
  1322.     # check if the host ends with any of the DNS suffixes
  1323.     for name in no_proxy.split(','):
  1324.         if name and (hostonly.endswith(name) or host.endswith(name)):
  1325.             return 1
  1326.     # otherwise, don't bypass
  1327.     return 0
  1328.  
  1329.  
  1330. if sys.platform == 'darwin':
  1331.  
  1332.     def _CFSetup(sc):
  1333.         from ctypes import c_int32, c_void_p, c_char_p, c_int
  1334.         sc.CFStringCreateWithCString.argtypes = [ c_void_p, c_char_p, c_int32 ]
  1335.         sc.CFStringCreateWithCString.restype = c_void_p
  1336.         sc.SCDynamicStoreCopyProxies.argtypes = [ c_void_p ]
  1337.         sc.SCDynamicStoreCopyProxies.restype = c_void_p
  1338.         sc.CFDictionaryGetValue.argtypes = [ c_void_p, c_void_p ]
  1339.         sc.CFDictionaryGetValue.restype = c_void_p
  1340.         sc.CFStringGetLength.argtypes = [ c_void_p ]
  1341.         sc.CFStringGetLength.restype = c_int32
  1342.         sc.CFStringGetCString.argtypes = [ c_void_p, c_char_p, c_int32, c_int32 ]
  1343.         sc.CFStringGetCString.restype = c_int32
  1344.         sc.CFNumberGetValue.argtypes = [ c_void_p, c_int, c_void_p ]
  1345.         sc.CFNumberGetValue.restype = c_int32
  1346.         sc.CFRelease.argtypes = [ c_void_p ]
  1347.         sc.CFRelease.restype = None
  1348.  
  1349.     def _CStringFromCFString(sc, value):
  1350.         from ctypes import create_string_buffer
  1351.         length = sc.CFStringGetLength(value) + 1
  1352.         buff = create_string_buffer(length)
  1353.         sc.CFStringGetCString(value, buff, length, 0)
  1354.         return buff.value
  1355.  
  1356.     def _CFNumberToInt32(sc, cfnum):
  1357.         from ctypes import byref, c_int
  1358.         val = c_int()
  1359.         kCFNumberSInt32Type = 3
  1360.         sc.CFNumberGetValue(cfnum, kCFNumberSInt32Type, byref(val))
  1361.         return val.value
  1362.  
  1363.  
  1364.     def proxy_bypass_macosx_sysconf(host):
  1365.         """
  1366.         Return True iff this host shouldn't be accessed using a proxy
  1367.  
  1368.         This function uses the MacOSX framework SystemConfiguration
  1369.         to fetch the proxy information.
  1370.         """
  1371.         from ctypes import cdll
  1372.         from ctypes.util import find_library
  1373.         import re
  1374.         import socket
  1375.         from fnmatch import fnmatch
  1376.  
  1377.         def ip2num(ipAddr):
  1378.             parts = ipAddr.split('.')
  1379.             parts = map(int, parts)
  1380.             if len(parts) != 4:
  1381.                 parts = (parts + [0, 0, 0, 0])[:4]
  1382.             return (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3]
  1383.  
  1384.         sc = cdll.LoadLibrary(find_library("SystemConfiguration"))
  1385.         _CFSetup(sc)
  1386.  
  1387.         hostIP = None
  1388.  
  1389.         if not sc:
  1390.             return False
  1391.  
  1392.         kSCPropNetProxiesExceptionsList = sc.CFStringCreateWithCString(0, "ExceptionsList", 0)
  1393.         kSCPropNetProxiesExcludeSimpleHostnames = sc.CFStringCreateWithCString(0,
  1394.                 "ExcludeSimpleHostnames", 0)
  1395.  
  1396.  
  1397.         proxyDict = sc.SCDynamicStoreCopyProxies(None)
  1398.         if proxyDict is None:
  1399.             return False
  1400.  
  1401.         try:
  1402.             # Check for simple host names:
  1403.             if '.' not in host:
  1404.                 exclude_simple = sc.CFDictionaryGetValue(proxyDict,
  1405.                         kSCPropNetProxiesExcludeSimpleHostnames)
  1406.                 if exclude_simple and _CFNumberToInt32(sc, exclude_simple):
  1407.                     return True
  1408.  
  1409.  
  1410.             # Check the exceptions list:
  1411.             exceptions = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesExceptionsList)
  1412.             if exceptions:
  1413.                 # Items in the list are strings like these: *.local, 169.254/16
  1414.                 for index in xrange(sc.CFArrayGetCount(exceptions)):
  1415.                     value = sc.CFArrayGetValueAtIndex(exceptions, index)
  1416.                     if not value: continue
  1417.                     value = _CStringFromCFString(sc, value)
  1418.  
  1419.                     m = re.match(r"(\d+(?:\.\d+)*)(/\d+)?", value)
  1420.                     if m is not None:
  1421.                         if hostIP is None:
  1422.                             hostIP = socket.gethostbyname(host)
  1423.                             hostIP = ip2num(hostIP)
  1424.  
  1425.                         base = ip2num(m.group(1))
  1426.                         mask = int(m.group(2)[1:])
  1427.                         mask = 32 - mask
  1428.  
  1429.                         if (hostIP >> mask) == (base >> mask):
  1430.                             return True
  1431.  
  1432.                     elif fnmatch(host, value):
  1433.                         return True
  1434.  
  1435.             return False
  1436.  
  1437.         finally:
  1438.             sc.CFRelease(kSCPropNetProxiesExceptionsList)
  1439.             sc.CFRelease(kSCPropNetProxiesExcludeSimpleHostnames)
  1440.  
  1441.  
  1442.  
  1443.     def getproxies_macosx_sysconf():
  1444.         """Return a dictionary of scheme -> proxy server URL mappings.
  1445.  
  1446.         This function uses the MacOSX framework SystemConfiguration
  1447.         to fetch the proxy information.
  1448.         """
  1449.         from ctypes import cdll
  1450.         from ctypes.util import find_library
  1451.  
  1452.         sc = cdll.LoadLibrary(find_library("SystemConfiguration"))
  1453.         _CFSetup(sc)
  1454.  
  1455.         if not sc:
  1456.             return {}
  1457.  
  1458.         kSCPropNetProxiesHTTPEnable = sc.CFStringCreateWithCString(0, "HTTPEnable", 0)
  1459.         kSCPropNetProxiesHTTPProxy = sc.CFStringCreateWithCString(0, "HTTPProxy", 0)
  1460.         kSCPropNetProxiesHTTPPort = sc.CFStringCreateWithCString(0, "HTTPPort", 0)
  1461.  
  1462.         kSCPropNetProxiesHTTPSEnable = sc.CFStringCreateWithCString(0, "HTTPSEnable", 0)
  1463.         kSCPropNetProxiesHTTPSProxy = sc.CFStringCreateWithCString(0, "HTTPSProxy", 0)
  1464.         kSCPropNetProxiesHTTPSPort = sc.CFStringCreateWithCString(0, "HTTPSPort", 0)
  1465.  
  1466.         kSCPropNetProxiesFTPEnable = sc.CFStringCreateWithCString(0, "FTPEnable", 0)
  1467.         kSCPropNetProxiesFTPPassive = sc.CFStringCreateWithCString(0, "FTPPassive", 0)
  1468.         kSCPropNetProxiesFTPPort = sc.CFStringCreateWithCString(0, "FTPPort", 0)
  1469.         kSCPropNetProxiesFTPProxy = sc.CFStringCreateWithCString(0, "FTPProxy", 0)
  1470.  
  1471.         kSCPropNetProxiesGopherEnable = sc.CFStringCreateWithCString(0, "GopherEnable", 0)
  1472.         kSCPropNetProxiesGopherPort = sc.CFStringCreateWithCString(0, "GopherPort", 0)
  1473.         kSCPropNetProxiesGopherProxy = sc.CFStringCreateWithCString(0, "GopherProxy", 0)
  1474.  
  1475.         proxies = {}
  1476.         proxyDict = sc.SCDynamicStoreCopyProxies(None)
  1477.  
  1478.         try:
  1479.             # HTTP:
  1480.             enabled = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesHTTPEnable)
  1481.             if enabled and _CFNumberToInt32(sc, enabled):
  1482.                 proxy = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesHTTPProxy)
  1483.                 port = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesHTTPPort)
  1484.  
  1485.                 if proxy:
  1486.                     proxy = _CStringFromCFString(sc, proxy)
  1487.                     if port:
  1488.                         port = _CFNumberToInt32(sc, port)
  1489.                         proxies["http"] = "http://%s:%i" % (proxy, port)
  1490.                     else:
  1491.                         proxies["http"] = "http://%s" % (proxy, )
  1492.  
  1493.             # HTTPS:
  1494.             enabled = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesHTTPSEnable)
  1495.             if enabled and _CFNumberToInt32(sc, enabled):
  1496.                 proxy = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesHTTPSProxy)
  1497.                 port = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesHTTPSPort)
  1498.  
  1499.                 if proxy:
  1500.                     proxy = _CStringFromCFString(sc, proxy)
  1501.                     if port:
  1502.                         port = _CFNumberToInt32(sc, port)
  1503.                         proxies["https"] = "http://%s:%i" % (proxy, port)
  1504.                     else:
  1505.                         proxies["https"] = "http://%s" % (proxy, )
  1506.  
  1507.             # FTP:
  1508.             enabled = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesFTPEnable)
  1509.             if enabled and _CFNumberToInt32(sc, enabled):
  1510.                 proxy = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesFTPProxy)
  1511.                 port = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesFTPPort)
  1512.  
  1513.                 if proxy:
  1514.                     proxy = _CStringFromCFString(sc, proxy)
  1515.                     if port:
  1516.                         port = _CFNumberToInt32(sc, port)
  1517.                         proxies["ftp"] = "http://%s:%i" % (proxy, port)
  1518.                     else:
  1519.                         proxies["ftp"] = "http://%s" % (proxy, )
  1520.  
  1521.             # Gopher:
  1522.             enabled = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesGopherEnable)
  1523.             if enabled and _CFNumberToInt32(sc, enabled):
  1524.                 proxy = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesGopherProxy)
  1525.                 port = sc.CFDictionaryGetValue(proxyDict, kSCPropNetProxiesGopherPort)
  1526.  
  1527.                 if proxy:
  1528.                     proxy = _CStringFromCFString(sc, proxy)
  1529.                     if port:
  1530.                         port = _CFNumberToInt32(sc, port)
  1531.                         proxies["gopher"] = "http://%s:%i" % (proxy, port)
  1532.                     else:
  1533.                         proxies["gopher"] = "http://%s" % (proxy, )
  1534.         finally:
  1535.             sc.CFRelease(proxyDict)
  1536.  
  1537.         sc.CFRelease(kSCPropNetProxiesHTTPEnable)
  1538.         sc.CFRelease(kSCPropNetProxiesHTTPProxy)
  1539.         sc.CFRelease(kSCPropNetProxiesHTTPPort)
  1540.         sc.CFRelease(kSCPropNetProxiesFTPEnable)
  1541.         sc.CFRelease(kSCPropNetProxiesFTPPassive)
  1542.         sc.CFRelease(kSCPropNetProxiesFTPPort)
  1543.         sc.CFRelease(kSCPropNetProxiesFTPProxy)
  1544.         sc.CFRelease(kSCPropNetProxiesGopherEnable)
  1545.         sc.CFRelease(kSCPropNetProxiesGopherPort)
  1546.         sc.CFRelease(kSCPropNetProxiesGopherProxy)
  1547.  
  1548.         return proxies
  1549.  
  1550.  
  1551.  
  1552.     def proxy_bypass(host):
  1553.         if getproxies_environment():
  1554.             return proxy_bypass_environment(host)
  1555.         else:
  1556.             return proxy_bypass_macosx_sysconf(host)
  1557.  
  1558.     def getproxies():
  1559.         return getproxies_environment() or getproxies_macosx_sysconf()
  1560.  
  1561. elif os.name == 'nt':
  1562.     def getproxies_registry():
  1563.         """Return a dictionary of scheme -> proxy server URL mappings.
  1564.  
  1565.         Win32 uses the registry to store proxies.
  1566.  
  1567.         """
  1568.         proxies = {}
  1569.         try:
  1570.             import _winreg
  1571.         except ImportError:
  1572.             # Std module, so should be around - but you never know!
  1573.             return proxies
  1574.         try:
  1575.             internetSettings = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER,
  1576.                 r'Software\Microsoft\Windows\CurrentVersion\Internet Settings')
  1577.             proxyEnable = _winreg.QueryValueEx(internetSettings,
  1578.                                                'ProxyEnable')[0]
  1579.             if proxyEnable:
  1580.                 # Returned as Unicode but problems if not converted to ASCII
  1581.                 proxyServer = str(_winreg.QueryValueEx(internetSettings,
  1582.                                                        'ProxyServer')[0])
  1583.                 if '=' in proxyServer:
  1584.                     # Per-protocol settings
  1585.                     for p in proxyServer.split(';'):
  1586.                         protocol, address = p.split('=', 1)
  1587.                         # See if address has a type:// prefix
  1588.                         import re
  1589.                         if not re.match('^([^/:]+)://', address):
  1590.                             address = '%s://%s' % (protocol, address)
  1591.                         proxies[protocol] = address
  1592.                 else:
  1593.                     # Use one setting for all protocols
  1594.                     if proxyServer[:5] == 'http:':
  1595.                         proxies['http'] = proxyServer
  1596.                     else:
  1597.                         proxies['http'] = 'http://%s' % proxyServer
  1598.                         proxies['ftp'] = 'ftp://%s' % proxyServer
  1599.             internetSettings.Close()
  1600.         except (WindowsError, ValueError, TypeError):
  1601.             # Either registry key not found etc, or the value in an
  1602.             # unexpected format.
  1603.             # proxies already set up to be empty so nothing to do
  1604.             pass
  1605.         return proxies
  1606.  
  1607.     def getproxies():
  1608.         """Return a dictionary of scheme -> proxy server URL mappings.
  1609.  
  1610.         Returns settings gathered from the environment, if specified,
  1611.         or the registry.
  1612.  
  1613.         """
  1614.         return getproxies_environment() or getproxies_registry()
  1615.  
  1616.     def proxy_bypass_registry(host):
  1617.         try:
  1618.             import _winreg
  1619.             import re
  1620.         except ImportError:
  1621.             # Std modules, so should be around - but you never know!
  1622.             return 0
  1623.         try:
  1624.             internetSettings = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER,
  1625.                 r'Software\Microsoft\Windows\CurrentVersion\Internet Settings')
  1626.             proxyEnable = _winreg.QueryValueEx(internetSettings,
  1627.                                                'ProxyEnable')[0]
  1628.             proxyOverride = str(_winreg.QueryValueEx(internetSettings,
  1629.                                                      'ProxyOverride')[0])
  1630.             # ^^^^ Returned as Unicode but problems if not converted to ASCII
  1631.         except WindowsError:
  1632.             return 0
  1633.         if not proxyEnable or not proxyOverride:
  1634.             return 0
  1635.         # try to make a host list from name and IP address.
  1636.         rawHost, port = splitport(host)
  1637.         host = [rawHost]
  1638.         try:
  1639.             addr = socket.gethostbyname(rawHost)
  1640.             if addr != rawHost:
  1641.                 host.append(addr)
  1642.         except socket.error:
  1643.             pass
  1644.         try:
  1645.             fqdn = socket.getfqdn(rawHost)
  1646.             if fqdn != rawHost:
  1647.                 host.append(fqdn)
  1648.         except socket.error:
  1649.             pass
  1650.         # make a check value list from the registry entry: replace the
  1651.         # '<local>' string by the localhost entry and the corresponding
  1652.         # canonical entry.
  1653.         proxyOverride = proxyOverride.split(';')
  1654.         i = 0
  1655.         while i < len(proxyOverride):
  1656.             if proxyOverride[i] == '<local>':
  1657.                 proxyOverride[i:i+1] = ['localhost',
  1658.                                         '127.0.0.1',
  1659.                                         socket.gethostname(),
  1660.                                         socket.gethostbyname(
  1661.                                             socket.gethostname())]
  1662.             i += 1
  1663.         # print proxyOverride
  1664.         # now check if we match one of the registry values.
  1665.         for test in proxyOverride:
  1666.             test = test.replace(".", r"\.")     # mask dots
  1667.             test = test.replace("*", r".*")     # change glob sequence
  1668.             test = test.replace("?", r".")      # change glob char
  1669.             for val in host:
  1670.                 # print "%s <--> %s" %( test, val )
  1671.                 if re.match(test, val, re.I):
  1672.                     return 1
  1673.         return 0
  1674.  
  1675.     def proxy_bypass(host):
  1676.         """Return a dictionary of scheme -> proxy server URL mappings.
  1677.  
  1678.         Returns settings gathered from the environment, if specified,
  1679.         or the registry.
  1680.  
  1681.         """
  1682.         if getproxies_environment():
  1683.             return proxy_bypass_environment(host)
  1684.         else:
  1685.             return proxy_bypass_registry(host)
  1686.  
  1687. else:
  1688.     # By default use environment variables
  1689.     getproxies = getproxies_environment
  1690.     proxy_bypass = proxy_bypass_environment
  1691.  
  1692. # Test and time quote() and unquote()
  1693. def test1():
  1694.     s = ''
  1695.     for i in range(256): s = s + chr(i)
  1696.     s = s*4
  1697.     t0 = time.time()
  1698.     qs = quote(s)
  1699.     uqs = unquote(qs)
  1700.     t1 = time.time()
  1701.     if uqs != s:
  1702.         print 'Wrong!'
  1703.     print repr(s)
  1704.     print repr(qs)
  1705.     print repr(uqs)
  1706.     print round(t1 - t0, 3), 'sec'
  1707.  
  1708.  
  1709. def reporthook(blocknum, blocksize, totalsize):
  1710.     # Report during remote transfers
  1711.     print "Block number: %d, Block size: %d, Total size: %d" % (
  1712.         blocknum, blocksize, totalsize)
  1713.  
  1714. # Test program
  1715. def test(args=[]):
  1716.     if not args:
  1717.         args = [
  1718.             '/etc/passwd',
  1719.             'file:/etc/passwd',
  1720.             'file://localhost/etc/passwd',
  1721.             'ftp://ftp.gnu.org/pub/README',
  1722.             'http://www.python.org/index.html',
  1723.             ]
  1724.         if hasattr(URLopener, "open_https"):
  1725.             args.append('https://synergy.as.cmu.edu/~geek/')
  1726.     try:
  1727.         for url in args:
  1728.             print '-'*10, url, '-'*10
  1729.             fn, h = urlretrieve(url, None, reporthook)
  1730.             print fn
  1731.             if h:
  1732.                 print '======'
  1733.                 for k in h.keys(): print k + ':', h[k]
  1734.                 print '======'
  1735.             fp = open(fn, 'rb')
  1736.             data = fp.read()
  1737.             del fp
  1738.             if '\r' in data:
  1739.                 table = string.maketrans("", "")
  1740.                 data = data.translate(table, "\r")
  1741.             print data
  1742.             fn, h = None, None
  1743.         print '-'*40
  1744.     finally:
  1745.         urlcleanup()
  1746.  
  1747. def main():
  1748.     import getopt, sys
  1749.     try:
  1750.         opts, args = getopt.getopt(sys.argv[1:], "th")
  1751.     except getopt.error, msg:
  1752.         print msg
  1753.         print "Use -h for help"
  1754.         return
  1755.     t = 0
  1756.     for o, a in opts:
  1757.         if o == '-t':
  1758.             t = t + 1
  1759.         if o == '-h':
  1760.             print "Usage: python urllib.py [-t] [url ...]"
  1761.             print "-t runs self-test;",
  1762.             print "otherwise, contents of urls are printed"
  1763.             return
  1764.     if t:
  1765.         if t > 1:
  1766.             test1()
  1767.         test(args)
  1768.     else:
  1769.         if not args:
  1770.             print "Use -h for help"
  1771.         for url in args:
  1772.             print urlopen(url).read(),
  1773.  
  1774. # Run test program when run as a script
  1775. if __name__ == '__main__':
  1776.     main()
  1777.