home *** CD-ROM | disk | FTP | other *** search
/ com!online 2005 April / com_0405_1.iso / opensource / BTpp-0.5.4-bin.exe / $INSTDIR / BT++.exe / urlparse.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-04-19  |  8.1 KB  |  309 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.2)
  3.  
  4. __all__ = [
  5.     'urlparse',
  6.     'urlunparse',
  7.     'urljoin']
  8. uses_relative = [
  9.     'ftp',
  10.     'http',
  11.     'gopher',
  12.     'nntp',
  13.     'wais',
  14.     'file',
  15.     'https',
  16.     'shttp',
  17.     'prospero',
  18.     'rtsp',
  19.     'rtspu',
  20.     '']
  21. uses_netloc = [
  22.     'ftp',
  23.     'http',
  24.     'gopher',
  25.     'nntp',
  26.     'telnet',
  27.     'wais',
  28.     'file',
  29.     'https',
  30.     'shttp',
  31.     'snews',
  32.     'prospero',
  33.     'rtsp',
  34.     'rtspu',
  35.     '']
  36. non_hierarchical = [
  37.     'gopher',
  38.     'hdl',
  39.     'mailto',
  40.     'news',
  41.     'telnet',
  42.     'wais',
  43.     'snews',
  44.     'sip']
  45. uses_params = [
  46.     'ftp',
  47.     'hdl',
  48.     'prospero',
  49.     'http',
  50.     'https',
  51.     'shttp',
  52.     'rtsp',
  53.     'rtspu',
  54.     'sip',
  55.     '']
  56. uses_query = [
  57.     'http',
  58.     'wais',
  59.     'https',
  60.     'shttp',
  61.     'gopher',
  62.     'rtsp',
  63.     'rtspu',
  64.     'sip',
  65.     '']
  66. uses_fragment = [
  67.     'ftp',
  68.     'hdl',
  69.     'http',
  70.     'gopher',
  71.     'news',
  72.     'nntp',
  73.     'wais',
  74.     'https',
  75.     'shttp',
  76.     'snews',
  77.     'file',
  78.     'prospero',
  79.     '']
  80. scheme_chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-.'
  81. MAX_CACHE_SIZE = 20
  82. _parse_cache = { }
  83.  
  84. def clear_cache():
  85.     global _parse_cache
  86.     _parse_cache = { }
  87.  
  88.  
  89. def urlparse(url, scheme = '', allow_fragments = 1):
  90.     tuple = urlsplit(url, scheme, allow_fragments)
  91.     (scheme, netloc, url, query, fragment) = tuple
  92.     if scheme in uses_params and ';' in url:
  93.         (url, params) = _splitparams(url)
  94.     else:
  95.         params = ''
  96.     return (scheme, netloc, url, params, query, fragment)
  97.  
  98.  
  99. def _splitparams(url):
  100.     if '/' in url:
  101.         i = url.find(';', url.rfind('/'))
  102.         if i < 0:
  103.             return (url, '')
  104.         
  105.     else:
  106.         i = url.find(';')
  107.     return (url[:i], url[i + 1:])
  108.  
  109.  
  110. def urlsplit(url, scheme = '', allow_fragments = 1):
  111.     key = (url, scheme, allow_fragments)
  112.     cached = _parse_cache.get(key, None)
  113.     if cached:
  114.         return cached
  115.     
  116.     if len(_parse_cache) >= MAX_CACHE_SIZE:
  117.         clear_cache()
  118.     
  119.     netloc = query = fragment = ''
  120.     i = url.find(':')
  121.     if i > 0:
  122.         if url[:i] == 'http':
  123.             scheme = url[:i].lower()
  124.             url = url[i + 1:]
  125.             if url[:2] == '//':
  126.                 i = url.find('/', 2)
  127.                 if i < 0:
  128.                     i = url.find('#')
  129.                     if i < 0:
  130.                         i = len(url)
  131.                     
  132.                 
  133.                 netloc = url[2:i]
  134.                 url = url[i:]
  135.             
  136.             if allow_fragments and '#' in url:
  137.                 (url, fragment) = url.split('#', 1)
  138.             
  139.             if '?' in url:
  140.                 (url, query) = url.split('?', 1)
  141.             
  142.             tuple = (scheme, netloc, url, query, fragment)
  143.             _parse_cache[key] = tuple
  144.             return tuple
  145.         
  146.         for c in url[:i]:
  147.             if c not in scheme_chars:
  148.                 break
  149.             
  150.         else:
  151.             (scheme, url) = (url[:i].lower(), url[i + 1:])
  152.     
  153.     if scheme in uses_netloc:
  154.         if url[:2] == '//':
  155.             i = url.find('/', 2)
  156.             if i < 0:
  157.                 i = len(url)
  158.             
  159.             (netloc, url) = (url[2:i], url[i:])
  160.         
  161.     
  162.     if allow_fragments and scheme in uses_fragment and '#' in url:
  163.         (url, fragment) = url.split('#', 1)
  164.     
  165.     if scheme in uses_query and '?' in url:
  166.         (url, query) = url.split('?', 1)
  167.     
  168.     tuple = (scheme, netloc, url, query, fragment)
  169.     _parse_cache[key] = tuple
  170.     return tuple
  171.  
  172.  
  173. def urlunparse(.0):
  174.     (scheme, netloc, url, params, query, fragment) = .0
  175.     if params:
  176.         url = '%s;%s' % (url, params)
  177.     
  178.     return urlunsplit((scheme, netloc, url, query, fragment))
  179.  
  180.  
  181. def urlunsplit(.0):
  182.     (scheme, netloc, url, query, fragment) = .0
  183.     if netloc and scheme and scheme in uses_netloc and url[:2] != '//':
  184.         if url and url[:1] != '/':
  185.             url = '/' + url
  186.         
  187.         if not netloc:
  188.             pass
  189.         url = '//' + '' + url
  190.     
  191.     if scheme:
  192.         url = scheme + ':' + url
  193.     
  194.     if query:
  195.         url = url + '?' + query
  196.     
  197.     if fragment:
  198.         url = url + '#' + fragment
  199.     
  200.     return url
  201.  
  202.  
  203. def urljoin(base, url, allow_fragments = 1):
  204.     if not base:
  205.         return url
  206.     
  207.     if not url:
  208.         return base
  209.     
  210.     (bscheme, bnetloc, bpath, bparams, bquery, bfragment) = urlparse(base, '', allow_fragments)
  211.     (scheme, netloc, path, params, query, fragment) = urlparse(url, bscheme, allow_fragments)
  212.     if scheme != bscheme or scheme not in uses_relative:
  213.         return url
  214.     
  215.     if scheme in uses_netloc:
  216.         if netloc:
  217.             return urlunparse((scheme, netloc, path, params, query, fragment))
  218.         
  219.         netloc = bnetloc
  220.     
  221.     if path[:1] == '/':
  222.         return urlunparse((scheme, netloc, path, params, query, fragment))
  223.     
  224.     if not path:
  225.         if not params:
  226.             params = bparams
  227.             if not query:
  228.                 query = bquery
  229.             
  230.         
  231.         return urlunparse((scheme, netloc, bpath, params, query, fragment))
  232.     
  233.     segments = bpath.split('/')[:-1] + path.split('/')
  234.     if segments[-1] == '.':
  235.         segments[-1] = ''
  236.     
  237.     while '.' in segments:
  238.         segments.remove('.')
  239.     while 1:
  240.         i = 1
  241.         n = len(segments) - 1
  242.         while i < n:
  243.             if segments[i] == '..' and segments[i - 1] not in ('', '..'):
  244.                 del segments[i - 1:i + 1]
  245.                 break
  246.             
  247.             i = i + 1
  248.         break
  249.     if segments == [
  250.         '',
  251.         '..']:
  252.         segments[-1] = ''
  253.     elif len(segments) >= 2 and segments[-1] == '..':
  254.         segments[-2:] = [
  255.             '']
  256.     
  257.     return urlunparse((scheme, netloc, '/'.join(segments), params, query, fragment))
  258.  
  259.  
  260. def urldefrag(url):
  261.     if '#' in url:
  262.         (s, n, p, a, q, frag) = urlparse(url)
  263.         defrag = urlunparse((s, n, p, a, q, ''))
  264.         return (defrag, frag)
  265.     else:
  266.         return (url, '')
  267.  
  268. 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'
  269.  
  270. def test():
  271.     import sys
  272.     base = ''
  273.     if sys.argv[1:]:
  274.         fn = sys.argv[1]
  275.         if fn == '-':
  276.             fp = sys.stdin
  277.         else:
  278.             fp = open(fn)
  279.     else:
  280.         import StringIO
  281.         fp = StringIO.StringIO(test_input)
  282.     while 1:
  283.         line = fp.readline()
  284.         if not line:
  285.             break
  286.         
  287.         words = line.split()
  288.         if not words:
  289.             continue
  290.         
  291.         url = words[0]
  292.         parts = urlparse(url)
  293.         print '%-10s : %s' % (url, parts)
  294.         abs = urljoin(base, url)
  295.         if not base:
  296.             base = abs
  297.         
  298.         wrapped = '<URL:%s>' % abs
  299.         print '%-10s = %s' % (url, wrapped)
  300.         if len(words) == 3 and words[1] == '=':
  301.             if wrapped != words[2]:
  302.                 print 'EXPECTED', words[2], '!!!!!!!!!!'
  303.             
  304.         
  305.  
  306. if __name__ == '__main__':
  307.     test()
  308.  
  309.