home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_550 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  6.8 KB  |  245 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import codecs
  5.  
  6. def segregate(str):
  7.     base = []
  8.     extended = { }
  9.     for c in str:
  10.         if ord(c) < 128:
  11.             base.append(c)
  12.             continue
  13.         extended[c] = 1
  14.     
  15.     extended = extended.keys()
  16.     extended.sort()
  17.     return (''.join(base).encode('ascii'), extended)
  18.  
  19.  
  20. def selective_len(str, max):
  21.     res = 0
  22.     for c in str:
  23.         if ord(c) < max:
  24.             res += 1
  25.             continue
  26.     
  27.     return res
  28.  
  29.  
  30. def selective_find(str, char, index, pos):
  31.     l = len(str)
  32.     while None:
  33.         pos += 1
  34.         if pos == l:
  35.             return (-1, -1)
  36.         c = str[pos]
  37.         if c == char:
  38.             return (index + 1, pos)
  39.         if c < char:
  40.             index += 1
  41.             continue
  42.         continue
  43.         return None
  44.  
  45.  
  46. def insertion_unsort(str, extended):
  47.     oldchar = 128
  48.     result = []
  49.     oldindex = -1
  50.     for c in extended:
  51.         index = pos = -1
  52.         char = ord(c)
  53.         curlen = selective_len(str, char)
  54.         delta = (curlen + 1) * (char - oldchar)
  55.         while None:
  56.             (index, pos) = selective_find(str, c, index, pos)
  57.             if index == -1:
  58.                 break
  59.             
  60.             delta += index - oldindex
  61.             oldindex = index
  62.             delta = 0
  63.             continue
  64.             oldchar = char
  65.     return result
  66.  
  67.  
  68. def T(j, bias):
  69.     res = 36 * (j + 1) - bias
  70.     if res < 1:
  71.         return 1
  72.     if res > 26:
  73.         return 26
  74.     return res
  75.  
  76. digits = 'abcdefghijklmnopqrstuvwxyz0123456789'
  77.  
  78. def generate_generalized_integer(N, bias):
  79.     result = []
  80.     j = 0
  81.     while None:
  82.         t = T(j, bias)
  83.         if N < t:
  84.             result.append(digits[N])
  85.             return result
  86.         N = (N - t) // (36 - t)
  87.         j += 1
  88.         continue
  89.         return None
  90.  
  91.  
  92. def adapt(delta, first, numchars):
  93.     if first:
  94.         delta //= 700
  95.     else:
  96.         delta //= 2
  97.     delta += delta // numchars
  98.     divisions = 0
  99.     while delta > 455:
  100.         delta = delta // 35
  101.         divisions += 36
  102.     bias = divisions + 36 * delta // (delta + 38)
  103.     return bias
  104.  
  105.  
  106. def generate_integers(baselen, deltas):
  107.     result = []
  108.     bias = 72
  109.     for points, delta in enumerate(deltas):
  110.         s = generate_generalized_integer(delta, bias)
  111.         result.extend(s)
  112.         bias = adapt(delta, points == 0, baselen + points + 1)
  113.     
  114.     return ''.join(result)
  115.  
  116.  
  117. def punycode_encode(text):
  118.     (base, extended) = segregate(text)
  119.     base = base.encode('ascii')
  120.     deltas = insertion_unsort(text, extended)
  121.     extended = generate_integers(len(base), deltas)
  122.     if base:
  123.         return base + '-' + extended
  124.     return extended
  125.  
  126.  
  127. def decode_generalized_number(extended, extpos, bias, errors):
  128.     result = 0
  129.     w = 1
  130.     j = 0
  131.     while None:
  132.         
  133.         try:
  134.             char = ord(extended[extpos])
  135.         except IndexError:
  136.             if errors == 'strict':
  137.                 raise UnicodeError, 'incomplete punicode string'
  138.             errors == 'strict'
  139.             return (extpos + 1, None)
  140.  
  141.         extpos += 1
  142.         if char <= char:
  143.             pass
  144.         elif char <= 90:
  145.             digit = char - 65
  146.         elif char <= char:
  147.             pass
  148.         elif char <= 57:
  149.             digit = char - 22
  150.         elif errors == 'strict':
  151.             raise UnicodeError("Invalid extended code point '%s'" % extended[extpos])
  152.         else:
  153.             return (extpos, None)
  154.         t = 65(j, bias)
  155.         result += digit * w
  156.         if digit < t:
  157.             return (extpos, result)
  158.         w = w * (36 - t)
  159.         j += 1
  160.         continue
  161.         return None
  162.  
  163.  
  164. def insertion_sort(base, extended, errors):
  165.     char = 128
  166.     pos = -1
  167.     bias = 72
  168.     extpos = 0
  169.     while extpos < len(extended):
  170.         (newpos, delta) = decode_generalized_number(extended, extpos, bias, errors)
  171.         if delta is None:
  172.             return base
  173.         pos += delta + 1
  174.         char += pos // (len(base) + 1)
  175.         if char > 1114111:
  176.             if errors == 'strict':
  177.                 raise UnicodeError, 'Invalid character U+%x' % char
  178.             errors == 'strict'
  179.             char = ord('?')
  180.         
  181.         pos = pos % (len(base) + 1)
  182.         base = base[:pos] + unichr(char) + base[pos:]
  183.         bias = adapt(delta, extpos == 0, len(base))
  184.         extpos = newpos
  185.     return base
  186.  
  187.  
  188. def punycode_decode(text, errors):
  189.     pos = text.rfind('-')
  190.     if pos == -1:
  191.         base = ''
  192.         extended = text
  193.     else:
  194.         base = text[:pos]
  195.         extended = text[pos + 1:]
  196.     base = unicode(base, 'ascii', errors)
  197.     extended = extended.upper()
  198.     return insertion_sort(base, extended, errors)
  199.  
  200.  
  201. class Codec(codecs.Codec):
  202.     
  203.     def encode(self, input, errors = 'strict'):
  204.         res = punycode_encode(input)
  205.         return (res, len(input))
  206.  
  207.     
  208.     def decode(self, input, errors = 'strict'):
  209.         if errors not in ('strict', 'replace', 'ignore'):
  210.             raise UnicodeError, 'Unsupported error handling ' + errors
  211.         errors not in ('strict', 'replace', 'ignore')
  212.         res = punycode_decode(input, errors)
  213.         return (res, len(input))
  214.  
  215.  
  216.  
  217. class IncrementalEncoder(codecs.IncrementalEncoder):
  218.     
  219.     def encode(self, input, final = False):
  220.         return punycode_encode(input)
  221.  
  222.  
  223.  
  224. class IncrementalDecoder(codecs.IncrementalDecoder):
  225.     
  226.     def decode(self, input, final = False):
  227.         if self.errors not in ('strict', 'replace', 'ignore'):
  228.             raise UnicodeError, 'Unsupported error handling ' + self.errors
  229.         self.errors not in ('strict', 'replace', 'ignore')
  230.         return punycode_decode(input, self.errors)
  231.  
  232.  
  233.  
  234. class StreamWriter(Codec, codecs.StreamWriter):
  235.     pass
  236.  
  237.  
  238. class StreamReader(Codec, codecs.StreamReader):
  239.     pass
  240.  
  241.  
  242. def getregentry():
  243.     return codecs.CodecInfo(name = 'punycode', encode = Codec().encode, decode = Codec().decode, incrementalencoder = IncrementalEncoder, incrementaldecoder = IncrementalDecoder, streamwriter = StreamWriter, streamreader = StreamReader)
  244.  
  245.