0x2620/openmedialibrary_platform
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

run update

Browse source
This commit is contained in:
j 2018-12-15 01:08:54 +01:00
commit 6806bebb7c
607 changed files with 52543 additions and 31832 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Shared/lib/python3.4/site-packages/ox/torrent/__init__.py
View file

@ -14,8 +14,8 @@ else:
__all__ = ['create_torrent', 'get_info_hash', 'get_torrent_info', 'get_files', 'get_torrent_size']
def create_torrent(file, url, params = {}, flag = Event(),
progress = lambda x: None, progress_percent = 1):
def create_torrent(file, url, params={}, flag=Event(),
progress=lambda x: None, progress_percent=1):
"Creates a torrent for a given file, using url as tracker url"
from .makemetafile import make_meta_file
return make_meta_file(file, url, params, flag, progress, progress_percent)

21
Shared/lib/python3.4/site-packages/ox/torrent/bencode.py
View file

@ -1,5 +1,6 @@
# Written by Petru Paler, Uoti Urpala, Ross Cohen and John Hoffman
# see LICENSE.txt for license information
from __future__ import print_function
from types import IntType, LongType, StringType, ListType, TupleType, DictType
try:
@ -53,8 +54,8 @@ def decode_dict(x, f):
lastkey = None
while x[f] != 'e':
k, f = decode_string(x, f)
#why is this needed
#if lastkey >= k:
# why is this needed
# if lastkey >= k:
# raise ValueError
lastkey = k
r[k], f = decode_func[x[f]](x, f)
@ -81,9 +82,9 @@ def bdecode(x, sloppy = 1):
r, l = decode_func[x[0]](x, 0)
# except (IndexError, KeyError):
except (IndexError, KeyError, ValueError):
raise ValueError, "bad bencoded data"
raise ValueError("bad bencoded data")
if not sloppy and l != len(x):
raise ValueError, "bad bencoded data"
raise ValueError("bad bencoded data")
return r
def test_bdecode():
@ -102,10 +103,10 @@ def test_bdecode():
assert 0
except ValueError:
pass
assert bdecode('i4e') == 4L
assert bdecode('i0e') == 0L
assert bdecode('i123456789e') == 123456789L
assert bdecode('i-10e') == -10L
assert bdecode('i4e') == 4
assert bdecode('i0e') == 0
assert bdecode('i123456789e') == 123456789
assert bdecode('i-10e') == -10
try:
bdecode('i-0e')
assert 0
@ -287,7 +288,7 @@ def bencode(x):
try:
encode_func[type(x)](x, r)
except:
print "*** error *** could not encode type %s (value: %s)" % (type(x), x)
print("*** error *** could not encode type %s (value: %s)" % (type(x), x))
assert 0
return ''.join(r)
@ -295,7 +296,7 @@ def test_bencode():
assert bencode(4) == 'i4e'
assert bencode(0) == 'i0e'
assert bencode(-10) == 'i-10e'
assert bencode(12345678901234567890L) == 'i12345678901234567890e'
assert bencode(12345678901234567890) == 'i12345678901234567890e'
assert bencode('') == '0:'
assert bencode('abc') == '3:abc'
assert bencode('1234567890') == '10:1234567890'

204
Shared/lib/python3.4/site-packages/ox/torrent/bencode3.py
View file

