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