PC Welt 2006 November (DVD)/PCWELT_11_2006.ISO/casper/filesystem.squashfs/usr/lib/python2.4/site-packages/BitTorrent/bencode.pyc

Python Compiled Bytecode | 2006-08-31 | 8.3 KB | 489 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.4)


def decode_int(x, f):
    f += 1
    newf = x.index('e', f)

    try:
        n = int(x[f:newf])
    except (OverflowError, ValueError):
        n = long(x[f:newf])

    if x[f] == '-':
        if x[f + 1] == '0':
            raise ValueError

    elif x[f] == '0' and newf != f + 1:
        raise ValueError

    return (n, newf + 1)


def decode_string(x, f):
    colon = x.index(':', f)

    try:
        n = int(x[f:colon])
    except (OverflowError, ValueError):
        n = long(x[f:colon])

    if x[f] == '0' and colon != f + 1:
        raise ValueError

    colon += 1
    return (x[colon:colon + n], colon + n)


def decode_list(x, f):
    r = []
    f = f + 1
    while x[f] != 'e':
        (v, f) = decode_func[x[f]](x, f)
        r.append(v)
    return (r, f + 1)


def decode_dict(x, f):
    r = { }
    f = f + 1
    lastkey = None
    while x[f] != 'e':
        (k, f) = decode_string(x, f)
        if lastkey >= k:
            raise ValueError

        lastkey = k
        (r[k], f) = decode_func[x[f]](x, f)
    return (r, f + 1)

decode_func = { }
decode_func['l'] = decode_list
decode_func['d'] = decode_dict
decode_func['i'] = decode_int
decode_func['0'] = decode_string
decode_func['1'] = decode_string
decode_func['2'] = decode_string
decode_func['3'] = decode_string
decode_func['4'] = decode_string
decode_func['5'] = decode_string
decode_func['6'] = decode_string
decode_func['7'] = decode_string
decode_func['8'] = decode_string
decode_func['9'] = decode_string

def bdecode(x):

    try:
        (r, l) = decode_func[x[0]](x, 0)
    except (IndexError, KeyError):
        raise ValueError

    if l != len(x):
        raise ValueError

    return r


def test_bdecode():

    try:
        bdecode('0:0:')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('ie')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('i341foo382e')
        if not 0:
            raise AssertionError
    except ValueError:
        pass

    if not bdecode('i4e') == 0x4L:
        raise AssertionError
    if not bdecode('i0e') == 0x0L:
        raise AssertionError
    if not bdecode('i123456789e') == 0x75BCD15L:
        raise AssertionError
    if not bdecode('i-10e') == -0xAL:
        raise AssertionError

    try:
        bdecode('i-0e')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('i123')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('i6easd')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('35208734823ljdahflajhdf')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('2:abfdjslhfld')
        if not 0:
            raise AssertionError
    except ValueError:
        pass

    if not bdecode('0:') == '':
        raise AssertionError
    if not bdecode('3:abc') == 'abc':
        raise AssertionError
    if not bdecode('10:1234567890') == '1234567890':
        raise AssertionError

    try:
        bdecode('02:xy')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('l')
        if not 0:
            raise AssertionError
    except ValueError:
        pass

    if not bdecode('le') == []:
        raise AssertionError

    try:
        bdecode('leanfdldjfh')
        if not 0:
            raise AssertionError
    except ValueError:
        pass

    if not bdecode('l0:0:0:e') == [
        '',
        '',
        '']:
        raise AssertionError

    try:
        bdecode('relwjhrlewjh')
        if not 0:
            raise AssertionError
    except ValueError:
        pass

    if not bdecode('li1ei2ei3ee') == [
        1,
        2,
        3]:
        raise AssertionError
    if not bdecode('l3:asd2:xye') == [
        'asd',
        'xy']:
        raise AssertionError
    if not bdecode('ll5:Alice3:Bobeli2ei3eee') == [
        [
            'Alice',
            'Bob'],
        [
            2,
            3]]:
        raise AssertionError

    try:
        bdecode('d')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('defoobar')
        if not 0:
            raise AssertionError
    except ValueError:
        pass

    if not bdecode('de') == { }:
        raise AssertionError
    if not bdecode('d3:agei25e4:eyes4:bluee') == {
        'age': 25,
        'eyes': 'blue' }:
        raise AssertionError
    if not bdecode('d8:spam.mp3d6:author5:Alice6:lengthi100000eee') == {
        'spam.mp3': {
            'author': 'Alice',
            'length': 100000 } }:
        raise AssertionError

    try:
        bdecode('d3:fooe')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('di1e0:e')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('d1:b0:1:a0:e')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('d1:a0:1:a0:e')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('i03e')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('l01:ae')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('9999:x')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('l0:')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('d0:0:')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('d0:')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('00:')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('l-3:e')
        if not 0:
            raise AssertionError
    except ValueError:
        pass


    try:
        bdecode('i-03e')
        if not 0:
            raise AssertionError
    except ValueError:
        pass

    bdecode('d0:i3ee')

