← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/util/bencode.py

  • Committer: Martin Pool
  • Date: 2007-02-20 05:41:12 UTC
  • mfrom: (2220.3.2 tags)
  • mto: This revision was merged to the branch mainline in revision 2309.
  • Revision ID: mbp@sourcefrog.net-20070220054112-5ch1jqmy9m5zbk72
merge bencode licence, branch todo

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/util/bencode.py
1
 
# Written by Petru Paler
2
 
# see LICENSE.txt for license information
3
 
 
4
 
def decode_int(x, f):
5
 
    f += 1
6
 
    newf = x.index('e', f)
7
 
    try:
8
 
        n = int(x[f:newf])
9
 
    except (OverflowError, ValueError):
10
 
        n = long(x[f:newf])
11
 
    if x[f] == '-':
12
 
        if x[f + 1] == '0':
13
 
            raise ValueError
14
 
    elif x[f] == '0' and newf != f+1:
15
 
        raise ValueError
16
 
    return (n, newf+1)
17
 
 
18
 
def decode_string(x, f):
19
 
    colon = x.index(':', f)
20
 
    try:
21
 
        n = int(x[f:colon])
22
 
    except (OverflowError, ValueError):
23
 
        n = long(x[f:colon])
24
 
    if x[f] == '0' and colon != f+1:
25
 
        raise ValueError
26
 
    colon += 1
27
 
    return (x[colon:colon+n], colon+n)
28
 
 
29
 
def decode_list(x, f):
30
 
    r, f = [], f+1
31
 
    while x[f] != 'e':
32
 
        v, f = decode_func[x[f]](x, f)
33
 
        r.append(v)
34
 
    return (r, f + 1)
35
 
 
36
 
def decode_dict(x, f):
37
 
    r, f = {}, f+1
38
 
    lastkey = None
39
 
    while x[f] != 'e':
40
 
        k, f = decode_string(x, f)
41
 
        if lastkey >= k:
42
 
            raise ValueError
43
 
        lastkey = k
44
 
        r[k], f = decode_func[x[f]](x, f)
45
 
    return (r, f + 1)
46
 
 
47
 
decode_func = {}
48
 
decode_func['l'] = decode_list
49
 
decode_func['d'] = decode_dict
50
 
decode_func['i'] = decode_int
51
 
decode_func['0'] = decode_string
52
 
decode_func['1'] = decode_string
53
 
decode_func['2'] = decode_string
54
 
decode_func['3'] = decode_string
55
 
decode_func['4'] = decode_string
56
 
decode_func['5'] = decode_string
57
 
decode_func['6'] = decode_string
58
 
decode_func['7'] = decode_string
59
 
decode_func['8'] = decode_string
60
 
decode_func['9'] = decode_string
61
 
 
62
 
def bdecode(x):
63
 
    try:
64
 
        r, l = decode_func[x[0]](x, 0)
65
 
    except (IndexError, KeyError):
66
 
        raise ValueError
67
 
    if l != len(x):
68
 
        raise ValueError
69
 
    return r
70
 
 
71
 
def test_bdecode():
72
 
    try:
73
 
        bdecode('0:0:')
74
 
        assert 0
75
 
    except ValueError:
76
 
        pass
77
 
    try:
78
 
        bdecode('ie')
79
 
        assert 0
80
 
    except ValueError:
81
 
        pass
82
 
    try:
83
 
        bdecode('i341foo382e')
84
 
        assert 0
85
 
    except ValueError:
86
 
        pass
87
 
    assert bdecode('i4e') == 4L
88
 
    assert bdecode('i0e') == 0L
89
 
    assert bdecode('i123456789e') == 123456789L
90
 
    assert bdecode('i-10e') == -10L
91
 
    try:
92
 
        bdecode('i-0e')
93
 
        assert 0
94
 
    except ValueError:
95
 
        pass
96
 
    try:
97
 
        bdecode('i123')
98
 
        assert 0
99
 
    except ValueError:
100
 
        pass
101
 
    try:
102
 
        bdecode('')
103
 
        assert 0
104
 
    except ValueError:
105
 
        pass
106
 
    try:
107
 
        bdecode('i6easd')
108
 
        assert 0
109
 
    except ValueError:
110
 
        pass
111
 
    try:
112
 
        bdecode('35208734823ljdahflajhdf')
113
 
        assert 0
114
 
    except ValueError:
115
 
        pass
116
 
    try:
117
 
        bdecode('2:abfdjslhfld')
118
 
        assert 0
119
 
    except ValueError:
120
 
        pass
121
 
    assert bdecode('0:') == ''
122
 
    assert bdecode('3:abc') == 'abc'
123
 
    assert bdecode('10:1234567890') == '1234567890'
124
 
    try:
125
 
        bdecode('02:xy')
126
 
        assert 0
127
 
    except ValueError:
128
 
        pass
129
 
    try:
130
 
        bdecode('l')
131
 
        assert 0
132
 
    except ValueError:
133
 
        pass
134
 
    assert bdecode('le') == []
135
 
    try:
136
 
        bdecode('leanfdldjfh')
137
 
        assert 0
138
 
    except ValueError:
139
 
        pass
140
 
    assert bdecode('l0:0:0:e') == ['', '', '']
141
 
    try:
142
 
        bdecode('relwjhrlewjh')
143
 
        assert 0
144
 
    except ValueError:
145
 
        pass
146
 
    assert bdecode('li1ei2ei3ee') == [1, 2, 3]
147
 
    assert bdecode('l3:asd2:xye') == ['asd', 'xy']
148
 
    assert bdecode('ll5:Alice3:Bobeli2ei3eee') == [['Alice', 'Bob'], [2, 3]]
149
 
    try:
150
 
        bdecode('d')
