/usr/share/pyshared/allmydata/util/base62.py is in tahoe-lafs 1.9.2-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | # from the Python Standard Library
import string
from allmydata.util.mathutil import log_ceil, log_floor
chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
BASE62CHAR = '[' + chars + ']'
vals = ''.join([chr(i) for i in range(62)])
c2vtranstable = string.maketrans(chars, vals)
v2ctranstable = string.maketrans(vals, chars)
identitytranstable = string.maketrans(chars, chars)
def b2a(os):
"""
@param os the data to be encoded (a string)
@return the contents of os in base-62 encoded form
"""
cs = b2a_l(os, len(os)*8)
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))
return cs
def b2a_l(os, lengthinbits):
"""
@param os the data to be encoded (a string)
@param lengthinbits the number of bits of data in os to be encoded
b2a_l() will generate a base-62 encoded string big enough to encode
lengthinbits bits. So for example if os is 3 bytes long and lengthinbits is
17, then b2a_l() will generate a 3-character- long base-62 encoded string
(since 3 chars is sufficient to encode more than 2^17 values). If os is 3
bytes long and lengthinbits is 18 (or None), then b2a_l() will generate a
4-character string (since 4 chars are required to hold 2^18 values). Note
that if os is 3 bytes long and lengthinbits is 17, the least significant 7
bits of os are ignored.
Warning: if you generate a base-62 encoded string with b2a_l(), and then someone else tries to
decode it by calling a2b() instead of a2b_l(), then they will (potentially) get a different
string than the one you encoded! So use b2a_l() only when you are sure that the encoding and
decoding sides know exactly which lengthinbits to use. If you do not have a way for the
encoder and the decoder to agree upon the lengthinbits, then it is best to use b2a() and
a2b(). The only drawback to using b2a() over b2a_l() is that when you have a number of
bits to encode that is not a multiple of 8, b2a() can sometimes generate a base-62 encoded
string that is one or two characters longer than necessary.
@return the contents of os in base-62 encoded form
"""
os = [ord(o) for o in reversed(os)] # treat os as big-endian -- and we want to process the least-significant o first
value = 0
numvalues = 1 # the number of possible values that value could be
for o in os:
o *= numvalues
value += o
numvalues *= 256
chars = []
while numvalues > 0:
chars.append(value % 62)
value //= 62
numvalues //= 62
return string.translate(''.join([chr(c) for c in reversed(chars)]), v2ctranstable) # make it big-endian
def num_octets_that_encode_to_this_many_chars(numcs):
return log_floor(62**numcs, 256)
def num_chars_that_this_many_octets_encode_to(numos):
return log_ceil(256**numos, 62)
def a2b(cs):
"""
@param cs the base-62 encoded data (a string)
"""
return a2b_l(cs, num_octets_that_encode_to_this_many_chars(len(cs))*8)
def a2b_l(cs, lengthinbits):
"""
@param lengthinbits the number of bits of data in encoded into cs
a2b_l() will return a result just big enough to hold lengthinbits bits. So
for example if cs is 2 characters long (encoding between 5 and 12 bits worth
of data) and lengthinbits is 8, then a2b_l() will return a string of length
1 (since 1 byte is sufficient to store 8 bits), but if lengthinbits is 9,
then a2b_l() will return a string of length 2.
Please see the warning in the docstring of b2a_l() regarding the use of
b2a() versus b2a_l().
@return the data encoded in cs
"""
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
value = 0
numvalues = 1 # the number of possible values that value could be
for c in cs:
c *= numvalues
value += c
numvalues *= 62
numvalues = 2**lengthinbits
bytes = []
while numvalues > 1:
bytes.append(value % 256)
value //= 256
numvalues //= 256
return ''.join([chr(b) for b in reversed(bytes)]) # make it big-endian
|