@ -4,139 +4,151 @@
#
##
def _decode_int(data):
"""
decode integer from bytearray
return int, remaining data
"""
data = data[1:]
end = data.index(b'e')
return int(data[:end],10), data[end+1:]
class Decoder(object):
def _decode_str(data):
"""
decode string from bytearray
return string, remaining data
"""
start = data.index(b':')
l = int(data[:start].decode(),10)
if l <= 0:
raise Exception('invalid string size: %d'%d)
start += 1
ret = bytes(data[start:start+l])
data = data[start+l:]
return ret, data
def _decode_int(self):
"""
decode integer from bytearray
return int
"""
self.idx += 1
start = self.idx
end = self.data.index(b'e', self.idx)
self.idx = end + 1
return int(self.data[start:end])
def _decode_list(data):
"""
decode list from bytearray
return list, remaining data
"""
ls = []
data = data[1:]
while data[0] != ord(b'e'):
elem, data = _decode(data)
ls.append(elem)
return ls, data[1:]
def _decode_str(self):
"""
decode string from bytearray
return string
"""
start = self.data.index(b':', self.idx)
l = int(self.data[self.idx:start].decode(), 10)
if l < 0:
raise Exception('invalid string size: %d' % l)
start += 1
ret = self.data[start:start+l]
try:
ret = ret.decode('utf-8')
except:
pass
self.idx = start + l
return ret
def _decode_dict(data):
"""
decode dict from bytearray
return dict, remaining data
"""
d = {}
data = data[1:]
while data[0] != ord(b'e'):
k, data = _decode_str(data)
v, data = _decode(data)
d[k.decode()] = v
return d, data[1:]
def _decode_list(self):
"""
decode list from bytearray
return list
"""
ls = []
self.idx += 1
while self.data[self.idx] != ord(b'e'):
ls.append(self._decode())
self.idx += 1
return ls
def _decode(data):
"""
decode a bytearray
return deserialized object, remaining data
"""
ch = chr(data[0])
if ch == 'l':
return _decode_list(data)
elif ch == 'i':
return _decode_int(data)
elif ch == 'd':
return _decode_dict(data)
elif ch.isdigit():
return _decode_str(data)
else:
raise Exception('could not deserialize data: %s'%data)
def _decode_dict(self):
"""
decode dict from bytearray
return dict
"""
d = {}
self.idx += 1
while self.data[self.idx] != ord(b'e'):
k = self._decode_str()
v = self._decode()
d[k] = v
self.idx += 1
return d
def _decode(self):
ch = chr(self.data[self.idx])
if ch == 'l':
return self._decode_list()
elif ch == 'i':
return self._decode_int()
elif ch == 'd':
return self._decode_dict()
elif ch.isdigit():
return self._decode_str()
else:
raise Exception('could not decode data: %s' % data)
def decode(self, data):
self.idx = 0
self.data = data
obj = self._decode()
if len(data) != self.idx:
raise Exception('failed to decode, extra data: %s' % data)
return obj
def bdecode(data):
"""
decode a bytearray
return deserialized object
return decoded object
"""
obj , data = _decode(data)
if len(data) > 0:
raise Exception('failed to deserialize, extra data: %s'%data)
return obj
return Decoder().decode(data)
def _encode_str(s,buff):
def _encode_str(s, buff):
"""
encode string to a buffer
"""
s = bytearray(s)
l = len(s)
buff.append(bytearray(str(l)+':','utf-8'))
buff.append(bytearray(str(l)+':', 'utf-8'))
buff.append(s)
def _encode_int(i,buff):
def _encode_int(i, buff):
"""
encode integer to a buffer
"""
buff.append(b'i')
buff.append(bytearray(str(i),'ascii'))
buff.append(bytearray(str(i), 'ascii'))
buff.append(b'e')
def _encode_list(l,buff):
def _encode_list(l, buff):
"""
encode list of elements to a buffer
"""
buff.append(b'l')
for i in l:
_encode(i,buff)
_encode(i, buff)
buff.append(b'e')
def _encode_dict(d,buff):
def _encode_dict(d, buff):
"""
encode dict
"""
buff.append(b'd')
l = list(d.keys())
l.sort()
for k in l:
_encode(str(k),buff)
_encode(d[k],buff)
for k in sorted(d):
if not isinstance(k, (bytes, str)):
k = str(k)
_encode(k, buff)
_encode(d[k], buff)
buff.append(b'e')
def _encode(obj,buff):
def _encode(obj, buff):
"""
encode element obj to a buffer buff
"""
if isinstance(obj,str):
_encode_str(bytearray(obj,'utf-8'),buff)
elif isinstance(obj,bytes):
_encode_str(bytearray(obj),buff)
elif isinstance(obj,bytearray):
_encode_str(obj,buff)
if isinstance(obj, str):
_encode_str(bytearray(obj, 'utf-8'), buff)
elif isinstance(obj, bytes):
_encode_str(bytearray(obj), buff)
elif isinstance(obj, bytearray):
_encode_str(obj, buff)
elif str(obj).isdigit():
_encode_int(obj,buff)
elif isinstance(obj,list):
_encode_list(obj,buff)
elif hasattr(obj,'keys') and hasattr(obj,'values'):
_encode_dict(obj,buff)
elif str(obj) in ['True','False']:
_encode_int(int(obj and '1' or '0'),buff)
_encode_int(obj, buff)
elif isinstance(obj, int):
_encode_int(obj, buff)
elif isinstance(obj, list):
_encode_list(obj, buff)
elif hasattr(obj, 'keys') and hasattr(obj, 'values'):
_encode_dict(obj, buff)
elif str(obj) in ['True', 'False']:
_encode_int(int(obj and '1' or '0'), buff)
else:
raise Exception('non serializable object: %s'%obj)
raise Exception('non serializable object: %s [%s]' % (obj, type(obj)))
def bencode(obj):
@ -144,8 +156,8 @@ def bencode(obj):
bencode element, return bytearray
"""
buff = []
_encode(obj,buff)
ret = bytearray()
_encode(obj, buff)
ret = bytearray()
for ba in buff:
ret += ba
ret += ba
return bytes(ret)