151
 
        assert 0
152
 
    except ValueError:
153
 
        pass
154
 
    try:
155
 
        bdecode('defoobar')
156
 
        assert 0
157
 
    except ValueError:
158
 
        pass
159
 
    assert bdecode('de') == {}
160
 
    assert bdecode('d3:agei25e4:eyes4:bluee') == {'age': 25, 'eyes': 'blue'}
161
 
    assert bdecode('d8:spam.mp3d6:author5:Alice6:lengthi100000eee') == {'spam.mp3': {'author': 'Alice', 'length': 100000}}
162
 
    try:
163
 
        bdecode('d3:fooe')
164
 
        assert 0
165
 
    except ValueError:
166
 
        pass
167
 
    try:
168
 
        bdecode('di1e0:e')
169
 
        assert 0
170
 
    except ValueError:
171
 
        pass
172
 
    try:
173
 
        bdecode('d1:b0:1:a0:e')
174
 
        assert 0
175
 
    except ValueError:
176
 
        pass
177
 
    try:
178
 
        bdecode('d1:a0:1:a0:e')
179
 
        assert 0
180
 
    except ValueError:
181
 
        pass
182
 
    try:
183
 
        bdecode('i03e')
184
 
        assert 0
185
 
    except ValueError:
186
 
        pass
187
 
    try:
188
 
        bdecode('l01:ae')
189
 
        assert 0
190
 
    except ValueError:
191
 
        pass
192
 
    try:
193
 
        bdecode('9999:x')
194
 
        assert 0
195
 
    except ValueError:
196
 
        pass
197
 
    try:
198
 
        bdecode('l0:')
199
 
        assert 0
200
 
    except ValueError:
201
 
        pass
202
 
    try:
203
 
        bdecode('d0:0:')
204
 
        assert 0
205
 
    except ValueError:
206
 
        pass
207
 
    try:
208
 
        bdecode('d0:')
209
 
        assert 0
210
 
    except ValueError:
211
 
        pass
212
 
    try:
213
 
        bdecode('00:')
214
 
        assert 0
215
 
    except ValueError:
216
 
        pass
217
 
    try:
218
 
        bdecode('l-3:e')
219
 
        assert 0
220
 
    except ValueError:
221
 
        pass
222
 
    try:
223
 
        bdecode('i-03e')
224
 
        assert 0
225
 
    except ValueError:
226
 
        pass
227
 
    bdecode('d0:i3ee')
228
 
 
229
 
from types import StringType, IntType, LongType, DictType, ListType, TupleType
230
 
 
231
 
class Bencached(object):
232
 
    __slots__ = ['bencoded']
233
 
 
234
 
    def __init__(self, s):
235
 
        self.bencoded = s
236
 
 
237
 
def encode_bencached(x,r):
238
 
    r.append(x.bencoded)
239
 
 
240
 
def encode_int(x, r):
241
 
    r.extend(('i', str(x), 'e'))
242
 
 
243
 
def encode_string(x, r):
244
 
    r.extend((str(len(x)), ':', x))
245
 
 
246
 
def encode_list(x, r):
247
 
    r.append('l')
248
 
    for i in x:
249
 
        encode_func[type(i)](i, r)
250
 
    r.append('e')
251
 
 
252
 
def encode_dict(x,r):
253
 
    r.append('d')
254
 
    ilist = x.items()
255
 
    ilist.sort()
256
 
    for k, v in ilist:
257
 
        r.extend((str(len(k)), ':', k))
258
 
        encode_func[type(v)](v, r)
259
 
    r.append('e')
260
 
 
261
 
encode_func = {}
262
 
encode_func[type(Bencached(0))] = encode_bencached
263
 
encode_func[IntType] = encode_int
264
 
encode_func[LongType] = encode_int
265
 
encode_func[StringType] = encode_string
266
 
encode_func[ListType] = encode_list
267
 
encode_func[TupleType] = encode_list
268
 
encode_func[DictType] = encode_dict
269
 
 
270
 
try:
271
 
    from types import BooleanType
272
 
    encode_func[BooleanType] = encode_int
273
 
except ImportError:
274
 
    pass
275
 
 
276
 
def bencode(x):
277
 
    r = []
278
 
    encode_func[type(x)](x, r)
279
 
    return ''.join(r)
280
 
 
281
 
def test_bencode():
282
 
    assert bencode(4) == 'i4e'
283
 
    assert bencode(0) == 'i0e'
284
 
    assert bencode(-10) == 'i-10e'
285
 
    assert bencode(12345678901234567890L) == 'i12345678901234567890e'
286
 
    assert bencode('') == '0:'
287
 
    assert bencode('abc') == '3:abc'
288
 
    assert bencode('1234567890') == '10:1234567890'
289
 
    assert bencode([]) == 'le'
290
 
    assert bencode([1, 2, 3]) == 'li1ei2ei3ee'
291
 
    assert bencode([['Alice', 'Bob'], [2, 3]]) == 'll5:Alice3:Bobeli2ei3eee'
292
 
    assert bencode({}) == 'de'
293
 
    assert bencode({'age': 25, 'eyes': 'blue'}) == 'd3:agei25e4:eyes4:bluee'
294
 
    assert bencode({'spam.mp3': {'author': 'Alice', 'length': 100000}}) == 'd8:spam.mp3d6:author5:Alice6:lengthi100000eee'
295
 
    assert bencode(Bencached(bencode(3))) == 'i3e'
296
 
    try:
297
 
        bencode({1: 'foo'})
298
 
    except TypeError:
299
 
        return
300
 
    assert 0
301
 
 
302
 
try:
303
 
    import psyco
304
 
    psyco.bind(bdecode)
305
 
    psyco.bind(bencode)
306
 
except ImportError:
307
 
    pass