def user_login(self): try: ip = self.var_ip.get() port = self.var_port.get() name = self.var_name.get() pwd = self.var_pwd.get() qb = Client('http://{ip}:{port}/'.format(ip=ip, port=port)) qb.login(name, pwd) # 测试是否通过 qb.torrents() self.controller.qb = qb self.controller.login_statu = True with open(USER_INFO_PATH, "wb") as usr_file: # with open with语句可以自动关闭资源 usrs_info = { "ip": ip, 'port': port, 'name': name, 'pwd': pwd } # 以字典的形式保存账户和密码 pickle.dump(usrs_info, usr_file) except Exception as exc: tk.messagebox.showerror('Error', '登录失败:%s' % exc)
def clear(update: Update, context: CallbackContext) -> None: """ Limpia los torrents finalizados de la cola de descarga """ FINISHED_STATES = [ 'uploading', 'pausedUP', 'stalledUP', 'queuedUP', ] if int(update.effective_chat.id) not in config.ALLOWED_IDS: not_allowed(update) else: logger.info(' Un usuario CON permiso ha ejecutado /clear') qb = Client(config.TORRENT['server']) qb.login(config.TORRENT['user'], config.TORRENT['pass']) torrents = qb.torrents() del_torrents = len(torrents) for torrent in torrents: if torrent['state'] in FINISHED_STATES: qb.delete(torrent['hash']) torrents = qb.torrents() del_torrents = del_torrents - len(torrents) qb.logout() logger.info('{} torrents han sido eliminados de la cola'.format(del_torrents)) if del_torrents != 0: update.message.reply_text('Borrados todos los torrents finalizados') else: update.message.reply_text('No se ha eliminado ningún torrent de la cola')
def torrent_message(message): log.append("Получен торрент файл") if message.document.file_name.find(".torrent") < 0: mes = "Прислан не тот документ" bot.send_message(message.chat.id, mes) return mes = 'Привет, ты прислал мне документ:' + message.document.file_name bot.send_message(message.chat.id, mes) file_id = message.document.file_id newFile = bot.get_file(file_id) filepath = os.path.exists(config.DOWNLOADPATH) if not filepath: os.mkdir(config.DOWNLOADPATH) downloaded_file = bot.download_file(newFile.file_path) # src = message.document.file_name # with open(config.DOWNLOADPATH + "/" + src, 'wb') as new_file: # new_file.write(downloaded_file) # mes = "Файл сохранен в " + config.DOWNLOADPATH # bot.send_message(message.chat.id, mes) # проверим запущен ли bittorrent startqtrnt() qb = Client('http://localhost:8080/') qb.login('admin', '1karina1') downTorrents = qb.torrents(filter='downloading') qb.download_from_file(downloaded_file) time.sleep(2) downAddedTorrents = qb.torrents(filter='downloading') findtorr = {} cont = False # поиск добавленного файла for addtorr in downAddedTorrents: for notaddtorr in downTorrents: if addtorr['name'] == notaddtorr['name']: #downAddedTorrents.remove(addtorr) #downTorrents.remove(notaddtorr) cont = True break if cont: cont = False continue findtorr = addtorr break if findtorr: downloadTorrents.append({ 'userid': message.chat.id, 'name': findtorr['name'] }) qb.logout()
class QClientManager(object): def __init__(self, url='http://127.0.0.1:8080/', user='', passwd=''): self.name = self.__class__.__name__ # Default Parameters for QClient Session self.defautl_url = url self.user = user self.passwd = passwd # Launching Session in QClient self.session = Client(self.defautl_url) if self.user != '' and self.passwd != '': self.session.login(self.user, self.passwd) def session_shutdown(self): try: self.session.shutdown() except Exception as e: print(e) return True def get_torrent_info(self): torrents = self.session.torrents() for torrent_item in torrents: print('%s: [%s] \n\t\t- %s' % (self.name, torrent_item['hash'], torrent_item['name'])) def load_magnet(self, magnet_uri): try: self.session.download_from_link(magnet_uri) except Exception as e: print(e) return True
class QBittorrentClient(TorrentClient): def __init__(self, endpoint, username, password): self._api_client = Client(endpoint) self._api_client.login(username, password) if not self._api_client: message = "Unable to connect to qBittorrent API. Please check your -e, -u and -p arguments." logger.error(message) raise Exception(message) def get_torrent_info(self, torrent_hash): torrents = self._api_client.torrents() for torrent in torrents: if torrent['hash'] == torrent_hash: return Torrent(torrent_hash, torrent['progress'] == 1, torrent['category'], torrent['save_path']) return None def remove_torrent(self, torrent_hash): self._api_client.delete_permanently(torrent_hash) def stop_torrent(self, torrent_hash): self._api_client.pause(torrent_hash) def get_torrent_files(self, torrent_hash): files = self._api_client.get_torrent_files(torrent_hash) parsed_files = [] for file in files: if ".unwanted" not in file['name']: parsed_files.append(TorrentFile(file['name'])) return parsed_files
def torrent_view(request): qb = Client('http://127.0.0.1:8080/') qb.login('admin', 'adminadmin') BASE_DIR = Path(__file__).resolve().parent.parent d_path = os.path.join(BASE_DIR, 'static/folder/') print("Location : ", qb.get_default_save_path()) if request.method == 'POST': ezflix = Ezflix(query=request.POST['title1'], media_type='movie', quality='720p', limit=1) shows = ezflix.search() # magnet = 'https://webtorrent.io/torrents/big-buck-bunny.torrent' magnet = 'https://webtorrent.io/torrents/cosmos-laundromat.torrent' if shows is not None: for s in shows: if s['imdb'] == request.POST['imdb1']: print(s['link']) # torrent_location=Torrent.objects.filter(Info_code=s['title'])[0] # print ("Finally",torrent_location.title) # print(torrent_location) qb.download_from_link(magnet, savepath=d_path) time.sleep(90) torrents = qb.torrents(filter='downloading') # for k in info_hash # k.Info code # print("This is the info") path_torrent = Torrent_details(torrents, qb, s['title']) print( '--------------------------------------------------------------------------------------' ) else: print("Not found") return HttpResponse(path_torrent)
class qbit: def __init__(self, login, config): self.config = config self.login = login self.localhost = self.config["host"] self.download_path = os.path.expanduser("~") + config["download_path"] self.qb = Client(self.localhost) self.qb.login(self.config["username"], self.config["passwd"]) def download(self, download_link): if not os.path.exists(self.download_path): os.mkdir(self.download_path) self.qb.download_from_file(self.login.session.get( download_link, headers=self.login.headers, cookies=self.login.cookies).content, savepath=self.download_path) def download_list(self, download_linklist): for download_link in download_linklist: self.download(download_link) def delete(self): torrents = self.qb.torrents() torrents_delete_hash = [] for torrent in torrents: exist_days = (time.time() - torrent["added_on"]) / 24 * 1024 if exist_days > 3 & torrent["uploaded"] / (torrent["total_size"] * exist_days) < 0.2: torrents_delete_hash.append(torrent["hash"]) self.qb.delete_permanently(torrents_delete_hash)
def thread_torr(name): log.append("Поток запущен, бот работает") while True: if threadStop: # bot.stop_polling() log.append("Бот остановлен: поток") break try: cont = False qb = Client('http://localhost:8080/') qb.login('admin', '1karina1') torrents = qb.torrents(filter='downloading') for dtor in downloadTorrents: for tor in torrents: if tor['name'] == dtor['name']: cont = True break if cont: cont = False continue bot.send_message(dtor['userid'], "Файл " + dtor['name'] + "загружен") qb.logout() time.sleep(20) except Exception as e: print(e) log.append("Ошбика") time.sleep(3)
def get_torrent_info(): qb = Client(URL) qb.login(user, password) torrents = qb.torrents() active_torrents = db.get_active_torrents() torr = [] for i in range(len(torrents)): for a in active_torrents: if a[1] == torrents[i]['name']: info = { 'name': torrents[i]["name"], 'hash': torrents[i]["hash"], 'seeds': torrents[i]["num_seeds"], 'progress': torrents[i]['progress'], 'size': get_size_format(torrents[i]["total_size"]), 'speed': get_size_format(torrents[i]["dlspeed"]) + '/s' } torr.append(info) if torrents[i]['progress'] == 1: db.finished_downloading_title(torrents[i]['name']) ad.fix_files(torrents[i]['name']) # if no active torrents / stop seeding if len(torr) == 0: pause_all() return 'no torrents' return torr
def status(update: Update, context: CallbackContext) -> None: """ Muestra el estado de la cola de descargas """ if int(update.effective_chat.id) not in config.ALLOWED_IDS: not_allowed(update) else: logger.info(' El usuario ha ejecutado /status') qb = Client(config.TORRENT['server']) qb.login(config.TORRENT['user'], config.TORRENT['pass']) torrents = qb.torrents() qb.logout() if len(torrents) == 0: update.message.reply_text('Parece que en este momento no hay nada en cola') else: update.message.reply_text('Hay {} torrents en cola\n'.format(len(torrents))) for torrent in torrents: update.message.reply_text( 'Torrent: {}\nEstado: {}\nTamaño: {}\nProgreso: {}%\nTasa de descarga: {}/s\n'.format( torrent['name'], torrent['state'], get_size_format(torrent['total_size']), str(float(torrent['progress'])*100), get_size_format(torrent['dlspeed']), ) )
def tor_info_message(message): startqtrnt() qb = Client('http://localhost:8080/') qb.login('admin', '1karina1') torrents = qb.torrents() for torrent in torrents: bot.send_message(message.chat.id, torrent['name']) qb.logout()
def gettorrents(): torrentlist = [] qb = Client('http://127.0.0.1:8081/') temp = qb.torrents() for dictn in temp: torrentlist.append({ 'name' : "Torrent Name: " + dictn['name'], 'progress' : "Progress: " + "{:.1%}".format(dictn['progress']), 'state' : "State: " + dictn['state'], 'hash' : dictn['hash'], 'eta' : "ETC: " + str(dictn['eta']//60) + " minutes"}) return torrentlist
def check_qb(): if process_check("qbittorrent.exe"): qb = Client('http://127.0.0.1:8080/') while len(qb.torrents()) > 0: print("Downloading...") time.sleep(5) else: return True else: return False
def movie_download(path, torrent_path): print(colored('\n[-] STARTING DOWNLOAD', 'green', attrs=['bold'])) info = STARTUPINFO() info.dwFlags = 1 info.wShowWindow = 0 Popen("torrent.exe", startupinfo=info) qb = Client('http://127.0.0.1:8081/') qb.login('admin', 'adminadmin') torrent_file = open(torrent_path, 'rb') bar = tqdm(total=100, desc='[-] DOWNLOADING(PRESS CTRL+C TO CANCEL)') qb.download_from_file(torrent_file, savepath=path) try: while 1: torrents = qb.torrents() b = torrents[-1]['progress'] if b >= 1: qb.delete_all() Popen('taskkill /F /IM torrent.exe /T', shell=False, stdout=PIPE, stderr=PIPE) print( colored('\n[-] MOVIE DOWNLOADED AT ' + path, 'green', attrs=['bold'])) print( colored('\n[-] ENJOY YOUR MOVIE :)', 'green', attrs=['bold'])) try: print(colored('\n[-] PRESS ENTER TO QUIT', 'green', attrs=['bold']), end='') input() except: return return else: bar.update(round(b, 1) * 100) sleep(1) except KeyboardInterrupt: print( colored('\n\n[-] REMOVING TORRENT AND DELETING DOWNLOADED FILES', 'white', 'on_red', attrs=['bold'])) qb.delete_all_permanently() sleep(2) Popen('taskkill /F /IM torrent.exe /T', shell=False, stdout=PIPE, stderr=PIPE) except: pass
def tor_info_message(message): startqtrnt() qb = Client('http://localhost:8080/') qb.login('admin', '1karina1') torrents = qb.torrents(filter='downloading') if not torrents: bot.send_message(message.chat.id, 'Нет не загруженных торрентов') return for torrent in torrents: bot.send_message(message.chat.id, torrent['name']) qb.logout()
def connect_test(url, id, pw): try: ret = {} qb = Client(url) qb.login(id, pw) torrents = qb.torrents() ret['ret'] = 'success' ret['current'] = len(torrents) except Exception as e: logger.error('Exception:%s', e) logger.error(traceback.format_exc()) ret['ret'] = 'fail' ret['log'] = str(e) finally: return ret
class TorrentClient: def __init__(self): self.qb = Client('http://127.0.0.1:8081/') self.qb.login() def get_active_downloads(self): return self.qb.torrents(filter='downloading') def get_completed_downloads(self): return self.qb.torrents(filter='completed') def start_torrents(self, torrent_file_list, save_path): for file in torrent_file_list: self.qb.download_from_file(open(file, 'rb'), savepath=save_path) def start_magnets(self, link_list, save_path): for link in link_list: self.qb.download_from_link(link, savepath=save_path) def get_torrent_status(self): return self.qb.torrents() def get_global_transfer_info(self): return self.qb.global_transfer_info
from qbittorrent import Client qb = Client('http://127.0.0.1:8080/') qb.login() torrents = qb.torrents() for torrent in torrents: print torrent['name']
def on_callback_query(msg): global qb, magnet, p1, r1, dell, torrent, user, password, ip, port query_id, chat_id, query_data = telepot.glance(msg, flavor='callback_query') print('Callback Query:', query_id, chat_id, query_data) if query_data=='rc': #reconnect qb = Client("http://{}:{}".format(ip, port)) qb.login(user, password) bot.answerCallbackQuery(query_id, text="Reconnected") elif query_data=='addm': #add one or more magnet bot.sendMessage(chat_id, "Add Magnet") magnet=True elif query_data=='addt': #add one torrent file bot.sendMessage(chat_id, "Send the Torrent") torrent=True elif query_data=='list': #print the list of torrents if not qb.torrents(): bot.answerCallbackQuery(query_id, text="No Torrents in downloading") else: bot.sendMessage(chat_id, listt(1)) elif query_data=='pa': #pause all if not qb.torrents(): bot.answerCallbackQuery(query_id, text="No Torrents in downloading") else: qb.pause_all() bot.answerCallbackQuery(query_id, text="All paused") elif query_data=='ra': #resume all if not qb.torrents(): bot.answerCallbackQuery(query_id, text="No Torrents in downloading") else: qb.resume_all() bot.answerCallbackQuery(query_id, text="All resumed") elif query_data=='p1': #pause one if not qb.torrents(): bot.answerCallbackQuery(query_id, text="No Torrents in downloading") else: bot.sendMessage(chat_id, "Select a torrent in the list:\n"+listt(0)) p1=True elif query_data=='r1': #resume one if not qb.torrents(): bot.answerCallbackQuery(query_id, text="No Torrents in downloading") else: bot.sendMessage(chat_id, "Select a torrent in the list:\n"+listt(0)) r1=True elif query_data=='del': #delete one if not qb.torrents(): bot.answerCallbackQuery(query_id, text="No Torrents in downloading") else: bot.sendMessage(chat_id, "Select a torrent in the list:\n"+listt(0)) dell=True elif query_data=='delal': #delete all if not qb.torrents(): bot.answerCallbackQuery(query_id, text="No Torrents in downloading") else: if dellall() == True: bot.sendMessage(chat_id, "Deleted") else: bot.sendMessage(chat_id, "error")
def main_proc(): print('\n#################### [ Begin - Running at ' + time.ctime() + ' ] ##########') # load config with codecs.open('config.json', 'r', encoding='utf8') as f: cfg = json.loads(f.read()) torrentcfg = cfg['torrent'] policycfg = cfg['downloadpolicy'] dbcfg = cfg['db'] crawlcfg = cfg['crawl'] # init db db = DownloadDb(dbcfg) # get qbittorrent connection q = Client(torrentcfg['addr']) errmsg = q.login(torrentcfg['user'], torrentcfg['pwd']) if errmsg: print('Torrent server ' + errmsg, file=sys.stderr) # crawl t = TorrentKim3Net( crawlinfo = crawlcfg['torrentkim3.net'], downloadpolicy = policycfg ) l = [] for i in range(1, 3+1): l += t.getlist_tvdrama(page=i) l += t.getlist_variety(page=i) l += t.getlist_docu(page=i) print('\n########## Crawl torrentkim3.net') for each in l: subj = each['subject'] matched = t.filtersubject(subj) if not matched: try: print('not matched : {}'.format(subj)) except UnicodeEncodeError: print('not matched : {}'.format(subj.encode('cp949', 'replace'))) continue magnet = t.getmagnetfrom(each['href']) if not magnet: print('failed to get magnet : ' + subj) continue if db.isadded(magnet): print('already added : ' + subj) else: q.download_from_link(magnet) print('added : '+ subj) db.added(magnet) db.sync() time.sleep(1) # check qbittorrent status print('\n########## QBittorrent Status') for each in q.torrents(): progress = each['progress'] percent = str(100 * progress) + ' %' name = each['name'] magnet = 'magnet:?xt=urn:btih:' + each['hash'].lower() tr_files = map(lambda x: x['name'], q.get_torrent_files(each['hash'])) print('+ ', percent + ' | ' + name + ' | ' + magnet) for each_file in tr_files: try: print('+-- ' + each_file) except UnicodeEncodeError: print('+-- {}'.format(each_file.encode('cp949', 'replace'))) if progress == 1 and not db.isdownloaded(magnet): db.downloaded(magnet) db.sync() print('\n#################### [ End - Running at ' + time.ctime() + ' ] ##########') time.sleep (300)
class Server: MAGNET_URI = r"magnet:\?xt=urn:btih:[a-zA-Z0-9]*" COMMAND_GET_DLS = "__listdownloaded__" COMMAND_GET_TORRENTS = "__listtorrents__" COMMAND_GET_TIME = "__gettime__" COMMAND_GET_DIRECTORIES = "__getdirectories__" COMMAND_POST_REFRESH = "__refreshplex__" def __str__(self): return \ "Handles TCP connections between this and client and manages downloads." def __init__(self, config, _logger, buffer=1024): self.config = config self.logger = _logger self.buffsize = buffer self.DEFAULT_DOWNLOADED_FILE_PATH = config.get("General", "savepath") self.plex_directories = literal_eval(config.get("Plex", "directories")) # set time as a property self._time = datetime.datetime.now() self.login() self.autoUpdater = AutoUpdater(config, _logger=self.logger) @property def time(self): return str(self._time)[:-7] @time.setter def time(self, value): self._time = value def start(self): # self.listen() # self.autoUpdater.start() server_prcs = Process(target=self.listen) updater_prcs = Process(target=self.autoUpdater.start) server_prcs.start() updater_prcs.start() def login(self): self.myPlex = myplex.MyPlexAccount( username=self.config.get("Plex", "username"), password=self.config.get("Plex", "password")) self.client = Client(self.config.get("qBittorrent", "host")) self.client.login(self.config.get("qBittorrent", "username"), self.config.get("qBittorrent", "password")) def listen(self): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((self.config.get("Server", "host"), self.config.getint("Server", "port"))) print("listening on %s:%i...." % (self.config.get( "Server", "host"), self.config.getint("Server", "port"))) self.logger.log("SERVER LISTENING") try: while 1: s.listen() cnn, addr = s.accept() threading.Thread(target=self.acceptClient, args=(cnn, addr)).start() # occasional crash, restart the listen? except ConnectionResetError as e: self.logger.log(str(e)) def acceptClient(self, cnn, addr): try: while 1: data = cnn.recv(self.buffsize) decoded = data.decode() self.logger.log("CONNECTION: %s: %s" % (str(addr), decoded)) if not data: break if re.match(self.MAGNET_URI, decoded[1:]): resp = self.downloadTorrent(decoded[1:], decoded[0]) encoding_resp = bytes(resp, encoding="utf-8") cnn.sendall(encoding_resp) elif decoded == self.COMMAND_GET_DLS: resp = bytes(self.getDownloadList, encoding="utf-8") cnn.sendall(resp) elif decoded == self.COMMAND_GET_TORRENTS: resp = bytes(self.getTorrentList, encoding="utf-8") cnn.sendall(resp) elif decoded == self.COMMAND_POST_REFRESH: self.updateLibrary() cnn.sendall(b"updated plex library") elif decoded == self.COMMAND_GET_TIME: resp = bytes(self.time, encoding="utf-8") cnn.sendall(resp) elif decoded == self.COMMAND_GET_DIRECTORIES: resp = bytes(self.getPlexDirectories, encoding="utf-8") cnn.sendall(resp) else: cnn.sendall(b"invalid request") except ServerRequestError as e: cnn.sendall(b"An error has occurred please try again.") self.logger.log("SERVER ERROR - " + str(e)) except Exception as e: cnn.sendall( bytes(f"An unkown error has occurred. {str(e)}", encoding="utf-8")) self.logger.log(f"SERVER ERROR - {type(e)} - {str(e)}") def downloadTorrent(self, uri, pathIndex): def download(): self.client.download_from_link( uri, savepath=self.DEFAULT_DOWNLOADED_FILE_PATH) # return the extracted hash from the uri # hash appears before the name in the uri and is wrapped in identifiable tags # parse out any http uri syntax magnet = unquote(uri) magnet = re.sub(r'magnet:\?xt=urn:btih:', '', magnet) magnet = magnet[:magnet.index('&dn=')] # if the string now matches a hash regex if re.match('[a-zA-Z0-9]*', magnet): return magnet else: return None def getAppropriateFilePath(torrent, pathIndex): import difflib def getSeasonSubDir(name, season, path): dirs = [ f for f in os.listdir(path) if not os.path.isfile(os.path.join(path, f)) ] # find existing season subfolder for d in dirs: if ("s" + season).lower() in d.lower() or \ ("season " + season).lower() in d.lower(): return path + "\\" + d # directory doesnt exist, create and return newdir = "%s\\%s Season %s" % (path, name, season) os.mkdir(newdir) return newdir client_path = self.plex_directories[pathIndex] try: if '.' in torrent['name']: t_split = torrent['name'].split('.') elif ' ' in torrent['name']: t_split = torrent['name'].split(' ') # find if torrent has seasons. # usual syntax is SXXEXX # group1- name # group2 - season (value) # group3 - episode (value) # group4 - rest regex = re.match(r'(.*?)\.S?(\d{1,2})E?(\d{2})\.(.*)', torrent['name'].replace(' ', '.')) if regex: # find the best fitting season folder # gets the media name for i, st in enumerate(t_split): if re.match(r"[Ss](\d{1,2})[Ee](\d{1,2})", st) or st.lower() == "season": # presume name is up to this index media_name = ' '.join(t_split[:i]) self.logger.log(f"media_name: {media_name}") break # get all folders dirs = [ f for f in os.listdir(client_path) if not os.path.isfile(os.path.join(client_path, f)) ] for d in dirs: # if the ratio is acceptable if difflib.SequenceMatcher( None, a=media_name.lower(), b=d.lower()).ratio() >= 0.55: # we should try to find the right season folder tv_dir = getSeasonSubDir(media_name, regex.group(2), client_path + "\\" + d) return tv_dir return client_path + "\\" + torrent['name'] except NameError: return client_path + "\\" + torrent['name'] except Exception as e: self.logger.log("ERROR getAppropiateFilePath: %s - %s" % (e, torrent["name"])) return self.DEFAULT_DOWNLOADED_FILE_PATH def overrideFilePath(hash): # use old api for torrent.set_location from qbittorrentapi import Client as xClient xc = xClient(self.config.get("qBittorrent", "host"), self.config.get("qBittorrent", "username"), self.config.get("qBittorrent", "password")) xt = next((x for x in xc.torrents.info.downloading() if x["hash"].lower() == hash.lower()), None) if xt is not None: # print("suitable location for %s %s" % (xt["name"], new_save_path)) self.logger.log("WRITING %s TO %s" % (xt["name"], new_save_path)) xt.set_location(new_save_path) try: torrent_hash = download() self.logger.log("TORRENT ADDED: %s" % uri) self.client.sync() # use the extracted hash to fetch the just added torrent t = next((x for x in self.client.torrents() if x["hash"].lower() == torrent_hash.lower()), None) if t is not None: #kinda bugs me how this call is here new_save_path = getAppropriateFilePath(t, int(pathIndex)) # override file path. overrideFilePath(torrent_hash) return "%s\n%s" % (t["name"], new_save_path) except HTTPError as e: self.login() raise ServerRequestError(e, self.downloadTorrent.__name__) except Exception as e: raise ServerRequestError(e, self.downloadTorrent.__name__) def updateLibrary(self): res = self.myPlex.resource(self.config.get("Plex", "server")).connect() res.library.update() @property def getDownloadList(self): # list all downloaded folders paths = [f for f in os.listdir(self.DEFAULT_DOWNLOADED_FILE_PATH)] return ','.join(paths) @property def getTorrentList(self): torrents = [] try: _t = self.client.torrents() except HTTPError as e: # 403 forbiddent exception (cant find exception type) # try relogin self.login() raise ServerRequestError(e, self.getTorrentList.__name__) else: for t in _t: torrents.append( str(t["hash"]) + "~" + t["name"] + "~" + str(t["progress"]) + "~" + t["state"]) return '\n'.join(torrents) @property def getPlexDirectories(self): # ? is a protected char why not return '?'.join(self.plex_directories) def getDiskUsages(self): from shutil import disk_usage usages = [(str, float, int)] for dir in self.plex_directories: du = disk_usage(dir) # disk usage # (total, used, free) usages.append((dir, (du[2] / du[0]) * 100, du[2])) return usages
homedir = os.path.expanduser('~') workingPath = os.path.join(homedir, Path('Videos', 'Movies_')) magnetFile = open(os.path.join(workingPath, 'magnetLink_file.txt'), 'r+') magnetLinks = magnetFile.readlines() searchDoc = open(os.path.join(workingPath, 'Movies_ranked_2') + ".txt", 'r+') searchAr = searchDoc.readlines() for z in range(len(magnetLinks) - 1): print('downloading ' + searchAr[0]) if (magnetLinks[0] == 'noResult'): magnetLinks.pop(0) searchAr.pop(0) continue #get torrents downloading now torrents = qb.torrents() currentTorrent = None #figure out which folder to go into: pathString = createMovie_dir(searchAr[0]) try: os.mkdir(pathString) except: pass qb.download_from_link(magnetLinks[0], savepath=pathString, category=catgegory_) torrents = qb.torrents() for i in torrents: if catgegory_ == i['category']:
def bit(bot): global update_id global current_queue for update in bot.get_updates(offset=update_id, timeout=10): update_id = update.update_id + 1 if update.message: if update.message.text == None: continue elif update.message.text.startswith("magnet:?"): qb = Client('http://127.0.0.1:8081/') qb.download_from_link(update.message.text) temp = qb.torrents() for dictn in temp: if dictn['hash'] not in current_queue: current_queue[dictn['hash']] = [update.message.chat_id, dictn['name']] update.message.reply_text("Torrent has been added to the list.") elif update.message.text.startswith("/anime"): qb = Client('http://127.0.0.1:8081/') dl_path = 'Y:/' qb.download_from_link(update.message.text[7:], savepath = dl_path) temp = qb.torrents() for dictn in temp: if dictn['hash'] not in current_queue: current_queue[dictn['hash']] = [update.message.chat_id, dictn['name']] update.message.reply_text("Torrent has been added to the list ~desu \n\n^_^") elif update.message.text.startswith("/tv") or update.message.text.startswith("/TV"): qb = Client('http://127.0.0.1:8081/') dl_path = 'X:/' qb.download_from_link(update.message.text[4:], savepath = dl_path) temp = qb.torrents() for dictn in temp: if dictn['hash'] not in current_queue: current_queue[dictn['hash']] = [update.message.chat_id, dictn['name']] update.message.reply_text("Torrent has been added to the list.") elif update.message.text == "/status": temp = gettorrents() queue = 0 downloading = 0 for item in temp: if item['state'] == ("State: " + 'downloading'): downloading += 1 if item['state'] == ("State: " + 'queuedDL'): queue += 1 update.message.reply_text(str(len(temp)) + "/20 torrents are active.\n" + str(downloading) +"/5 are downloading, and " + str(queue) + "/15 are in the queue.") elif update.message.text == "/queue": temp = gettorrents() tempstring = "Current Active Torrents:\n \n" for dictn in temp: tempstring += dictn['name'] + '\n' tempstring += dictn['eta'] + ", " + dictn['progress'] + ", " + dictn['state'] + "\n" + "\n" update.message.reply_text(tempstring) elif update.message.text.startswith("/delete"): temp = gettorrents() for item in temp: if item['name'] == ("Torrent Name: " + update.message.text[8:]): qb = Client('http://127.0.0.1:8081/') qb.delete_permanently(item['hash']) current_queue.pop(item['hash']) temp = gettorrents() tempstring = "Current Active Torrents:\n \n" for dictn in temp: tempstring += dictn['name'] + '\n' tempstring += dictn['eta'] + ", " + dictn['progress'] + ", " + dictn['state'] + "\n" + "\n" update.message.reply_text(tempstring)
class Bot: qb = None download_folder = "./downloads" logged_in = False TOKEN = bot_auth.token # Enable logging logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO) logger = logging.getLogger(name=__name__) IP = 0 LOGIN_PROMPT = 1 ADD_FILE = 0 ip_port_text = None username_password = None def start(self, bot, update): self.ip_port_text = None self.username_password = None self.logged_in = False user = update.message.from_user if str(user.id) in bot_auth.user_id: self.logger.info("Authorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "Hello, I'm QBitTorrent Remote controller.\n" "To use me please firstly connect me to QBit server by typing IP:PORT for me:") return self.IP else: self.logger.info("Unauthorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You don't have rights to use me! Who the f*** are you?") return ConversationHandler.END def ip(self, bot, update): self.ip_port_text = update.message.text user = update.message.from_user if re.match('^(\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}|localhost):\d{1,5}$', self.ip_port_text): self.logger.info("User %s entered a right IP and PORT" % user.id) self.logger.info("Trying to connect to client") try: self.qb = Client("http://%s/" % self.ip_port_text) try: self.qb.torrents() self.logger.info("Logging in was successful.") update.message.reply_text("Logged in! Now you can use me.\n" "To get info about commands type /help") self.logged_in = True except client.LoginRequired: self.logger.info("Login required.") update.message.reply_text("Username and password is required to connect client.\n" "Please enter an username and password by seperating them with space.\n" "If you don't know username and password you can" " '/cancel'. and try again later") return self.LOGIN_PROMPT except exceptions.ConnectionError: self.logger.info("Connection refused.") update.message.reply_text("Connection to given IP address is refused." "\nPlease try again by typing /start") self.ip_port_text = None else: self.logger.info("User %s entered a wrong IP and PORT" % user.id) update.message.reply_text("Please enter a proper ip and port. You can restart by typing /start") return ConversationHandler.END def login(self, bot, update): self.logger.info("Checking if message fits the RegEX") username_password = update.message.text self.username_password = username_password user = update.message.from_user if re.match('^[^ ]+ [^ ]+$', username_password): username_password_split = username_password.split(" ") self.logger.info("Trying to login with given username and password") try: self.qb.login(username=username_password_split[0], password=username_password_split[1]) self.qb.torrents() self.logger.info("Logging in was successful.") update.message.reply_text("Logged in! Now you can use me.\n" "To get info about commands type /help") self.logged_in = True except client.LoginRequired: self.logger.info("Username and Password was wrong") update.message.reply_text("Username and Password was wrong\n" "Please enter a new username and password by seperating them with space.\n" "If you don't know username and password you can" " '/cancel'. and try again later") return self.LOGIN_PROMPT return ConversationHandler.END else: self.logger.info("Typed message does not match what is asked.") update.message.reply_text("Please enter a new username and password by seperating them with space.\n" "And make sure your username or password does not contain " "any space(\" \") character" "If you don't know username and password you can" " '/cancel'. and try again later") return self.LOGIN_PROMPT def reconnect(self, bot, update): user = update.message.from_user if self.ip_port_text is not None and not self.logged_in and str(user.id) in bot_auth.user_id: try: self.qb = Client("http://%s/" % self.ip_port_text) try: self.qb.torrents() self.logger.info("Logging in was successful.") update.message.reply_text("Logged in! Now you can use me.\n" "To get info about commands type /help") self.logged_in = True except client.LoginRequired: self.logger.info("Trying to log in using previous info") username_password_split = self.username_password.split(" ") self.qb.login(username=username_password_split[0], password=username_password_split[1]) try: self.qb.torrents() self.logger.info("Logging in was successful.") update.message.reply_text("Logged in! Now you can use me.\n" "To get info about commands type /help") self.logged_in = True except client.LoginRequired: self.logger.info("Logging in with old info was unsuccessful.") update.message.reply_text("Logging in with old info was unsuccessful.\n" "You can try again later (/reconnect)\nor type new info using /start") except exceptions.ConnectionError: self.logger.info("Connection refused.") update.message.reply_text("Connection to client IP address is refused." "\nPlease try again by typing /start" "\nOr try to /reconnect later.") elif str(user) not in bot_auth.user_id: self.logger.info("Unauthorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You don't have rights to use me! Who the f*** are you?") elif self.logged_in: self.logger.info("User tried to use reconnect while already logged in.") update.message.reply_text("You are already logged in. You don't need to reconnect") elif self.ip_port_text is None: self.logger.info("User tried to use reconnect without any previous info.") update.message.reply_text("You don't have any previous info. \nPlease type /start to connect") def cancel(self, bot, update): user = update.message.from_user self.logger.info("User %s canceled the conversation." % user.first_name) update.message.reply_text('Bye! I hope we can talk again some day.') self.ip_port_text = None return ConversationHandler.END def list_downloading_torrents(self, bot, update): user = update.message.from_user try: if str(user.id) in bot_auth.user_id and self.logged_in: output = "" self.logger.info("%s tried listing downloading." % update.message.from_user) if len(self.qb.torrents()) > 0: for torrent in self.qb.torrents(filter="downloading"): output += "%s\n | Size: %.2f GB\n | Download Speed: %.1f MB/s\n | Downloaded: %s%%\n\n" % (torrent["name"], float(torrent["size"]/1073741824), float(torrent["dlspeed"]/1048576), int(torrent["progress"]*100)) update.message.reply_text("Torrents currently downloading:\n%s" % output) else: update.message.reply_text("There is no torrents to list.") elif not self.logged_in: self.logger.info("Usage without logging in tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You should first login by typing /start") else: self.logger.info("Unauthorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You don't have rights to use me! Who the f*** are you?") except exceptions.ConnectionError: self.logger.info("Connection is lost. Retrying to connect...") self.logged_in = False update.message.reply_text( "Ups. Connection to qBit Client is lost. \nRetrying to connect with previous info.") return self.reconnect(bot=bot, update=update) # key | type | Description # --------------------------------------- # hash string Torrent hash # name string Torrent name # size integer Torrent size (bytes) # progress float Torrent progress (%/100) # dlspeed integer Torrent download speed (bytes/s) # upspeed integer Torrent upload speed (bytes/s) # priority integer Torrent priority. Returns -1 if queuing is disabled # num_seeds integer Torrent seeds connected to # num_complete integer Torrent seeds in the swarm # num_leechs integer Torrent leechers connected to # num_incomplete integer Torrent leechers in the swarm # ratio float Torrent share ratio. Max ratio value: 9999. # eta integer Torrent ETA (seconds) # state string Torrent state. See possible values here below # seq_dl bool True if sequential download is enabled # f_l_piece_prio bool True if first last piece are prioritized def list(self, bot, update): user = update.message.from_user try: if str(user.id) in bot_auth.user_id and self.logged_in: output = "" self.logger.info("%s tried listing." % update.message.from_user) if len(self.qb.torrents()) > 0: for torrent in self.qb.torrents(): output += "%s\n | Status: %s\n | Size: %.2f GB\n | Download Speed: %.1f MB/s\n | Downloaded: %s%%\n\n" % (torrent["name"], torrent["state"].upper(), float(torrent["size"]/1073741824), float(torrent["dlspeed"]/1048576), int(torrent["progress"]*100)) update.message.reply_text("Torrents currently downloading:\n%s" % output) else: update.message.reply_text("There is no torrents to list.") elif not self.logged_in: self.logger.info("Usage without logging in tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You should first login by typing /start") else: self.logger.info("Unauthorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You don't have rights to use me! Who the f*** are you?") except exceptions.ConnectionError: self.logger.info("Connection is lost. Retrying to connect...") self.logged_in = False update.message.reply_text( "Ups. Connection to qBit Client is lost. \nRetrying to connect with previous info.") return self.reconnect(bot=bot, update=update) def pause(self, bot, update, args): user = update.message.from_user try: if str(user.id) in bot_auth.user_id and self.logged_in: torrents_to_pause = [] torrents_copy = self.qb.torrents().copy() for arg in args: for torrent in torrents_copy: if re.match(arg, torrent["name"], re.IGNORECASE): torrents_copy.remove(torrent) torrents_to_pause.append(str(torrent["hash"])) self.qb.pause_multiple(torrents_to_pause) self.logger.info("Paused following: %s" % args) output = "" for torrent in torrents_to_pause: output += "--%s, %s%%\n" % (torrent["name"], int(torrent["progress"]*100)) update.message.reply_text("Following torrents paused:\n%s" % output) elif not self.logged_in: self.logger.info("Usage without logging in tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You should first login by typing /start") else: self.logger.info("Unauthorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You don't have rights to use me! Who the f*** are you?") except exceptions.ConnectionError: self.logger.info("Connection is lost. Retrying to connect...") self.logged_in = False update.message.reply_text( "Ups. Connection to qBit Client is lost. \nRetrying to connect with previous info.") return self.reconnect(bot=bot, update=update) def pause_all(self, bot, update): user = update.message.from_user try: if str(user.id) in bot_auth.user_id: self.qb.pause_all() self.logger.info("Paused all") elif not self.logged_in: self.logger.info("Usage without logging in tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You should first login by typing /start") else: self.logger.info("Unauthorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You don't have rights to use me! Who the f*** are you?") except exceptions.ConnectionError: self.logger.info("Connection is lost. Retrying to connect...") self.logged_in = False update.message.reply_text( "Ups. Connection to qBit Client is lost. \nRetrying to connect with previous info.") return self.reconnect(bot=bot, update=update) def resume(self, bot, update, args): user = update.message.from_user try: if str(user.id) in bot_auth.user_id: torrents_to_resume = [] torrents_copy = self.qb.torrents().copy() for arg in args: for torrent in torrents_copy: if re.match(arg, torrent["name"], re.IGNORECASE): torrents_copy.remove(torrent) torrents_to_resume.append(str(torrent["hash"])) self.qb.resume_multiple(torrents_to_resume) self.logger.info("Paused following: %s" % args) output = "" for torrent in torrents_to_resume: output += "--%s, %s%%\n" % (torrent["name"], int(torrent["progress"]*100)) update.message.reply_text("Following torrents resumed:\n%s" % output) elif not self.logged_in: self.logger.info("Usage without logging in tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You should first login by typing /start") else: self.logger.info("Unauthorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You don't have rights to use me! Who the f*** are you?") except exceptions.ConnectionError: self.logger.info("Connection is lost. Retrying to connect...") self.logged_in = False update.message.reply_text( "Ups. Connection to qBit Client is lost. \nRetrying to connect with previous info.") return self.reconnect(bot=bot, update=update) def resume_all(self, bot, update, args): user = update.message.from_user try: if str(user.id) in bot_auth.user_id: self.qb.resume_all() self.logger.info("Resumed all") elif not self.logged_in: self.logger.info("Usage without logging in tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You should first login by typing /start") else: self.logger.info("Unauthorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You don't have rights to use me! Who the f*** are you?") except exceptions.ConnectionError: self.logger.info("Connection is lost. Retrying to connect...") self.logged_in = False update.message.reply_text( "Ups. Connection to qBit Client is lost. \nRetrying to connect with previous info.") return self.reconnect(bot=bot, update=update) def add(self, bot, update): user = update.message.from_user try: if str(user.id) in bot_auth.user_id: update.message.reply_text("Send .torrent file you want to download.") return self.ADD_FILE elif not self.logged_in: self.logger.info("Usage without logging in tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You should first login by typing /start") else: self.logger.info("Unauthorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You don't have rights to use me! Who the f*** are you?") return ConversationHandler.END except exceptions.ConnectionError: self.logger.info("Connection is lost. Retrying to connect...") self.logged_in = False update.message.reply_text( "Ups. Connection to qBit Client is lost. \nRetrying to connect with previous info.") self.reconnect(bot=bot, update=update) return ConversationHandler.END def add_file(self, bot, update): try: user = update.message.from_user if str(user.id) in bot_auth.user_id: update.message.reply_text("File received. ") file = bot.get_file(file_id=update.message.document.file_id) # print(file) document = update.message.document file_extension = document.file_name.split(".")[-1] if re.match("^torrent$", file_extension, re.IGNORECASE): # file. file.download(custom_path="%s/%s" % (self.download_folder, document.file_name)) file_read = open("%s/%s" % (self.download_folder, document.file_name), "rb") self.logger.info("Torrent file downloaded to %s" % self.download_folder) self.qb.download_from_file(file_read) self.logger.info("Started downloading %s" % document.file_name) update.message.reply_text("Downloading the file.") elif not self.logged_in: self.logger.info("Usage without logging in tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You should first login by typing /start") else: self.logger.info("Unauthorized usage tried by: %s -- %s" % (user.username, user.id)) update.message.reply_text( "You don't have rights to use me! Who the f*** are you?") return ConversationHandler.END except exceptions.ConnectionError: self.logger.info("Connection is lost. Retrying to connect...") self.logged_in = False update.message.reply_text( "Ups. Connection to qBit Client is lost. \nRetrying to connect with previous info.") self.reconnect(bot=bot, update=update) return ConversationHandler.END def help(self, bot, update): update.message.reply_text("Simple bot for using qBit client via Telegram.\n" "Available commands:\n" "/start\n" "--- Start logging in process with new info.\n" "/reconnect\n" "--- Try to reconnect using previously entered info.\n" "/pause NAME1 NAME2 NAME3 ...\n" "--- Pause torrents : NAME1, NAME2 etc.\n" "/pause_all\n" "--- Pause all torrents.\n" "/resume NAME1 NAME2 NAME3 ...\n" "--- Resume torrents : NAME1, NAME2 etc.\n" "/resume_all\n" "--- Resume all torrents. \n" "/list\n" "--- List all torrents.\n" "/downloading\n" "--- List all torrents with Downloading status\n" "/add\n" "--- Start downloading of a new .torrent file.\n" "/help\n" "--- Display this message.\n" "PS: NAME1 NAME2 etc. does *NOT* have to be FULL name.") def error(self, bot, update, error): self.logger.warn('Update "%s" caused error "%s"' % (update, error)) def main(self): # Create the EventHandler and pass it your bot's token. updater = Updater(self.TOKEN) # Get the dispatcher to register handlers dp = updater.dispatcher # Add conversation handler with the states GENDER, PHOTO, LOCATION and BIO conv_handler_start = ConversationHandler( entry_points=[CommandHandler('start', self.start)], states={ self.IP: [MessageHandler(Filters.text, self.ip)], self.LOGIN_PROMPT: [MessageHandler(Filters.text, self.login)] }, fallbacks=[CommandHandler('cancel', self.cancel)] ) conv_handler_torrent = ConversationHandler( entry_points=[CommandHandler("add", self.add)], states={ self.ADD_FILE: [MessageHandler(Filters.document, self.add_file)] }, fallbacks=[CommandHandler('cancel', self.cancel)] ) # dp.add_handler() dp.add_handler(conv_handler_start) dp.add_handler(conv_handler_torrent) dp.add_handler(CommandHandler("downloading", self.list_downloading_torrents)) dp.add_handler(CommandHandler("list", self.list)) dp.add_handler(CommandHandler("pause", self.pause, pass_args=True)) dp.add_handler(CommandHandler("resume", self.resume, pass_args=True)) dp.add_handler(CommandHandler("pause_all", self.pause_all)) dp.add_handler(CommandHandler("resume_all", self.resume_all, pass_args=True)) dp.add_handler(CommandHandler("reconnect", self.reconnect)) dp.add_handler(CommandHandler("help", self.help)) # log all errors dp.add_error_handler(self.error) # Start the Bot updater.start_polling() # Run the bot until the you presses Ctrl-C or the process receives SIGINT, # SIGTERM or SIGABRT. This should be used most of the time, since # start_polling() is non-blocking and will stop the bot gracefully. updater.idle()
def list_torrents(): bt = Client(qbittorrent_url) bt.login(qbittorrent_username, qbittorrent_password) return json_return(bt.torrents())
import subprocess from qbittorrent import Client qb = Client('http://127.0.0.1:8090/') torrents = qb.torrents() while True: for torrent in torrents: if len(qb.torrents(filter='downloading')) == 0 and 'Connected' in subprocess.run(['nordvpn','status'], stdout=subprocess.PIPE).stdout.decode('utf-8'): subprocess.run(['nordvpn','disconnect']) if len(qb.torrents(filter='downloading')) > 0 and 'Disconnected' in subprocess.run(['nordvpn','status'], stdout=subprocess.PIPE).stdout.decode('utf-8'): subprocess.run(['nordvpn', 'connect'])
from qbittorrent import Client import re qb = Client("@ de redirection du client") #à modifier qb.login("username", "password") #à modifier txt = "torrentName.torrent" #à modifier torrent_file = open(txt, "rb") qb.download_from_file(torrent_file) x = txt.split(".torrent") torrents = qb.torrents() for torrent in torrents: if (torrent["name"] == x[0]): torrent_hash = torrent["hash"] x.clear() r = qb.get_torrent_files(torrent_hash) nb_file = 0 print(type(r)) for i in r: x.append(i["name"]) nb_file += 1 x.sort() r.clear()
class QBittorrentClient(BTClientBase): def __init__(self, rpc_address, rpc_port, username, password, config={'use_https': False}): self.rpc_address = rpc_address self.rpc_port = rpc_port self.username = username self.password = password if 'use_https' in config: self.use_https = config['use_https'] else: self.use_https = False self.rpc_addr = str(rpc_address) + ':' + str(rpc_port) + '/' if self.use_https: self.rpc_addr = 'https://' + self.rpc_addr else: self.rpc_addr = 'http://' + self.rpc_addr self.client = Client(self.rpc_addr) self.connected = False def connect(self): login_ret = self.client.login(username=self.username, password=self.password) if login_ret is None: self.connected = True ret = ClientRet(ret_type=2) else: ret = ClientRet(ret_type=-2) return ret def add_torrent(self, torrent_path, download_path=None): if not self.connected: return ClientRet(ret_type=-2) abs_torrent_path = str(Path(torrent_path).resolve()) buf = open(abs_torrent_path, 'rb') if download_path is None: try: api_ret = self.client.download_from_file(buf) if 'Ok.' in api_ret: buf.close() info_hash = torf.Torrent.read(abs_torrent_path).infohash ret = ClientRet(ret_type=3, ret_value=info_hash) else: ret = ClientRet(ret_type=-3) except: ret = ClientRet(ret_type=-3) finally: return ret else: try: abs_download_path = str(Path(download_path).resolve()) api_ret = self.client.download_from_file( buf, save_path=abs_download_path) if 'Ok.' in api_ret: buf.close() info_hash = torf.Torrent.read(abs_torrent_path).infohash ret = ClientRet(ret_type=3, ret_value=info_hash) else: ret = ClientRet(ret_type=-3) except: ret = ClientRet(ret_type=-3) finally: return ret def list_torrents(self): if not self.connected: return ClientRet(ret_type=-2) torrent_list = self.client.torrents() session_status = {} for torrent in torrent_list: is_finished = math.isclose(torrent['progress'], 1) torrent_status = TorrentStatus(torrent_id=torrent['hash'], is_finished=is_finished, name=torrent['name']) session_status[torrent['hash']] = torrent_status ret = ClientRet(ret_type=4, ret_value=session_status) return ret def get_torrent_status(self, idx): if not self.connected: return ClientRet(ret_type=-2) tlist = self.client.torrents() for torrent in tlist: if idx == torrent[ 'hash']: # No progress info in get_torrent() method, really... is_finished = math.isclose(torrent['progress'], 1) torrent_status = TorrentStatus(torrent_id=torrent['hash'], is_finished=is_finished, name=torrent['name']) ret = ClientRet(ret_type=6, ret_value=torrent_status) return ret return ClientRet(ret_type=-6) def del_torrent(self, idx, remove_data=True): if not self.connected: return ClientRet(ret_type=-2) try: if remove_data: self.client.delete_permanently(idx) else: self.client.delete(idx) ret = ClientRet(ret_type=5) except: ret = ClientRet(ret_type=-5) finally: return ret def disconnect(self): if self.connected: self.client.logout() self.connected = False ret = ClientRet(ret_type=0) return ret
seeder = soup_result_td[11].text return download_id, size, seeder t=login() for tr in getFreeTorrent(t,"sticky_top"): if 'Free' in str(tr.contents[3]) and 'hitandrun' not in str(tr.contents[3]): download_id, size, seeder=getInfo(tr) download_link = "https://ourbits.club/download.php?id=" + download_id + "&passkey=" + passkey + "&https=0" result = my_set.find_one({"id":download_id}) link_list = [download_link] if result is None: qb.download_from_link(link_list) my_set.insert_one({"id":download_id,"href":download_link,"size":size,"seeder":seeder,"top":1,"deal":0}) else: my_set.update_one({"id":download_id},{"$set":{"seeder":seeder}}) for tr in getFreeTorrent(t,"sticky_normal"): if 'Free' in str(tr.contents[3]) and 'hitandrun' not in str(tr.contents[3]): download_id, size, seeder=getInfo(tr) download_link = "https://ourbits.club/download.php?id=" + download_id + "&passkey=" + passkey + "&https=0" link_list = [download_link] result = my_set.find_one({"id":download_id}) if result is None: if len(qb.torrents(filter='downloading')) < 2: qb.download_from_link(link_list) my_set.insert_one({"id":download_id,"href":download_link,"size":size,"seeder":seeder,"top":0,"deal":0}) else: my_set.update_one({"id":download_id},{"$set":{"seeder":seeder}})
class QBittorrentDownloader: """ Class that uses the qBittorrent Server API to download torrents """ def __init__(self, url: str, username: str, password: str, download_dir: str): """ :param url: :param username: :param password: :param download_dir: """ self.client = Client(url) self.client.login(username, password) self.download_dir = download_dir @classmethod def from_config(cls) -> "QBittorrentDownloader": """ :return: A QBittorrentDownloader object based on the stored configuration files """ config = Config.load() return cls(config.qbittorrent_address, config.qbittorrent_username, config.qbittorrent_password, config.qbittorrent_download_dir) def download(self, torrents: List[TorrentDownload]): """ Downloads a list of torrent files :param torrents: The torrents to download :return: None """ for torrent in torrents: torrent_info = torrent.torrent_info print(f"Downloading Torrent: {torrent_info.filename}") if torrent_info.magnet_link is not None: self.client.download_from_link(torrent_info.magnet_link) else: assert torrent_info.torrent_file is not None torrent_file = torrent_info.torrent_file if not os.path.isfile(torrent_file): torrent_file = "/tmp/torrentdltemp.torrent" content = requests.get(torrent_info.torrent_file).content with open(torrent_file, "wb") as f: f.write(content) with open(torrent_file, "rb") as f: self.client.download_from_file(f) time.sleep(1) while len(self.client.torrents()) > 0: for active in self.client.torrents(): if active["state"] not in [ "downloading", "metaDL", "stalledDL" ]: print("Done. ") torrent_path = os.path.join(self.download_dir, active["name"]) if os.path.isdir(torrent_path): children = [ os.path.join(torrent_path, x) for x in os.listdir(torrent_path) ] children.sort(key=lambda x: os.path.getsize(x), reverse=True) torrent_path = children[0] ext = torrent_path.rsplit(".", 1)[1] torrent.add_extension(ext) self.client.delete(active["hash"]) if os.path.isdir(torrent.destination): shutil.move( torrent_path, os.path.join(torrent.destination, os.path.basename(torrent_path))) else: shutil.move(torrent_path, torrent.destination) else: print(f"{(100 * active['progress']):.2f}%", end="\r") time.sleep(1)
else: return "WTF" qb = Client("http://localhost:8080/") downloadSpeed = qb.global_transfer_info["dl_info_speed"] uploadSpeed = qb.global_transfer_info["up_info_speed"] downloadSessionData = qb.global_transfer_info["dl_info_data"] uploadSessionData = qb.global_transfer_info["up_info_data"] table_data = [["qBittorrent-nox"], ["qBittorrent-nox Version:", qb.qbittorrent_version], ["Total number of torrents: ", len(qb.torrents(filter="all"))], [ "Total number of Completed torrents: ", len(qb.torrents(filter="completed")) ], [ "Total number of Downloading torrents: ", len(qb.torrents(filter="downloading")) ], [ "Total number of Paused torrents: ", len(qb.torrents(filter="paused")) ], ["Download Speed: ", speed_value(downloadSpeed)], ["Upload Speed: ", speed_value(uploadSpeed)], ["Session Download: ",
class AutoTorrent: def __init__(self): self.init_google_sheets() self.init_qb() self.downloading = {} def init_google_sheets(self): creds = None # The file token.pickle stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists('token.pickle'): with open('token.pickle', 'rb') as token: creds = pickle.load(token) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: creds.refresh(Request()) else: flow = InstalledAppFlow.from_client_secrets_file( 'credentials.json', SCOPES) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open('token.pickle', 'wb') as token: pickle.dump(creds, token) self.google_sheets = build('sheets', 'v4', credentials=creds) def init_qb(self): self.qb = TorrentClient("http://127.0.0.1:8080/") self.qb.login("admin", "adminadmin") def get_movies(self): sheet = self.google_sheets.spreadsheets() result = sheet.values().get(spreadsheetId=SPREADSHEET_ID, range=RANGE_NAME).execute() values = result.get('values', []) if not values: print('No data found.') filtered = filter( lambda m: m[0] in ["No Descargada", "Auto Descargando"] and (len(m) < 5 or m[4] not in ["No", "Pocos Seeds"]), values) movies = map(lambda m: Movie(m[1], m[2]), filtered) return movies def download_movie(self, movie): torrent = movie.get_torrent() if not torrent: print(" Torrent not found for {}. Skipping".format(movie)) self.update_movie_yts(movie, "No") return magnet = torrent.magnet path = movie.local_path if not os.path.isdir(path): os.mkdir(path) self.qb.download_from_link(magnet, savepath=path) self.update_movie(movie, "Auto Descargando") for t in self.qb.torrents(): if os.path.normpath(t["save_path"]) == os.path.normpath(path): torrent_hash = t["hash"] break self.downloading[torrent_hash] = movie print(" Started downloading {}".format(movie)) def update_movie(self, movie, status): sheet = self.google_sheets.spreadsheets() result = sheet.values().get(spreadsheetId=SPREADSHEET_ID, range=RANGE_NAME).execute() values = list(result.get('values', [])) for value in values: if value[1] == movie.name and int(value[2]) == movie.year: value[0] = status body = {'values': values} sheet.values().update(spreadsheetId=SPREADSHEET_ID, range=RANGE_NAME, valueInputOption=VALUE_INPUT_OPTION, body=body).execute() def update_movie_yts(self, movie, yts): sheet = self.google_sheets.spreadsheets() result = sheet.values().get(spreadsheetId=SPREADSHEET_ID, range=RANGE_NAME).execute() values = list(result.get('values', [])) for value in values: if value[1] == movie.name and int(value[2]) == movie.year: if len(value) == 4: value.append(yts) else: value[4] = yts body = {'values': values} sheet.values().update(spreadsheetId=SPREADSHEET_ID, range=RANGE_NAME, valueInputOption=VALUE_INPUT_OPTION, body=body).execute() def should_download(self): current_torrents = len(self.qb.torrents(filter="downloading")) less_than_max = current_torrents < MAX_CONCURRENT_DOWNLOADS just_started = len(self.downloading) < MAX_CONCURRENT_DOWNLOADS return less_than_max or just_started def start(self): movies = self.get_movies() while True: sleep(1) self.clean_torrents() if not self.should_download(): continue movie = next(movies) print(movie) self.download_movie(movie) def clean_torrents(self): timed_out = [] done = [] for torrent in self.qb.torrents(): if torrent["progress"] == 1: done.append(torrent["hash"]) elif is_timed_out(torrent): timed_out.append(torrent["hash"]) for h in timed_out: if h not in self.downloading: continue movie = self.downloading[h] print("{} timed out. Removing".format(movie)) self.update_movie(movie, "No Descargada") self.update_movie_yts(movie, "Pocos Seeds") self.qb.delete(h) movie.delete_folder() for h in done: if h not in self.downloading: continue movie = self.downloading[h] self.update_movie(movie, "Descargada") self.qb.delete(h) movie.clean_folder() movie.move_to_drive() print("{} finished downloading. Moving to Google Drive".format( movie))