b1cdc32f73
The move to using auto-formatter makes it easier to read, submit and speeds up development time. https://github.com/ambv/black/ Although I would prefer 79 chars, the default line length of 88 chars used by black suffices. The flake8 line length remains at 120 chars since black does not touch comments or docstrings and this will require another round of fixes. The only black setting that is not standard is the use of double-quotes for strings so disabled any formatting of these. Note however that flake8 will still flag usage of double-quotes. I may change my mind on double vs single quotes but for now leave them. A new pyproject.toml file has been created for black configuration.
380 lines
12 KiB
Python
380 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
|
|
#
|
|
# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
|
|
# the additional special exception to link portions of this program with the OpenSSL library.
|
|
# See LICENSE for more details.
|
|
#
|
|
|
|
from __future__ import division, unicode_literals
|
|
|
|
import os
|
|
from hashlib import sha1 as sha
|
|
|
|
from deluge.bencode import bencode
|
|
from deluge.common import get_path_size, utf8_encode_structure
|
|
|
|
|
|
class InvalidPath(Exception):
|
|
"""Raised when an invalid path is supplied."""
|
|
|
|
pass
|
|
|
|
|
|
class InvalidPieceSize(Exception):
|
|
"""Raised when an invalid piece size is set.
|
|
|
|
Note:
|
|
Piece sizes must be multiples of 16KiB.
|
|
"""
|
|
|
|
pass
|
|
|
|
|
|
class TorrentMetadata(object):
|
|
"""This class is used to create .torrent files.
|
|
|
|
Examples:
|
|
|
|
>>> t = TorrentMetadata()
|
|
>>> t.data_path = '/tmp/torrent'
|
|
>>> t.comment = 'My Test Torrent'
|
|
>>> t.trackers = [['http://tracker.openbittorent.com']]
|
|
>>> t.save('/tmp/test.torrent')
|
|
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.__data_path = None
|
|
self.__piece_size = 0
|
|
self.__comment = ''
|
|
self.__private = False
|
|
self.__trackers = []
|
|
self.__webseeds = []
|
|
self.__pad_files = False
|
|
|
|
def save(self, torrent_path, progress=None):
|
|
"""Creates and saves the torrent file to `path`.
|
|
|
|
Args:
|
|
torrent_path (str): Location to save the torrent file.
|
|
progress(func, optional): The function to be called when a piece is hashed. The
|
|
provided function should be in the format `func(num_completed, num_pieces)`.
|
|
|
|
Raises:
|
|
InvalidPath: If the data_path has not been set.
|
|
|
|
"""
|
|
if not self.data_path:
|
|
raise InvalidPath('Need to set a data_path!')
|
|
|
|
torrent = {'info': {}}
|
|
|
|
if self.comment:
|
|
torrent['comment'] = self.comment
|
|
|
|
if self.private:
|
|
torrent['info']['private'] = True
|
|
|
|
if self.trackers:
|
|
torrent['announce'] = self.trackers[0][0]
|
|
torrent['announce-list'] = self.trackers
|
|
else:
|
|
torrent['announce'] = ''
|
|
|
|
if self.webseeds:
|
|
httpseeds = []
|
|
webseeds = []
|
|
for w in self.webseeds:
|
|
if w.endswith('.php'):
|
|
httpseeds.append(w)
|
|
else:
|
|
webseeds.append(w)
|
|
|
|
if httpseeds:
|
|
torrent['httpseeds'] = httpseeds
|
|
if webseeds:
|
|
torrent['url-list'] = webseeds
|
|
|
|
datasize = get_path_size(self.data_path)
|
|
|
|
if self.piece_size:
|
|
piece_size = self.piece_size * 1024
|
|
else:
|
|
# We need to calculate a piece size
|
|
piece_size = 16384
|
|
while (datasize // piece_size) > 1024 and piece_size < (8192 * 1024):
|
|
piece_size *= 2
|
|
|
|
# Calculate the number of pieces we will require for the data
|
|
num_pieces = datasize // piece_size
|
|
if datasize % piece_size:
|
|
num_pieces += 1
|
|
|
|
torrent['info']['piece length'] = piece_size
|
|
torrent['info']['name'] = os.path.split(self.data_path)[1]
|
|
|
|
# Create the info
|
|
if os.path.isdir(self.data_path):
|
|
files = []
|
|
padding_count = 0
|
|
# Collect a list of file paths and add padding files if necessary
|
|
for (dirpath, dirnames, filenames) in os.walk(self.data_path):
|
|
for index, filename in enumerate(filenames):
|
|
size = get_path_size(
|
|
os.path.join(self.data_path, dirpath, filename)
|
|
)
|
|
p = dirpath[len(self.data_path) :]
|
|
p = p.lstrip('/')
|
|
p = p.split('/')
|
|
if p[0]:
|
|
p += [filename]
|
|
else:
|
|
p = [filename]
|
|
files.append((size, p))
|
|
# Add a padding file if necessary
|
|
if self.pad_files and (index + 1) < len(filenames):
|
|
left = size % piece_size
|
|
if left:
|
|
p = list(p)
|
|
p[-1] = '_____padding_file_' + str(padding_count)
|
|
files.append((piece_size - left, p))
|
|
padding_count += 1
|
|
|
|
# Run the progress function with 0 completed pieces
|
|
if progress:
|
|
progress(0, num_pieces)
|
|
|
|
fs = []
|
|
pieces = []
|
|
# Create the piece hashes
|
|
buf = b''
|
|
for size, path in files:
|
|
path = [s.encode('UTF-8') for s in path]
|
|
fs.append({b'length': size, b'path': path})
|
|
if path[-1].startswith(b'_____padding_file_'):
|
|
buf += b'\0' * size
|
|
pieces.append(sha(buf).digest())
|
|
buf = b''
|
|
fs[-1][b'attr'] = b'p'
|
|
else:
|
|
with open(
|
|
os.path.join(self.data_path.encode('utf8'), *path), 'rb'
|
|
) as _file:
|
|
r = _file.read(piece_size - len(buf))
|
|
while r:
|
|
buf += r
|
|
if len(buf) == piece_size:
|
|
pieces.append(sha(buf).digest())
|
|
# Run the progress function if necessary
|
|
if progress:
|
|
progress(len(pieces), num_pieces)
|
|
buf = b''
|
|
else:
|
|
break
|
|
r = _file.read(piece_size - len(buf))
|
|
torrent['info']['files'] = fs
|
|
if buf:
|
|
pieces.append(sha(buf).digest())
|
|
if progress:
|
|
progress(len(pieces), num_pieces)
|
|
buf = ''
|
|
|
|
elif os.path.isfile(self.data_path):
|
|
torrent['info']['length'] = get_path_size(self.data_path)
|
|
pieces = []
|
|
|
|
with open(self.data_path, 'rb') as _file:
|
|
r = _file.read(piece_size)
|
|
while r:
|
|
pieces.append(sha(r).digest())
|
|
if progress:
|
|
progress(len(pieces), num_pieces)
|
|
|
|
r = _file.read(piece_size)
|
|
|
|
torrent['info']['pieces'] = b''.join(pieces)
|
|
|
|
# Write out the torrent file
|
|
with open(torrent_path, 'wb') as _file:
|
|
_file.write(bencode(utf8_encode_structure(torrent)))
|
|
|
|
def get_data_path(self):
|
|
"""Get the path to the files that the torrent will contain.
|
|
|
|
Note:
|
|
It can be either a file or a folder.
|
|
|
|
Returns:
|
|
str: The torrent data path, either a file or a folder.
|
|
|
|
"""
|
|
return self.__data_path
|
|
|
|
def set_data_path(self, path):
|
|
"""Set the path to the files (data) that the torrent will contain.
|
|
|
|
Note:
|
|
This property needs to be set before the torrent file can be created and saved.
|
|
|
|
Args:
|
|
path (str): The path to the torrent data and can be either a file or a folder.
|
|
|
|
Raises:
|
|
InvalidPath: If the path is not found.
|
|
|
|
"""
|
|
if os.path.exists(path) and (os.path.isdir(path) or os.path.isfile(path)):
|
|
self.__data_path = os.path.abspath(path)
|
|
else:
|
|
raise InvalidPath('No such file or directory: %s' % path)
|
|
|
|
def get_piece_size(self):
|
|
"""The size of the pieces.
|
|
|
|
Returns:
|
|
int: The piece size in multiples of 16 KiBs.
|
|
"""
|
|
return self.__piece_size
|
|
|
|
def set_piece_size(self, size):
|
|
"""Set piece size.
|
|
|
|
Note:
|
|
If no piece size is set, one will be automatically selected to
|
|
produce a torrent with less than 1024 pieces or the smallest possible
|
|
with a 8192KiB piece size.
|
|
|
|
Args:
|
|
size (int): The desired piece size in multiples of 16 KiBs.
|
|
|
|
Raises:
|
|
InvalidPieceSize: If the piece size is not a valid multiple of 16 KiB.
|
|
|
|
"""
|
|
if size % 16 and size:
|
|
raise InvalidPieceSize('Piece size must be a multiple of 16 KiB')
|
|
self.__piece_size = size
|
|
|
|
def get_comment(self):
|
|
"""Get the torrent comment.
|
|
|
|
Returns:
|
|
str: An informational string about the torrent.
|
|
|
|
"""
|
|
return self.__comment
|
|
|
|
def set_comment(self, comment):
|
|
"""Set the comment for the torrent.
|
|
|
|
Args:
|
|
comment (str): An informational string about the torrent.
|
|
|
|
"""
|
|
self.__comment = comment
|
|
|
|
def get_private(self):
|
|
"""Get the private flag of the torrent.
|
|
|
|
Returns:
|
|
bool: True if private flag has been set, else False.
|
|
|
|
"""
|
|
return self.__private
|
|
|
|
def set_private(self, private):
|
|
"""Set the torrent private flag.
|
|
|
|
Note:
|
|
Private torrents only announce to trackers and will not use DHT or
|
|
Peer Exchange. See http://bittorrent.org/beps/bep_0027.html
|
|
|
|
Args:
|
|
private (bool): True if the torrent is to be private.
|
|
|
|
"""
|
|
self.__private = private
|
|
|
|
def get_trackers(self):
|
|
"""Get the announce trackers.
|
|
|
|
Note:
|
|
See http://bittorrent.org/beps/bep_0012.html
|
|
|
|
Returns:
|
|
list of lists: A list containing a list of trackers.
|
|
|
|
"""
|
|
return self.__trackers
|
|
|
|
def set_trackers(self, trackers):
|
|
"""Set the announce trackers.
|
|
|
|
Args:
|
|
private (list of lists): A list containing lists of trackers as strings, each list is a tier.
|
|
|
|
"""
|
|
self.__trackers = trackers
|
|
|
|
def get_webseeds(self):
|
|
"""Get the webseeds.
|
|
|
|
Note:
|
|
The web seeds can either be:
|
|
Hoffman-style: http://bittorrent.org/beps/bep_0017.html
|
|
GetRight-style: http://bittorrent.org/beps/bep_0019.html
|
|
|
|
If the url ends in '.php' then it will be considered Hoffman-style, if
|
|
not it will be considered GetRight-style.
|
|
|
|
Returns:
|
|
list: The webseeds.
|
|
|
|
"""
|
|
return self.__webseeds
|
|
|
|
def set_webseeds(self, webseeds):
|
|
"""Set webseeds.
|
|
|
|
Note:
|
|
The web seeds can either be:
|
|
Hoffman-style: http://bittorrent.org/beps/bep_0017.html
|
|
GetRight-style: http://bittorrent.org/beps/bep_0019.html
|
|
|
|
If the url ends in '.php' then it will be considered Hoffman-style, if
|
|
not it will be considered GetRight-style.
|
|
|
|
Args:
|
|
private (list): The webseeds URLs which can be either Hoffman or GetRight style.
|
|
|
|
"""
|
|
self.__webseeds = webseeds
|
|
|
|
def get_pad_files(self):
|
|
"""Get status of padding files for the torrent.
|
|
|
|
Returns:
|
|
bool: True if padding files have been enabled to align files on piece boundaries.
|
|
|
|
"""
|
|
return self.__pad_files
|
|
|
|
def set_pad_files(self, pad):
|
|
"""Enable padding files for the torrent.
|
|
|
|
Args:
|
|
private (bool): True adds padding files to align files on piece boundaries.
|
|
|
|
"""
|
|
self.__pad_files = pad
|
|
|
|
data_path = property(get_data_path, set_data_path)
|
|
piece_size = property(get_piece_size, set_piece_size)
|
|
comment = property(get_comment, set_comment)
|
|
private = property(get_private, set_private)
|
|
trackers = property(get_trackers, set_trackers)
|
|
webseeds = property(get_webseeds, set_webseeds)
|
|
pad_files = property(get_pad_files, set_pad_files)
|