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 generateTorrentOfdownloadedFiles(downloadedFolder): print("generateTorrentOfdownloaded Files for sharing...") # http://www.libtorrent.org/reference-Create_Torrents.html # downloadedFolder = utils.getHomeFolder()+"/"+config.DOWNLOAD_FOLDER from os import listdir for file in listdir (downloadedFolder): print (file) fs = lt.file_storage() # file_storage fs; # // recursively adds files in directories # add_files(fs, "./my_torrent"); lt.add_files(fs, downloadedFolder) t = lt.create_torrent() # ?¿?¿?¿?¿?¿?¿?¿?¿¿?¿¿? # create_torrent t(fs); lt.create_torrent(t, fs) t.add_tracker("http://my.tracker.com/announce"); t.set_creator("Ultraviolet test"); # // reads the files and calculates the hashes # set_piece_hashes(t, "."); lt.set_piece_hashes(t,".") # ofstream out("my_torrent.torrent", std::ios_base::binary); # bencode(std::ostream_iterator<char>(out), t.generate()); fileContent = t.generate() # byteContent= bytearray(fileContent) # newFile = open (utils.getHomeFolder()+"torrents/newTorrnet.torrent", "wb") # newFile.write(byteContent) writeBinaryFile(utils.getHomeFolder()+"torrents/newTorrnet.torrent", fileContent)
def finalize(self, path, uid): #print 'finalize', path, uid try: fs = lt.file_storage() tmp_fn = os.path.join(self.tmp, uid) try: st_size = os.stat(tmp_fn).st_size except: traceback.print_exc() return #print tmp_fn, st_size lt.add_files(fs, tmp_fn, st_size) t = lt.create_torrent(fs) t.set_creator("DelugeFS"); lt.set_piece_hashes(t, self.tmp) tdata = t.generate() #print tdata with open(self.hgdb+path, 'wb') as f: f.write(lt.bencode(tdata)) #print 'wrote', self.hgdb+path dat_dir = os.path.join(self.dat, uid[:2]) if not os.path.isdir(dat_dir): try: os.mkdir(dat_dir) except: pass os.rename(tmp_fn, os.path.join(dat_dir, uid)) #if os.path.exists(self.shadow+path): os.remove(self.shadow+path) #os.symlink(os.path.join(dat_dir, uid), self.shadow+path) #print 'committing', self.hgdb+path self.repo.hg_commit('wrote %s' % path, files=[self.hgdb+path]) self.should_push = True self.__add_torrent(tdata, path) except Exception as e: traceback.print_exc() raise e
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 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 file_complete(self, torrent): info_hash=str(torrent.info_hash()) nt=lt.create_torrent(torrent) tname=self._tname(info_hash) f = open(tname, 'wb') f.write(lt.bencode(nt.generate())) f.close()
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 _save_torrent_info(self, torr_handle): """ Save torrent metatata and a .torrent file for resume. @param torr_handle: object - torrent handle @return: """ if self._persistent: info_hash = str(torr_handle.info_hash()) torr_filepath = os.path.join(self._resume_dir, info_hash + '.torrent') meta_filepath = os.path.join(self._resume_dir, info_hash + '.resume') torr_info = torr_handle.get_torrent_info() torr_file = libtorrent.create_torrent(torr_info) torr_content = torr_file.generate() torr_bencoded = libtorrent.bencode(torr_content) with open(torr_filepath, 'wb') as t_file: t_file.write(torr_bencoded) metadata = {'name': torr_handle.name(), 'info_hash': info_hash, 'save_path': torr_handle.save_path(), 'resume_data': None} with open(meta_filepath, mode='wb') as m_file: pickle.dump(metadata, m_file) else: raise TorrenterError('Trying to save torrent metadata for a non-persistent instance!')
def create_torrent(path,filename=""): fs = lt.file_storage() if filename=="": listz = list_folder(top) for tuplez in listz: path=tuplez[0] filename=tuplez[1] fs.add_file(pathz , size) else: pathz = os.path.join(path,filename) print "pathz", pathz size = os.path.getsize(pathz) fs.add_file(filename, size) #fs.add_file(pathz , size) tor = lt.create_torrent(fs) lt.set_piece_hashes(tor,'.') tor.set_comment("COMEONES") tor.set_creator("PEONDUSUD") announce_url = "http://www.gks.gs/tracker" tor.add_tracker(announce_url) tor.set_priv(True) tor.add_url_seed("http://192.168.70.136:58888") print dir(tor) f = open(save_torrent_folder + filename + ".torrent", "wb") f.write(lt.bencode(tor.generate())) f.close() print "torrent raw :" print lt.bencode(tor.generate())
def fetch_magnet(magnet_uri): tempdir = tempfile.mkdtemp() logger.debug("Fetching magnet to '%s'" % tempdir) params = { "save_path" : tempdir, "duplicate_is_error" : True, "paused" : False, "auto_managed" : True, "url" : magnet_uri, "storage_mode" : lt.storage_mode_t(2) } handle = ses.add_torrent(params) def cleanup(): ses.remove_torrent(handle) shutil.rmtree(tempdir) while not handle.has_metadata(): try : time.sleep(1) except NameError as e: logger.debug("Exception!! %s" % str(e)) cleanup() return logger.debug("Magnet %s fetched!" % magnet_uri) torrent_data = lt.create_torrent(handle.get_torrent_info()).generate() add_from_torrent_info(handle.get_torrent_info(), lt.bencode(torrent_data)) cleanup()
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 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 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 createTorrent(torrent_file_path, content_folder_path, progress_cb = None): print("createTorrent") fs = libtorrent.file_storage() if not os.path.isabs(torrent_file_path): raise "Torrent path not absolute" if not os.path.isabs(content_folder_path): raise "Content path not absolute" libtorrent.add_files(fs, content_folder_path) if fs.num_files() == 0: print("No files to add.") return t = libtorrent.create_torrent(fs, piece_size=0, pad_file_limit=(4 * 1024 * 1024)) def progress(piece_num): if progress_cb: pc = int((100.0 * (1.0+ piece_num)) / fs.num_pieces()) progress_cb(pc) parent = os.path.dirname(content_folder_path) libtorrent.set_piece_hashes(t, parent, progress) data = libtorrent.bencode(t.generate()) file = open(torrent_file_path,'wb') file.write(data) file.close()
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 _create_torrent(self, resource, fs, root='.', use_sudo=False): t = lt.create_torrent(fs) transports = resource.transports() torrent_transport = next( (x for x in transports if x['name'] == 'torrent')) trackers = torrent_transport['trackers'] for tracker in trackers: t.add_tracker(tracker) lt.set_piece_hashes(t, os.path.join(root, '..')) torrent = t.generate() torrent['priv'] = True # private torrent, no DHT, only trackers name = self._create_torrent_name() try: # not checking for path existence with open(name, 'wb') as f: f.write(lt.bencode(torrent)) except IOError as e: if e.errno != errno.ENOENT: raise os.makedirs(self._torrent_path) with open(name, 'wb') as f: f.write(lt.bencode(torrent)) log.debug("Created torrent file %s", name) magnet_uri = lt.make_magnet_uri(lt.torrent_info(name)) # self._torrents[root] = (name, magnet_uri) if not use_sudo: self._torrents.append((name, magnet_uri, root)) else: self._sudo_torrents.append((name, magnet_uri, root)) return name
def render_GET(self, request): """ .. http:get:: /download/(string: infohash)/torrent A GET request to this endpoint returns the .torrent file associated with the specified download. **Example request**: .. sourcecode:: none curl -X GET http://localhost:8085/downloads/4344503b7e797ebf31582327a5baae35b11bda01/torrent **Example response**: The contents of the .torrent file. """ download = self.session.get_download(self.infohash) if not download: return DownloadSpecificEndpoint.return_404(request) if not download.handle or not download.handle.is_valid() or not download.handle.has_metadata(): return DownloadSpecificEndpoint.return_404(request) torrent_info = get_info_from_handle(download.handle) t = create_torrent(torrent_info) torrent = t.generate() bencoded_torrent = bencode(torrent) request.setHeader(b'content-type', 'application/x-bittorrent') request.setHeader(b'Content-Disposition', 'attachment; filename=%s.torrent' % hexlify(self.infohash)) return bencoded_torrent
def make_torrent(self, tracker_url, torrent_name, dir_name): mkdir_p('torrent_files') fs = lt.file_storage() lt.add_files(fs, dir_name) t = lt.create_torrent(fs) t.add_tracker(tracker_url) lt.set_piece_hashes(t, './torrent_data') f = open(torrent_name, "wb") f.write(lt.bencode(t.generate())) f.close() e = lt.bdecode(open(torrent_name, 'rb').read()) info = lt.torrent_info(e) params = { 'save_path': './torrent_data', 'ti': info, 'seed_mode': True } h = self.ses.add_torrent(params) # Wait a bit for the tracker sleep(5)
def run(self): """run the converter. using the class attribute initiated at init function. Returns: Filename of created torrent. Raises: KeyboardInterrupt: This error caused by user to stop this. When downloading metadata from magnet link, it requires an additional step before the error reraised again. """ print("Downloading Metadata (this may take a while)") # used to control "Maybe..." and "or the" msgs after sleep(1) wait_time = 1 soft_limit = 120 while not self.handle.has_metadata(): try: sleep(1) if wait_time > soft_limit: print("Downloading is taking a while, maybe there is an " "issue with the magnet link or your network connection") soft_limit += 30 wait_time += 1 except KeyboardInterrupt: print("\nAborting...") self.ses.pause() print("Cleanup dir " + self.tempdir) shutil.rmtree(self.tempdir) raise self.ses.pause() print("Done") torinfo = self.handle.get_torrent_info() torfile = lt.create_torrent(torinfo) output = pt.abspath(torinfo.name() + ".torrent") if self.output_name: if pt.isdir(self.output_name): output = pt.abspath(pt.join(self.output_name, torinfo.name() + ".torrent")) elif pt.isdir(pt.dirname(pt.abspath(self.output_name))): output = pt.abspath(self.output_name) else: output = pt.abspath(torinfo.name() + ".torrent") print("Saving torrent file here : " + output + " ...") with open(output, "wb") as outfile: torcontent = lt.bencode(torfile.generate()) outfile.write(torcontent) print("Saved! Cleaning up dir: " + self.tempdir) self.ses.remove_torrent(self.handle) shutil.rmtree(self.tempdir) return output
def file_complete(self, torrent, url=None): info_hash=str(torrent.info_hash()) nt=lt.create_torrent(torrent) tname=self._tname(info_hash) with open(tname, 'wb') as f: f.write(lt.bencode(nt.generate())) if url: self.save(url,info_hash)
def test_from_torrent_info(self): ti = lt.torrent_info('unordered.torrent') ct = lt.create_torrent(ti) entry = ct.generate() content = lt.bencode(entry).strip() with open('unordered.torrent', 'r') as f: file_content = f.read().strip() self.assertEqual(content, file_content)
def GenerateTorrent(): fs = lt.file_storage() lt.add_files(fs, PackagesDirectory) t = lt.create_torrent(fs, flags = 1&8&16) # 16 does nothing right now #t = lt.create_torrent(fs) t.add_tracker("http://tpm.blogwithme.net:81/tracker") lt.set_piece_hashes(t,MasterDirectory)# ## Not working return t.generate()
def magnet2torrent(magnet, output_name = None): if output_name and \ not pt.isdir(output_name) and \ not pt.isdir(pt.dirname(pt.abspath(output_name))): print "Invalid output folder: " + pt.dirname(pt.abspath(output_name)) print "" return tempdir = tempfile.mkdtemp() ses = lt.session() params = { 'save_path': tempdir, 'duplicate_is_error': True, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } handle = lt.add_magnet_uri(ses, magnet, params) print "Downloading Metadata (this may take a while)" while (not handle.has_metadata()): try: time.sleep(1) except KeyboardInterrupt: print "Abrorting..." ses.pause() print "Cleanup dir " + tempdir shutil.rmtree(tempdir) return print "done" torinfo = handle.get_torrent_info() output = pt.abspath(torinfo.name() + ".torrent" ) if output_name: if pt.isdir(output_name): output = pt.abspath(pt.join(output_name, torinfo.name() + ".torrent")) elif pt.isdir(pt.dirname(pt.abspath(output_name))) == True: output = pt.abspath(output_name) print 'saving torrent file here : ' + output + " ..." fs = lt.file_storage() for file in torinfo.files(): fs.add_file(file) torfile = lt.create_torrent(fs) torfile.set_comment(torinfo.comment()) torfile.set_creator(torinfo.creator()) torcontent = lt.bencode(torfile.generate()) f = open(output, "wb") f.write(lt.bencode(torfile.generate())) f.close() print 'Saved! Cleaning up dir: ' + tempdir shutil.rmtree(tempdir) return output
def create_torrent(self): # TODO check if root tarball_uid = self.get('tarball') if not tarball_uid: self.log.error("No tarball in DB.") return False cluster = Cluster(mongo_db=self._mongo_db) tarball = cluster.get('path') + "/torrents/" + tarball_uid + ".tgz" if not os.path.exists(tarball): self.log.error("Wrong path in DB.") return False tracker_address = cluster.get('frontend_address') if tracker_address == '': self.log.error("Tracker address needs to be configured.") return False tracker_port = cluster.get('frontend_port') if tracker_port == 0: self.log.error("Tracker port needs to be configured.") return False user = cluster.get('user') user_id = pwd.getpwnam(user).pw_uid grp_id = pwd.getpwnam(user).pw_gid old_cwd = os.getcwd() os.chdir(os.path.dirname(tarball)) uid = str(uuid.uuid4()) torrentfile = cluster.get('path') + "/torrents/" + uid + ".torrent" fs = libtorrent.file_storage() libtorrent.add_files(fs, os.path.basename(tarball)) t = libtorrent.create_torrent(fs) if cluster.get('frontend_https'): proto = 'https' else: proto = 'http' t.add_tracker((proto + "://" + str(tracker_address) + ":" + str(tracker_port) + "/announce")) t.set_creator(torrent_key) t.set_comment(uid) libtorrent.set_piece_hashes(t, ".") f = open(torrentfile, 'w') f.write(libtorrent.bencode(t.generate())) f.close() os.chown(torrentfile, user_id, grp_id) self.set('torrent', str(uid)) os.chdir(old_cwd) return True
def make_torrent(path): abs_path = os.path.abspath(path) fs = libtorrent.file_storage() libtorrent.add_files(fs, abs_path) ct = libtorrent.create_torrent(fs) ct.add_tracker("http://127.0.0.1/announce") # set True if private torrent. ct.set_priv(True) libtorrent.set_piece_hashes(ct, os.path.split(abs_path)[0]) return ct.generate()
def magnet2torrent(magnet, output_name=None): if output_name and \ not pt.isdir(output_name) and \ not pt.isdir(pt.dirname(pt.abspath(output_name))): print("Invalid output folder: " + pt.dirname(pt.abspath(output_name))) print("") sys.exit(0) tempdir = tempfile.mkdtemp() ses = lt.session() params = { 'save_path': tempdir, 'duplicate_is_error': True, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': 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() print("Done") torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) output = pt.abspath(torinfo.name() + ".torrent") if output_name: if pt.isdir(output_name): output = pt.abspath(pt.join( output_name, torinfo.name() + ".torrent")) elif pt.isdir(pt.dirname(pt.abspath(output_name))): output = pt.abspath(output_name) print("Saving torrent file here : " + output + " ...") torcontent = lt.bencode(torfile.generate()) f = open(output, "wb") f.write(lt.bencode(torfile.generate())) f.close() print("Saved! Cleaning up dir: " + tempdir) ses.remove_torrent(handle) shutil.rmtree(tempdir) return output
def create(target): url = "http://{0}:6969/announce".format(socket.gethostname()) creator = "Ports Management Team <*****@*****.**>" fs = libtorrent.file_storage() libtorrent.add_files(fs, target) torrent = libtorrent.create_torrent(fs) torrent.add_tracker(url, 0) torrent.set_creator(creator) libtorrent.set_piece_hashes(torrent, os.path.dirname(target)) data = libtorrent.bencode(torrent.generate()) return Torrent(target, data=data)
def save_metadata(self, info_hash, torinfo): torfile = lt.create_torrent(torinfo) dirname = self._metadata_dir + '/' + '%s_%s' % (time.strftime('%Y%m%d'), "meta") if os.path.isdir(dirname) is False: os.mkdir(dirname) filename = dirname + '/' + str(info_hash) + '.torrent' with open(filename,'wb') as f: f.write(lt.bencode(torfile.generate())) print "save metadata " , filename
def test_from_torrent_info(self): ti = lt.torrent_info("unordered.torrent") ct = lt.create_torrent(ti) entry = ct.generate() content = lt.bencode(entry).strip() with open("unordered.torrent", "rb") as f: file_content = bytearray(f.read().strip()) print(content) print(file_content) print(entry) self.assertEqual(content, file_content)
def file_complete(self, torrent, url=None): info_hash=str(torrent.info_hash()) nt=lt.create_torrent(torrent).generate() #this is a fix for issue https://github.com/arvidn/libtorrent/issues/945 #however proper fix is to migrate to latest 1.1 if not nt['info']: nt['info'] = lt.bdecode(torrent.metadata()) tname=self._tname(info_hash) with open(tname, 'wb') as f: f.write(lt.bencode(nt)) if url: self.save(url,info_hash)
def magnet_to_torrent(magnet_uri, book_uid, dst): ses = lt.session() params = { 'save_path': dst, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } link = magnet_uri handle = lt.add_magnet_uri(ses, link, params) print('downloading metadata...') while not handle.has_metadata(): s = handle.status() time.sleep(1) torinfo = handle.get_torrent_info() torrent_file = lt.create_torrent(torinfo) torrent_path = os.path.join(dst, "{0}.torrent".format(book_uid)) with open(torrent_path, "wb") as f: f.write(lt.bencode(torrent_file.generate())) print("Torrent saved to %s" % torrent_path) return torrent_path
def createTorrent(torrent_file_path, content_folder_path, progress_cb=None): print("createTorrent") fs = libtorrent.file_storage() if not os.path.isabs(torrent_file_path): raise "Torrent path not absolute" if not os.path.isabs(content_folder_path): raise "Content path not absolute" libtorrent.add_files(fs, content_folder_path) if fs.num_files() == 0: print("No files to add.") return t = libtorrent.create_torrent(fs, piece_size=0, pad_file_limit=(4 * 1024 * 1024)) def progress(piece_num): if progress_cb: pc = int((100.0 * (1.0 + piece_num)) / fs.num_pieces()) progress_cb(pc) parent = os.path.dirname(content_folder_path) libtorrent.set_piece_hashes(t, parent, progress) data = libtorrent.bencode(t.generate()) file = open(torrent_file_path, 'wb') file.write(data) file.close()
def magnet_to_torrent(self, magnet_uri, destination_folder, timeout): import libtorrent params = libtorrent.parse_magnet_uri(magnet_uri) session = libtorrent.session() lt_version = [int(v) for v in libtorrent.version.split('.')] if lt_version > [0,16,13,0]: # for some reason the info_hash needs to be bytes but it's a struct called sha1_hash params['info_hash'] = params['info_hash'].to_bytes() 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 magnet2torrent(magnet, output_name=None): if output_name and \ not pt.isdir(output_name) and \ not pt.isdir(pt.dirname(pt.abspath(output_name))): print("Invalid output folder: " + pt.dirname(pt.abspath(output_name))) print("") sys.exit(0) tempdir = tempfile.mkdtemp() ses = lt.session() # one could want to set this #ses.listen_on(6881, 6882) # add 'url'. for add_torrent() params = { 'url': magnet, 'save_path': tempdir, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } # add_magnet_uri is deprecated # http://www.rasterbar.com/products/libtorrent/manual.html#add-magnet-uri #handle = lt.add_magnet_uri(ses, magnet, params) handle = ses.add_torrent(params) print("Downloading Metadata (this may take a while)") # used to control "Maybe..." and "or the" msgs # after sleep(1) x = 1 limit = 120 while (not handle.has_metadata()): try: sleep(1) if x > limit: print("Maybe your firewall is blocking, ") print(" or the magnet link is not right...") limit += 30 x += 1 except KeyboardInterrupt: print("Aborting...") ses.pause() print("Cleanup dir " + tempdir) shutil.rmtree(tempdir) sys.exit(0) ses.pause() print("Done") torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) output = pt.abspath(torinfo.name() + ".torrent") if output_name: if pt.isdir(output_name): output = pt.abspath(pt.join( output_name, torinfo.name() + ".torrent")) elif pt.isdir(pt.dirname(pt.abspath(output_name))): output = pt.abspath(output_name) print("Saving torrent file here : " + output + " ...") torcontent = lt.bencode(torfile.generate()) f = open(output, "wb") f.write(lt.bencode(torfile.generate())) f.close() print("Saved! Cleaning up dir: " + tempdir) ses.remove_torrent(handle) shutil.rmtree(tempdir) return output
#ses.listen_on(6881, 6891) params = {'save_path': TorrentFilePath, 'duplicate_is_error': True} link = pyperclip.paste() # link = "magnet:?xt=urn:btih:91AF2B3F172B251E5106146D3DDDCB16C0C631D2&dn=%5B+FreeCourseWeb+%5D+The+Complete+2019+Web+Development+Bootcamp+%28Updated+2-2019%29&tr=udp%3A%2F%2Ftracker.coppersurfer.tk%3A6969%2Fannounce&tr=udp%3A%2F%2Ftracker.torrent.eu.org%3A451%2Fannounce&tr=udp%3A%2F%2Fthetracker.org%3A80%2Fannounce&tr=udp%3A%2F%2Fretracker.lanta-net.ru%3A2710%2Fannounce&tr=udp%3A%2F%2Fdenis.stalker.upeer.me%3A6969%2Fannounce&tr=udp%3A%2F%2Fexplodie.org%3A6969%2Fannounce&tr=udp%3A%2F%2Ftracker.filemail.com%3A6969%2Fannounce&tr=udp%3A%2F%2Ftracker.iamhansen.xyz%3A2000%2Fannounce&tr=udp%3A%2F%2Fretracker.netbynet.ru%3A2710%2Fannounce&tr=udp%3A%2F%2Ftracker.nyaa.uk%3A6969%2Fannounce&tr=udp%3A%2F%2Ftorrentclub.tech%3A6969%2Fannounce&tr=udp%3A%2F%2Ftracker.supertracker.net%3A1337%2Fannounce&tr=udp%3A%2F%2Fopen.demonii.si%3A1337%2Fannounce&tr=udp%3A%2F%2Ftracker.moeking.me%3A6969%2Fannounce&tr=udp%3A%2F%2Ftracker.zer0day.to%3A1337%2Fannounce&tr=udp%3A%2F%2Ftracker.leechers-paradise.org%3A6969%2Fannounce&tr=udp%3A%2F%2Fcoppersurfer.tk%3A6969%2Fannounce" handle = lt.add_magnet_uri(ses, link, params) # ses.start_dht() print 'saving torrent file here : ' + TorrentFilePath2 + " ..." while (not handle.has_metadata()): time.sleep(.1) torinfo = handle.get_torrent_info() fs = lt.file_storage() for file in torinfo.files(): fs.add_file(file) torfile = lt.create_torrent(fs) torfile.set_comment(torinfo.comment()) torfile.set_creator(torinfo.creator()) f = open(TorrentFilePath2 + "torrentfile.torrent", "wb") f.write(lt.bencode(torfile.generate())) f.close() print 'saved and closing...' #Uncomment to Download the Torrent: # print 'starting torrent download...' # while (handle.status().state != lt.torrent_status.seeding): # s = handle.status() # time.sleep(55) # print 'downloading...'
print("Downloading Metadata (this may take a while)") while (not handle.has_metadata()): try: print '.', time.sleep(.5) except KeyboardInterrupt: print("Aborting...") ses.pause() sys.exit(0) except Exception, E: traceback.print_exc() print("Done") torinfo = handle.get_torrent_info() torfile = lt.create_torrent(torinfo) print(torinfo.name() + ".torrent") s = handle.status() while (not s.is_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(1)
def create_torrent_file(file_path_list, params): fs = libtorrent.file_storage() # filter all non-files file_path_list_filtered = [] for path in file_path_list: if not os.path.exists(path): raise IOError('Path does not exist: %s' % path) elif os.path.isfile(path): file_path_list_filtered.append(path) # get the directory where these files are in. If there are multiple files, take the common directory they are in if len(file_path_list_filtered) == 1: base_path = os.path.split(file_path_list_filtered[0])[0] else: base_path = os.path.abspath(commonprefix(file_path_list_filtered)) # the base_dir directory is the parent directory of the base_path and is passed to the set_piece_hash method base_dir = os.path.split(base_path)[0] if len(file_path_list_filtered) == 1: filename = os.path.basename(file_path_list_filtered[0]) fs.add_file(filename, os.path.getsize(file_path_list_filtered[0])) else: for full_file_path in file_path_list_filtered: filename = os.path.join(base_path[len(base_dir) + 1:], full_file_path[len(base_dir):])[1:] fs.add_file(filename, os.path.getsize(full_file_path)) if params.get('piece length'): piece_size = params['piece length'] else: piece_size = 0 flags = libtorrent.create_torrent_flags_t.optimize # This flag doesn't exist anymore in libtorrent V1.1.0 if hasattr(libtorrent.create_torrent_flags_t, 'calculate_file_hashes'): flags |= libtorrent.create_torrent_flags_t.calculate_file_hashes torrent = libtorrent.create_torrent(fs, piece_size=piece_size, flags=flags) if params.get('comment'): torrent.set_comment(params['comment']) if params.get('created by'): torrent.set_creator(params['created by']) # main tracker if params.get('announce'): torrent.add_tracker(params['announce']) # tracker list if params.get('announce-list'): tier = 1 for tracker in params['announce-list']: torrent.add_tracker(tracker, tier=tier) tier += 1 # DHT nodes # http://www.bittorrent.org/beps/bep_0005.html if params.get('nodes'): for node in params['nodes']: torrent.add_node(*node) # HTTP seeding # http://www.bittorrent.org/beps/bep_0017.html if params.get('httpseeds'): torrent.add_http_seed(params['httpseeds']) # Web seeding # http://www.bittorrent.org/beps/bep_0019.html if len(file_path_list) == 1: if params.get('urllist', False): torrent.add_url_seed(params['urllist']) # read the files and calculate the hashes if len(file_path_list) == 1: libtorrent.set_piece_hashes(torrent, base_path) else: libtorrent.set_piece_hashes(torrent, base_dir) t1 = torrent.generate() torrent = libtorrent.bencode(t1) postfix = u'.torrent' if params.get('name'): if not isinstance(params['name'], unicode): params['name'] = unicode(params['name'], 'utf-8') torrent_file_name = os.path.join(base_path, params['name'] + postfix) else: torrent_file_name = os.path.join(base_path, unicode(t1['info']['name'], 'utf-8') + postfix) with open(torrent_file_name, 'wb') as f: f.write(torrent) return {'success': True, 'base_path': base_path, 'base_dir': base_dir, 'torrent_file_path': torrent_file_name}
]) and alert.info_hash not in seen: seen.add(alert.info_hash) torrent_params = get_params_for_info_hash(alert.info_hash) handles.add(session.add_torrent(torrent_params)) # TODO: https://www.libtorrent.org/reference-Core.html#post_torrent_updates() to_remove = set() for handle in handles: status = handle.status() if (status.has_metadata): metadata = status.torrent_file print('<ut_metadata> {} ({})'.format(metadata.name(), handle.info_hash()), flush=True) with open(metadata.name() + '.torrent', 'wb') as f: f.write(lt.bencode(lt.create_torrent(metadata).generate())) meta_info_count += 1 to_remove.add(handle) else: print('{} - {} peers ({} connected), prio {}, {} {:2}%'.format( status.info_hash, status.list_peers, status.num_peers, status.queue_position, state_str[status.state], status.progress * 100), flush=True) for handle in to_remove: session.remove_torrent(handle) handles -= to_remove time.sleep(10)
def file_complete(self, torrent): info_hash = str(torrent.info_hash()) nt = lt.create_torrent(torrent) tname = self._tname(info_hash) with open(tname, 'wb') as f: f.write(lt.bencode(nt.generate()))
def create_torrent(path, trackers=(), private=True, pieces=None, piece_size=None, source=None, predicate=None, progress=None, min_piece_exp=14, max_piece_exp=24): # type: (Path, Iterable[str], Optional[int], Optional[int], int, Optional[str], Optional[Callable], Optional[Callable], int, int) -> bytes """ min_piece_exp: default 16k max_piece_exp: default 16M """ if pieces is None and piece_size is None: pieces = 1000 elif pieces is None and piece_size is not None: if piece_size % 16384 != 0: raise ValueError("piece_size must be a multiple of 16384") elif pieces is not None and piece_size is None: pass else: raise ValueError("Cannot specify `pieces` and `piece_size`") fs = libtorrent.file_storage() path = path.resolve() if path.is_file(): fs.add_file(path.name, path.stat().st_size) elif path.is_dir(): predicate = predicate or (lambda path: True) libtorrent.add_files(fs, fspath(path), predicate) else: assert False, "Path neither file nor directory" if pieces: piece_size = 2**min( max(round(log2(fs.total_size() / pieces)), min_piece_exp), max_piece_exp) logger.info("piece_size", piece_size) t = libtorrent.create_torrent(fs, piece_size) for tracker in trackers: t.add_tracker(tracker) if private: t.set_priv(private) libtorrent.set_piece_hashes( t, fspath(path.parent), partial(progress, ceil(fs.total_size() / piece_size))) d = t.generate() if source: d[b"info"][b"source"] = source.encode("utf-8") return libtorrent.bencode(d)
def play(url, is_view=None): # -- Necesario para algunas webs -------------------------- - if not url.endswith(".torrent") and not url.startswith("magnet"): t_file = scrapertools.get_header_from_response( url, header_to_get="location") if len(t_file) > 0: url = t_file t_file = scrapertools.get_header_from_response( url, header_to_get="location") if len(t_file) > 0: url = t_file # -- Crear dos carpetas en descargas para los archivos ------ save_path_videos = os.path.join(config.get_setting("downloadpath"), "torrent-videos") save_path_torrents = os.path.join(config.get_setting("downloadpath"), "torrent-torrents") if not os.path.exists(save_path_torrents): os.mkdir(save_path_torrents) # -- Usar - archivo torrent desde web, meagnet o HD --------- if not os.path.isfile(url) and not url.startswith("magnet"): # -- http - crear archivo torrent ----------------------- data = url_get(url) # -- El nombre del torrent será el que contiene en los -- # -- datos. - #re_name_len = int( scrapertools.get_match(data,':name(\d+):') ) re_name = library.title_to_folder_name( urllib.unquote(scrapertools.get_match(data, ':name\d+:(.*?)\d+:'))) torrent_file = os.path.join(save_path_torrents, re_name + '.torrent') f = open(torrent_file, 'wb') f.write(data) f.close() elif os.path.isfile(url): # -- file - para usar torrens desde el HD --------------- torrent_file = url else: # -- magnet --------------------------------------------- torrent_file = url # ----------------------------------------------------------- # -- MCT - MiniClienteTorrent ------------------------------- ses = lt.session() print "#########################" print lt.version print "#########################" ses.add_dht_router("router.bittorrent.com", 6881) ses.add_dht_router("router.utorrent.com", 6881) ses.add_dht_router("router.bitcomet.com", 554) ses.add_dht_router("dht.transmissionbt.com", 6881) trackers = [ "http://exodus.desync.com:6969/announce", "udp://tracker.publicbt.com:80/announce", "udp://tracker.openbittorrent.com:80/announce", "http://tracker.torrentbay.to:6969/announce", "http://fr33dom.h33t.com:3310/announce", "http://tracker.pow7.com/announce", "udp://tracker.ccc.de:80/announce", "http://tracker.bittorrent.am:80/announce", "http://denis.stalker.h3q.com:6969/announce", "udp://tracker.prq.to:80/announce", "udp://tracker.istole.it:80/announce", "udp://open.demonii.com:1337", "http://9.rarbg.com:2710/announce", "http://announce.torrentsmd.com:6969/announce", "http://bt.careland.com.cn:6969/announce", "http://explodie.org:6969/announce", "http://mgtracker.org:2710/announce", "http://tracker.best-torrents.net:6969/announce", "http://tracker.tfile.me/announce", "http://tracker.torrenty.org:6969/announce", "http://tracker1.wasabii.com.tw:6969/announce", "udp://9.rarbg.com:2710/announce", "udp://9.rarbg.me:2710/announce", "udp://coppersurfer.tk:6969/announce", "udp://tracker.btzoo.eu:80/announce", "http://www.spanishtracker.com:2710/announce", "http://www.todotorrents.com:2710/announce", ] video_file = "" ## -- magnet2torrent ---------------------------------------- if torrent_file.startswith("magnet"): tempdir = tempfile.mkdtemp() params = { 'save_path': tempdir, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_allocate, 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } h = lt.add_magnet_uri(ses, torrent_file, params) dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') while not h.has_metadata(): message, porcent, msg_file, s, download = getProgress( h, "Creando torrent desde magnet") dp.update(porcent, message, msg_file) dp.close() info = h.get_torrent_info() data = lt.bencode(lt.create_torrent(info).generate()) torrent_file = os.path.join(save_path_torrents, info.name() + ".torrent") f = open(torrent_file, 'wb') f.write(data) f.close() ses.remove_torrent(h) shutil.rmtree(tempdir) # ----------------------------------------------------------- # -- Archivos torrent --------------------------------------- e = lt.bdecode(open(torrent_file, 'rb').read()) info = lt.torrent_info(e) # -- El más gordo o uno de los más gordo se entiende que es - # -- el vídeo o es el vídeo que se usará como referencia - # -- para el tipo de archivo - _index_file, _video_file, _size_file = get_video_file(info) if not _video_file.endswith('.avi'): print "##### storage_mode_t.storage_mode_sparse (no avi) #####" h = ses.add_torrent({ 'ti': info, 'save_path': save_path_videos, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_sparse }) else: print "##### storage_mode_t.storage_mode_allocate (avi) #####" h = ses.add_torrent({ 'ti': info, 'save_path': save_path_videos, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_allocate }) ## ---------------------------------------------------------- # -- Prioritarizar ------------------------------------------ _index, video_file, video_size = get_video_files_sizes(info) if _index == -1: _index = _index_file video_file = _video_file video_size = _size_file piece_set = set_priority_pieces(h, _index, video_file, video_size, _log=True) # -- Descarga secuencial - trozo 1, trozo 2, ... ------------ #h.set_sequential_download(True) h.force_reannounce() h.force_dht_announce() # -- Crear diálogo de progreso para el primer bucle --------- dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') # -- Para log ----------------------------------------------- timer = time.time() # -- Local con el número de piezas por cluster global ------- _cluster_pieces = __pieces__ ''' # -- Estimar cuando se comenzará el visionado --------------- # -- Pruebas: Porcentaje fijo - porcentage_to_play = 1.50 ''' # -- Estimar cuando se comenzará el visionado --------------- # -- Pruebas: Porcentaje segun tamaño cuando sólo hay un - # -- vídeo en torrent - porcentage_to_play = set_porcentage_to_play(video_size) # -- Doble bucle anidado ------------------------------------ # -- Descarga - Primer bucle - while not h.is_seed(): s = h.status() xbmc.sleep(100) # -- Recuperar los datos del progreso ------------------- message, porcent, msg_file, s, download = getProgress(h, video_file) # -- Si hace 'checking' existe descarga ----------------- # -- 'download' Se usará para saber si hay datos - # -- descargados para el diálogo de 'remove_files' - if s.state == 1: download = 1 # -- Añadido: Log para las pruebas ---------------------- # -- Print log have_piece. Procedimiento al final del - # -- archivo - timer2 = time.time() - timer if timer2 > time_sleep: print_have_piece_set(h, piece_set) timer = time.time() # -- Print log y procedimiento incrementar cluster -- # -- Parte 1 - _cluster = False if _cluster_pieces < len(piece_set): _cluster = \ cluster_stat( h, piece_set[_cluster_pieces - __pieces__], piece_set[_cluster_pieces], _log=True ) else: _cluster_pieces = len(piece_set) - 1 # -- Parte 2 - if _cluster: _cluster_pieces += __pieces__ cluster_set(h, _cluster_pieces, piece_set, 7, _log=True) _cluster_pieces2 = _cluster_pieces + __pieces__ cluster_set(h, _cluster_pieces2, piece_set, 6, _log=True) _cluster_pieces3 = _cluster_pieces2 + __pieces__ cluster_set(h, _cluster_pieces3, piece_set, 5, _log=True) # -- Player - play -------------------------------------- option_view = ((s.progress * 100) >= porcentage_to_play) # -- Modificado: Se tendrá en cuenta el primer cluster -- # -- completado para el inicio de la reproducción - first_cluster = True _p = "##### first_cluster: " for i in range(piece_set[0], piece_set[__pieces__]): _p += "[%s:%s]" % (i, h.have_piece(i)) first_cluster &= h.have_piece(i) print _p if (option_view and is_view != "Ok" and s.state == 3 and first_cluster): print "##### porcentage_to_play ## %s ##" % porcentage_to_play is_view = "Ok" dp.close() # -- Player - Ver el vídeo -------------------------- player = play_video() player.play(os.path.join(save_path_videos, video_file)) # -- Segundo bucle - Player - Control de eventos ---- while player.isPlaying(): xbmc.sleep(100) # -- Añadido: Log para las pruebas -------------- # -- Print log have_piece. Procedimiento al - # -- final del archivo - timer2 = time.time() - timer if timer2 > time_sleep: print_have_piece_set(h, piece_set) timer = time.time() # -- Print log y procedimiento incrementar -- # -- cluster - # -- Parte 1 - _cluster = False if _cluster_pieces < len(piece_set): _cluster = \ cluster_stat( h, piece_set[_cluster_pieces - __pieces__], piece_set[_cluster_pieces], _log=True ) else: _cluster_pieces = len(piece_set) - 1 # -- Parte 2 - if _cluster: _cluster_pieces += __pieces__ cluster_set(h, _cluster_pieces, piece_set, 7, _log=True) _cluster_pieces2 = _cluster_pieces + __pieces__ cluster_set(h, _cluster_pieces2, piece_set, 6, _log=True) _cluster_pieces3 = _cluster_pieces2 + __pieces__ cluster_set(h, _cluster_pieces3, piece_set, 5, _log=True) # -- Cerrar el diálogo de progreso -------------- if player.resumed: dp.close() # -- Mostrar el diálogo de progreso ------------- if player.paused: # -- Crear diálogo si no existe ------------- if not player.statusDialogoProgress: dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') player.setDialogoProgress() # -- Diálogos de estado en el visionado ----- if not h.is_seed(): # -- Recuperar los datos del progreso --- message, porcent, msg_file, s, download = getProgress( h, video_file) dp.update(porcent, message, msg_file) else: dp.update(100, "Descarga completa: " + video_file) # -- Se canceló el progreso en el visionado - # -- Continuar - if dp.iscanceled(): dp.close() player.pause() # -- El usuario cancelo el visionado -------- # -- Terminar - if player.ended: if info.num_files() > 1: _index, video_file, video_size = get_video_files_sizes( info) if _index == -1: # -- Diálogo eliminar archivos ---------- remove_files(download, torrent_file, video_file, ses, h) return else: set_porcentage_to_play(video_size) piece_set = set_priority_pieces(h, _index, video_file, video_size, _log=True) else: # -- Diálogo eliminar archivos ---------- remove_files(download, torrent_file, video_file, ses, h) return # -- Kodi - Se cerró el visionado ----------------------- # -- Continuar | Terminar - if is_view == "Ok" and not xbmc.Player().isPlaying(): # -- Diálogo continuar o terminar ------------------- d = xbmcgui.Dialog() ok = d.yesno('pelisalacarta-MCT', 'XBMC-Kodi Cerró el vídeo.', '¿Continuar con la sesión?') # -- SI ------------------------------------------------- if ok: # -- Continuar -------------------------------------- is_view = None else: # -- Terminar --------------------------------------- if info.num_files() > 1: _index, video_file, video_size = get_video_files_sizes( info) if _index == -1: # -- Diálogo eliminar archivos - remove_files(download, torrent_file, video_file, ses, h) return else: set_porcentage_to_play(video_size) piece_set = set_priority_pieces(h, _index, video_file, video_size, _log=True) is_view = None dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') else: # -- Diálogo eliminar archivos ---------- remove_files(download, torrent_file, video_file, ses, h) return # -- Mostar progeso antes del visionado ----------------- if is_view != "Ok": dp.update(porcent, message, msg_file) # -- Se canceló el progreso antes del visionado --------- # -- Terminar - if dp.iscanceled(): dp.close() if info.num_files() > 1: _index, video_file, video_size = get_video_files_sizes(info) if _index == -1: # -- Diálogo eliminar archivos - remove_files(download, torrent_file, video_file, ses, h) return else: set_porcentage_to_play(video_size) piece_set = set_priority_pieces(h, _index, video_file, video_size, _log=True) is_view = None dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') else: # -- Diálogo eliminar archivos ---------- remove_files(download, torrent_file, video_file, ses, h) return # -- Kodi - Error? - No debería llegar aquí ----------------- if is_view == "Ok" and not xbmc.Player().isPlaying(): dp.close() # -- Diálogo eliminar archivos -------------------------- remove_files(download, torrent_file, video_file, ses, h) return
def parse_magnet_uri( self, magnet_uri, scrape=None, use_dht=None, timeout=None, trackers=None, no_cache=None, n_try=None, to_torrent=None, http_proxy=None, ): try: import libtorrent as lt except ImportError as _e: raise ImportError("libtorrent package required") from _e # default function arguments from db if scrape is None: scrape = ModelSetting.get_bool("scrape") if use_dht is None: use_dht = ModelSetting.get_bool("use_dht") if timeout is None: timeout = ModelSetting.get_int("timeout") if trackers is None: trackers = json.loads(ModelSetting.get("trackers")) if n_try is None: n_try = ModelSetting.get_int("n_try") if no_cache is None: no_cache = False if to_torrent is None: to_torrent = False if http_proxy is None: http_proxy = ModelSetting.get("http_proxy") # parameters params = lt.parse_magnet_uri(magnet_uri) # prevent downloading # https://stackoverflow.com/q/45680113 if isinstance(params, dict): params["flags"] |= lt.add_torrent_params_flags_t.flag_upload_mode else: params.flags |= lt.add_torrent_params_flags_t.flag_upload_mode lt_version = [int(v) for v in lt.version.split(".")] if [0, 16, 13, 0] < lt_version < [1, 1, 3, 0]: # for some reason the info_hash needs to be bytes but it's a struct called sha1_hash if isinstance(params, dict): params["info_hash"] = params["info_hash"].to_bytes() else: params.info_hash = params.info_hash.to_bytes() # 캐시에 있으면... info_hash_from_magnet = str(params["info_hash"] if isinstance(params, dict) else params.info_hash) self.cache_init() if (not no_cache) and (info_hash_from_magnet in self.torrent_cache): return self.torrent_cache[info_hash_from_magnet]["info"] # add trackers if isinstance(params, dict): if len(params["trackers"]) == 0: params["trackers"] = trackers else: if len(params.trackers) == 0: params.trackers = trackers # session settings = { # basics # 'user_agent': 'libtorrent/' + lt.__version__, "listen_interfaces": "0.0.0.0:6881", # dht "enable_dht": use_dht, "use_dht_as_fallback": True, "dht_bootstrap_nodes": "router.bittorrent.com:6881,dht.transmissionbt.com:6881,router.utorrent.com:6881,127.0.0.1:6881", "enable_lsd": False, "enable_upnp": True, "enable_natpmp": True, "announce_to_all_tiers": True, "announce_to_all_trackers": True, "aio_threads": 4 * 2, "checking_mem_usage": 1024 * 2, } if http_proxy: proxy_url = urlparse(http_proxy) settings.update( { "proxy_username": proxy_url.username, "proxy_password": proxy_url.password, "proxy_hostname": proxy_url.hostname, "proxy_port": proxy_url.port, "proxy_type": lt.proxy_type_t.http_pw if proxy_url.username and proxy_url.password else lt.proxy_type_t.http, "force_proxy": True, "anonymous_mode": True, } ) session = lt.session(settings) session.add_extension("ut_metadata") session.add_extension("ut_pex") session.add_extension("metadata_transfer") # handle handle = session.add_torrent(params) if use_dht: handle.force_dht_announce() max_try = max(n_try, 1) for tryid in range(max_try): timeout_value = timeout logger.debug("Trying to get metadata... %d/%d", tryid + 1, max_try) while not handle.has_metadata(): time.sleep(0.1) timeout_value -= 0.1 if timeout_value <= 0: break if handle.has_metadata(): lt_info = handle.get_torrent_info() logger.debug( "Successfully got metadata after %d*%d+%.2f seconds", tryid, timeout, timeout - timeout_value ) time_metadata = tryid * timeout + (timeout - timeout_value) break if tryid + 1 == max_try: session.remove_torrent(handle, True) raise Exception(f"Timed out after {max_try}*{timeout} seconds") # create torrent object and generate file stream torrent = lt.create_torrent(lt_info) torrent.set_creator(f"libtorrent v{lt.version}") # signature torrent_dict = torrent.generate() torrent_info = self.convert_torrent_info(lt_info) torrent_info.update( { "trackers": params.trackers if not isinstance(params, dict) else params["trackers"], "creation_date": datetime.fromtimestamp(torrent_dict[b"creation date"]).isoformat(), "time": {"total": time_metadata, "metadata": time_metadata}, } ) if scrape: # start scraping for tryid in range(max_try): timeout_value = timeout logger.debug("Trying to get peerinfo... %d/%d", tryid + 1, max_try) while handle.status(0).num_complete < 0: time.sleep(0.1) timeout_value -= 0.1 if timeout_value <= 0: break if handle.status(0).num_complete >= 0: torrent_status = handle.status(0) logger.debug( "Successfully got peerinfo after %d*%d+%.2f seconds", tryid, timeout, timeout - timeout_value ) time_scrape = tryid * timeout + (timeout - timeout_value) torrent_info.update( { "seeders": torrent_status.num_complete, "peers": torrent_status.num_incomplete, } ) torrent_info["time"]["scrape"] = time_scrape torrent_info["time"]["total"] = torrent_info["time"]["metadata"] + torrent_info["time"]["scrape"] break if tryid + 1 == max_try: logger.error("Timed out after %d*%d seconds", max_try, timeout) session.remove_torrent(handle, True) # caching for later use self.torrent_cache[torrent_info["info_hash"]] = { "info": torrent_info, } if to_torrent: return lt.bencode(torrent_dict), pathscrub(lt_info.name(), os="windows", filename=True) return torrent_info
dp.create('Alfa-MCT') while not h.has_metadata(): message, porcent, msg_file, s, download = getProgress( h, "Creando torrent desde magnet") dp.update(porcent, message, msg_file) if s.state == 1: download = 1 if dp.iscanceled(): dp.close() remove_files(download, torrent_file, video_file, ses, h) return h.force_dht_announce() xbmc.sleep(1000) dp.close() info = h.get_torrent_info() data = lt.bencode(lt.create_torrent(info).generate()) #torrent_file = os.path.join(save_path_torrents, unicode(info.name()+"-"+btih, "'utf-8'", errors="replace") + ".torrent") torrent_file = os.path.join(save_path_torrents, info.name() + "-" + btih + ".torrent") f = open(torrent_file, 'wb') f.write(data) f.close() ses.remove_torrent(h) shutil.rmtree(tempdir) # ----------------------------------------------------------- # -- Archivos torrent --------------------------------------- e = lt.bdecode(open(torrent_file, 'rb').read()) info = lt.torrent_info(e)
def test_priv(self) -> None: fs = lt.file_storage() fs.add_file("test.txt", 1024) ct = lt.create_torrent(fs) ct.set_priv(True) self.assertTrue(ct.priv())
for f in files: # skip files starting with . if f[0] == '.': continue # skip thumbs.db on windows if f == 'Thumbs.db': continue fname = os.path.join(root[len(parent_input) + 1:], f) size = os.path.getsize(os.path.join(parent_input, fname)) print('%10d kiB %s' % (size / 1024, fname)) fs.add_file(fname, size) if fs.num_files() == 0: print('no files added') sys.exit(1) t = libtorrent.create_torrent(fs, 0, 4 * 1024 * 1024) t.add_tracker(sys.argv[2]) t.set_creator('libtorrent %s' % libtorrent.__version__) libtorrent.set_piece_hashes(t, parent_input, lambda x: sys.stdout.write('.')) sys.stdout.write('\n') f = open('out.torrent', 'wb+') f.write(libtorrent.bencode(t.generate())) f.close()
def run(self): """run the converter. using the class attribute initiated at init function. Returns: Filename of created torrent. Raises: KeyboardInterrupt: This error caused by user to stop this. When downloading metadata from magnet link, it requires an additional step before the error reraised again. """ print("Downloading Metadata (this may take a while)") # used to control "Maybe..." and "or the" msgs after sleep(1) wait_time = 1 soft_limit = 120 while not self.handle.has_metadata(): try: sleep(1) if wait_time > soft_limit: print( "Downloading is taking a while, maybe there is an " "issue with the magnet link or your network connection" ) soft_limit += 30 wait_time += 1 except KeyboardInterrupt: print("\nAborting...") self.ses.pause() print("Cleanup dir " + self.tempdir) shutil.rmtree(self.tempdir) raise self.ses.pause() print("Done") torinfo = self.handle.get_torrent_info() torfile = lt.create_torrent(torinfo) output = pt.abspath(torinfo.name() + ".torrent") if self.output_name: if pt.isdir(self.output_name): output = pt.abspath( pt.join(self.output_name, torinfo.name() + ".torrent")) elif pt.isdir(pt.dirname(pt.abspath(self.output_name))): output = pt.abspath(self.output_name) else: output = pt.abspath(torinfo.name() + ".torrent") print("Saving torrent file here : " + output + " ...") with open(output, "wb") as outfile: torcontent = lt.bencode(torfile.generate()) outfile.write(torcontent) print("Saved! Cleaning up dir: " + self.tempdir) self.ses.remove_torrent(self.handle) shutil.rmtree(self.tempdir) return output
import binascii ses = lt.session() ses.listen_on(6881, 6891) magnet = lt.parse_magnet_uri(sys.argv[1]) e = str(magnet.info_hash) if len(e) == 40: info_hash = binascii.unhexlify(e) elif len(e) == 32: info_hash = base64.b32decode(e) else: raise Exception("Unable to parse infohash") trackers = magnet.trackers h = ses.add_torrent({'info_hash': info_hash, 'trackers': trackers}) dots=0 while not h.has_metadata(): dots += 1 sys.stdout.write('.') sys.stdout.flush() time.sleep(1) if (dots): sys.stdout.write('\n') ses.pause() tinf = h.get_torrent_info() f = open('/tmp/b2pgen' + '.torrent', 'wb') f.write(lt.bencode( lt.create_torrent(tinf).generate())) f.close() ses.remove_torrent(h)
def test_num_pieces(self) -> None: fs = lt.file_storage() fs.add_file("test.txt", 1024) ct = lt.create_torrent(fs) self.assertEqual(ct.num_pieces(), 1)
def run(self): """ Called every few seconds to handle any running/finished torrents """ if not LIBTORRENT_AVAILABLE: return if not self.loadedRunningTorrents: torrent_save_file = _get_running_torrents_pickle_path(False) if os.path.isfile(torrent_save_file): logger.log( u'Saved torrents found in %s, loading' % (torrent_save_file), logger.DEBUG) _load_saved_torrents() self.loadedRunningTorrents = True sess = _get_session(False) if sess is not None: while 1: a = sess.pop_alert() if not a: break if type(a) == str: logger.log(a, logger.DEBUG) else: logger.log( u'(%s): %s' % (type(a).__name__, ek.fixStupidEncodings(a.message(), True)), logger.DEBUG) logTorrentStatus = (time.time() - self.lastTorrentStatusLogTS) >= 600 for torrent_data in running_torrents: if torrent_data['handle'].has_metadata(): ti = torrent_data['handle'].get_torrent_info() name = ti.name() torrent_data['name'] = name torrent_data['total_size'] = ti.total_size() if not torrent_data['have_torrentFile']: # if this was a magnet or url, and we now have downloaded the metadata # for it, best to save it locally in case we need to resume ti = torrent_data['handle'].get_torrent_info() torrentFile = lt.create_torrent(ti) torrent_data['torrent'] = lt.bencode( torrentFile.generate()) torrent_data['have_torrentFile'] = True logger.log( u'Created torrent file for %s as metadata d/l is now complete' % (name), logger.DEBUG) else: name = '-' s = torrent_data['handle'].status() torrent_data['status'] = str(s.state) torrent_data['progress'] = s.progress torrent_data['rate_down'] = s.download_rate torrent_data['rate_up'] = s.upload_rate torrent_data['paused'] = s.paused torrent_data['error'] = s.error #currentRatio = 0.0 if s.total_download == 0 else float(s.total_upload)/float(s.total_download) currentRatio = 0.0 if s.all_time_download == 0 else float( s.all_time_upload) / float(s.all_time_download) torrent_data['ratio'] = currentRatio if s.state in [ lt.torrent_status.seeding, lt.torrent_status.finished ]: with torrent_data['lock']: # this is the post-processing & removing code, so make sure that there's # only one thread doing either here, as the two could easily interfere with # one another if not torrent_data['post_processed']: # torrent has just completed download, so we need to do # post-processing on it. ti = torrent_data['handle'].get_torrent_info() any_file_success = False for f in ti.files(): fullpath = os.path.join( sickbeard.LIBTORRENT_WORKING_DIR, 'data', f.path) logger.log( u'Post-processing "%s"' % (fullpath), logger.DEBUG) if isMediaFile(fullpath): logger.log(u'this is a media file', logger.DEBUG) try: processor = postProcessor.PostProcessor( fullpath, name) if processor.process( forceKeepOriginalFiles=True): logger.log( u'Success post-processing "%s"' % (fullpath), logger.DEBUG) any_file_success = True except exceptions.PostProcessingFailed, e: logger.log( u'Failed post-processing file "%s" with error "%s"' % (fullpath, ex(e)), logger.ERROR) if not any_file_success: logger.log( u'When post-processing the completed torrent %s, no useful files were found.' % (name), logger.ERROR) torrent_data['post_processed'] = True else: # post-processing has already been performed. So we just # need to ensure check the ratio and delete the torrent # if we're good. if currentRatio >= sickbeard.LIBTORRENT_SEED_TO_RATIO: logger.log( u'Torrent "%s" has seeded to ratio %f. Removing it.' % (name, currentRatio), logger.MESSAGE) deleteFilesToo = True if not torrent_data['post_processed']: logger.log( u'Torrent has not been post_processed. Keeping files.', logger.MESSAGE) deleteFilesToo = False _remove_torrent_by_handle( torrent_data['handle'], deleteFilesToo) else: if logTorrentStatus: self.lastTorrentStatusLogTS = time.time() logger.log( u'"%s" seeding %0.3f' % (name, currentRatio), logger.DEBUG) elif s.state == lt.torrent_status.downloading: if logTorrentStatus: self.lastTorrentStatusLogTS = time.time() logger.log( u'"%s" downloading %0.2f' % (name, s.progress * 100.0), logger.DEBUG)
def test_piece_length(self) -> None: fs = lt.file_storage() fs.add_file("test.txt", 1024) ct = lt.create_torrent(fs) self.assertEqual(ct.piece_length(), 16384)
print data # collect sha1 piece_hash = re.findall(r'^sha1: (.*)$', data, re.M) print piece_hash # collect offset and length offset = re.findall(r'^offset: (.*)$', data, re.M) length = re.findall(r'^length: (.*)$', data, re.M) print "offset: ", offset print "length: ", length fs = lt.file_storage() fs.set_piece_length(16 * 1024 * 1024) # 16MiB for o, l in zip(offset, length): fs.add_file("a/" + o, int(l, 16)) torrent = lt.create_torrent(fs, 16 * 1024 * 1024, flags=0) torrent.set_creator("Test") print "file:", torrent.files().num_files() print torrent.files().file_path(0) for index, h in enumerate(piece_hash): torrent.set_hash(index, h.decode('hex')) with open('a.torrent', 'wb') as f: f.write(lt.bencode(torrent.generate()))
def test_http_seed_deprecated(self) -> None: fs = lt.file_storage() ct = lt.create_torrent(fs) with self.assertWarns(DeprecationWarning): ct.add_http_seed("http://example.com")
def play(url, xlistitem={}, is_view=None, subtitle="", item=None): allocate = True try: import platform xbmc.log( "XXX KODI XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" ) xbmc.log("OS platform: %s %s" % (platform.system(), platform.release())) xbmc.log("xbmc/kodi version: %s" % xbmc.getInfoLabel("System.BuildVersion")) xbmc_version = int(xbmc.getInfoLabel("System.BuildVersion")[:2]) xbmc.log("xbmc/kodi version number: %s" % xbmc_version) xbmc.log( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX KODI XXXX" ) _platform = get_platform() if str(_platform['system']) in [ "android_armv7", "linux_armv6", "linux_armv7" ]: allocate = False # -- log ------------------------------------------------ xbmc.log( "XXX platform XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" ) xbmc.log("_platform['system']: %s" % _platform['system']) xbmc.log("allocate: %s" % allocate) xbmc.log( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX platform XXXX" ) # -- ---------------------------------------------------- except: pass DOWNLOAD_PATH = config.get_setting("downloadpath") # -- adfly: ------------------------------------ if url.startswith("http://adf.ly/"): try: data = httptools.downloadpage(url).data url = decode_adfly(data) except: ddd = xbmcgui.Dialog() ddd.ok( "alfa-MCT: Sin soporte adf.ly", "El script no tiene soporte para el acortador de urls adf.ly.", "", "url: " + url) return # -- Necesario para algunas webs ---------------------------- if not url.endswith(".torrent") and not url.startswith("magnet"): t_file = scrapertools.get_header_from_response( url, header_to_get="location") if len(t_file) > 0: url = t_file t_file = scrapertools.get_header_from_response( url, header_to_get="location") if len(t_file) > 0: url = t_file # -- Crear dos carpetas en descargas para los archivos ------ save_path_videos = os.path.join(DOWNLOAD_PATH, "torrent-videos") save_path_torrents = os.path.join(DOWNLOAD_PATH, "torrent-torrents") if not os.path.exists(save_path_torrents): os.mkdir(save_path_torrents) # -- Usar - archivo torrent desde web, magnet o HD --------- if not os.path.isfile(url) and not url.startswith("magnet"): # -- http - crear archivo torrent ----------------------- data = url_get(url) # -- El nombre del torrent será el que contiene en los -- # -- datos. - re_name = urllib.unquote( scrapertools.scrapertools.find_single_match( data, ':name\d+:(.*?)\d+:')) torrent_file = filetools.join(save_path_torrents, filetools.encode(re_name + '.torrent')) f = open(torrent_file, 'wb') f.write(data) f.close() elif os.path.isfile(url): # -- file - para usar torrens desde el HD --------------- torrent_file = url else: # -- magnet --------------------------------------------- torrent_file = url # ----------------------------------------------------------- # -- MCT - MiniClienteTorrent ------------------------------- ses = lt.session() # -- log ---------------------------------------------------- xbmc.log("### Init session ########") xbmc.log(lt.version) xbmc.log("#########################") # -- -------------------------------------------------------- ses.add_dht_router("router.bittorrent.com", 6881) ses.add_dht_router("router.utorrent.com", 6881) ses.add_dht_router("dht.transmissionbt.com", 6881) trackers = [ "udp://tracker.openbittorrent.com:80/announce", "http://tracker.torrentbay.to:6969/announce", "http://tracker.pow7.com/announce", "udp://tracker.ccc.de:80/announce", "udp://open.demonii.com:1337", "http://9.rarbg.com:2710/announce", "http://bt.careland.com.cn:6969/announce", "http://explodie.org:6969/announce", "http://mgtracker.org:2710/announce", "http://tracker.best-torrents.net:6969/announce", "http://tracker.tfile.me/announce", "http://tracker1.wasabii.com.tw:6969/announce", "udp://9.rarbg.com:2710/announce", "udp://9.rarbg.me:2710/announce", "udp://coppersurfer.tk:6969/announce", "http://www.spanishtracker.com:2710/announce", "http://www.todotorrents.com:2710/announce", ] video_file = "" # -- magnet2torrent ----------------------------------------- if torrent_file.startswith("magnet"): try: import zlib btih = hex( zlib.crc32( scrapertools.scrapertools.find_single_match( torrent_file, 'magnet:\?xt=urn:(?:[A-z0-9:]+|)([A-z0-9]{32})')) & 0xffffffff) files = [ f for f in os.listdir(save_path_torrents) if os.path.isfile(os.path.join(save_path_torrents, f)) ] for file in files: if btih in os.path.basename(file): torrent_file = os.path.join(save_path_torrents, file) except: pass if torrent_file.startswith("magnet"): try: tempdir = tempfile.mkdtemp() except IOError: tempdir = os.path.join(save_path_torrents, "temp") if not os.path.exists(tempdir): os.mkdir(tempdir) params = { 'save_path': tempdir, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_allocate, 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } h = lt.add_magnet_uri(ses, torrent_file, params) dp = xbmcgui.DialogProgress() dp.create('alfa-MCT') while not h.has_metadata(): message, porcent, msg_file, s, download = getProgress( h, "Creando torrent desde magnet") dp.update(porcent, message, msg_file) if s.state == 1: download = 1 if dp.iscanceled(): dp.close() remove_files(download, torrent_file, video_file, ses, h) return h.force_dht_announce() xbmc.sleep(1000) dp.close() info = h.get_torrent_info() data = lt.bencode(lt.create_torrent(info).generate()) torrent_file = os.path.join( save_path_torrents, unicode(info.name() + "-" + btih, "'utf-8'", errors="replace") + ".torrent") f = open(torrent_file, 'wb') f.write(data) f.close() ses.remove_torrent(h) shutil.rmtree(tempdir) # ----------------------------------------------------------- # -- Archivos torrent --------------------------------------- e = lt.bdecode(open(torrent_file, 'rb').read()) info = lt.torrent_info(e) # -- El más gordo o uno de los más gordo se entiende que es - # -- el vídeo o es el vídeo que se usará como referencia - # -- para el tipo de archivo - xbmc.log("##### Archivos ## %s ##" % len(info.files())) _index_file, _video_file, _size_file = get_video_file(info) # -- Prioritarizar/Seleccionar archivo----------------------- _index, video_file, video_size, len_files = get_video_files_sizes(info) if len_files == 0: dp = xbmcgui.Dialog().ok( "No se puede reproducir", "El torrent no contiene ningún archivo de vídeo") if _index == -1: _index = _index_file video_file = _video_file video_size = _size_file _video_file_ext = os.path.splitext(_video_file)[1] xbmc.log("##### _video_file_ext ## %s ##" % _video_file_ext) if (_video_file_ext == ".avi" or _video_file_ext == ".mp4") and allocate: xbmc.log("##### storage_mode_t.storage_mode_allocate (" + _video_file_ext + ") #####") h = ses.add_torrent({ 'ti': info, 'save_path': save_path_videos, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_allocate }) else: xbmc.log("##### storage_mode_t.storage_mode_sparse (" + _video_file_ext + ") #####") h = ses.add_torrent({ 'ti': info, 'save_path': save_path_videos, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_sparse }) allocate = True # ----------------------------------------------------------- # -- Descarga secuencial - trozo 1, trozo 2, ... ------------ h.set_sequential_download(True) h.force_reannounce() h.force_dht_announce() # -- Inicio de variables para 'pause' automático cuando el - # -- el vídeo se acerca a una pieza sin completar - is_greater_num_pieces = False is_greater_num_pieces_plus = False is_greater_num_pieces_pause = False porcent4first_pieces = int(video_size * 0.000000005) if porcent4first_pieces < 10: porcent4first_pieces = 10 if porcent4first_pieces > 100: porcent4first_pieces = 100 porcent4last_pieces = int(porcent4first_pieces / 2) num_pieces_to_resume = int(video_size * 0.0000000025) if num_pieces_to_resume < 5: num_pieces_to_resume = 5 if num_pieces_to_resume > 25: num_pieces_to_resume = 25 xbmc.log("##### porcent4first_pieces ## %s ##" % porcent4first_pieces) xbmc.log("##### porcent4last_pieces ## %s ##" % porcent4last_pieces) xbmc.log("##### num_pieces_to_resume ## %s ##" % num_pieces_to_resume) # -- Prioritarizar o seleccionar las piezas del archivo que - # -- se desea reproducir con 'file_priorities' - piece_set = set_priority_pieces(h, _index, video_file, video_size, porcent4first_pieces, porcent4last_pieces, allocate) # -- Crear diálogo de progreso para el primer bucle --------- dp = xbmcgui.DialogProgress() dp.create('alfa-MCT') _pieces_info = {} # -- Doble bucle anidado ------------------------------------ # -- Descarga - Primer bucle - while not h.is_seed(): s = h.status() xbmc.sleep(100) # -- Recuperar los datos del progreso ------------------- message, porcent, msg_file, s, download = getProgress(h, video_file, _pf=_pieces_info) # -- Si hace 'checking' existe descarga ----------------- # -- 'download' Se usará para saber si hay datos - # -- descargados para el diálogo de 'remove_files' - if s.state == 1: download = 1 # -- Player - play -------------------------------------- # -- Comprobar si se han completado las piezas para el - # -- inicio del vídeo - first_pieces = True _c = 0 for i in range(piece_set[0], piece_set[porcent4first_pieces]): first_pieces &= h.have_piece(i) if h.have_piece(i): _c += 1 _pieces_info = { 'current': 0, 'continuous': "%s/%s" % (_c, porcent4first_pieces), 'continuous2': "", 'have': h.status().num_pieces, 'len': len(piece_set) } last_pieces = True if not allocate: _c = len(piece_set) - 1 _cc = 0 for i in range( len(piece_set) - porcent4last_pieces, len(piece_set)): last_pieces &= h.have_piece(i) if h.have_piece(i): _c -= 1 _cc += 1 _pieces_info['continuous2'] = "[%s/%s] " % (_cc, porcent4last_pieces) if is_view != "Ok" and first_pieces and last_pieces: _pieces_info['continuous2'] = "" xbmc.log("##### porcent [%.2f%%]" % (s.progress * 100)) is_view = "Ok" dp.close() # -- Player - Ver el vídeo -------------------------- playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) playlist.clear() ren_video_file = os.path.join(save_path_videos, video_file) try: playlist.add(ren_video_file, xlistitem) except: playlist.add(ren_video_file) if xbmc_version < 17: player = play_video(xbmc.PLAYER_CORE_AUTO) else: player = play_video() player.play(playlist) # -- Contador de cancelaciones para la ventana de - # -- 'pause' automático - is_greater_num_pieces_canceled = 0 continuous_pieces = 0 porcent_time = 0.00 current_piece = 0 set_next_continuous_pieces = porcent4first_pieces # -- Impedir que kodi haga 'resume' a un archivo ---- # -- que se reprodujo con anterioridad y que se - # -- eliminó para impedir que intente la reprucción - # -- en una pieza que aún no se ha completado y se - # -- active 'pause' automático - not_resume = True # -- Bandera subTítulos _sub = False # -- Segundo bucle - Player - Control de eventos ---- while player.isPlaying(): xbmc.sleep(100) # -- Añadir subTítulos if subtitle != "" and not _sub: _sub = True player.setSubtitles(subtitle) # -- Impedir que kodi haga 'resume' al inicio --- # -- de la descarga de un archivo conocido - if not_resume: player.seekTime(0) not_resume = False # -- Control 'pause' automático - continuous_pieces = count_completed_continuous_pieces( h, piece_set) if xbmc.Player().isPlaying(): # -- Porcentage del progreso del vídeo ------ player_getTime = player.getTime() player_getTotalTime = player.getTotalTime() porcent_time = player_getTime / player_getTotalTime * 100 # -- Pieza que se está reproduciendo -------- current_piece = int(porcent_time / 100 * len(piece_set)) # -- Banderas de control -------------------- is_greater_num_pieces = ( current_piece > continuous_pieces - num_pieces_to_resume) is_greater_num_pieces_plus = ( current_piece + porcent4first_pieces > continuous_pieces) is_greater_num_pieces_finished = ( current_piece + porcent4first_pieces >= len(piece_set)) # -- Activa 'pause' automático -------------- if is_greater_num_pieces and not player.paused and not is_greater_num_pieces_finished: is_greater_num_pieces_pause = True player.pause() if continuous_pieces >= set_next_continuous_pieces: set_next_continuous_pieces = continuous_pieces + num_pieces_to_resume next_continuous_pieces = str( continuous_pieces - current_piece) + "/" + str(set_next_continuous_pieces - current_piece) _pieces_info = { 'current': current_piece, 'continuous': next_continuous_pieces, 'continuous2': _pieces_info['continuous2'], 'have': h.status().num_pieces, 'len': len(piece_set) } # si es un archivo de la videoteca enviar a marcar como visto if item.strm_path: from platformcode import xbmc_videolibrary xbmc_videolibrary.mark_auto_as_watched(item) # -- Cerrar el diálogo de progreso -------------- if player.resumed: dp.close() # -- Mostrar el diálogo de progreso ------------- if player.paused: # -- Crear diálogo si no existe ------------- if not player.statusDialogoProgress: dp = xbmcgui.DialogProgress() dp.create('alfa-MCT') player.setDialogoProgress() # -- Diálogos de estado en el visionado ----- if not h.is_seed(): # -- Recuperar los datos del progreso --- message, porcent, msg_file, s, download = getProgress( h, video_file, _pf=_pieces_info) dp.update(porcent, message, msg_file) else: dp.update(100, "Descarga completa: " + video_file) # -- Se canceló el progreso en el visionado - # -- Continuar - if dp.iscanceled(): dp.close() player.pause() # -- Se canceló el progreso en el visionado - # -- en la ventana de 'pause' automático. - # -- Parar si el contador llega a 3 - if dp.iscanceled() and is_greater_num_pieces_pause: is_greater_num_pieces_canceled += 1 if is_greater_num_pieces_canceled == 3: player.stop() # -- Desactiva 'pause' automático y --------- # -- reinicia el contador de cancelaciones - if not dp.iscanceled( ) and not is_greater_num_pieces_plus and is_greater_num_pieces_pause: dp.close() player.pause() is_greater_num_pieces_pause = False is_greater_num_pieces_canceled = 0 # -- El usuario cancelo el visionado -------- # -- Terminar - if player.ended: # -- Diálogo eliminar archivos ---------- remove_files(download, torrent_file, video_file, ses, h) return # -- Kodi - Se cerró el visionado ----------------------- # -- Continuar | Terminar - if is_view == "Ok" and not xbmc.Player().isPlaying(): if info.num_files() == 1: # -- Diálogo continuar o terminar --------------- d = xbmcgui.Dialog() ok = d.yesno('alfa-MCT', 'XBMC-Kodi Cerró el vídeo.', '¿Continuar con la sesión?') else: ok = False # -- SI --------------------------------------------- if ok: # -- Continuar: --------------------------------- is_view = None else: # -- Terminar: ---------------------------------- # -- Comprobar si el vídeo pertenece a una ------ # -- lista de archivos - _index, video_file, video_size, len_files = get_video_files_sizes( info) if _index == -1 or len_files == 1: # -- Diálogo eliminar archivos -------------- remove_files(download, torrent_file, video_file, ses, h) return else: # -- Lista de archivos. Diálogo de opciones - piece_set = set_priority_pieces(h, _index, video_file, video_size, porcent4first_pieces, porcent4last_pieces, allocate) is_view = None dp = xbmcgui.DialogProgress() dp.create('alfa-MCT') # -- Mostar progeso antes del visionado ----------------- if is_view != "Ok": dp.update(porcent, message, msg_file) # -- Se canceló el progreso antes del visionado --------- # -- Terminar - if dp.iscanceled(): dp.close() # -- Comprobar si el vídeo pertenece a una lista de - # -- archivos - _index, video_file, video_size, len_files = get_video_files_sizes( info) if _index == -1 or len_files == 1: # -- Diálogo eliminar archivos ------------------ remove_files(download, torrent_file, video_file, ses, h) return else: # -- Lista de archivos. Diálogo de opciones ----- piece_set = set_priority_pieces(h, _index, video_file, video_size, porcent4first_pieces, porcent4last_pieces, allocate) is_view = None dp = xbmcgui.DialogProgress() dp.create('alfa-MCT') # -- Kodi - Error? - No debería llegar aquí ----------------- if is_view == "Ok" and not xbmc.Player().isPlaying(): dp.close() # -- Diálogo eliminar archivos -------------------------- remove_files(download, torrent_file, video_file, ses, h) return
def make_torrent(cls, path, save_dir, tracker_url, _type='file'): """make a torrent file.""" chain = list() if _type == 'vhd': vhd = RBTreeVHD(path) chain = vhd.get_chain() log.debug("vhd-chain: %s" % chain) def file_filter(name): print "filter name:", name print "torrent type:", _type if os.path.samefile(name, os.path.dirname(path)): return True #if _type == 'vhd': # vhd = RBTreeVHD(path) # chain = vhd.get_chain() # log.debug("vhd-chain: %s" % chain) if _type == 'vhd': if name in chain: return True else: if os.path.samefile(name, path): return True #return False if not os.path.exists(path): raise InvalidParamError("%s not exists." % path) source_path = os.path.abspath(path) torrent_file = "%s/%s.torrent" % (save_dir, os.path.basename(source_path)) fs = lt.file_storage() # lt.add_files(fs, source_path) # add_files(fs, source_path, _type) lt.add_files(fs, os.path.dirname(source_path), file_filter) log.debug("add %s files to torrent." % fs.num_files()) log.debug("total_size: %s" % fs.total_size()) creator = lt.create_torrent(fs, 0, 4 * 1024 * 1024) print "tracker_url:", tracker_url, "type:", type( tracker_url), "len:", len(tracker_url) creator.add_tracker(str(tracker_url).strip()) creator.set_creator("RBTree Vtrans %s" % VTRANS_VERSION) comment = dict() comment["type"] = _type creator.set_comment(json.dumps(comment)) #lt.set_piece_hashes(creator, os.path.split(source_path)[0], lambda x: sys.stderr.write('.')) #lt.set_piece_hashes(creator, "/home/xjc/vtrans-master/test", lambda x: sys.stderr.write('.')) #lt.set_piece_hashes(creator, os.path.dirname(os.path.dirname(source_path)), lambda x: sys.stderr.write('.')) num_pieces = creator.num_pieces() def piece_hash_process(x): print "\rall %s pieces, setting piece %s, porcess: %s%%" % ( num_pieces, x + 1, (x + 1) * 100 / num_pieces), sys.stdout.flush() #lt.set_piece_hashes(creator, os.path.dirname(os.path.dirname(source_path)), lambda x: sys.stderr.write("%s " % x/)) lt.set_piece_hashes(creator, os.path.dirname(os.path.dirname(source_path)), piece_hash_process) sys.stderr.write('\n') with open(torrent_file, "wb") as f: f.write(lt.bencode(creator.generate())) return 0, "make torrent succesfully."
def magnet2torrent(magnet, output_name=None): try: import libtorrent as lt except ImportError: try: # noinspection PyUnresolvedReferences from lib.libtorrent import libtorrent as lt except ImportError: logger.error( "Unable to import libtorrent, disabling magnet conversion") lazylibrarian.CONFIG['TOR_CONVERT_MAGNET'] = False return False if output_name and \ not pt.isdir(output_name) and \ not pt.isdir(pt.dirname(pt.abspath(output_name))): logger.debug("Invalid output folder: " + pt.dirname(pt.abspath(output_name))) return False tempdir = tempfile.mkdtemp() # noinspection PyUnresolvedReferences ses = lt.session() # noinspection PyUnresolvedReferences params = { 'save_path': tempdir, 'storage_mode': lt.storage_mode_t(2), 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } # noinspection PyUnresolvedReferences handle = lt.add_magnet_uri(ses, magnet, params) logger.debug("Downloading Metadata (this may take a while)") counter = 90 while counter and not handle.has_metadata(): try: sleep(1) counter -= 1 except KeyboardInterrupt: counter = 0 if not counter: logger.debug("magnet2Torrent Aborting...") ses.pause() logger.debug("Cleanup dir " + tempdir) try: shutil.rmtree(tempdir) except Exception as e: logger.debug("%s removing directory: %s" % (type(e).__name__, str(e))) return False ses.pause() torinfo = handle.get_torrent_info() # noinspection PyUnresolvedReferences torfile = lt.create_torrent(torinfo) # noinspection PyUnresolvedReferences torcontent = lt.bencode(torfile.generate()) ses.remove_torrent(handle) output = pt.abspath(torinfo.name() + ".torrent") if output_name: if pt.isdir(output_name): output = pt.abspath( pt.join(output_name, torinfo.name() + ".torrent")) elif pt.isdir(pt.dirname(pt.abspath(output_name))): output = pt.abspath(output_name) logger.debug("Saving torrent file here : " + output + " ...") with open(output, 'wb') as f: f.write(torcontent) logger.debug("Saved! Cleaning up dir: " + tempdir) try: shutil.rmtree(tempdir) except Exception as e: logger.debug("%s removing directory: %s" % (type(e).__name__, str(e))) return output
def record_torrent(self, item, hist_folder): tmp_dir = TMPDIR name = '' if not os.path.exists(hist_folder): os.makedirs(hist_folder) if item.startswith('http') or os.path.isfile(item): home = hist_folder name1 = os.path.basename(item).replace('.torrent', '') torrent_dest1 = os.path.join(tmp_dir, name1+'.torrent') if not os.path.exists(torrent_dest1): if item.startswith('http'): ccurl(item+'#'+'-o'+'#'+torrent_dest1) else: shutil.copy(item, torrent_dest1) if os.path.exists(torrent_dest1): info = lt.torrent_info(torrent_dest1) name = info.name() torrent_dest = os.path.join(home, name+'.torrent') shutil.copy(torrent_dest1, torrent_dest) logger.info(name) elif item.startswith('magnet:'): torrent_handle, stream_session, info = get_torrent_info_magnet( item, tmp_dir, self, ui.progress, tmp_dir) torrent_file = lt.create_torrent(info) home = hist_folder name = info.name() torrent_dest = os.path.join(home, name+'.torrent') with open(torrent_dest, "wb") as f: f.write(lt.bencode(torrent_file.generate())) torrent_handle.pause() stream_session.pause() ui.stop_torrent_forcefully() if name: torrent_dest = os.path.join(home, name+'.torrent') info = lt.torrent_info(torrent_dest) file_arr = [] for f in info.files(): file_path = f.path file_path = os.path.basename(file_path) file_arr.append(file_path) if file_arr: hist_path = os.path.join(home, 'history.txt') if not os.path.isfile(hist_path): hist_dir, last_field = os.path.split(hist_path) if not os.path.exists(hist_dir): os.makedirs(hist_dir) f = open(hist_path, 'w').close() if os.path.isfile(hist_path): if (os.stat(hist_path).st_size == 0): write_files(hist_path, name, line_by_line=True) else: lines = open_files(hist_path, True) line_list = [] for i in lines: i = i.strip() line_list.append(i) if name not in line_list: write_files(hist_path, name, line_by_line=True) hist_site = os.path.join(hist_folder, name) if not os.path.exists(hist_site): try: os.makedirs(hist_site) hist_epn = os.path.join(hist_site, 'Ep.txt') write_files(hist_epn, file_arr, line_by_line=True) except Exception as e: print(e) return name
["zip", "-r", zip_filename, image_directory + "/"]) subprocess.check_call(zip_commandline, stdout=sys.stdout, stderr=sys.stderr, stdin=subprocess.PIPE, shell=True) else: print("ZIP file already created: {}".format(zip_filename)) torrent_filename = filename_base + ".torrent" if not torrent_filename in os.listdir("."): print("Creating torrent file: {}".format(torrent_filename)) #Make a torrent file fs = lt.file_storage() lt.add_files(fs, zip_filename) t = lt.create_torrent(fs) t.add_tracker("udp://tracker.openbittorrent.com:80/announce", 0) t.set_creator(torrent_author) torrent_info = torrent_info_template.format(**dict(globals(), **locals())) t.set_comment(torrent_info) lt.set_piece_hashes(t, '.') torrent = t.generate() with open(torrent_filename, 'w') as f: f.write(lt.bencode(torrent)) else: print("Torrent file already created: {}".format(torrent_filename)) wiki_description_filename = filename_base + "_wiki.txt" if not wiki_description_filename in os.listdir("."): print("Creating wiki description: {}".format(wiki_description_filename)) image_sha1 = get_sha1_for_file(image_path, sha1_bufsize)
def parse_magnet_uri(magnet_uri, scrape=False, use_dht=True, force_dht=False, timeout=10, trackers=None, no_cache=False, n_try=3): try: import libtorrent as lt except ImportError: raise ImportError('libtorrent package required') # parameters params = lt.parse_magnet_uri(magnet_uri) # prevent downloading # https://stackoverflow.com/q/45680113 if isinstance(params, dict): params['flags'] |= lt.add_torrent_params_flags_t.flag_upload_mode else: params.flags |= lt.add_torrent_params_flags_t.flag_upload_mode lt_version = [int(v) for v in lt.version.split('.')] if [0, 16, 13, 0] < lt_version < [1, 1, 3, 0]: # for some reason the info_hash needs to be bytes but it's a struct called sha1_hash if type({}) == type(params): params['info_hash'] = params['info_hash'].to_bytes() else: params.info_hash = params.info_hash.to_bytes() # 캐시에 있으면 ... info_hash_from_magnet = str(params['info_hash'] if type({}) == type(params) else params.info_hash) if (not no_cache) and (info_hash_from_magnet in Logic.torrent_cache): return Logic.torrent_cache[info_hash_from_magnet]['info'] # add trackers if type({}) == type(params): if len(params['trackers']) == 0: if trackers is None: trackers = json.loads(ModelSetting.get('trackers')) params['trackers'] = random.sample(trackers, 5) else: if len(params.trackers) == 0: if trackers is None: trackers = json.loads(ModelSetting.get('trackers')) params.trackers = random.sample(trackers, 5) # session session = lt.session() session.listen_on(6881, 6891) session.add_extension('ut_metadata') session.add_extension('ut_pex') session.add_extension('metadata_transfer') if use_dht: session.add_dht_router('router.utorrent.com', 6881) session.add_dht_router('router.bittorrent.com', 6881) session.add_dht_router("dht.transmissionbt.com", 6881) session.add_dht_router('127.0.0.1', 6881) session.start_dht() # handle handle = session.add_torrent(params) if force_dht: handle.force_dht_announce() for tryid in range(max(n_try, 1)): timeout_value = timeout while not handle.has_metadata(): time.sleep(0.1) timeout_value -= 0.1 if timeout_value <= 0: logger.debug( 'Failed to get metadata on trial: {}/{}'.format( tryid + 1, n_try)) break if handle.has_metadata(): lt_info = handle.get_torrent_info() logger.debug( 'Successfully get metadata after {} seconds on trial {}'. format(timeout - timeout_value, tryid + 1)) break else: if tryid + 1 == max(n_try, 1): session.remove_torrent(handle, True) raise Exception( 'Timed out after {}x{} seconds trying to get metainfo'. format(timeout, n_try)) # create torrent object and generate file stream torrent = lt.create_torrent(lt_info) torrent.set_creator('libtorrent v{}'.format(lt.version)) # signature torrent_dict = torrent.generate() torrent_info = Logic.convert_torrent_info(lt_info) torrent_info.update({ 'trackers': params.trackers if type({}) != type(params) else params['trackers'], 'creation_date': datetime.fromtimestamp(torrent_dict[b'creation date']).isoformat(), 'time': { 'total': timeout - timeout_value, 'metadata': timeout - timeout_value }, }) if scrape: # start scraping timeout_value = timeout while handle.status(0).num_complete < 0: time.sleep(0.1) timeout_value -= 0.1 if timeout_value <= 0: logger.error( 'Timed out after {} seconds trying to get peer info'. format(timeout)) if handle.status(0).num_complete >= 0: torrent_status = handle.status(0) torrent_info.update({ 'seeders': torrent_status.num_complete, 'peers': torrent_status.num_incomplete, }) torrent_info['time']['scrape'] = timeout - timeout_value torrent_info['time']['total'] = torrent_info['time'][ 'metadata'] + torrent_info['time']['scrape'] session.remove_torrent(handle, True) # caching for later use if Logic.torrent_cache is None: Logic.cache_init() Logic.torrent_cache[torrent_info['info_hash']] = { 'info': torrent_info, } return torrent_info
def play(url, xlistitem, is_view=None, subtitle=""): # -- Necesario para algunas webs ---------------------------- if not url.endswith(".torrent") and not url.startswith("magnet"): t_file = scrapertools.get_header_from_response( url, header_to_get="location") if len(t_file) > 0: url = t_file t_file = scrapertools.get_header_from_response( url, header_to_get="location") if len(t_file) > 0: url = t_file # -- Crear dos carpetas en descargas para los archivos ------ save_path_videos = os.path.join(config.get_setting("downloadpath"), "torrent-videos") save_path_torrents = os.path.join(config.get_setting("downloadpath"), "torrent-torrents") if not os.path.exists(save_path_torrents): os.mkdir(save_path_torrents) # -- Usar - archivo torrent desde web, meagnet o HD --------- if not os.path.isfile(url) and not url.startswith("magnet"): # -- http - crear archivo torrent ----------------------- data = url_get(url) # -- El nombre del torrent será el que contiene en los -- # -- datos. - re_name = urllib.unquote( scrapertools.get_match(data, ':name\d+:(.*?)\d+:')) torrent_file = filetools.join(save_path_torrents, filetools.encode(re_name + '.torrent')) f = open(torrent_file, 'wb') f.write(data) f.close() elif os.path.isfile(url): # -- file - para usar torrens desde el HD --------------- torrent_file = url else: # -- magnet --------------------------------------------- torrent_file = url # ----------------------------------------------------------- # -- MCT - MiniClienteTorrent ------------------------------- ses = lt.session() print "### Init session ########" print lt.version print "#########################" ses.add_dht_router("router.bittorrent.com", 6881) ses.add_dht_router("router.utorrent.com", 6881) ses.add_dht_router("dht.transmissionbt.com", 6881) trackers = [ "udp://tracker.openbittorrent.com:80/announce", "http://tracker.torrentbay.to:6969/announce", "http://tracker.pow7.com/announce", "udp://tracker.ccc.de:80/announce", "udp://open.demonii.com:1337", "http://9.rarbg.com:2710/announce", "http://bt.careland.com.cn:6969/announce", "http://explodie.org:6969/announce", "http://mgtracker.org:2710/announce", "http://tracker.best-torrents.net:6969/announce", "http://tracker.tfile.me/announce", "http://tracker1.wasabii.com.tw:6969/announce", "udp://9.rarbg.com:2710/announce", "udp://9.rarbg.me:2710/announce", "udp://coppersurfer.tk:6969/announce", "http://www.spanishtracker.com:2710/announce", "http://www.todotorrents.com:2710/announce", ] video_file = "" # -- magnet2torrent ----------------------------------------- if torrent_file.startswith("magnet"): try: tempdir = tempfile.mkdtemp() except IOError: tempdir = os.path.join(save_path_torrents, "temp") if not os.path.exists(tempdir): os.mkdir(tempdir) params = { 'save_path': tempdir, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_allocate, 'paused': False, 'auto_managed': True, 'duplicate_is_error': True } h = lt.add_magnet_uri(ses, torrent_file, params) dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') while not h.has_metadata(): message, porcent, msg_file, s, download = getProgress( h, "Creando torrent desde magnet") dp.update(porcent, message, msg_file) if s.state == 1: download = 1 if dp.iscanceled(): dp.close() remove_files(download, torrent_file, video_file, ses, h) return h.force_dht_announce() xbmc.sleep(1000) dp.close() info = h.get_torrent_info() data = lt.bencode(lt.create_torrent(info).generate()) #torrent_file = os.path.join(save_path_torrents, info.name() + ".torrent") torrent_file = os.path.join( save_path_torrents, unicode(info.name(), "'utf-8'", errors="replace") + ".torrent") f = open(torrent_file, 'wb') f.write(data) f.close() ses.remove_torrent(h) shutil.rmtree(tempdir) # ----------------------------------------------------------- # -- Archivos torrent --------------------------------------- e = lt.bdecode(open(torrent_file, 'rb').read()) info = lt.torrent_info(e) # -- El más gordo o uno de los más gordo se entiende que es - # -- el vídeo o es el vídeo que se usará como referencia - # -- para el tipo de archivo - print "##### Archivos ## %s ##" % len(info.files()) _index_file, _video_file, _size_file = get_video_file(info) _video_file_ext = os.path.splitext(_video_file)[1] if _video_file_ext == ".avi" or _video_file_ext == ".mp4": print "##### storage_mode_t.storage_mode_allocate (" + _video_file_ext + ") #####" h = ses.add_torrent({ 'ti': info, 'save_path': save_path_videos, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_allocate }) else: print "##### storage_mode: none (" + _video_file_ext + ") #####" h = ses.add_torrent({ 'ti': info, 'save_path': save_path_videos, 'trackers': trackers, 'storage_mode': lt.storage_mode_t.storage_mode_sparse }) # ----------------------------------------------------------- # -- Descarga secuencial - trozo 1, trozo 2, ... ------------ h.set_sequential_download(True) h.force_reannounce() h.force_dht_announce() # -- Prioritarizar/Seleccionar archivo----------------------- _index, video_file, video_size = get_video_files_sizes(info) if _index == -1: _index = _index_file video_file = _video_file video_size = _size_file # -- Inicio de variables para 'pause' automático cuando el - # -- el vídeo se acerca a una pieza sin completar - is_greater_num_pieces = False is_greater_num_pieces_plus = False is_greater_num_pieces_pause = False #porcent4first_pieces = int( video_size / 1073741824 ) porcent4first_pieces = int(video_size * 0.000000005) if porcent4first_pieces < 10: porcent4first_pieces = 10 if porcent4first_pieces > 100: porcent4first_pieces = 100 #num_pieces_to_resume = int( video_size / 1610612736 ) num_pieces_to_resume = int(video_size * 0.0000000025) if num_pieces_to_resume < 5: num_pieces_to_resume = 5 if num_pieces_to_resume > 25: num_pieces_to_resume = 25 print "##### porcent4first_pieces ## %s ##" % porcent4first_pieces print "##### num_pieces_to_resume ## %s ##" % num_pieces_to_resume # -- Prioritarizar o seleccionar las piezas del archivo que - # -- se desea reproducir con 'file_priorities' - piece_set = set_priority_pieces(h, _index, video_file, video_size) # -- Crear diálogo de progreso para el primer bucle --------- dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') _pieces_info = {} # -- Doble bucle anidado ------------------------------------ # -- Descarga - Primer bucle - while not h.is_seed(): s = h.status() xbmc.sleep(100) # -- Recuperar los datos del progreso ------------------- message, porcent, msg_file, s, download = getProgress(h, video_file, _pf=_pieces_info) # -- Si hace 'checking' existe descarga ----------------- # -- 'download' Se usará para saber si hay datos - # -- descargados para el diálogo de 'remove_files' - if s.state == 1: download = 1 # -- Player - play -------------------------------------- # -- Comprobar si se han completado las piezas para el - # -- inicio del vídeo ............... - first_pieces = True _p = "" _c = 0 for i in range(piece_set[0], piece_set[porcent4first_pieces]): _p += "[%s:%s]" % (i, h.have_piece(i)) first_pieces &= h.have_piece(i) if h.have_piece(i): _c += 1 _pieces_info = { 'current': 0, 'continuous': "%s/%s" % (_c, porcent4first_pieces), 'have': h.status().num_pieces, 'len': len(piece_set) } _p = "##### first_pieces [%s/%s][%s]: " % (_c, porcent4first_pieces, len(piece_set)) + _p print _p # -- -------------------------------------------------- - if is_view != "Ok" and first_pieces: print "##### porcent [%.2f%%]" % (s.progress * 100) is_view = "Ok" dp.close() # -- Player - Ver el vídeo -------------------------- playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO) playlist.clear() #ren_video_file = os.path.join( save_path_videos, video_file ).replace('\\','\\\\') ren_video_file = os.path.join(save_path_videos, video_file) playlist.add(ren_video_file, xlistitem) #playlist.add( os.path.join( save_path_videos, video_file ), xlistitem ) #playlist.add( "http://192.168.0.200/mctplay/" + video_file.replace(' ','%20'), xlistitem ) player = play_video(xbmc.PLAYER_CORE_AUTO) player.play(playlist) ''' # -- Player - Ver el vídeo -------------------------- player = play_video() #player.play( os.path.join( save_path_videos, video_file ) ) player.play( "http://192.168.0.200/mctplay/" + video_file.replace(' ','%20') ) ''' #player.play( os.path.join( save_path_videos, video_file ) ) # -- Contador de cancelaciones para la ventana de - # -- 'pause' automático - is_greater_num_pieces_canceled = 0 continuous_pieces = 0 porcent_time = 0.00 current_piece = 0 # -- Impedir que kodi haga 'resume' a un archivo ---- # -- que se reprodució con anterioridad y que se - # -- eliminó para impedir que intente la reprucción - # -- en una pieza que aún no se ha completado y se - # -- active 'pause' automático - not_resume = True # -- Bandera subTítulos _sub = False # -- Segundo bucle - Player - Control de eventos ---- while player.isPlaying(): xbmc.sleep(100) # -- Añadir subTítulos if subtitle != "" and not _sub: _sub = True player.setSubtitles(subtitle) # -- Impedir que kodi haga 'resume' al inicio --- # -- de la descarga de un archivo conocido - if not_resume: player.seekTime(0) not_resume = False #xbmc.sleep(1000) # -- Control 'pause' automático - continuous_pieces = count_completed_continuous_pieces( h, piece_set) if xbmc.Player().isPlaying(): # -- Porcentage del progreso del vídeo ------ porcent_time = player.getTime() / player.getTotalTime( ) * 100 # -- Pieza que se está reproduciendo -------- current_piece = int(porcent_time / 100 * len(piece_set)) # -- Banderas de control -------------------- is_greater_num_pieces = ( current_piece > continuous_pieces - num_pieces_to_resume) is_greater_num_pieces_plus = ( current_piece + porcent4first_pieces > continuous_pieces) is_greater_num_pieces_finished = ( current_piece + porcent4first_pieces >= len(piece_set)) # -- Activa 'pause' automático -------------- if is_greater_num_pieces and not player.paused and not is_greater_num_pieces_finished: is_greater_num_pieces_pause = True player.pause() # -- Log ------------------------------------ _TotalTime = player.getTotalTime() _Time = player.getTime() _print_log = "\n##### Player ##################################" _print_log += "\nTamaño del vídeo: %s" % video_size _print_log += "\nTotal piezas: %s" % len(piece_set) _print_log += "\nPiezas contiguas: %s" % continuous_pieces _print_log += "\n-----------------------------------------------" _print_log += "\nVídeo-Total segundos: %s" % _TotalTime _print_log += "\nVídeo-Progreso segundos: %s" % _Time _print_log += "\nVídeo-Progreso porcentaje: %.2f%%" % porcent_time _print_log += "\n-----------------------------------------------" _print_log += "\ncurrent_piece: %s" % current_piece _print_log += "\nis_greater_num_pieces: %s" % is_greater_num_pieces _print_log += "\nis_greater_num_pieces_plus: %s" % is_greater_num_pieces_plus _print_log += "\nis_greater_num_pieces_pause: %s" % is_greater_num_pieces_pause _print_log += "\nis_greater_num_pieces_finished: %s" % is_greater_num_pieces_finished _print_log += "\nPieza que se está visionando: %.2f" % ( porcent_time / 100 * len(piece_set)) _print_log += "\nOffset que se está visionando: %.2f" % ( porcent_time / 100 * video_size) if is_greater_num_pieces and not player.paused and not is_greater_num_pieces_finished: _print_log += "\n+++++++++++++++++++++++++++++++++++++++++++++++" _print_log += "\nPausa con:" _print_log += "\n current_piece = %s" % current_piece _print_log += "\n continuous_pieces = %s" % continuous_pieces _print_log += "\n###############################################" print _print_log # ------------------------------------------- _pieces_info = { 'current': current_piece, 'continuous': continuous_pieces, 'have': h.status().num_pieces, 'len': len(piece_set) } # -- Cerrar el diálogo de progreso -------------- if player.resumed: dp.close() # -- Mostrar el diálogo de progreso ------------- if player.paused: # -- Crear diálogo si no existe ------------- if not player.statusDialogoProgress: dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') player.setDialogoProgress() # -- Diálogos de estado en el visionado ----- if not h.is_seed(): # -- Recuperar los datos del progreso --- message, porcent, msg_file, s, download = getProgress( h, video_file, _pf=_pieces_info) dp.update(porcent, message, msg_file) else: dp.update(100, "Descarga completa: " + video_file) # -- Se canceló el progreso en el visionado - # -- Continuar - if dp.iscanceled(): dp.close() player.pause() # -- Se canceló el progreso en el visionado - # -- en la ventana de 'pause' automático. - # -- Parar si el contador llega a 3 - if dp.iscanceled() and is_greater_num_pieces_pause: is_greater_num_pieces_canceled += 1 if is_greater_num_pieces_canceled == 3: player.stop() # -- Desactiva 'pause' automático y --------- # -- reinicia el contador de cancelaciones - if not dp.iscanceled( ) and not is_greater_num_pieces_plus and is_greater_num_pieces_pause: dp.close() player.pause() is_greater_num_pieces_pause = False is_greater_num_pieces_canceled = 0 # -- El usuario cancelo el visionado -------- # -- Terminar - if player.ended: # -- Diálogo eliminar archivos ---------- remove_files(download, torrent_file, video_file, ses, h) return # -- Kodi - Se cerró el visionado ----------------------- # -- Continuar | Terminar - if is_view == "Ok" and not xbmc.Player().isPlaying(): if info.num_files() == 1: # -- Diálogo continuar o terminar --------------- d = xbmcgui.Dialog() ok = d.yesno('pelisalacarta-MCT', 'XBMC-Kodi Cerró el vídeo.', '¿Continuar con la sesión?') else: ok = False # -- SI --------------------------------------------- if ok: # -- Continuar: --------------------------------- is_view = None else: # -- Terminar: ---------------------------------- # -- Comprobar si el vídeo pertenece a una ------ # -- lista de archivos - _index, video_file, video_size = get_video_files_sizes(info) if _index == -1 or info.num_files() == 1: # -- Diálogo eliminar archivos -------------- remove_files(download, torrent_file, video_file, ses, h) return else: # -- Lista de archivos. Diálogo de opciones - piece_set = set_priority_pieces(h, _index, video_file, video_size) is_view = None dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') # -- Mostar progeso antes del visionado ----------------- if is_view != "Ok": dp.update(porcent, message, msg_file) # -- Se canceló el progreso antes del visionado --------- # -- Terminar - if dp.iscanceled(): dp.close() # -- Comprobar si el vídeo pertenece a una lista de - # -- archivos - _index, video_file, video_size = get_video_files_sizes(info) if _index == -1 or info.num_files() == 1: # -- Diálogo eliminar archivos ------------------ remove_files(download, torrent_file, video_file, ses, h) return else: # -- Lista de archivos. Diálogo de opciones ----- piece_set = set_priority_pieces(h, _index, video_file, video_size) is_view = None dp = xbmcgui.DialogProgress() dp.create('pelisalacarta-MCT') # -- Kodi - Error? - No debería llegar aquí ----------------- if is_view == "Ok" and not xbmc.Player().isPlaying(): dp.close() # -- Diálogo eliminar archivos -------------------------- remove_files(download, torrent_file, video_file, ses, h) return
import libtorrent as lt import time piece_size = 256 * 1024 creator_str = "peerbay.p2p" thetracker = "bttracker.debian.org" theurlseed = "your desired url seed" fs = lt.file_storage() lt.add_files(fs, "demoCA") fs.num_files() t = lt.create_torrent(fs, piece_size) t.add_tracker(thetracker) lt.set_piece_hashes(t, ".") t.set_root_cert("newkey.pem") t.set_creator(creator_str) #~ t.add_url_seed(theurlseed) f = open("dom.torrent", "wb") f.write(lt.bencode(t.generate())) f.close() ses = lt.session() ses.listen_on(6881, 6891) e = lt.bdecode(open("dom.torrent", 'rb').read()) info = lt.torrent_info(e) params = { "save_path": './', \ "storage_mode": lt.storage_mode_t.storage_mode_sparse, \ "ti": info }