1 # from the Python Standard Library
4 from allmydata.util.mathutil import log_ceil, log_floor
6 chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
8 BASE62CHAR = '[' + chars + ']'
10 vals = ''.join([chr(i) for i in range(62)])
11 c2vtranstable = string.maketrans(chars, vals)
12 v2ctranstable = string.maketrans(vals, chars)
13 identitytranstable = string.maketrans(chars, chars)
17 @param os the data to be encoded (a string)
19 @return the contents of os in base-62 encoded form
21 cs = b2a_l(os, len(os)*8)
22 assert num_octets_that_encode_to_this_many_chars(len(cs)) == len(os), "%s != %s, numchars: %s" % (num_octets_that_encode_to_this_many_chars(len(cs)), len(os), len(cs))
25 def b2a_l(os, lengthinbits):
27 @param os the data to be encoded (a string)
28 @param lengthinbits the number of bits of data in os to be encoded
30 b2a_l() will generate a base-62 encoded string big enough to encode
31 lengthinbits bits. So for example if os is 3 bytes long and lengthinbits is
32 17, then b2a_l() will generate a 3-character- long base-62 encoded string
33 (since 3 chars is sufficient to encode more than 2^17 values). If os is 3
34 bytes long and lengthinbits is 18 (or None), then b2a_l() will generate a
35 4-character string (since 4 chars are required to hold 2^18 values). Note
36 that if os is 3 bytes long and lengthinbits is 17, the least significant 7
37 bits of os are ignored.
39 Warning: if you generate a base-62 encoded string with b2a_l(), and then someone else tries to
40 decode it by calling a2b() instead of a2b_l(), then they will (potentially) get a different
41 string than the one you encoded! So use b2a_l() only when you are sure that the encoding and
42 decoding sides know exactly which lengthinbits to use. If you do not have a way for the
43 encoder and the decoder to agree upon the lengthinbits, then it is best to use b2a() and
44 a2b(). The only drawback to using b2a() over b2a_l() is that when you have a number of
45 bits to encode that is not a multiple of 8, b2a() can sometimes generate a base-62 encoded
46 string that is one or two characters longer than necessary.
48 @return the contents of os in base-62 encoded form
50 os = [ord(o) for o in reversed(os)] # treat os as big-endian -- and we want to process the least-significant o first
53 numvalues = 1 # the number of possible values that value could be
61 chars.append(value % 62)
65 return string.translate(''.join([chr(c) for c in reversed(chars)]), v2ctranstable) # make it big-endian
67 def num_octets_that_encode_to_this_many_chars(numcs):
68 return log_floor(62**numcs, 256)
70 def num_chars_that_this_many_octets_encode_to(numos):
71 return log_ceil(256**numos, 62)
75 @param cs the base-62 encoded data (a string)
77 return a2b_l(cs, num_octets_that_encode_to_this_many_chars(len(cs))*8)
79 def a2b_l(cs, lengthinbits):
81 @param lengthinbits the number of bits of data in encoded into cs
83 a2b_l() will return a result just big enough to hold lengthinbits bits. So
84 for example if cs is 2 characters long (encoding between 5 and 12 bits worth
85 of data) and lengthinbits is 8, then a2b_l() will return a string of length
86 1 (since 1 byte is sufficient to store 8 bits), but if lengthinbits is 9,
87 then a2b_l() will return a string of length 2.
89 Please see the warning in the docstring of b2a_l() regarding the use of
92 @return the data encoded in cs
94 cs = [ord(c) for c in reversed(string.translate(cs, c2vtranstable))] # treat cs as big-endian -- and we want to process the least-significant c first
97 numvalues = 1 # the number of possible values that value could be
103 numvalues = 2**lengthinbits
106 bytes.append(value % 256)
110 return ''.join([chr(b) for b in reversed(bytes)]) # make it big-endian