from types import StringType, IntType, LongType, DictType, ListType, TupleType

class Bencached(object):
    __slots__ = [
        'bencoded']

    def __init__(self, s):
        self.bencoded = s



def encode_bencached(x, r):
    r.append(x.bencoded)


def encode_int(x, r):
    r.extend(('i', str(x), 'e'))


def encode_string(x, r):
    r.extend((str(len(x)), ':', x))


def encode_list(x, r):
    r.append('l')
    for i in x:
        encode_func[type(i)](i, r)

    r.append('e')


def encode_dict(x, r):
    r.append('d')
    ilist = x.items()
    ilist.sort()
    for k, v in ilist:
        r.extend((str(len(k)), ':', k))
        encode_func[type(v)](v, r)

    r.append('e')

encode_func = { }
encode_func[type(Bencached(0))] = encode_bencached
encode_func[IntType] = encode_int
encode_func[LongType] = encode_int
encode_func[StringType] = encode_string
encode_func[ListType] = encode_list
encode_func[TupleType] = encode_list
encode_func[DictType] = encode_dict

try:
    from types import BooleanType
    encode_func[BooleanType] = encode_int
except ImportError:
    pass


def bencode(x):
    r = []
    encode_func[type(x)](x, r)
    return ''.join(r)


def test_bencode():
    if not bencode(4) == 'i4e':
        raise AssertionError
    if not bencode(0) == 'i0e':
        raise AssertionError
    if not bencode(-10) == 'i-10e':
        raise AssertionError
    if not bencode(0xAB54A98CEB1F0AD2L) == 'i12345678901234567890e':
        raise AssertionError
    if not bencode('') == '0:':
        raise AssertionError
    if not bencode('abc') == '3:abc':
        raise AssertionError
    if not bencode('1234567890') == '10:1234567890':
        raise AssertionError
    if not bencode([]) == 'le':
        raise AssertionError
    if not bencode([
        1,
        2,
        3]) == 'li1ei2ei3ee':
        raise AssertionError
    if not bencode([
        [
            'Alice',
            'Bob'],
        [
            2,
            3]]) == 'll5:Alice3:Bobeli2ei3eee':
        raise AssertionError
    if not bencode({ }) == 'de':
        raise AssertionError
    if not bencode({
        'age': 25,
        'eyes': 'blue' }) == 'd3:agei25e4:eyes4:bluee':
        raise AssertionError
    if not bencode({
        'spam.mp3': {
            'author': 'Alice',
            'length': 100000 } }) == 'd8:spam.mp3d6:author5:Alice6:lengthi100000eee':
        raise AssertionError
    if not bencode(Bencached(bencode(3))) == 'i3e':
        raise AssertionError

    try:
        bencode({
            1: 'foo' })
    except TypeError:
        return None

    if not 0:
        raise AssertionError


try:
    import psyco
    psyco.bind(bdecode)
    psyco.bind(bencode)
except ImportError:
    pass