home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2833 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  10.9 KB  |  435 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'urlparse',
  6.     'urlunparse',
  7.     'urljoin',
  8.     'urldefrag',
  9.     'urlsplit',
  10.     'urlunsplit',
  11.     'parse_qs',
  12.     'parse_qsl']
  13. uses_relative = [
  14.     'ftp',
  15.     'http',
  16.     'gopher',
  17.     'nntp',
  18.     'imap',
  19.     'wais',
  20.     'file',
  21.     'https',
  22.     'shttp',
  23.     'mms',
  24.     'prospero',
  25.     'rtsp',
  26.     'rtspu',
  27.     '',
  28.     'sftp']
  29. uses_netloc = [
  30.     'ftp',
  31.     'http',
  32.     'gopher',
  33.     'nntp',
  34.     'telnet',
  35.     'imap',
  36.     'wais',
  37.     'file',
  38.     'mms',
  39.     'https',
  40.     'shttp',
  41.     'snews',
  42.     'prospero',
  43.     'rtsp',
  44.     'rtspu',
  45.     'rsync',
  46.     '',
  47.     'svn',
  48.     'svn+ssh',
  49.     'sftp']
  50. non_hierarchical = [
  51.     'gopher',
  52.     'hdl',
  53.     'mailto',
  54.     'news',
  55.     'telnet',
  56.     'wais',
  57.     'imap',
  58.     'snews',
  59.     'sip',
  60.     'sips']
  61. uses_params = [
  62.     'ftp',
  63.     'hdl',
  64.     'prospero',
  65.     'http',
  66.     'imap',
  67.     'https',
  68.     'shttp',
  69.     'rtsp',
  70.     'rtspu',
  71.     'sip',
  72.     'sips',
  73.     'mms',
  74.     '',
  75.     'sftp']
  76. uses_query = [
  77.     'http',
  78.     'wais',
  79.     'imap',
  80.     'https',
  81.     'shttp',
  82.     'mms',
  83.     'gopher',
  84.     'rtsp',
  85.     'rtspu',
  86.     'sip',
  87.     'sips',
  88.     '']
  89. uses_fragment = [
  90.     'ftp',
  91.     'hdl',
  92.     'http',
  93.     'gopher',
  94.     'news',
  95.     'nntp',
  96.     'wais',
  97.     'https',
  98.     'shttp',
  99.     'snews',
  100.     'file',
  101.     'prospero',
  102.     '']
  103. scheme_chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-.'
  104. MAX_CACHE_SIZE = 20
  105. _parse_cache = { }
  106.  
  107. def clear_cache():
  108.     _parse_cache.clear()
  109.  
  110.  
  111. class ResultMixin(object):
  112.     
  113.     def username(self):
  114.         netloc = self.netloc
  115.         if '@' in netloc:
  116.             userinfo = netloc.rsplit('@', 1)[0]
  117.             if ':' in userinfo:
  118.                 userinfo = userinfo.split(':', 1)[0]
  119.             
  120.             return userinfo
  121.  
  122.     username = property(username)
  123.     
  124.     def password(self):
  125.         netloc = self.netloc
  126.         if '@' in netloc:
  127.             userinfo = netloc.rsplit('@', 1)[0]
  128.             if ':' in userinfo:
  129.                 return userinfo.split(':', 1)[1]
  130.         
  131.  
  132.     password = property(password)
  133.     
  134.     def hostname(self):
  135.         netloc = self.netloc
  136.         if '@' in netloc:
  137.             netloc = netloc.rsplit('@', 1)[1]
  138.         
  139.         if ':' in netloc:
  140.             netloc = netloc.split(':', 1)[0]
  141.         
  142.         if not netloc.lower():
  143.             pass
  144.  
  145.     hostname = property(hostname)
  146.     
  147.     def port(self):
  148.         netloc = self.netloc
  149.         if '@' in netloc:
  150.             netloc = netloc.rsplit('@', 1)[1]
  151.         
  152.         if ':' in netloc:
  153.             port = netloc.split(':', 1)[1]
  154.             return int(port, 10)
  155.  
  156.     port = property(port)
  157.  
  158. from collections import namedtuple
  159.  
  160. class SplitResult(namedtuple('SplitResult', 'scheme netloc path query fragment'), ResultMixin):
  161.     __slots__ = ()
  162.     
  163.     def geturl(self):
  164.         return urlunsplit(self)
  165.  
  166.  
  167.  
  168. class ParseResult(namedtuple('ParseResult', 'scheme netloc path params query fragment'), ResultMixin):
  169.     __slots__ = ()
  170.     
  171.     def geturl(self):
  172.         return urlunparse(self)
  173.  
  174.  
  175.  
  176. def urlparse(url, scheme = '', allow_fragments = True):
  177.     tuple = urlsplit(url, scheme, allow_fragments)
  178.     (scheme, netloc, url, query, fragment) = tuple
  179.     if scheme in uses_params and ';' in url:
  180.         (url, params) = _splitparams(url)
  181.     else:
  182.         params = ''
  183.     return ParseResult(scheme, netloc, url, params, query, fragment)
  184.  
  185.  
  186. def _splitparams(url):
  187.     if '/' in url:
  188.         i = url.find(';', url.rfind('/'))
  189.         if i < 0:
  190.             return (url, '')
  191.     else:
  192.         i = url.find(';')
  193.     return (url[:i], url[i + 1:])
  194.  
  195.  
  196. def _splitnetloc(url, start = 0):
  197.     delim = len(url)
  198.     for c in '/?#':
  199.         wdelim = url.find(c, start)
  200.         if wdelim >= 0:
  201.             delim = min(delim, wdelim)
  202.             continue
  203.     
  204.     return (url[start:delim], url[delim:])
  205.  
  206.  
  207. def urlsplit(url, scheme = '', allow_fragments = True):
  208.     allow_fragments = bool(allow_fragments)
  209.     key = (url, scheme, allow_fragments, type(url), type(scheme))
  210.     cached = _parse_cache.get(key, None)
  211.     if cached:
  212.         return cached
  213.     if len(_parse_cache) >= MAX_CACHE_SIZE:
  214.         clear_cache()
  215.     
  216.     netloc = query = fragment = ''
  217.     i = url.find(':')
  218.     if i > 0:
  219.         if url[:i] == 'http':
  220.             scheme = url[:i].lower()
  221.             url = url[i + 1:]
  222.             if url[:2] == '//':
  223.                 (netloc, url) = _splitnetloc(url, 2)
  224.             
  225.             if allow_fragments and '#' in url:
  226.                 (url, fragment) = url.split('#', 1)
  227.             
  228.             if '?' in url:
  229.                 (url, query) = url.split('?', 1)
  230.             
  231.             v = SplitResult(scheme, netloc, url, query, fragment)
  232.             _parse_cache[key] = v
  233.             return v
  234.         for c in url[:i]:
  235.             if c not in scheme_chars:
  236.                 break
  237.                 continue
  238.             url[:i] == 'http'
  239.         else:
  240.             scheme = url[:i].lower()
  241.             url = url[i + 1:]
  242.     
  243.     if scheme in uses_netloc and url[:2] == '//':
  244.         (netloc, url) = _splitnetloc(url, 2)
  245.     
  246.     if allow_fragments and scheme in uses_fragment and '#' in url:
  247.         (url, fragment) = url.split('#', 1)
  248.     
  249.     if scheme in uses_query and '?' in url:
  250.         (url, query) = url.split('?', 1)
  251.     
  252.     v = SplitResult(scheme, netloc, url, query, fragment)
  253.     _parse_cache[key] = v
  254.     return v
  255.  
  256.  
  257. def urlunparse(data):
  258.     (scheme, netloc, url, params, query, fragment) = data
  259.     if params:
  260.         url = '%s;%s' % (url, params)
  261.     
  262.     return urlunsplit((scheme, netloc, url, query, fragment))
  263.  
  264.  
  265. def urlunsplit(data):
  266.     (scheme, netloc, url, query, fragment) = data
  267.     if (netloc or scheme) and scheme in uses_netloc and url[:2] != '//':
  268.         if url and url[:1] != '/':
  269.             url = '/' + url
  270.         
  271.         if not netloc:
  272.             pass
  273.         url = '//' + '' + url
  274.     
  275.     if scheme:
  276.         url = scheme + ':' + url
  277.     
  278.     if query:
  279.         url = url + '?' + query
  280.     
  281.     if fragment:
  282.         url = url + '#' + fragment
  283.     
  284.     return url
  285.  
  286.  
  287. def urljoin(base, url, allow_fragments = True):
  288.     if not base:
  289.         return url
  290.     if not url:
  291.         return base
  292.     (bscheme, bnetloc, bpath, bparams, bquery, bfragment) = urlparse(base, '', allow_fragments)
  293.     (scheme, netloc, path, params, query, fragment) = urlparse(url, bscheme, allow_fragments)
  294.     if scheme != bscheme or scheme not in uses_relative:
  295.         return url
  296.     if path[:1] == '/':
  297.         return urlunparse((scheme, netloc, path, params, query, fragment))
  298.     if not path:
  299.         path = bpath
  300.         if not params:
  301.             params = bparams
  302.         else:
  303.             path = path[:-1]
  304.             return urlunparse((scheme, netloc, path, params, query, fragment))
  305.         return urlunparse((scheme, netloc, path, params, query, fragment))
  306.     segments = bpath.split('/')[:-1] + path.split('/')
  307.     while '.' in segments:
  308.         segments.remove('.')
  309.         continue
  310.         url if scheme in uses_netloc else scheme not in uses_relative if segments[-1] == '.' else path[:1] == '/'
  311.     while None:
  312.         i = 1
  313.         n = len(segments) - 1
  314.         while i < n:
  315.             if segments[i] == '..' and segments[i - 1] not in ('', '..'):
  316.                 del segments[i - 1:i + 1]
  317.                 break
  318.             
  319.             i = i + 1
  320.         break
  321.         continue
  322.         if segments == [
  323.             '',
  324.             '..']:
  325.             segments[-1] = ''
  326.         elif len(segments) >= 2 and segments[-1] == '..':
  327.             segments[-2:] = [
  328.                 '']
  329.         
  330.     return urlunparse((scheme, netloc, '/'.join(segments), params, query, fragment))
  331.  
  332.  
  333. def urldefrag(url):
  334.     if '#' in url:
  335.         (s, n, p, a, q, frag) = urlparse(url)
  336.         defrag = urlunparse((s, n, p, a, q, ''))
  337.         return (defrag, frag)
  338.     return (url, '')
  339.  
  340. _hextochr = dict((lambda .0: for i in .0:
  341. ('%02x' % i, chr(i)))(range(256)))
  342. _hextochr.update((lambda .0: for i in .0:
  343. ('%02X' % i, chr(i)))(range(256)))
  344.  
  345. def unquote(s):
  346.     res = s.split('%')
  347.     for i in xrange(1, len(res)):
  348.         item = res[i]
  349.         
  350.         try:
  351.             res[i] = _hextochr[item[:2]] + item[2:]
  352.         continue
  353.         except KeyError:
  354.             res[i] = '%' + item
  355.             continue
  356.             except UnicodeDecodeError:
  357.                 res[i] = unichr(int(item[:2], 16)) + item[2:]
  358.                 continue
  359.             
  360.         return ''.join(res)
  361.  
  362.  
  363.  
  364. def parse_qs(qs, keep_blank_values = 0, strict_parsing = 0):
  365.     dict = { }
  366.     for name, value in parse_qsl(qs, keep_blank_values, strict_parsing):
  367.         if name in dict:
  368.             dict[name].append(value)
  369.             continue
  370.         dict[name] = [
  371.             value]
  372.     
  373.     return dict
  374.  
  375.  
  376. def parse_qsl(qs, keep_blank_values = 0, strict_parsing = 0):
  377.     pairs = [ s2 for s1 in qs.split('&') for s2 in s1.split(';') ]
  378.     r = []
  379.     for name_value in pairs:
  380.         nv = name_value.split('=', 1)
  381.         if len(nv[1]) or keep_blank_values:
  382.             name = unquote(nv[0].replace('+', ' '))
  383.             value = unquote(nv[1].replace('+', ' '))
  384.             r.append((name, value))
  385.             continue
  386.         None if len(nv) != 2 else None if not name_value and not strict_parsing else []
  387.     
  388.     return r
  389.  
  390. test_input = '\n      http://a/b/c/d\n\n      g:h        = <URL:g:h>\n      http:g     = <URL:http://a/b/c/g>\n      http:      = <URL:http://a/b/c/d>\n      g          = <URL:http://a/b/c/g>\n      ./g        = <URL:http://a/b/c/g>\n      g/         = <URL:http://a/b/c/g/>\n      /g         = <URL:http://a/g>\n      //g        = <URL:http://g>\n      ?y         = <URL:http://a/b/c/d?y>\n      g?y        = <URL:http://a/b/c/g?y>\n      g?y/./x    = <URL:http://a/b/c/g?y/./x>\n      .          = <URL:http://a/b/c/>\n      ./         = <URL:http://a/b/c/>\n      ..         = <URL:http://a/b/>\n      ../        = <URL:http://a/b/>\n      ../g       = <URL:http://a/b/g>\n      ../..      = <URL:http://a/>\n      ../../g    = <URL:http://a/g>\n      ../../../g = <URL:http://a/../g>\n      ./../g     = <URL:http://a/b/g>\n      ./g/.      = <URL:http://a/b/c/g/>\n      /./g       = <URL:http://a/./g>\n      g/./h      = <URL:http://a/b/c/g/h>\n      g/../h     = <URL:http://a/b/c/h>\n      http:g     = <URL:http://a/b/c/g>\n      http:      = <URL:http://a/b/c/d>\n      http:?y         = <URL:http://a/b/c/d?y>\n      http:g?y        = <URL:http://a/b/c/g?y>\n      http:g?y/./x    = <URL:http://a/b/c/g?y/./x>\n'
  391.  
  392. def test():
  393.     import sys
  394.     base = ''
  395.     if sys.argv[1:]:
  396.         fn = sys.argv[1]
  397.         if fn == '-':
  398.             fp = sys.stdin
  399.         else:
  400.             fp = open(fn)
  401.     else:
  402.         
  403.         try:
  404.             StringIO = StringIO
  405.             import cStringIO
  406.         except ImportError:
  407.             StringIO = StringIO
  408.             import StringIO
  409.  
  410.         fp = StringIO(test_input)
  411.     for line in fp:
  412.         words = line.split()
  413.         if not words:
  414.             continue
  415.         
  416.         url = words[0]
  417.         parts = urlparse(url)
  418.         print '%-10s : %s' % (url, parts)
  419.         abs = urljoin(base, url)
  420.         if not base:
  421.             base = abs
  422.         
  423.         wrapped = '<URL:%s>' % abs
  424.         print '%-10s = %s' % (url, wrapped)
  425.         if len(words) == 3 and words[1] == '=':
  426.             if wrapped != words[2]:
  427.                 print 'EXPECTED', words[2], '!!!!!!!!!!'
  428.             
  429.         wrapped != words[2]
  430.     
  431.  
  432. if __name__ == '__main__':
  433.     test()
  434.  
  435.