home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / urlparse.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  8.5 KB  |  341 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Parse (absolute and relative) URLs.
  5.  
  6. See RFC 1808: "Relative Uniform Resource Locators", by R. Fielding,
  7. UC Irvine, June 1995.
  8. '''
  9. __all__ = [
  10.     'urlparse',
  11.     'urlunparse',
  12.     'urljoin',
  13.     'urldefrag',
  14.     'urlsplit',
  15.     'urlunsplit']
  16. uses_relative = [
  17.     'ftp',
  18.     'http',
  19.     'gopher',
  20.     'nntp',
  21.     'imap',
  22.     'wais',
  23.     'file',
  24.     'https',
  25.     'shttp',
  26.     'mms',
  27.     'prospero',
  28.     'rtsp',
  29.     'rtspu',
  30.     '']
  31. uses_netloc = [
  32.     'ftp',
  33.     'http',
  34.     'gopher',
  35.     'nntp',
  36.     'telnet',
  37.     'imap',
  38.     'wais',
  39.     'file',
  40.     'mms',
  41.     'https',
  42.     'shttp',
  43.     'snews',
  44.     'prospero',
  45.     'rtsp',
  46.     'rtspu',
  47.     'rsync',
  48.     '']
  49. non_hierarchical = [
  50.     'gopher',
  51.     'hdl',
  52.     'mailto',
  53.     'news',
  54.     'telnet',
  55.     'wais',
  56.     'imap',
  57.     'snews',
  58.     'sip']
  59. uses_params = [
  60.     'ftp',
  61.     'hdl',
  62.     'prospero',
  63.     'http',
  64.     'imap',
  65.     'https',
  66.     'shttp',
  67.     'rtsp',
  68.     'rtspu',
  69.     'sip',
  70.     'mms',
  71.     '']
  72. uses_query = [
  73.     'http',
  74.     'wais',
  75.     'imap',
  76.     'https',
  77.     'shttp',
  78.     'mms',
  79.     'gopher',
  80.     'rtsp',
  81.     'rtspu',
  82.     'sip',
  83.     '']
  84. uses_fragment = [
  85.     'ftp',
  86.     'hdl',
  87.     'http',
  88.     'gopher',
  89.     'news',
  90.     'nntp',
  91.     'wais',
  92.     'https',
  93.     'shttp',
  94.     'snews',
  95.     'file',
  96.     'prospero',
  97.     '']
  98. scheme_chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-.'
  99. MAX_CACHE_SIZE = 20
  100. _parse_cache = { }
  101.  
  102. def clear_cache():
  103.     '''Clear the parse cache.'''
  104.     global _parse_cache
  105.     _parse_cache = { }
  106.  
  107.  
  108. def urlparse(url, scheme = '', allow_fragments = 1):
  109.     """Parse a URL into 6 components:
  110.     <scheme>://<netloc>/<path>;<params>?<query>#<fragment>
  111.     Return a 6-tuple: (scheme, netloc, path, params, query, fragment).
  112.     Note that we don't break the components up in smaller bits
  113.     (e.g. netloc is a single string) and we don't expand % escapes."""
  114.     tuple = urlsplit(url, scheme, allow_fragments)
  115.     (scheme, netloc, url, query, fragment) = tuple
  116.     if scheme in uses_params and ';' in url:
  117.         (url, params) = _splitparams(url)
  118.     else:
  119.         params = ''
  120.     return (scheme, netloc, url, params, query, fragment)
  121.  
  122.  
  123. def _splitparams(url):
  124.     if '/' in url:
  125.         i = url.find(';', url.rfind('/'))
  126.         if i < 0:
  127.             return (url, '')
  128.         
  129.     else:
  130.         i = url.find(';')
  131.     return (url[:i], url[i + 1:])
  132.  
  133.  
  134. def _splitnetloc(url, start = 0):
  135.     for c in '/?#':
  136.         delim = url.find(c, start)
  137.         if delim >= 0:
  138.             break
  139.             continue
  140.     else:
  141.         delim = len(url)
  142.     return (url[start:delim], url[delim:])
  143.  
  144.  
  145. def urlsplit(url, scheme = '', allow_fragments = 1):
  146.     """Parse a URL into 5 components:
  147.     <scheme>://<netloc>/<path>?<query>#<fragment>
  148.     Return a 5-tuple: (scheme, netloc, path, query, fragment).
  149.     Note that we don't break the components up in smaller bits
  150.     (e.g. netloc is a single string) and we don't expand % escapes."""
  151.     key = (url, scheme, allow_fragments)
  152.     cached = _parse_cache.get(key, None)
  153.     if cached:
  154.         return cached
  155.     
  156.     if len(_parse_cache) >= MAX_CACHE_SIZE:
  157.         clear_cache()
  158.     
  159.     netloc = query = fragment = ''
  160.     i = url.find(':')
  161.     if i > 0:
  162.         if url[:i] == 'http':
  163.             scheme = url[:i].lower()
  164.             url = url[i + 1:]
  165.             if url[:2] == '//':
  166.                 (netloc, url) = _splitnetloc(url, 2)
  167.             
  168.             if allow_fragments and '#' in url:
  169.                 (url, fragment) = url.split('#', 1)
  170.             
  171.             if '?' in url:
  172.                 (url, query) = url.split('?', 1)
  173.             
  174.             tuple = (scheme, netloc, url, query, fragment)
  175.             _parse_cache[key] = tuple
  176.             return tuple
  177.         
  178.         for c in url[:i]:
  179.             if c not in scheme_chars:
  180.                 break
  181.                 continue
  182.         else:
  183.             scheme = url[:i].lower()
  184.             url = url[i + 1:]
  185.     
  186.     if scheme in uses_netloc and url[:2] == '//':
  187.         (netloc, url) = _splitnetloc(url, 2)
  188.     
  189.     if allow_fragments and scheme in uses_fragment and '#' in url:
  190.         (url, fragment) = url.split('#', 1)
  191.     
  192.     if scheme in uses_query and '?' in url:
  193.         (url, query) = url.split('?', 1)
  194.     
  195.     tuple = (scheme, netloc, url, query, fragment)
  196.     _parse_cache[key] = tuple
  197.     return tuple
  198.  
  199.  
  200. def urlunparse(.0):
  201.     '''Put a parsed URL back together again.  This may result in a
  202.     slightly different, but equivalent URL, if the URL that was parsed
  203.     originally had redundant delimiters, e.g. a ? with an empty query
  204.     (the draft states that these are equivalent).'''
  205.     (scheme, netloc, url, params, query, fragment) = .0
  206.     if params:
  207.         url = '%s;%s' % (url, params)
  208.     
  209.     return urlunsplit((scheme, netloc, url, query, fragment))
  210.  
  211.  
  212. def urlunsplit(.0):
  213.     (scheme, netloc, url, query, fragment) = .0
  214.     if (netloc or scheme) and scheme in uses_netloc and url[:2] != '//':
  215.         if url and url[:1] != '/':
  216.             url = '/' + url
  217.         
  218.         if not netloc:
  219.             pass
  220.         url = '//' + '' + url
  221.     
  222.     if scheme:
  223.         url = scheme + ':' + url
  224.     
  225.     if query:
  226.         url = url + '?' + query
  227.     
  228.     if fragment:
  229.         url = url + '#' + fragment
  230.     
  231.     return url
  232.  
  233.  
  234. def urljoin(base, url, allow_fragments = 1):
  235.     '''Join a base URL and a possibly relative URL to form an absolute
  236.     interpretation of the latter.'''
  237.     if not base:
  238.         return url
  239.     
  240.     if not url:
  241.         return base
  242.     
  243.     (bscheme, bnetloc, bpath, bparams, bquery, bfragment) = urlparse(base, '', allow_fragments)
  244.     (scheme, netloc, path, params, query, fragment) = urlparse(url, bscheme, allow_fragments)
  245.     if scheme != bscheme or scheme not in uses_relative:
  246.         return url
  247.     
  248.     if scheme in uses_netloc:
  249.         if netloc:
  250.             return urlunparse((scheme, netloc, path, params, query, fragment))
  251.         
  252.         netloc = bnetloc
  253.     
  254.     if path[:1] == '/':
  255.         return urlunparse((scheme, netloc, path, params, query, fragment))
  256.     
  257.     if not path and params or query:
  258.         return urlunparse((scheme, netloc, bpath, bparams, bquery, fragment))
  259.     
  260.     segments = bpath.split('/')[:-1] + path.split('/')
  261.     if segments[-1] == '.':
  262.         segments[-1] = ''
  263.     
  264.     while '.' in segments:
  265.         segments.remove('.')
  266.     while None:
  267.         i = 1
  268.         n = len(segments) - 1
  269.         while i < n:
  270.             if segments[i] == '..' and segments[i - 1] not in ('', '..'):
  271.                 del segments[i - 1:i + 1]
  272.                 break
  273.             
  274.             i = i + 1
  275.         break
  276.     if segments == [
  277.         '',
  278.         '..']:
  279.         segments[-1] = ''
  280.     elif len(segments) >= 2 and segments[-1] == '..':
  281.         segments[-2:] = [
  282.             '']
  283.     
  284.     return urlunparse((scheme, netloc, '/'.join(segments), params, query, fragment))
  285.  
  286.  
  287. def urldefrag(url):
  288.     '''Removes any existing fragment from URL.
  289.  
  290.     Returns a tuple of the defragmented URL and the fragment.  If
  291.     the URL contained no fragments, the second element is the
  292.     empty string.
  293.     '''
  294.     if '#' in url:
  295.         (s, n, p, a, q, frag) = urlparse(url)
  296.         defrag = urlunparse((s, n, p, a, q, ''))
  297.         return (defrag, frag)
  298.     else:
  299.         return (url, '')
  300.  
  301. 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'
  302.  
  303. def test():
  304.     import sys
  305.     base = ''
  306.     if sys.argv[1:]:
  307.         fn = sys.argv[1]
  308.         if fn == '-':
  309.             fp = sys.stdin
  310.         else:
  311.             fp = open(fn)
  312.     else:
  313.         import StringIO
  314.         fp = StringIO.StringIO(test_input)
  315.     while None:
  316.         line = fp.readline()
  317.         if not line:
  318.             break
  319.         
  320.         words = line.split()
  321.         if not words:
  322.             continue
  323.         
  324.         url = words[0]
  325.         parts = urlparse(url)
  326.         print '%-10s : %s' % (url, parts)
  327.         abs = urljoin(base, url)
  328.         if not base:
  329.             base = abs
  330.         
  331.         wrapped = '<URL:%s>' % abs
  332.         print '%-10s = %s' % (url, wrapped)
  333.         if len(words) == 3 and words[1] == '=':
  334.             if wrapped != words[2]:
  335.                 print 'EXPECTED', words[2], '!!!!!!!!!!'
  336.             
  337.  
  338. if __name__ == '__main__':
  339.     test()
  340.  
  341.