home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / GestionFichiers / metamorphose / metamorphose2_0.8.2_setup.exe / metamorphose2.exe / base64.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2011-01-12  |  7KB  |  292 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import re
  5. import struct
  6. import binascii
  7. __all__ = [
  8.     'encode',
  9.     'decode',
  10.     'encodestring',
  11.     'decodestring',
  12.     'b64encode',
  13.     'b64decode',
  14.     'b32encode',
  15.     'b32decode',
  16.     'b16encode',
  17.     'b16decode',
  18.     'standard_b64encode',
  19.     'standard_b64decode',
  20.     'urlsafe_b64encode',
  21.     'urlsafe_b64decode']
  22. _translation = [ chr(_x) for _x in range(256) ]
  23. EMPTYSTRING = ''
  24.  
  25. def _translate(s, altchars):
  26.     translation = _translation[:]
  27.     for k, v in altchars.items():
  28.         translation[ord(k)] = v
  29.     
  30.     return s.translate(''.join(translation))
  31.  
  32.  
  33. def b64encode(s, altchars = None):
  34.     encoded = binascii.b2a_base64(s)[:-1]
  35.     if altchars is not None:
  36.         return _translate(encoded, {
  37.             '+': altchars[0],
  38.             '/': altchars[1] })
  39.     return encoded
  40.  
  41.  
  42. def b64decode(s, altchars = None):
  43.     if altchars is not None:
  44.         s = _translate(s, {
  45.             altchars[0]: '+',
  46.             altchars[1]: '/' })
  47.     
  48.     
  49.     try:
  50.         return binascii.a2b_base64(s)
  51.     except binascii.Error:
  52.         msg = None
  53.         raise TypeError(msg)
  54.  
  55.  
  56.  
  57. def standard_b64encode(s):
  58.     return b64encode(s)
  59.  
  60.  
  61. def standard_b64decode(s):
  62.     return b64decode(s)
  63.  
  64.  
  65. def urlsafe_b64encode(s):
  66.     return b64encode(s, '-_')
  67.  
  68.  
  69. def urlsafe_b64decode(s):
  70.     return b64decode(s, '-_')
  71.  
  72. _b32alphabet = {
  73.     0: 'A',
  74.     9: 'J',
  75.     18: 'S',
  76.     27: '3',
  77.     1: 'B',
  78.     10: 'K',
  79.     19: 'T',
  80.     28: '4',
  81.     2: 'C',
  82.     11: 'L',
  83.     20: 'U',
  84.     29: '5',
  85.     3: 'D',
  86.     12: 'M',
  87.     21: 'V',
  88.     30: '6',
  89.     4: 'E',
  90.     13: 'N',
  91.     22: 'W',
  92.     31: '7',
  93.     5: 'F',
  94.     14: 'O',
  95.     23: 'X',
  96.     6: 'G',
  97.     15: 'P',
  98.     24: 'Y',
  99.     7: 'H',
  100.     16: 'Q',
  101.     25: 'Z',
  102.     8: 'I',
  103.     17: 'R',
  104.     26: '2' }
  105. _b32tab = _b32alphabet.items()
  106. _b32tab.sort()
  107. _b32tab = [ v for k, v in _b32tab ]
  108. _b32rev = []([ (v, long(k)) for k, v in _b32alphabet.items() ])
  109.  
  110. def b32encode(s):
  111.     parts = []
  112.     (quanta, leftover) = divmod(len(s), 5)
  113.     if leftover:
  114.         s += '\x00' * (5 - leftover)
  115.         quanta += 1
  116.     
  117.     for i in range(quanta):
  118.         (c1, c2, c3) = struct.unpack('!HHB', s[i * 5:(i + 1) * 5])
  119.         c2 += (c1 & 1) << 16
  120.         c3 += (c2 & 3) << 8
  121.         parts.extend([
  122.             _b32tab[c1 >> 11],
  123.             _b32tab[c1 >> 6 & 31],
  124.             _b32tab[c1 >> 1 & 31],
  125.             _b32tab[c2 >> 12],
  126.             _b32tab[c2 >> 7 & 31],
  127.             _b32tab[c2 >> 2 & 31],
  128.             _b32tab[c3 >> 5],
  129.             _b32tab[c3 & 31]])
  130.     
  131.     encoded = EMPTYSTRING.join(parts)
  132.     if leftover == 1:
  133.         return encoded[:-6] + '======'
  134.     if leftover == 2:
  135.         return encoded[:-4] + '===='
  136.     if leftover == 3:
  137.         return encoded[:-3] + '==='
  138.     if leftover == 4:
  139.         return encoded[:-1] + '='
  140.     return encoded
  141.  
  142.  
  143. def b32decode(s, casefold = False, map01 = None):
  144.     (quanta, leftover) = divmod(len(s), 8)
  145.     if leftover:
  146.         raise TypeError('Incorrect padding')
  147.     leftover
  148.     if map01:
  149.         s = _translate(s, {
  150.             '0': 'O',
  151.             '1': map01 })
  152.     
  153.     if casefold:
  154.         s = s.upper()
  155.     
  156.     padchars = 0
  157.     mo = re.search('(?P<pad>[=]*)$', s)
  158.     if mo:
  159.         padchars = len(mo.group('pad'))
  160.         if padchars > 0:
  161.             s = s[:-padchars]
  162.         
  163.     
  164.     parts = []
  165.     acc = 0
  166.     shift = 35
  167.     for c in s:
  168.         val = _b32rev.get(c)
  169.         if val is None:
  170.             raise TypeError('Non-base32 digit found')
  171.         val is None
  172.         acc += _b32rev[c] << shift
  173.         shift -= 5
  174.         if shift < 0:
  175.             parts.append(binascii.unhexlify('%010x' % acc))
  176.             acc = 0
  177.             shift = 35
  178.             continue
  179.     
  180.     last = binascii.unhexlify('%010x' % acc)
  181.     if padchars == 0:
  182.         last = ''
  183.     elif padchars == 1:
  184.         last = last[:-1]
  185.     elif padchars == 3:
  186.         last = last[:-2]
  187.     elif padchars == 4:
  188.         last = last[:-3]
  189.     elif padchars == 6:
  190.         last = last[:-4]
  191.     else:
  192.         raise TypeError('Incorrect padding')
  193.     (padchars == 0).append(last)
  194.     return EMPTYSTRING.join(parts)
  195.  
  196.  
  197. def b16encode(s):
  198.     return binascii.hexlify(s).upper()
  199.  
  200.  
  201. def b16decode(s, casefold = False):
  202.     if casefold:
  203.         s = s.upper()
  204.     
  205.     if re.search('[^0-9A-F]', s):
  206.         raise TypeError('Non-base16 digit found')
  207.     re.search('[^0-9A-F]', s)
  208.     return binascii.unhexlify(s)
  209.  
  210. MAXLINESIZE = 76
  211. MAXBINSIZE = (MAXLINESIZE // 4) * 3
  212.  
  213. def encode(input, output):
  214.     while True:
  215.         s = input.read(MAXBINSIZE)
  216.         if not s:
  217.             break
  218.         
  219.         while len(s) < MAXBINSIZE:
  220.             ns = input.read(MAXBINSIZE - len(s))
  221.             if not ns:
  222.                 break
  223.             
  224.             s += ns
  225.         line = binascii.b2a_base64(s)
  226.         output.write(line)
  227.  
  228.  
  229. def decode(input, output):
  230.     while True:
  231.         line = input.readline()
  232.         if not line:
  233.             break
  234.         
  235.         s = binascii.a2b_base64(line)
  236.         output.write(s)
  237.  
  238.  
  239. def encodestring(s):
  240.     pieces = []
  241.     for i in range(0, len(s), MAXBINSIZE):
  242.         chunk = s[i:i + MAXBINSIZE]
  243.         pieces.append(binascii.b2a_base64(chunk))
  244.     
  245.     return ''.join(pieces)
  246.  
  247.  
  248. def decodestring(s):
  249.     return binascii.a2b_base64(s)
  250.  
  251.  
  252. def test():
  253.     import sys as sys
  254.     import getopt as getopt
  255.     
  256.     try:
  257.         (opts, args) = getopt.getopt(sys.argv[1:], 'deut')
  258.     except getopt.error:
  259.         msg = None
  260.         sys.stdout = sys.stderr
  261.         print msg
  262.         print "usage: %s [-d|-e|-u|-t] [file|-]\n        -d, -u: decode\n        -e: encode (default)\n        -t: encode and decode string 'Aladdin:open sesame'" % sys.argv[0]
  263.         sys.exit(2)
  264.  
  265.     func = encode
  266.     for o, a in opts:
  267.         if o == '-e':
  268.             func = encode
  269.         
  270.         if o == '-d':
  271.             func = decode
  272.         
  273.         if o == '-u':
  274.             func = decode
  275.         
  276.         if o == '-t':
  277.             test1()
  278.             return None
  279.     
  280.     if args and args[0] != '-':
  281.         func(open(args[0], 'rb'), sys.stdout)
  282.     else:
  283.         func(sys.stdin, sys.stdout)
  284.  
  285.  
  286. def test1():
  287.     s0 = 'Aladdin:open sesame'
  288.     s1 = encodestring(s0)
  289.     s2 = decodestring(s1)
  290.     print s0, repr(s1), s2
  291.  
  292.