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