async def download(torrent_file: str, download_location: str):
"""
Download coroutine to start a download by accepting a torrent file and download location
:param torrent_file: torrent file to be downloaded
:param download_location: location to download it to
"""
torrent = Torrent(torrent_file)
torrent_writer = FileSaver(download_location, torrent)
session = DownloadSession(
torrent, torrent_writer.get_received_pieces_queue()) # FILESAVER
done_pieces = 0
while done_pieces < torrent.number_of_pieces:
await torrent.get_peers()
peers_info = list(set(torrent.peers))
seen_peers = set()
peers = [Peer(session, host, port) for host, port in peers_info]
seen_peers.update([str(p) for p in peers])
print('[Peers]: {} {}'.format(len(seen_peers), seen_peers))
for peer in peers:
peer.inflight_requests = 0
print("STARTING")
await (asyncio.gather(*[peer.download() for peer in peers]))
print("received", len(session.received_pieces))
print("progress", len(session.pieces_in_progress))
pprint(session.pieces_in_progress)
print("resetting session.pieces_in_progress")
session.pieces_in_progress = {}
print("alive peers")
peers = [peer for peer in peers if peer.have_pieces is not None]
print("bitfields")
pprint([(peer, peer.have_pieces) for peer in peers])
done_pieces = len(session.received_pieces)
print("Done pieces:", done_pieces)
print("RESTARTING")
return True
async def download(t_file : str, download_loc : str, loop=None):
'''Entry point for client, initializes `Peers` and `DownloadSession` according to
configureation present in `t_file` which is the .torrent file and saves the
downloaded file to `download_loc` directory'''
torrent = Torrent(t_file)
LOG.info('Torrent : {}'.format(torrent))
torrent_writer = FileSaver(download_loc, torrent)
session = DownloadSession(torrent, torrent_writer.get_received_blocks_queue())
tracker = Tracker(torrent) # implement Tracker class
peer_info = await tracker.get_peers()
seen_peers = set()
peers = [Peer(session, host, port) for host, port in peer_info]
seen_peers.update([str(p) for p in peers])
LOG.info('Peers : {}'.format(seen_peers))
asyncio.gather([peer.download() for peer in peers])
def parse():
car_parser = CarParser()
url = input(
'Введите URL с сайта auto.ria.com из раздела новые автомобили:')
url = url.strip()
html = car_parser.get_html(url)
if html.status_code != 200:
print('Error')
return
pages_count = car_parser.get_pages_count(html.text)
soup = BeautifulSoup(html.text, 'html.parser')
mark = car_parser.get_mark(soup)
saver = FileSaver(mark)
for page in range(1, pages_count + 1):
print(f'Парсинг страницы {page} из {pages_count}...')
html = car_parser.get_html(url, params={'page': page})
soup = BeautifulSoup(html.text, 'html.parser')
for new_car in car_parser.get_content(soup):
saver.save(new_car, mark)
print(f'Файл записан')
async def download(torrent_file, download_path):
torrent_info = TorrentInfo.from_file(torrent_file,
download_dir=download_path)
download_info: DownloadInfo = torrent_info.download_info
tracker = Tracker(torrent_info)
files = [
download_info.files[0],
] # download first file
received_pieces_queue = asyncio.Queue()
download_info.select_files(files)
file_writer = FileSaver(torrent_info, files[0], received_pieces_queue)
peers_info = await tracker.request_peers()
sessions = list()
for peer in peers_info:
session = DownloadSession(torrent_info, received_pieces_queue, peer)
sessions.append(session)
await asyncio.gather(*[session.download() for session in sessions])
def saveFile(self, text):
self._isTextUnsave = False
fileSaver = FileSaver(self._currentFileLocation, text)
fileSaver.save()
def test_file_saving(self):
Fs = FileSaver()
res = Fs.save_file("test.json", b"abc")
path = pl.Path("data_dump/test.json")
self.assertIsFile(path)
def __init__(self):
self.filesaver = FileSaver()
self.pm = PredictionManager()
logging.debug("Initialised periodic prediction saver")
self.pp = PredictionPlotter()
def save(self, py_object):
time_path = datetime.datetime.now().strftime("%y_%m_%d/%H_%M_%S")
fs = FileSaver(os.path.join(self._folder_path,
time_path), self._file_path,
self._file_extension, self._save_method)
return fs.save(py_object)
parser.add_argument('-S', help="The strategy to be used")
parser.add_argument('input_file',
help="The input file containing the SAT problem")
# Parse the arguments
arguments = parser.parse_args()
if not arguments.input_file:
raise Exception("Invalid input file")
utils.lambda_value = 0.45
utils.beta_value = 0.5
split_method = SplitMethod.DEFAULT
if arguments.S == "2":
split_method = SplitMethod.MOM
elif arguments.S == "3":
split_method = SplitMethod.TK
formula = Formula(Operation.AND)
formula.add_elements_from_file(arguments.input_file)
sat_solver = SatSolver(formula, split_method)
solved, values = sat_solver.solve()
output_file_name = f'{arguments.input_file}.out'
file_saver = FileSaver()
if solved:
file_saver.save_values_in_dimacs(values, output_file_name)
else:
file_saver.save_values_in_dimacs({}, output_file_name)
def __init__(self):
self.filesaver = FileSaver()
