home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1460 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  11.2 KB  |  336 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from BaseHTTPServer import BaseHTTPRequestHandler
  5. response_codes = BaseHTTPRequestHandler.responses.copy()
  6. response_codes[500] = ('Internal Server Error', 'The server encountered an unexpected condition which prevented it from fulfilling the request.')
  7. response_codes[503] = ('Service Unavailable', 'The server is currently unable to handle the request due to a temporary overloading or maintenance of the server.')
  8. import cgi
  9. import re
  10. from rfc822 import formatdate as HTTPDate
  11.  
  12. def urljoin(*atoms):
  13.     url = [](_[1])
  14.     while '//' in url:
  15.         url = url.replace('//', '/')
  16.         continue
  17.         []
  18.     if not url:
  19.         pass
  20.     return '/'
  21.  
  22.  
  23. def protocol_from_http(protocol_str):
  24.     return (int(protocol_str[5]), int(protocol_str[7]))
  25.  
  26.  
  27. def get_ranges(headervalue, content_length):
  28.     if not headervalue:
  29.         return None
  30.     result = []
  31.     (bytesunit, byteranges) = headervalue.split('=', 1)
  32.     for brange in byteranges.split(','):
  33.         (start, stop) = [ x.strip() for x in brange.split('-', 1) ]
  34.         if start:
  35.             (start, stop) = map(int, (start, stop))
  36.             if start >= content_length:
  37.                 continue
  38.             
  39.             if stop < start:
  40.                 return None
  41.             result.append((start, stop + 1))
  42.             continue
  43.         stop < start
  44.         if not stop:
  45.             return None
  46.         result.append((content_length - int(stop), content_length))
  47.     
  48.     return result
  49.  
  50.  
  51. class HeaderElement(object):
  52.     
  53.     def __init__(self, value, params = None):
  54.         self.value = value
  55.         if params is None:
  56.             params = { }
  57.         
  58.         self.params = params
  59.  
  60.     
  61.     def __unicode__(self):
  62.         p = [ ';%s=%s' % (k, v) for k, v in self.params.iteritems() ]
  63.         return u'%s%s' % (self.value, ''.join(p))
  64.  
  65.     
  66.     def __str__(self):
  67.         return str(self.__unicode__())
  68.  
  69.     
  70.     def parse(elementstr):
  71.         atoms = _[1]
  72.         initial_value = atoms.pop(0).strip()
  73.         params = { }
  74.         for atom in atoms:
  75.             atom = _[2]
  76.             key = atom.pop(0)
  77.             params[key] = val
  78.         
  79.         return (initial_value, params)
  80.  
  81.     parse = staticmethod(parse)
  82.     
  83.     def from_str(cls, elementstr):
  84.         (ival, params) = cls.parse(elementstr)
  85.         return cls(ival, params)
  86.  
  87.     from_str = classmethod(from_str)
  88.  
  89. q_separator = re.compile('; *q *=')
  90.  
  91. class AcceptElement(HeaderElement):
  92.     
  93.     def from_str(cls, elementstr):
  94.         qvalue = None
  95.         atoms = q_separator.split(elementstr, 1)
  96.         media_range = atoms.pop(0).strip()
  97.         if atoms:
  98.             qvalue = HeaderElement.from_str(atoms[0].strip())
  99.         
  100.         (media_type, params) = cls.parse(media_range)
  101.         if qvalue is not None:
  102.             params['q'] = qvalue
  103.         
  104.         return cls(media_type, params)
  105.  
  106.     from_str = classmethod(from_str)
  107.     
  108.     def qvalue(self):
  109.         val = self.params.get('q', '1')
  110.         if isinstance(val, HeaderElement):
  111.             val = val.value
  112.         
  113.         return float(val)
  114.  
  115.     qvalue = property(qvalue, doc = 'The qvalue, or priority, of this value.')
  116.     
  117.     def __cmp__(self, other):
  118.         diff = cmp(other.qvalue, self.qvalue)
  119.         if diff == 0:
  120.             diff = cmp(str(other), str(self))
  121.         
  122.         return diff
  123.  
  124.  
  125.  
  126. def header_elements(fieldname, fieldvalue):
  127.     if not fieldvalue:
  128.         return None
  129.     headername = fieldname.lower()
  130.     result = []
  131.     for element in fieldvalue.split(','):
  132.         if headername.startswith('accept') or headername == 'te':
  133.             hv = AcceptElement.from_str(element)
  134.         else:
  135.             hv = HeaderElement.from_str(element)
  136.         result.append(hv)
  137.     
  138.     result.sort()
  139.     return result
  140.  
  141.  
  142. def decode_TEXT(value):
  143.     decode_header = decode_header
  144.     import email.Header
  145.     atoms = decode_header(value)
  146.     decodedvalue = ''
  147.     for atom, charset in atoms:
  148.         if charset is not None:
  149.             atom = atom.decode(charset)
  150.         
  151.         decodedvalue += atom
  152.     
  153.     return decodedvalue
  154.  
  155.  
  156. def valid_status(status):
  157.     if not status:
  158.         status = 200
  159.     
  160.     status = str(status)
  161.     parts = status.split(' ', 1)
  162.     if len(parts) == 1:
  163.         (code,) = parts
  164.         reason = None
  165.     else:
  166.         (code, reason) = parts
  167.         reason = reason.strip()
  168.     
  169.     try:
  170.         code = int(code)
  171.     except ValueError:
  172.         raise ValueError('Illegal response status from server (%s is non-numeric).' % repr(code))
  173.  
  174.     if code < 100 or code > 599:
  175.         raise ValueError('Illegal response status from server (%s is out of range).' % repr(code))
  176.     code > 599
  177.     if code not in response_codes:
  178.         (default_reason, message) = ('', '')
  179.     else:
  180.         (default_reason, message) = response_codes[code]
  181.     if reason is None:
  182.         reason = default_reason
  183.     
  184.     return (code, reason, message)
  185.  
  186. image_map_pattern = re.compile('[0-9]+,[0-9]+')
  187.  
  188. def parse_query_string(query_string, keep_blank_values = True):
  189.     if image_map_pattern.match(query_string):
  190.         pm = query_string.split(',')
  191.         pm = {
  192.             'x': int(pm[0]),
  193.             'y': int(pm[1]) }
  194.     else:
  195.         pm = cgi.parse_qs(query_string, keep_blank_values)
  196.         for key, val in pm.items():
  197.             if len(val) == 1:
  198.                 pm[key] = val[0]
  199.                 continue
  200.         
  201.     return pm
  202.  
  203.  
  204. def params_from_CGI_form(form):
  205.     params = { }
  206.     for key in form.keys():
  207.         value_list = form[key]
  208.         if isinstance(value_list, list):
  209.             params[key] = []
  210.             for item in value_list:
  211.                 if item.filename is not None:
  212.                     value = item
  213.                 else:
  214.                     value = item.value
  215.                 params[key].append(value)
  216.             
  217.         if value_list.filename is not None:
  218.             value = value_list
  219.         else:
  220.             value = value_list.value
  221.         params[key] = value
  222.     
  223.     return params
  224.  
  225.  
  226. class CaseInsensitiveDict(dict):
  227.     
  228.     def __getitem__(self, key):
  229.         return dict.__getitem__(self, str(key).title())
  230.  
  231.     
  232.     def __setitem__(self, key, value):
  233.         dict.__setitem__(self, str(key).title(), value)
  234.  
  235.     
  236.     def __delitem__(self, key):
  237.         dict.__delitem__(self, str(key).title())
  238.  
  239.     
  240.     def __contains__(self, key):
  241.         return dict.__contains__(self, str(key).title())
  242.  
  243.     
  244.     def get(self, key, default = None):
  245.         return dict.get(self, str(key).title(), default)
  246.  
  247.     
  248.     def has_key(self, key):
  249.         return dict.has_key(self, str(key).title())
  250.  
  251.     
  252.     def update(self, E):
  253.         for k in E.keys():
  254.             self[str(k).title()] = E[k]
  255.         
  256.  
  257.     
  258.     def fromkeys(cls, seq, value = None):
  259.         newdict = cls()
  260.         for k in seq:
  261.             newdict[str(k).title()] = value
  262.         
  263.         return newdict
  264.  
  265.     fromkeys = classmethod(fromkeys)
  266.     
  267.     def setdefault(self, key, x = None):
  268.         key = str(key).title()
  269.         
  270.         try:
  271.             return self[key]
  272.         except KeyError:
  273.             self[key] = x
  274.             return x
  275.  
  276.  
  277.     
  278.     def pop(self, key, default):
  279.         return dict.pop(self, str(key).title(), default)
  280.  
  281.  
  282.  
  283. class HeaderMap(CaseInsensitiveDict):
  284.     
  285.     def elements(self, key):
  286.         key = str(key).title()
  287.         h = self.get(key)
  288.         if h is None:
  289.             return []
  290.         return header_elements(key, h)
  291.  
  292.     
  293.     def output(self, protocol = (1, 1)):
  294.         header_list = []
  295.         for key, v in self.iteritems():
  296.             if isinstance(v, unicode):
  297.                 
  298.                 try:
  299.                     v = v.encode('iso-8859-1')
  300.                 except UnicodeEncodeError:
  301.                     if protocol >= (1, 1):
  302.                         Header = Header
  303.                         import email.Header
  304.                         v = Header(v, 'utf-8').encode()
  305.                     else:
  306.                         raise 
  307.                     protocol >= (1, 1)
  308.                 
  309.  
  310.             None<EXCEPTION MATCH>UnicodeEncodeError
  311.             v = str(v)
  312.             header_list.append((key, v))
  313.         
  314.         return header_list
  315.  
  316.  
  317.  
  318. class Host(object):
  319.     ip = '0.0.0.0'
  320.     port = 80
  321.     name = 'unknown.tld'
  322.     
  323.     def __init__(self, ip, port, name = None):
  324.         self.ip = ip
  325.         self.port = port
  326.         if name is None:
  327.             name = ip
  328.         
  329.         self.name = name
  330.  
  331.     
  332.     def __repr__(self):
  333.         return 'http.Host(%r, %r, %r)' % (self.ip, self.port, self.name)
  334.  
  335.  
  336.