def get_torrent(self, ses, hash_info): ''' Add hash_info to session, begin down load torrent ''' self._insert_info_hash(hash_info) if self._is_download_meta == False: return if (self._download_meta_params.has_key(hash_info) is True): print "info hash" + hash_info + "already downloading" return magnet='magnet:?xt=urn:btih:'+hash_info print "Add magnet ", magnet tempdir = tempfile.mkdtemp() params = { 'save_path': tempdir, 'duplicate_is_error': True, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } lt.add_magnet_uri(ses, magnet, params) download_param = DownloadParam() download_param.start_time = time.time() download_param.download_dir= tempdir self._download_meta_params[hash_info] = download_param
def magnet2torrent(magnet): tempdir = tempfile.mkdtemp() ses = lt.session() params = { 'save_path': tempdir, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True, 'flag_merge_resume_trackers': True } handle = lt.add_magnet_uri(ses, magnet, params) print("Downloading Metadata (this may take a while)") while (not handle.has_metadata()): try: sleep(1) except KeyboardInterrupt: print("Aborting...") ses.pause() print("Cleanup dir " + tempdir) shutil.rmtree(tempdir) sys.exit(0) ses.pause() shutil.rmtree(tempdir) print("Done") torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) torcontent = lt.bencode(torfile.generate()) return torcontent
def __add_magnet(self, uri, info_hash): self.l.log("TorrentAgent:adding magnet " + uri) if self.__check_dups(uri): self.l.log("TorrentAgent:skipping, already added " + uri) return resume_data = self.__get_resume_data(info_hash) params = {"save_path":self.c["save_path"], "resume_data":resume_data, "storage_mode":self.c["storage_mode"], "paused":self.c["start_as_paused"], "duplicate_is_error":self.c["dup_is_error"], "auto_managed":self.c["auto_managed"]} try: h = LT.add_magnet_uri(self.session, uri, params) except: self.l.log("TorrentAgent:error adding magnet, malformed URI? " + uri, L.ERR) return try: fname = self.c["watch_path"] + "/" + str(h.info_hash()) + ".magnet" self.l.log("TorrentAgent:writing magnet restart file " + fname, L.DBG) f = open(fname, "wb") f.write(uri) f.close() except: self.l.log("TorrentAgent:error writing magnet restart file " + fname, L.ERR) self.__setup_handle(h) self.handle_by_name[uri] = (h, True)
def magnet2t(link, tfile): sess = lt.session() params = { "save_path": '/', "storage_mode": lt.storage_mode_t.storage_mode_sparse, "paused": True, "auto_managed": True, "duplicate_is_error": True } try: handle = lt.add_magnet_uri(sess, link, params) state_str = ['queued', 'checking', 'downloading metadata', 'downloading', 'finished', 'seeding', 'allocating'] while (not handle.has_metadata()): s = handle.status() print '%.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d) %s' % ( s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000, s. num_peers, state_str[s.state]) time.sleep(5) print handle.has_metadata() torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) t = open(tfile, "wb") t.write(lt.bencode(torfile.generate())) t.close() print '%s generated!' % tfile except Exception, ex: print Exception, ":", ex return False
def add_magnet(self, client, url, params): handle = lt.add_magnet_uri(self.session, url, params) ih = str(handle.info_hash()) if ih in self.torrents: raise Exception('Duplicate torrent') self.torrents[ih] = client return handle
def generate_metadata(self, magnet): tempdir = tempfile.mkdtemp() ses = lt.session() handle = lt.add_magnet_uri(ses, magnet, generate_params(tempdir)) print("Downloading Metadata of {}".format(magnet)) while not handle.has_metadata(): try: sleep(1) except KeyboardInterrupt: print("Aborting...") session.pause(ses) print("Cleanup dir " + tempdir) shutil.rmtree(tempdir) sys.exit(0) session.pause(ses) print("Done") torinfo = handle.get_torrent_info() info_entry = { "trackers": [t.url for t in torinfo.trackers()], "name": torinfo.name(), "link": magnet, "files": [f.path for f in torinfo.files()], "num_files": torinfo.num_files() } return info_entry
def download_iso(self): session = lt.session() session.listen_on(6881, 6891) params = { 'save_path': self.path, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } handle = lt.add_magnet_uri(session, self.magnet_link, params) session.start_dht() LOG.debug('Downloading metadata for build {0}'.format( self.stable_iso_build)) while not handle.has_metadata(): time.sleep(1) LOG.debug('Got metadata, starting torrent download...') while handle.status().state != lt.torrent_status.seeding: status = handle.status() state_str = [ 'queued', 'checking', 'downloading metadata', 'downloading', 'finished', 'seeding', 'allocating' ] LOG.debug('{0:.2f}% complete (down: {1:.1f} kb/s up: {2:.1f} kB/s ' 'peers: {3:d}) {4:s} {5:d}.3'.format( status.progress * 100, status.download_rate / 1000, status.upload_rate / 1000, status.num_peers, state_str[status.state], status.total_download / 1000000)) time.sleep(5) LOG.debug('Ready for deploy iso {0}'.format(self.stable_iso_build))
def get_subtitle(magnet, lang): print("Explorando torrent") lt_session = session() lt_session.listen_on(6881, 6891) params = {"save_path": "/tmp"} handle = add_magnet_uri(lt_session, magnet, params) lt_session.start_dht() print "esperando" while (not handle.has_metadata()): sleep(.1) print "esperando" info = handle.get_torrent_info() print "esperando", info files = info.files() biggest_file = ("", 0) for file_ in files: if file_.size > biggest_file[1]: biggest_file = [file_.path, file_.size] print("Adivinando data") filepath = biggest_file[0] guess = guess_video_info(filepath, info=['filename']) video = Video.fromguess(filepath, guess) video.size = biggest_file[1] print("Bajando el subtitulo para lang = " + lang) subtitle = download_best_subtitles([video], {Language(lang)}, single=True) if not len(subtitle): subtitle = None else: subtitle = get_subtitle_path(video.name) lt_session.remove_torrent(handle) return subtitle
def download_torrent(magnet): tempdir = tempfile.mkdtemp() ses = libtorrent.session() params = { 'save_path': tempdir, 'duplicate_is_error': True, 'storage_mode': libtorrent.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } handle = libtorrent.add_magnet_uri(ses, magnet, params) _wait_for_metadata(handle) ses.pause() # Exract torrent file content torinfo = handle.get_torrent_info() # Cleanup ses.remove_torrent(handle) shutil.rmtree(tempdir) return libtorrent.create_torrent(torinfo), torinfo.name()
def downloadMagnet(self,magnetlink,location=''): try: savepath = self.TORRENT_DIR if len(location)>0: savepath = os.path.join(savepath, location) if not os.path.exists(savepath): os.makedirs(savepath) self.logger.info("Created directory "+str(savepath)) params = { 'save_path': savepath} handle = lt.add_magnet_uri(self.ses, magnetlink, params) self.logger.info( 'downloading metadata...') while (not handle.has_metadata()): time.sleep(1) self.logger.info( 'got metadata, starting torrent download...') while (handle.status().state != lt.torrent_status.seeding): try: percentComplete = int(handle.status().progress*100) except: percentComplete = handle.status().progress*100 self.logger.info("DL " + handle.name()+ " ["+ str(handle.status().download_rate/1000)+"kb/s : "+str(handle.status().upload_rate/1000)+"kb/s.] [" + str(percentComplete)+"%]" + " [S:"+str(handle.status().num_seeds)+ " P:"+str(handle.status().num_peers)+"]" ) # self.logger.info("Tracker: "+ handle.status().current_tracker ) time.sleep(10) self.logger.info( "[Complete] Download complete of "+handle.name()) self.logCompletedDownload(handle.name()) try: self.logger.info("Removing torrent: "+str(handle.name())) self.ses.remove_torrent(handle) except Exception as ee: self.logger.error(traceback.format_exc()) except Exception as e: self.logger.error(traceback.format_exc())
def StartSession(self): self.params = { 'save_path': '.', 'storage_mode': lt.storage_mode_t(2), 'paused': True, 'auto_managed': True, 'duplicate_is_error': True } self.tmr_pauseTorrent = wx.Timer(self, -1) self.Bind(wx.EVT_TIMER, self.PauseTorrent, self.tmr_pauseTorrent) self.tmr_pauseTorrent.Start(milliseconds=100, oneShot=False) if os.path.exists(self.path): decodedTorrent = lt.bdecode(open(self.path, 'rb').read()) self.torrentInfo = lt.torrent_info(decodedTorrent) self.params.update({'ti': self.torrentInfo}) self.torrent = self.parent.ses.add_torrent(self.params) self.loaded = True self.ggb_metadata.Hide() self.lbl_metadata.Hide() self.GetTorrentData() else: self.torrent = lt.add_magnet_uri(self.parent.ses, self.path, self.params) self.ggb_metadata.Pulse() self.btn_ok.Disable() self.timeoutCounter = 0 self.tmr_metadata = wx.Timer(self, -1) self.Bind(wx.EVT_TIMER, self.GetMetadata, self.tmr_metadata) self.tmr_metadata.Start(milliseconds=100, oneShot=False)
def generate_torrent_from_magnet(url): try: session = libtorrent.session() tempdir = tempfile.mkdtemp() params = { 'save_path': tempdir, 'storage_mode': libtorrent.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } handle = libtorrent.add_magnet_uri(session, url, params) while (not handle.has_metadata()): time.sleep(.1) session.pause() torinfo = handle.get_torrent_info() fs = libtorrent.file_storage() for file in torinfo.files(): fs.add_file(file) torfile = libtorrent.create_torrent(fs) torfile.set_comment(torinfo.comment()) torfile.set_creator(torinfo.creator()) torrent_data = libtorrent.bencode(torfile.generate()) session.remove_torrent(handle) return torrent_data except: torrent_data = None if handle and session: session.remove_torrent(handle) return torrent_data
def get_subtitle(magnet, lang): print("Explorando torrent") lt_session = session() lt_session.listen_on(6881, 6891) params = {"save_path": "/tmp"} handle = add_magnet_uri(lt_session, magnet, params) lt_session.start_dht() print "esperando" while (not handle.has_metadata()): sleep(.1) print "esperando" info = handle.get_torrent_info() print "esperando", info files = info.files() biggest_file = ("", 0) for file_ in files: if file_.size > biggest_file[1]: biggest_file = [file_.path, file_.size] print("Adivinando data") filepath = biggest_file[0] guess = guess_video_info(filepath, info = ['filename']) video = Video.fromguess(filepath, guess) video.size = biggest_file[1] print("Bajando el subtitulo para lang = " + lang) subtitle = download_best_subtitles([video], {Language(lang)}, single=True) if not len(subtitle): subtitle = None else: subtitle = get_subtitle_path(video.name) lt_session.remove_torrent(handle) return subtitle
def main(): count = 0 ses = lt.session() params = { 'save_path': PATH} print "Introduce el magnet :" link = raw_input() handle = lt.add_magnet_uri(ses, link, params) handle.set_sequential_download(True) salida = 0 print 'Descargando metadatos' while (not handle.has_metadata()): time.sleep(1) print 'Cargando' print "0%" while (handle.status().state != lt.torrent_status.seeding): porcen_ini = handle.status().progress time.sleep(1) if handle.status().progress*100 > porcen_ini*100: salida = handle.status().progress*100 print ("%.2f %%" % salida) if salida >= 5 and count < 1: #buffer hilo = threading.Thread(target = abrevideo) hilo.start() count += 1 os.system("rm -rf "+PATH) return 0
def run(self): params = {'save_path': './'} handle = libtorrent.add_magnet_uri(self.session, str(self.torrent.magnet_link), params) while (not handle.has_metadata()): time.sleep(1) total_download = 0 total_upload = 0 while True: status = handle.status() self.speed_download = (status.total_download - total_download)/1 self.speed_upload = (status.total_upload - total_upload)/1 total_download = status.total_download total_upload = status.total_upload torrent = TorrentDownload() torrent.ID = self.torrent.ID torrent.magnet_link = self.torrent.magnet_link torrent.name = self.torrent.name torrent.size = status.total_wanted torrent.seed = [None, None] # [int, int] torrent.leech = [None, None] # [int, int] torrent.state = status.state torrent.downloaded = total_download torrent.uploaded = total_upload torrent.downspeed = self.speed_download torrent.upspeed = self.speed_upload self.emit(SIGNAL('update(PyQt_PyObject)'), torrent) time.sleep(1)
def index(): if request.args.has_key("magnet"): magnet = url_unquote(request.args["magnet"]).encode(request.charset) magnet_xt = url_decode(magnet[magnet.index("?") + 1 :])["xt"] torrent = cache.get(magnet_xt) if not torrent: try: handle = lt.add_magnet_uri( ses, magnet, {"save_path": "./invalid", "paused": False, "auto_managed": False, "duplicate_is_error": False}, ) while not handle.has_metadata(): time.sleep(0.01) handle.pause() info = handle.get_torrent_info() torrent = create_torrent(info) cache.set(magnet_xt, torrent) ses.remove_torrent(handle, lt.options_t.delete_files) except: torrent = cache.get(magnet_xt) response = Response(response=torrent[1], mimetype="application/x-bittorrent") response.headers.add("Content-Disposition", "attachment", filename=torrent[0]) return response return render_template("index.html")
def magnet2torrent(link): sess = lt.session() sess.add_dht_router("router.bittorrent.com", 6881) sess.add_dht_router("router.utorrent.com", 6881) sess.add_dht_router("router.bitcomet.com", 6881) sess.add_dht_router("dht.transmissionbt.com", 6881) sess.start_dht() params = { "save_path": "/tmp/tor", # "storage_mode":lt.storage_mode_t.storage_mode_sparse, # "paused": True, # "auto_managed": True, "duplicate_is_error": True, } handle = lt.add_magnet_uri(sess, link, params) # waiting for metadata while True: if not handle.has_metadata(): time.sleep(6) else: break sess.pause() # create a torrent torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) torcontent = lt.bencode(torfile.generate()) torname = torinfo.name() sess.remove_torrent(handle, 1) return {"status": 200, "name": torname, "data": torcontent}
def construct_handler(ses, torrent, destination): """ helper for handling magnet link, http links and torrent files""" tinfo = None params = { 'save_path': destination, 'storage_mode': lt.storage_mode_t(2), 'auto_managed': True, } # if case if ULR was provided download it to file # TODO: add nice REGXP URL validator, the 'http' can be a folder name if torrent.startswith('http'): torrent_body = requests.get(torrent) torrent = os.path.join(location_context, 'torrent_file') tmp_torrent = torrent + '.tmp' with open(tmp_torrent, 'wb') as dist: dist.write(torrent_body.text.encode('utf-8')) os.rename(tmp_torrent, torrent) # check if file contain magnet link # XXX: shitty magnet support from file torrent_data = open(torrent).read().strip(" \n\t") if torrent_data.startswith("magnet:"): torrent_handler = lt.add_magnet_uri(ses, torrent_data, params) else: tinfo = lt.torrent_info(torrent) params['ti'] = tinfo torrent_handler = ses.add_torrent(params) # waiting for metadata to be downloaded while (not torrent_handler.has_metadata()): time.sleep(0.1) return torrent_handler
def get_subtitle(magnet, lang): print("Obtaining subtitle (experimental, might take a while)") lt_session = session() params = {"save_path": "/tmp"} handle = add_magnet_uri(lt_session, magnet, params) while (not handle.has_metadata()): sleep(.1) info = handle.get_torrent_info() files = info.files() biggest_file = ("", 0) for file_ in files: if file_.size > biggest_file[1]: biggest_file = [file_.path, file_.size] print("Guessing data") filepath = biggest_file[0] guess = guess_video_info(filepath, info = ['filename']) video = Video.fromguess(filepath, guess) video.size = biggest_file[1] print("Donwloading Subtitle") subtitle = download_best_subtitles([video], {Language(lang)}, single=True) if not len(subtitle): subtitle = None else: subtitle = get_subtitle_path(video.name) lt_session.remove_torrent(handle) return subtitle
async def infohash_to_torrent(infohash): ses = lt.session() ses.add_dht_router('router.bittorrent.com', 6881) ses.add_dht_router('router.utorrent.com', 6881) ses.add_dht_router('dht.transmissionbt.com', 6881) ses.start_dht() params = { 'save_path': runPath + '/torrent', 'storage_mode': lt.storage_mode_t(2), # 'storage_mode': lt.storage_mode_t.storage_mode_sparse, 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } handle = lt.add_magnet_uri(ses, 'magnet:?xt=urn:btih:' + infohash, params) while (not handle.has_metadata()): time.sleep(1) # print('下载中') ses.pause() print('完成') torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) output = op.abspath(torinfo.name() + ".torrent")
def __init__(self, magnet_link, params, ports): params_ = { 'save_path': '.', 'auto_managed': True, 'paused': False, 'port': 6881, 'ratio': 0, 'max_download_rate': -1, 'max_upload_rate': -1, 'storage_mode': lt.storage_mode_t.storage_mode_sparse } #: I know it's not nice to add trackers like this... magnet_link += "&tr=udp://tracker.openbittorrent.com:80" params_.update(params) self.session = lt.session() self.session.set_severity_level(lt.alert.severity_levels.critical) self.session.listen_on(*ports) self.session.start_lsd() self.session.start_upnp() self.session.start_natpmp() self.session.start_dht() self.session.add_dht_router("router.bittorrent.com", 6881) self.session.add_dht_router("router.utorrent.com", 6881) self.session.add_dht_router("router.bitcomet.com", 6881) self.handle = lt.add_magnet_uri(self.session, magnet_link, params_)
def magnet2torrent(link): sess = lt.session() sess.add_dht_router('router.bittorrent.com', 6881) sess.add_dht_router('router.utorrent.com', 6881) sess.add_dht_router('router.bitcomet.com', 6881) sess.add_dht_router('dht.transmissionbt.com', 6881) sess.start_dht() params = { "save_path": '/tmp/tor', # "storage_mode":lt.storage_mode_t.storage_mode_sparse, #"paused": True, #"auto_managed": True, "duplicate_is_error": True } handle = lt.add_magnet_uri(sess, link, params) # waiting for metadata while True: if (not handle.has_metadata()): time.sleep(6) else: break sess.pause() # create a torrent torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) torcontent = lt.bencode(torfile.generate()) torname = torinfo.name() sess.remove_torrent(handle, 1) return {'status': 200, 'name': torname, 'data': torcontent}
def downloadCinema(linkManget): # CREDITOS => https://gist.github.com/samukasmk/940ca5d5abd9019e8b1af77c819e4ca9 folder = "/torrent" pathFIle = os.getcwd() + folder ses = lt.session() ses.listen_on(6881, 6891) params = { 'save_path': pathFIle, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } link = linkManget handle = lt.add_magnet_uri(ses, link, params) ses.start_dht() print('downloading metadata...') while (not handle.has_metadata()): time.sleep(1) print('got metadata, starting torrent download...') while (handle.status().state != lt.torrent_status.seeding): s = handle.status() state_str = ['queued', 'checking', 'downloading metadata', \ 'downloading', 'finished', 'seeding', 'allocating'] print ('%.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d) %s' % \ (s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000, \ s.num_peers, state_str[s.state])) time.sleep(5)
def add_torrent(self): self.logger.debug("Adding torrent hash {0}".format(self.info_hash)) info = lt.torrent_info(lt.big_number(self.info_hash.decode('hex'))) # Add OpenBitTorrent trackers info.add_tracker('udp://tracker.openbittorrent.com:80', 0) info.add_tracker('udp://tracker.publicbt.com:80', 0) info.add_tracker('udp://tracker.ccc.de:80', 0) info.add_tracker('udp://tracker.istole.it:80', 0) self.logger.info("Adding hash {0} to session".format(self.info_hash)) # self.handle = self.libtorrent_session.add_torrent(info, './') self.handle = lt.add_magnet_uri(self.libtorrent_session, str(self.magnet), {'save_path': '/tmp', 'storage_mode': lt.storage_mode_t.storage_mode_sparse, 'paused':True }) #wait for the download to start while not self.handle.status().state == self.handle.status().downloading: time.sleep(1) self.logger.debug("{0} changed state to downloading".format(self.info_hash)) #set all file prio to 0 self.handle.prioritize_files([0 for i in self.handle.file_priorities()]) # for i in range(0, self.handle.get_torrent_info().num_pieces()): # self.handle.piece_priority(i, 0) self.logger.debug("Done setting priority 0 for hash {0}".format(self.info_hash))
def magnet2torrent(link, torrent_file): sess = lt.session() sess.add_dht_router('router.bittorrent.com', 6881) sess.add_dht_router('router.utorrent.com', 6881) sess.add_dht_router('router.bitcomet.com', 6881) sess.add_dht_router('dht.transmissionbt.com', 6881) sess.start_dht(); params = { "save_path": 'D:\\Desktop', #"storage_mode":lt.storage_mode_t.storage_mode_sparse, #"paused": True, #"auto_managed": True, "duplicate_is_error": True } handle = lt.add_magnet_uri(sess, link, params) # waiting for metadata while (not handle.has_metadata()): time.sleep(5) # create a torrent torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) torcontent = lt.bencode(torfile.generate()) # save to file t = open(torrent_file, "wb") t.write(torcontent) t.close() return True
def crawl(magnet_link): print magnet_link h = lt.add_magnet_uri(ses, magnet_link, params) timeout_counter = 0 while (not h.has_metadata()): #print "Sleeping..." time.sleep(1) # Kill this torrent when the timeout reaches 3minutes timeout_counter += 1 if timeout_counter == 180: with open("failed_magnets.txt", "a") as fail: fail.write(magnet_link + '\n') return if h.has_metadata(): #print "Got the metadata" torinfo = h.get_torrent_info() torfile = lt.create_torrent( torinfo ) name = (magnet_link.split("magnet:?xt=urn:btih:")[1][:40]).upper() with open( name + ".torrent", "wb" ) as f: f.write(lt.bencode(torfile.generate())) return
def download_module(self, module): """ Download module :param module: module :type module: Module :return: None """ modules_directory = os.path.join(self.working_directory, MODULES_DIR) params = {'save_path': modules_directory} torrent = "magnet:?xt=urn:btih:{0}&dn={1}".format( module.id.content_hash, module.name) h = lt.add_magnet_uri(self.ses, torrent, params) self._logger.debug("transport: checking torrent (%s)", h.name()) while not h.has_metadata(): time.sleep(.1) self._logger.debug("transport: metadata complete for torrent (%s)", module.id.content_hash) torrent_info = h.get_torrent_info() h = self.ses.add_torrent({ 'ti': torrent_info, 'save_path': modules_directory, 'seed_mode': True })
def magnetToTorrent(self, magnet): session = libtorrent.session() session.start_dht() session.add_dht_router("router.bittorrent.com", 6881) session.add_dht_router("router.utorrent.com", 6881) session.add_dht_router("router.bitcomet.com", 6881) session.listen_on(6881, 6891) session.set_alert_mask( libtorrent.alert.category_t.storage_notification) handle = libtorrent.add_magnet_uri( session, magnet, {'save_path': self.storageDirectory}) iterator = 0 progressBar = xbmcgui.DialogProgress() progressBar.create('Подождите', 'Идёт преобразование magnet-ссылки.') while not handle.has_metadata(): time.sleep(0.1) progressBar.update(iterator) iterator += 1 if iterator == 100: iterator = 0 if progressBar.iscanceled(): progressBar.update(0) progressBar.close() return progressBar.update(0) progressBar.close() torrent = libtorrent.create_torrent(handle.get_torrent_info()) torentFile = open(self.torrentFile, "wb") torentFile.write(libtorrent.bencode(torrent.generate())) torentFile.close() session.remove_torrent(handle)
def fetch_torrent(session, ih, timeout): name = ih.upper() url = 'magnet:?xt=urn:btih:%s' % (name, ) data = '' params = { 'save_path': '/tmp/downloads/', 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': False, 'duplicate_is_error': True } try: handle = lt.add_magnet_uri(session, url, params) except: return None status = session.status() #print 'downloading metadata:', url handle.set_sequential_download(1) meta = None down_time = time.time() down_path = None for i in xrange(0, timeout): if handle.has_metadata(): info = handle.get_torrent_info() down_path = '/tmp/downloads/%s' % info.name() #print 'status', 'p', status.num_peers, 'g', status.dht_global_nodes, 'ts', status.dht_torrents, 'u', status.total_upload, 'd', status.total_download meta = info.metadata() break time.sleep(1) if down_path and os.path.exists(down_path): os.system('rm -rf "%s"' % down_path) session.remove_torrent(handle) return meta
def exp1(): ses = lt.session() ses.listen_on(6881, 6891) down_dir = '//home//qqq//download' if os.path.exists(down_dir): shutil.rmtree(down_dir) os.makedirs(down_dir) params = { 'save_path': '//home//www//download', 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } link = "magnet:?xt=urn:btih:6e5bbd0399a401c1316760ed13bcc76712467d5a&dn=%E7%97%85%E6%AF%92%E5%85%A5%E4%BE%B5.Pandemic.2016.720p.WEB-DL.DD5.1.H264.Chs%2BEng-homefei" handle = lt.add_magnet_uri(ses, link, params) ses.start_dht() print 'downloading metadata...' while (not handle.has_metadata()): print 'sleep 3 secs...' time.sleep(3) print 'got metadata, starting torrent download...' while (handle.status().state != lt.torrent_status.seeding): s = handle.status() state_str = ['queued', 'checking', 'downloading metadata', \ 'downloading', 'finished', 'seeding', 'allocating'] print '%.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d) %s %.3' % \ (s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000, \ s.num_peers, state_str[s.state], s.total_download / 1000000) time.sleep(5)
def downloadtorrent(""): try: params = { 'save_path' : savePath, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } #Inicia o Download ses = lt.session() ses.listen_on(6881, 6891) handle = lt.add_magnet_uri(ses, link, params) ses.start_dht() while (not handle.has_metadata()): time.sleep(1) while (handle.status().state != lt.torrent_status.seeding): s = handle.status() time.sleep(5) except: pass
def construct_handler(ses, torrent, destination): """ helper for handling magnet link, http links and torrent files""" tinfo = None params = { 'save_path': destination, 'storage_mode': lt.storage_mode_t(2), 'auto_managed': True, } # if case if ULR was provided download it to file # TODO: add nice REGXP URL validator, the 'http' can be a folder name if torrent.startswith('http'): torrent_body = requests.get(torrent) torrent = os.path.join(location_context, 'torrent_file') tmp_torrent = torrent+'.tmp' with open(tmp_torrent, 'wb') as dist: dist.write(torrent_body.text.encode('utf-8')) os.rename(tmp_torrent, torrent) # check if file contain magnet link # XXX: shitty magnet support from file torrent_data = open(torrent).read().strip(" \n\t") if torrent_data.startswith("magnet:"): torrent_handler = lt.add_magnet_uri(ses, torrent_data, params) else: tinfo = lt.torrent_info(torrent) params['ti'] = tinfo torrent_handler = ses.add_torrent(params) # waiting for metadata to be downloaded while (not torrent_handler.has_metadata()): time.sleep(0.1) return torrent_handler
def magnet_to_torrent(self, magnet_uri, destination_folder, timeout): import libtorrent params = libtorrent.parse_magnet_uri(magnet_uri) session = libtorrent.session() # for some reason the info_hash needs to be bytes but it's a struct called sha1_hash params['info_hash'] = bytes(params['info_hash']) handle = libtorrent.add_magnet_uri(session, magnet_uri, params) log.debug('Acquiring torrent metadata for magnet %s', magnet_uri) timeout_value = timeout while not handle.has_metadata(): time.sleep(0.1) timeout_value -= 0.1 if timeout_value <= 0: raise plugin.PluginError( 'Timed out after {} seconds trying to magnetize'.format( timeout)) log.debug('Metadata acquired') torrent_info = handle.get_torrent_info() torrent_file = libtorrent.create_torrent(torrent_info) torrent_path = pathscrub( os.path.join(destination_folder, torrent_info.name() + ".torrent")) with open(torrent_path, "wb") as f: f.write(libtorrent.bencode(torrent_file.generate())) log.debug('Torrent file wrote to %s', torrent_path) return torrent_path
def get_torrent_info_magnet(v1, v3, u, p_bar, tmp_dir): global handle, ses, info, cnt, cnt_limit, file_name, ui, progress, tmp_dir_folder ui = u progress = p_bar tmp_dir_folder = tmp_dir progress.setValue(0) progress.show() sett = lt.session_settings() sett.user_agent = 'qBittorrent v3.3.5' sett.always_send_user_agent = True fingerprint = lt.fingerprint('qB', 3, 3, 5, 0) ses = lt.session(fingerprint) ses.listen_on(40000, 50000) ses.set_settings(sett) handle = lt.add_magnet_uri(ses, v1, {'save_path': v3}) i = 0 while (not handle.has_metadata()): time.sleep(1) i = i + 1 print('finding metadata {0}'.format(i)) if i > 300: print('No Metadata Available: {0}s'.format(i)) break info = handle.get_torrent_info() handle.set_sequential_download(True) print(handle.trackers()) return handle, ses, info
def get_torrent_info_magnet(v1,v3,u,p_bar,tmp_dir): global handle,ses,info,cnt,cnt_limit,file_name,ui,progress,tmp_dir_folder ui = u progress = p_bar tmp_dir_folder = tmp_dir progress.setValue(0) progress.show() #print(v1,'------------hello----------info---') sett = lt.session_settings() sett.user_agent = 'qBittorrent v3.3.5' sett.always_send_user_agent = True fingerprint = lt.fingerprint('qB',3,3,5,0) ses = lt.session(fingerprint) ses.listen_on(40000, 50000) ses.set_settings(sett) handle = lt.add_magnet_uri(ses,v1,{'save_path':v3}) i = 0 while (not handle.has_metadata()): time.sleep(1) i = i+1 print('finding metadata') if i > 300: print('No Metadata Available') break info = handle.get_torrent_info() handle.set_sequential_download(True) print(handle.trackers()) return handle,ses,info
def mag2tor(mag_link): sess = libtorrent.session() prms = { 'save_path':os.path.abspath(os.path.curdir), # 'storage_mode':libtorrent.storage_mode_t(2), 'paused':False, 'auto_managed':False, 'upload_mode':True, } torr = libtorrent.add_magnet_uri(sess, mag_link, prms) dots = 0 # sys.stdout.write('%s: ' % mag_link) while not torr.has_metadata(): dots += 1 sys.stdout.write('.') sys.stdout.flush() time.sleep(1) if (dots): sys.stdout.write('\n') sess.pause() tinf = torr.get_torrent_info() f = open(tinf.name() + '.torrent', 'wb') f.write(libtorrent.bencode( libtorrent.create_torrent(tinf).generate())) f.close() sess.remove_torrent(torr)
def fetch_torrent(session, ih, timeout): name = ih.upper() url = 'magnet:?xt=urn:btih:%s' % (name,) data = '' params = { 'save_path': '/tmp/downloads/', 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': False, 'duplicate_is_error': True} try: handle = lt.add_magnet_uri(session, url, params) except: return None status = session.status() #print 'downloading metadata:', url handle.set_sequential_download(1) meta = None down_time = time.time() down_path = None for i in xrange(0, timeout): if handle.has_metadata(): info = handle.get_torrent_info() down_path = '/tmp/downloads/%s' % info.name() #print 'status', 'p', status.num_peers, 'g', status.dht_global_nodes, 'ts', status.dht_torrents, 'u', status.total_upload, 'd', status.total_download meta = info.metadata() break time.sleep(1) if down_path and os.path.exists(down_path): os.system('rm -rf "%s"' % down_path) session.remove_torrent(handle) return meta
def torrentInfo(self, donotload=False): if not self.session: raise Exception("Need session first") # URL: # http://piratebaytorrents.info/5579280/Big_Buck_Bunny_(1080p).ogv.5579280.TPB.torrent if not donotload and len(self.location)>4 and self.location[0:4] == 'http': # Create tmp torrent file in the tmp dir dest = self.tmpdir + '/' + hashlib.md5(self.location).hexdigest() + '.torrent' urllib.urlretrieve(self.location, dest) # Set the location to this file self.location = dest # Magnet: # magnet:?xt=urn:btih:e541adf64e5d10c0827579447948aefba651e4f4&dn=Big+Buck+Bunny+%281080p%29.ogv&tr=udp%3A%2F%2Ftracker.openbittorrent.com%3A80&tr=udp%3A%2F%2Ftracker.publicbt.com%3A80&tr=udp%3A%2F%2Ftracker.istole.it%3A6969&tr=udp%3A%2F%2Ftracker.ccc.de%3A80&tr=udp%3A%2F%2Fopen.demonii.com%3A1337 if len(self.location)>6 and self.location[0:6] == 'magnet': if donotload and not self.torrent_handle: print >> sys.stderr, "NOT Loading" return None if not self.torrent_handle or not hasattr(self,"magnet"): self.magnet = lt.add_magnet_uri(self.session, self.location, self.torrent_params) print >> sys.stderr, 'Downloading metadata...' while (not self.magnet.has_metadata()): time.sleep(1) self.torrent_handle = self.magnet # Return info return self.magnet.get_torrent_info() elif self.location: try: return lt.torrent_info(self.location) except: pass return None
def magnet2torrent(link, torrent_file): sess = lt.session() sess.add_dht_router('router.bittorrent.com', 6881) sess.add_dht_router('router.utorrent.com', 6881) sess.add_dht_router('router.bitcomet.com', 6881) sess.add_dht_router('dht.transmissionbt.com', 6881) sess.start_dht() params = { "save_path": 'D:\\Desktop', #"storage_mode":lt.storage_mode_t.storage_mode_sparse, #"paused": True, #"auto_managed": True, "duplicate_is_error": True } handle = lt.add_magnet_uri(sess, link, params) # waiting for metadata while (not handle.has_metadata()): time.sleep(5) # create a torrent torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) torcontent = lt.bencode(torfile.generate()) # save to file t = open(torrent_file, "wb") t.write(torcontent) t.close() return True
def convertManget(self, magnet): sess = lt.session() sess.listen_on(6881, 6891) prms = { 'save_path': '/', 'paused': False, 'auto_managed': False, 'upload_mode': True } torr = lt.add_magnet_uri(sess, magnet, prms) dots = 0 sess.start_dht() while not torr.has_metadata(): dots += 1 sys.stdout.write('.') sys.stdout.flush() time.sleep(1) if (dots): sys.stdout.write('\n') sess.pause() tinf = torr.get_torrent_info() fname = tinf.name() + '.torrent' f = open(fname, 'wb') f.write(lt.bencode(lt.create_torrent(tinf).generate())) f.close() sess.remove_torrent(torr) return fname
def download_iso(self): if not self.magnet_link: LOG.error("magnet_link for newtest Fuel ISO not found. Aborted") return None session = lt.session() session.listen_on(6881, 6891) params = { 'save_path': self.path, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True} handle = lt.add_magnet_uri(session, self.magnet_link, params) session.start_dht() while not handle.has_metadata(): time.sleep(1) filename = handle.get_torrent_info().files()[0].path LOG.debug('Got metadata, starting torrent download...') while handle.status().state != lt.torrent_status.seeding: status = handle.status() state_str = ['queued', 'checking', 'downloading metadata', 'downloading', 'finished', 'seeding', 'allocating'] LOG.info('{0:.2f}% complete (down: {1:.1f} kb/s up: {2:.1f} kB/s ' 'peers: {3:d}) {4:s} {5:d}.3' .format(status.progress * 100, status.download_rate / 1000, status.upload_rate / 1000, status.num_peers, state_str[status.state], status.total_download / 1000000)) time.sleep(5) LOG.info('Ready for deploy iso {0}'.format(filename)) return '/'.join([self.path, filename])
def magnetWorker(link, path): params = { 'save_path': path, 'paused': False, 'auto_managed': False, } handle = lt.add_magnet_uri(session, link, params)
def torrent(): ses = lt.session() ses.listen_on(6881, 6891) params = { 'save_path': SAVEPATH, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } link = "magnet:?xt=urn:btih:" + HASH + TRAKERS print(link) handle = lt.add_magnet_uri(ses, link, params) ses.start_dht() print('downloading metadata...') while (not handle.has_metadata()): time.sleep(1) print("#", end='') print('got metadata, starting torrent download...') while (handle.status().state != lt.torrent_status.seeding): s = handle.status() state_str = ['queued', 'checking', 'downloading metadata', \ 'downloading', 'finished', 'seeding', 'allocating'] # print '%.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d) %s %.3' % \ # (s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000, \ # s.num_peers, state_str[s.state], s.total_download/1000000) print(s.progress * 100, end="\r") time.sleep(5)
def downloadtorrent(link): try: params = { 'save_path' : savePath, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } #Inicia o Download ses = lt.session() ses.listen_on(6881, 6891) handle = lt.add_magnet_uri(ses, link, params) ses.start_dht() while (not handle.has_metadata()): time.sleep(1) while (handle.status().state != lt.torrent_status.seeding): s = handle.status() time.sleep(5) except: pass
def fetch_torrent(self, ih): if ih in downloading: return None downloading.add(ih) name = ih.upper() url = 'magnet:?xt=urn:btih:%s' % (name,) data = '' params = { 'save_path': '/tmp/downloads/', 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': False, 'duplicate_is_error': True} try: handle = lt.add_magnet_uri(self.ses, url, params) except: downloading.remove(ih) return None status = self.ses.status() #print 'downloading metadata:', url handle.set_sequential_download(1) down_time = time.time() for i in xrange(0, 60): if handle.has_metadata(): info = handle.get_torrent_info() print '\n', time.ctime(), (time.time()-down_time), 's, got', url, info.name() #print 'status', 'p', status.num_peers, 'g', status.dht_global_nodes, 'ts', status.dht_torrents, 'u', status.total_upload, 'd', status.total_download meta = info.metadata() self.ses.remove_torrent(handle) downloading.remove(ih) return meta time.sleep(1) downloading.remove(ih) self.ses.remove_torrent(handle) return None
def fetch_torrent(ses, info_hash): print "+" * 60 info_hash = info_hash.upper() url = "magnet:?xt=urn:btih:%s" % (info_hash,) print "url:", url params = { "save_path": "downloads", "storage_mode": lt.storage_mode_t(2), "paused": False, "auto_managed": False, "duplicate_is_error": True, } handle = lt.add_magnet_uri(ses, url, params) status = ses.status() handle.set_sequential_download(1) down_time = time.time() if handle.has_metadata(): info = handle.get_torrent_info() print "\n", time.ctime(), (time.time() - down_time), "s, got", url, info.name() print "status", "p", status.num_peers, "g", status.dht_global_nodes, "ts", status.dht_torrents, "u", status.total_upload, "d", status.total_download meta = info.metadata() print meta return meta else: print "no metadata" ses.remove_torrent(handle) print "+" * 60, "\n"
def get_subtitle(magnet, lang): print("Obtaining subtitle (experimental, might take a while)") lt_session = session() params = {"save_path": "/tmp"} handle = add_magnet_uri(lt_session, magnet, params) while (not handle.has_metadata()): sleep(.1) info = handle.get_torrent_info() files = info.files() biggest_file = ("", 0) for file_ in files: if file_.size > biggest_file[1]: biggest_file = [file_.path, file_.size] print("Guessing data") filepath = biggest_file[0] guess = guess_video_info(filepath, info=['filename']) video = Video.fromguess(filepath, guess) video.size = biggest_file[1] print("Donwloading Subtitle") subtitle = download_best_subtitles([video], {Language(lang)}, single=True) if not len(subtitle): subtitle = None else: subtitle = get_subtitle_path(video.name) lt_session.remove_torrent(handle) return subtitle
def get_peers_count_from_magnet(magnet): tempdir = tempfile.mkdtemp() session = lt.session() params = { 'save_path': tempdir, 'storage_mode': lt.storage_mode_t(2), 'auto_managed': True, 'file_priorities': [0] * 5 } handle = lt.add_magnet_uri(session, magnet, params) print("Downloading Metadata (this may take a while)") while not handle.has_metadata(): print("Waiting ... ") time.sleep(1) print("Metadata downloaded") peers = set() start = time.time() while not handle.is_seed() and time.time() - start < 5: p = handle.get_peer_info() for i in p: peers.add(i.ip) print(peers) session.remove_torrent(handle) shutil.rmtree(tempdir) return len(peers)
def fetch_torrent(self, ih): if ih in downloading: return None downloading.add(ih) name = ih.upper() url = 'magnet:?xt=urn:btih:%s' % (name,) data = '' params = { 'save_path': '/tmp/downloads/', 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': False, 'duplicate_is_error': True} try: handle = lt.add_magnet_uri(self.ses, url, params) except: downloading.remove(ih) return None status = self.ses.status() #print 'downloading metadata:', url handle.set_sequential_download(1) down_time = time.time() for i in xrange(0, 60): if handle.has_metadata(): info = handle.get_torrent_info() print '\n', time.ctime(), (time.time()-down_time), 's, got', url, info.name() meta = info.metadata() self.ses.remove_torrent(handle) downloading.remove(ih) return meta time.sleep(1) downloading.remove(ih) self.ses.remove_torrent(handle) return None
def main(): ses = lt.session() ses.listen_on(6881, 6891) params = { 'save_path': '/tmp', 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } link = "magnet:?xt=urn:btih:37e77490bc4f285dbfa837514715a20bd405a502&dn=Spider-Man+Far+from+Home+%282019%29+%5BWEBRip%5D+%5B1080p%5D+English&tr=udp%3A%2F%2Ftracker.leechers-paradise.org%3A6969&tr=udp%3A%2F%2Fzer0day.ch%3A1337&tr=udp%3A%2F%2Fopen.demonii.com%3A1337&tr=udp%3A%2F%2Ftracker.coppersurfer.tk%3A6969&tr=udp%3A%2F%2Fexodus.desync.com%3A6969" handle = lt.add_magnet_uri(ses, link, params) ses.start_dht() print('downloading metadata...') while (not handle.has_metadata()): time.sleep(1) print('got metadata, starting torrent download...') timeout = time.time() + cfg.p2pdownload_timer # 10 secs from now while (handle.status().state != lt.torrent_status.seeding): s = handle.status() state_str = [ 'queued', 'checking', 'downloading metadata', 'downloading', 'finished', 'seeding', 'allocating' ] print('%.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d) %s' % (s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000, s.num_peers, state_str[s.state])) if time.time() > timeout: break time.sleep(2)
def magnet2t(link, tfile): sess = lt.session() params = { "save_path": './tfile/', "storage_mode": lt.storage_mode_t.storage_mode_sparse, "paused": True, "auto_managed": True, "duplicate_is_error": True } handle = lt.add_magnet_uri(sess, link, params) state_str = [ 'queued', 'checking', 'downloading metadata', 'downloading', 'finished', 'seeding', 'allocating' ] while (not handle.has_metadata()): s = handle.status() print '%.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d) %s' % ( s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000, s.num_peers, state_str[s.state]) time.sleep(5) print handle.has_metadata() torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) t = open(tfile, "wb") t.write(lt.bencode(torfile.generate())) t.close() print '%s generated!' % tfile
def magnetToTorrent(self, magnet): session = libtorrent.session() session.start_dht() session.add_dht_router("router.bittorrent.com", 6881) session.add_dht_router("router.utorrent.com", 6881) session.add_dht_router("router.bitcomet.com", 6881) session.listen_on(6881, 6891) session.set_alert_mask(libtorrent.alert.category_t.storage_notification) handle = libtorrent.add_magnet_uri(session, magnet, {'save_path': self.storageDirectory}) iterator = 0 progressBar = xbmcgui.DialogProgress() progressBar.create('Подождите', 'Идёт преобразование magnet-ссылки.') while not handle.has_metadata(): time.sleep(0.1) progressBar.update(iterator) iterator += 1 if iterator == 100: iterator = 0 if progressBar.iscanceled(): progressBar.update(0) progressBar.close() return progressBar.update(0) progressBar.close() torrent = libtorrent.create_torrent(handle.get_torrent_info()) torentFile = open(self.torrentFile, "wb") torentFile.write(libtorrent.bencode(torrent.generate())) torentFile.close() session.remove_torrent(handle)
def download_torrent(torrent, directory): session = libtorrent.session() session.listen_on(6881, 6891) params = { "save_path": directory, "storage_mode": libtorrent.storage_mode_t(2), "paused": False, "auto_managed": True, "duplicate_is_error": True } magnet = torrent.magnet handle = libtorrent.add_magnet_uri(session, magnet, params) session.start_dht() print("Downloading metadata...") while (not handle.has_metadata()): time.sleep(1) print("Starting torrent download...") while (handle.status().state != libtorrent.torrent_status.seeding): s = handle.status() state_str = ['queued', 'checking', 'downloading metadata', \ 'downloading', 'finished', 'seeding', 'allocating'] print("%.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d) %s" % \ (s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000, \ s.num_peers, state_str[s.state])) time.sleep(5) print("Torrent downloaded")
def fetch_torrent(session, ih, timeout): name = ih.upper() url = 'magnet:?xt=urn:btih:%s' % (name, ) params = { 'save_path': '/tmp/downloads/', 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': False, 'duplicate_is_error': True } try: handle = lt.add_magnet_uri(session, url, params) except Exception: return None handle.set_sequential_download(1) meta = None down_path = None for i in range(0, timeout): if handle.has_metadata(): info = handle.get_torrent_info() down_path = '/tmp/downloads/%s' % info.name() meta = info.metadata() break time.sleep(1) if down_path and os.path.exists(down_path): os.system('rm -rf "%s"' % down_path) session.remove_torrent(handle) return meta
async def get_torrent_handle(log, torrent): th = None wait_metatada_timeout = 60 if isinstance(torrent, str): if torrent.startswith('magnet'): log.info('Downloading metadata...') th = lt.add_magnet_uri(session, torrent, {'save_path': './'}) time_elasped = 0 while (not th.has_metadata()): await asyncio.sleep(3) time_elasped += 3 log.debug('Wait metadata, time elapsed = {}s'.format( str(time_elasped))) if time_elasped >= wait_metatada_timeout: session.remove_torrent(th) log.info('Magnet link resolve timeout') raise NoMetadataError log.info('Got metadata, starting torrent download...') else: raise Exception('String not a magnet link') elif isinstance(torrent, bytes): bd = lt.bdecode(torrent) info = lt.torrent_info(bd) th = session.add_torrent({'ti': info, 'save_path': '.'}) else: log.error('Torrent handler creating failed, not valid torrent: ', torrent) raise Exception("Not valid torrent") th.calc_prioritized_piece_count() th.prepare_pieces_priority() return th
def start_download(save_path, magnet_link): ses = lt.session() ses.listen_on(6881, 6891) params = { 'save_path': save_path, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } link = magnet_link handle = lt.add_magnet_uri(ses, link, params) ses.start_dht() print('downloading metadata...') while (not handle.has_metadata()): time.sleep(1) print('got metadata, starting torrent download...') while (handle.status().state != lt.torrent_status.seeding): s = handle.status() state_str = ['queued', 'checking', 'downloading metadata', \ 'downloading', 'finished', 'seeding', 'allocating'] print('%.2f%% complete (down: %.1f kb/s up: %.1f kB/s peers: %d) %s' % \ (s.progress * 100, s.download_rate / 1000, s.upload_rate / 1000, \ s.num_peers, state_str[s.state])) time.sleep(5)
def add_from_ml(self, link): params = { 'save_path': 'queue/', 'storage_mode': lt.storage_mode_t(1) } handle = lt.add_magnet_uri(self.ses, link, params) self.prepare_handle(handle) return handle