Create bot.py

initial commit

bot.py

@@ -0,0 +1,813 @@
+""""
+Copyright © twilsonco 2020
+Description: This is a discord bot to manage torrent transfers through the Transmission transmissionrpc python library.
+
+Version: 1.0
+"""
+
+import discord
+import asyncio
+import aiohttp
+import json
+import subprocess
+from discord.ext.commands import Bot
+from discord.ext import commands
+from platform import python_version
+import os
+from os.path import expanduser, join
+import re
+import datetime
+import pytz
+import platform
+import transmissionrpc
+import logging
+
+BOT_PREFIX = 't/'
+TOKEN = 'SECRET_TOKEN'
+OWNERS = [OWNER_USER_IDS]
+BLACKLIST = [USER_IDS]
+WHITELIST = [USER_IDS]
+CHANNEL_IDS=[CHANNEL_IDS]
+LOGO_URL="https://iyanovich.files.wordpress.com/2009/04/transmission-logo.png"
+
+TSCLIENT_CONFIG={
+	'host': "10.0.1.2",
+	'port': 9091,
+	'user': "USERNAME",
+	'password': "PASSWORD"
+}
+DRYRUN = False
+
+logging.basicConfig(format='%(asctime)s %(message)s',filename=join(expanduser("~"),'transmissionbot.log'))
+
+
+
+client = Bot(command_prefix=BOT_PREFIX)
+TSCLIENT = None
+
+
+
+logger = logging.getLogger('transmission_bot')
+logger.setLevel(logging.INFO)
+DEFAULT_REASON="TransmissionBot"
+
+# Begin transmissionrpc functions, lovingly taken from https://github.com/leighmacdonald/transmission_scripts
+
+class TSClient(transmissionrpc.Client):
+	""" Basic subclass of the standard transmissionrpc client which provides some simple
+	helper functionality.
+	"""
+
+	def get_torrents_by(self, sort_by=None, filter_by=None, reverse=False, filter_regex=None, id_list=None):
+		"""This method will call get_torrents and then perform any sorting or filtering
+		actions requested on the returned torrent set.
+
+		:param sort_by: Sort key which must exist in `Sort.names` to be valid;
+		:type sort_by: str
+		:param filter_by:
+		:type filter_by: str
+		:param reverse:
+		:return: Sorted and filter torrent list
+		:rtype: transmissionrpc.Torrent[]
+		"""
+		torrents = self.get_torrents()
+		if filter_regex:
+			regex = re.compile(filter_regex, re.IGNORECASE)
+			torrents = [tor for tor in torrents if regex.search(tor.name)]
+		if id_list:
+			torrents = [tor for tor in torrents if tor.id in id_list]
+		if filter_by:
+			torrents = filter_torrents_by(torrents, key=getattr(Filter, filter_by))
+			if sort_by is None:
+				if filter_by == "downloading":
+					sort_by = "speed_down"
+				elif filter_by == "seeding":
+					sort_by = "speed_up"
+				elif filter_by in ["stopped","finished"]:
+					sort_by = "ratio"
+		if sort_by:
+			torrents = sort_torrents_by(torrents, key=getattr(Sort, sort_by), reverse=reverse)
+		return torrents
+		
+def make_client():
+	""" Create a new transmission RPC client
+
+	If you want to parse more than the standard CLI arguments, like when creating a new customized
+	script, you can append your options to the argument parser.
+
+	:param args: Optional CLI args passed in.
+	:return:
+	"""
+	try:
+		return TSClient(
+			TSCLIENT_CONFIG['host'],
+			port=TSCLIENT_CONFIG['port'],
+			user=TSCLIENT_CONFIG['user'],
+			password=TSCLIENT_CONFIG['password']
+		)
+	except:
+		return None
+
+filter_names = (
+	"all",
+	"active",
+	"downloading",
+	"seeding",
+	"stopped",
+	"finished"
+)
+
+class Filter(object):
+	"""A set of filtering operations that can be used against a list of torrent objects"""
+
+	names = (
+		"all",
+		"active",
+		"downloading",
+		"seeding",
+		"stopped",
+		"finished"
+	)
+
+	@staticmethod
+	def all(t):
+		return t
+
+	@staticmethod
+	def active(t):
+		return t.rateUpload > 0 or t.rateDownload > 0
+
+	@staticmethod
+	def downloading(t):
+		return t.status == 'downloading'
+
+	@staticmethod
+	def seeding(t):
+		return t.status == 'seeding'
+
+	@staticmethod
+	def stopped(t):
+		return t.status == 'stopped'
+
+	@staticmethod
+	def finished(t):
+		return t.status == 'finished'
+
+	@staticmethod
+	def lifetime(t):
+		return t.date_added
+
+
+def filter_torrents_by(torrents, key=Filter.all):
+	"""
+
+	:param key:
+	:param torrents:
+	:return: []transmissionrpc.Torrent
+	"""
+	filtered_torrents = []
+	for torrent in torrents:
+		if key(torrent):
+			filtered_torrents.append(torrent)
+	return filtered_torrents
+	
+sort_names = (
+	"id",
+	"progress",
+	"name",
+	"size",
+	"ratio",
+	"speed",
+	"speed_up",
+	"speed_down",
+	"status",
+	"queue",
+	"age",
+	"activity"
+)
+	
+class Sort(object):
+	""" Defines methods for sorting torrent sequences """
+
+	names = (
+		"id",
+		"progress",
+		"name",
+		"size",
+		"ratio",
+		"speed",
+		"speed_up",
+		"speed_down",
+		"status",
+		"queue",
+		"age",
+		"activity"
+	)
+
+	@staticmethod
+	def activity(t):
+		return t.date_active
+
+	@staticmethod
+	def age(t):
+		return t.date_added
+
+	@staticmethod
+	def queue(t):
+		return t.queue_position
+
+	@staticmethod
+	def status(t):
+		return t.status
+
+	@staticmethod
+	def progress(t):
+		return t.progress
+
+	@staticmethod
+	def name(t):
+		return t.name.lower()
+
+	@staticmethod
+	def size(t):
+		return -t.totalSize
+
+	@staticmethod
+	def id(t):
+		return t.id
+
+	@staticmethod
+	def ratio(t):
+		return t.ratio
+
+	@staticmethod
+	def speed(t):
+		return t.rateUpload + t.rateDownload
+
+	@staticmethod
+	def speed_up(t):
+		return t.rateUpload
+
+	@staticmethod
+	def speed_down(t):
+		return t.rateDownload
+
+
+def sort_torrents_by(torrents, key=Sort.name, reverse=False):
+	return sorted(torrents, key=key, reverse=reverse)
+	
+# def print_torrent_line(torrent, colourize=True):
+#	 name = torrent.name
+#	 progress = torrent.progress / 100.0
+#	 print("[{}] [{}] {} {}[{}/{}]{} ra: {} up: {} dn: {} [{}]".format(
+#		 white_on_blk(torrent.id),
+#		 find_tracker(torrent),
+#		 print_pct(torrent) if colourize else name.decode("latin-1"),
+#		 white_on_blk(""),
+#		 red_on_blk("{:.0%}".format(progress)) if progress < 1 else green_on_blk("{:.0%}".format(progress)),
+#		 magenta_on_blk(natural_size(torrent.totalSize)),
+#		 white_on_blk(""),
+#		 red_on_blk(torrent.ratio) if torrent.ratio < 1.0 else green_on_blk(torrent.ratio),
+#		 green_on_blk(natural_size(float(torrent.rateUpload)) + "/s") if torrent.rateUpload else "0.0 kB/s",
+#		 green_on_blk(natural_size(float(torrent.rateDownload)) + "/s") if torrent.rateDownload else "0.0 kB/s",
+#		 yellow_on_blk(torrent.status)
+#	 ))
+
+def remove_torrent(torrent, reason=DEFAULT_REASON, delete_files=False):
+	""" Remove a torrent from the client stopping it first if its in a started state.
+
+	:param client: Transmission RPC Client
+	:type client: transmissionrpc.Client
+	:param torrent: Torrent instance to remove
+	:type torrent: transmissionrpc.Torrent
+	:param reason: Reason for removal
+	:type reason: str
+	:param dry_run: Do a dry run without actually running any commands
+	:type dry_run: bool
+	:return:
+	"""
+	if torrent.status != "stopped":
+		if not DRYRUN:
+			TSCLIENT.stop_torrent(torrent.hashString)
+	if not DRYRUN:
+		TSCLIENT.remove_torrent(torrent.hashString, delete_data=delete_files)
+	logger.info("Removed: {} {}\n\tReason: {}\n\tDry run: {}, Delete files: {}".format(torrent.name, torrent.hashString, reason, DRYRUN,delete_files))
+
+def remove_torrents(torrents, reason=DEFAULT_REASON, delete_files=False):
+	""" Remove a torrent from the client stopping it first if its in a started state.
+
+	:param client: Transmission RPC Client
+	:type client: transmissionrpc.Client
+	:param torrent: Torrent instance to remove
+	:type torrent: transmissionrpc.Torrent
+	:param reason: Reason for removal
+	:type reason: str
+	:param dry_run: Do a dry run without actually running any commands
+	:type dry_run: bool
+	:return:
+	"""
+	for torrent in torrents:
+		remove_torrent(torrent, reason=reason, delete_files=delete_files)
+	
+def stop_torrents(torrents=[], reason=DEFAULT_REASON):
+	""" Stop (pause) a list of torrents from the client.
+
+	:param client: Transmission RPC Client
+	:type client: transmissionrpc.Client
+	:param torrent: Torrent instance to remove
+	:type torrent: transmissionrpc.Torrent
+	:param reason: Reason for removal
+	:type reason: str
+	:param dry_run: Do a dry run without actually running any commands
+	:type dry_run: bool
+	:return:
+	"""
+	for torrent in (torrents if len(torrents) > 0 else TSCLIENT.get_torrents()):
+		if torrent.status not in ["stopped","finished"]:
+			if not DRYRUN:
+				TSCLIENT.stop_torrent(torrent.hashString)
+			logger.info("Paused: {} {}\n\tReason: {}\n\tDry run: {}".format(torrent.name, torrent.hashString, reason, DRYRUN))
+
+def resume_torrents(torrents=[], reason=DEFAULT_REASON):
+	""" Stop (pause) a list of torrents from the client.
+
+	:param client: Transmission RPC Client
+	:type client: transmissionrpc.Client
+	:param torrent: Torrent instance to remove
+	:type torrent: transmissionrpc.Torrent
+	:param reason: Reason for removal
+	:type reason: str
+	:param dry_run: Do a dry run without actually running any commands
+	:type dry_run: bool
+	:return:
+	"""
+	for torrent in (torrents if len(torrents) > 0 else TSCLIENT.get_torrents()):
+		if torrent.status == "stopped":
+			if not DRYRUN:
+				TSCLIENT.start_torrent(torrent.hashString)
+			logger.info("Resumed: {} {}\n\tReason: {}\n\tDry run: {}".format(torrent.name, torrent.hashString, reason, DRYRUN))
+
+def add_torrent(torStr):
+	tor = None
+	if torStr != "":
+		tor = TSCLIENT.add_torrent(torStr)
+	return tor
+
+
+# Begin discord bot functions, adapted from https://github.com/kkrypt0nn/Python-Discord-Bot-Template
+
+# async def status_task():
+# 	while True:
+# 		await client.change_presence(activity=discord.Game("{}help".format(BOT_PREFIX)))
+# 		await asyncio.sleep(86400)
+
+@client.event
+async def on_ready():
+	global TSCLIENT
+	TSCLIENT = make_client()
+	if TSCLIENT is None:
+		print("Failed to create transmissionrpc client")
+	else:
+		# client.loop.create_task(status_task())
+		await client.change_presence(activity=discord.Game("{}help".format(BOT_PREFIX)))
+		print('Logged in as ' + client.user.name)
+		print("Discord.py API version:", discord.__version__)
+		print("Python version:", platform.python_version())
+		print("Running on:", platform.system(), platform.release(), "(" + os.name + ")")
+		print('-------------------')
+
+def humanbytes(B):
+	'Return the given bytes as a human friendly KB, MB, GB, or TB string'
+	B = float(B)
+	KB = float(1024)
+	MB = float(KB ** 2) # 1,048,576
+	GB = float(KB ** 3) # 1,073,741,824
+	TB = float(KB ** 4) # 1,099,511,627,776
+
+	if B < KB:
+		return '{0} {1}'.format(B,'B')
+	elif KB <= B < MB:
+		return '{0:.2f} kB'.format(B/KB)
+	elif MB <= B < GB:
+		return '{0:.2f} MB'.format(B/MB)
+	elif GB <= B < TB:
+		return '{0:.2f} GB'.format(B/GB)
+	elif TB <= B:
+		return '{0:.2f} TB'.format(B/TB)
+	  
+def tobytes(B):
+	'Return the number of bytes given by a string (a float followed by a space and the unit of prefix-bytes eg. "21.34 GB")'
+	numstr = B.lower().split(' ')
+	KB = (('kilo','kb','kb/s'),float(1024))
+	MB = (('mega','mb','mb/s'),float(KB[1] ** 2)) # 1,048,576
+	GB = (('giga','gb','gb/s'),float(KB[1] ** 3)) # 1,073,741,824
+	TB = (('tera','tb','tb/s'),float(KB[1] ** 4)) # 1,099,511,627,776
+	
+	for prefix in (KB,MB,GB,TB):
+		if numstr[1] in prefix[0]:
+			return float(float(numstr[0]) * prefix[1])
+
+# check that message author is allowed and message was sent in allowed channel
+async def CommandPrecheck(context):
+	if len(CHANNEL_IDS) > 0 and context.message.channel.id not in CHANNEL_IDS:
+		await context.message.channel.send("I don't respond to commands in this channel...")
+		return False
+	elif context.message.author.id in BLACKLIST or (len(WHITELIST) > 0 and context.message.author.id not in WHITELIST):
+		await context.message.channel.send("You're not allowed to use this...")
+		return False
+	return True
+				
+@client.command(name='add', pass_context=True)
+async def add(context, *, content):
+	if await CommandPrecheck(context):
+		if content == "":
+			await context.message.channel.send("Invalid string")
+		else:
+			torStr = None
+			for t in content.strip().split(" "):
+				await context.message.channel.send('Adding torrent {}\n Please wait...'.format(t))
+				tor = add_torrent(t)
+				if torStr:
+					torStr += "\n{}" % tor.name
+				else:
+					torStr = tor.name
+			await context.message.channel.send('✅ Added torrent{}:\n{}'.format("s" if len(content.strip().split(" ")) > 1 else "", torStr))
+@client.command(name='a', pass_context=True)
+async def a(context, *, content=""):
+	await add(context, content=content)
+	
+# def torInfo(t):
+# 	states = ('downloading', 'seeding', 'stopped', 'finished','all')
+# 	stateEmoji = {i:j for i,j in zip(states,['🔻','🌱','⏸','🏁','🔁'])}
+#
+# 	downStr = humanbytes(t.progress * 0.01 * t.totalSize)
+# 	upStr = "{} (Ratio: {:.2f})".format(humanbytes(t.uploadedEver), t.uploadRatio)
+# 	runTime =
+#
+# 	if t.progress < 100.0:
+# 		have = "{} of {} ({:.1f}){}{}".format(downStr,humanbytes(t.totalSize), t.progress, '' if t.haveUnchecked == 0 else ', {} Unverified'.format(humanbytes(t.haveUnchecked)), '' if t.corruptEver == 0 else ', {} Corrupt'.format(humanbytes(t.corruptEver)))
+# 		avail = "{:.1f}%".format(t.desiredAvailable/t.leftUntilDone)
+# 	else:
+# 		have = "{} ({:d}){}{}".format(humanbytes(t.totalSize), t.progress, '' if t.haveUnchecked == 0 else ', {} Unverified'.format(humanbytes(t.haveUnchecked)), '' if t.corruptEver == 0 else ', {} Corrupt'.format(humanbytes(t.corruptEver)))
+# 		avail = "100%"
+#
+#
+#
+# 	embed=discord.Embed(title=t.name,color=0xb51a00)
+#
+# 	return embed
+
+torListLegend="• Legend:\n⬇️download  rate, ⬆️upload  rate, ⚖️seed  ratio, 🔻downloading, 🌱seeding, 🏁finished, ⏸paused\n• Error:\n✅none, ⚠️tracker  warning, ☄️tracker  error, 🔥local  error\n• Info:\n🐢stalled, 🐇running, 🔒private, 🔓public "
+
+def torList(torrents, author_name="Torrent Transfers",title=None,description=None):
+	states = ('downloading', 'seeding', 'stopped', 'finished','all')
+	stateEmoji = {i:j for i,j in zip(states,['🔻','🌱','⏸','🏁','🔁'])}
+	errorStrs = ['✅','📡⚠️','📡‼️','🖥‼️']
+
+	def torListLine(t):
+		down = humanbytes(t.progress * 0.01 * t.totalSize)
+		out = "{} {} {} {} ".format(stateEmoji[t.status],errorStrs[t.error],'🐢' if t.isStalled else '🐇', '🔒' if t.isPrivate else '🔓')
+		if t.status == 'downloading':
+			out += "{}/{} ⬇️ {}/s ⬆️ {}/s ⚖️ {:.2f}".format(down,humanbytes(t.totalSize),humanbytes(t.rateDownload),humanbytes(t.rateUpload),t.uploadRatio)
+		elif t.status == 'seeding':
+			out += "{} ⬆️ {}/s ⚖️ {:.2f}".format(humanbytes(t.totalSize),humanbytes(t.rateUpload),t.uploadRatio)
+		elif t.status == 'stopped':
+			out += "{}/{} ⚖️ {:.2f}".format(down,humanbytes(t.totalSize),t.uploadRatio)
+		elif t.status == 'finished':
+			out += "{} ⚖️ {:.2f}".format(humanbytes(t.totalSize),t.uploadRatio)
+		
+		return out
+	
+	nameList = ["{}) {:.245}{}".format(t.id,t.name,"..." if len(t.name) > 245 else "") for t in torrents]
+	valList = [torListLine(t) for t in torrents]
+	
+	n = 0
+	i = 0
+	embeds = []
+	if len(torrents) > 0:
+		while i < len(torrents):
+			embed=discord.Embed(title=title,description=description,color=0xb51a00)
+			embed.set_author(name=author_name, icon_url=LOGO_URL)
+			for j in range(25):
+				embed.add_field(name=nameList[i],value=valList[i],inline=False)
+				i += 1
+				n += 1
+				if n >= 25:
+					n = 0
+					break
+				if i >= len(torrents):
+					break
+			embed.timestamp = datetime.datetime.now(tz=pytz.timezone('America/Denver'))
+			embeds.append(embed)
+	
+		embeds[-1].set_footer(text=torListLegend)
+	else:
+		embeds.append(discord.Embed(title=title, description="No matching transfers found!", color=0xb51a00))
+		embeds[-1].set_author(name=author_name, icon_url=LOGO_URL)
+		embeds[-1].timestamp = datetime.datetime.now(tz=pytz.timezone('America/Denver'))
+	
+	return embeds
+
+def torGetListOpsFromStr(listOpStr):
+	filter_by = None
+	sort_by = None
+	splitcontent = listOpStr.split(" ")
+	
+	if "--filter" in splitcontent:
+		ind = splitcontent.index("--filter")
+		if len(splitcontent) > ind + 1:
+			filter_by = splitcontent[ind+1]
+			del splitcontent[ind+1]
+		del splitcontent[ind]
+	elif "-f" in splitcontent:
+		ind = splitcontent.index("-f")
+		if len(splitcontent) > ind + 1:
+			filter_by = splitcontent[ind+1]
+			del splitcontent[ind+1]
+		del splitcontent[ind]
+	
+	if "--sort" in splitcontent:
+		ind = splitcontent.index("--sort")
+		if len(splitcontent) > ind + 1:
+			sort_by = splitcontent[ind+1]
+			del splitcontent[ind+1]
+		del splitcontent[ind]
+	elif "-s" in splitcontent:
+		ind = splitcontent.index("-s")
+		if len(splitcontent) > ind + 1:
+			sort_by = splitcontent[ind+1]
+			del splitcontent[ind+1]
+		del splitcontent[ind]
+	
+	filter_regex = " ".join(splitcontent).strip()
+	if filter_regex == "":
+		filter_regex = None
+	
+	if filter_by is not None and filter_by not in filter_names:
+		return -1, None, None
+	if sort_by is not None and sort_by not in sort_names:
+		return None, -1, None
+		
+	return filter_by, sort_by, filter_regex
+
+@client.command(name='list', pass_context=True)
+async def list(context, *, content=""):
+	if await CommandPrecheck(context):
+		filter_by, sort_by, filter_regex = torGetListOpsFromStr(content)
+		if filter_by == -1:
+			await context.message.channel.send("Invalid filter specified. Choose one of {}".format(str(filter_names)))
+			return
+		if sort_by == -1:
+			await context.message.channel.send("Invalid sort specified. Choose one of {}".format(str(sort_names)))
+			return
+		
+		torrents = TSCLIENT.get_torrents_by(sort_by=sort_by, filter_by=filter_by, filter_regex=filter_regex)
+		
+		embeds = torList(torrents, title="{} transfer{} matching '`{}`'".format(len(torrents),'' if len(torrents)==1 else 's',content))
+		
+		for e in embeds:
+			await context.message.channel.send(embed=e)
+@client.command(name='l', pass_context=True)
+async def l(context, *, content=""):
+	await list(context, content=content)
+
+def torSummary(torrents):
+	states = ('downloading', 'seeding', 'paused', 'finished')
+	numInState = [len([True for t in torrents if t.status == s]) for s in states]
+	numTot = len(torrents)
+	
+	sumTot = sum([t.totalSize for t in torrents])
+	totSize = humanbytes(sumTot)
+	totUpRate = humanbytes(sum([t.rateUpload for t in torrents]))
+	totDownRate = humanbytes(sum([t.rateDownload for t in torrents]))
+	
+	downList = [t.progress*0.01*t.totalSize for t in torrents]
+	upList = [t.ratio * j for t,j in zip(torrents,downList)]
+	
+	sumDown = sum(downList)
+	sumUp = sum(upList)
+	
+	totDown = humanbytes(sumDown)
+	totUp = humanbytes(sumUp)
+	
+	totRatio = '{:.2f}'.format(sumUp / sumDown)
+	
+	totDownRatio = '{:.2f}'.format(sumDown / sumTot * 100.0)
+	
+	numTopRatios = min([len(torrents),5])
+	topRatios = "• Top {} ratio{}:".format(numTopRatios,"s" if numTopRatios > 0 else "")
+	sortByRatio = sorted(torrents,key=lambda t:float(t.ratio),reverse=True)
+	for i in range(numTopRatios):
+		topRatios += "\n {:.1f} {:.35}{}".format(float(sortByRatio[i].ratio),sortByRatio[i].name,"..." if len(sortByRatio[i].name) > 35 else "")
+	
+	embed=discord.Embed(title="🌊 Torrent Summary", description="*React to see list of corresponding transfers*", color=0xb51a00)
+	embed.set_thumbnail(url=LOGO_URL)
+	embed.add_field(name="⬇️ {}/s".format(totDownRate), value="⬆️ {}/s".format(totUpRate), inline=False)
+	embed.add_field(name="⏬ {} of {}".format(totDown,totSize), value="⏫ {}  ⚖️ {}".format(totUp,totRatio), inline=False)
+	embed.add_field(name="🔁 {} transfer{} total".format(numTot,"" if numTot == 0 else "s"), value="🔻 {} 🌱 {} 🏁 {} ⏸ {}".format(numInState[0],numInState[1],numInState[3],numInState[2]), inline=False)
+	embed.set_footer(text=topRatios+'\n• Legend:\n⬇️total  download  rate, ⬆️total  upload  rate, ⏬total  downloaded, ⏫total  uploaded, 🔻downloading, 🌱seeding, 🏁finished, ⏸paused, ⚖️total  seed  ratio')
+	embed.timestamp = datetime.datetime.now(tz=pytz.timezone('America/Denver'))
+	# await context.message.channel.send(embed=embed)
+	return embed,numInState
+				
+@client.command(name='summary', pass_context=True)
+async def summary(context, *, content=""):
+	if await CommandPrecheck(context):
+		states = ('downloading', 'seeding', 'paused', 'finished','all')
+		stateEmoji = ['🔻','🌱','⏸','🏁','🔃']
+		
+		summary=torSummary(TSCLIENT.get_torrents())
+		msg = await context.message.channel.send(embed=summary[0])
+		for i in range(len(summary[1])):
+			if summary[1][i] > 0:
+				await msg.add_reaction(stateEmoji[i])
+		await msg.add_reaction(stateEmoji[-1])
+		
+		def check(reaction, user):
+			return user == context.message.author and str(reaction.emoji) in stateEmoji
+		
+		try:
+			reaction, user = await client.wait_for('reaction_add', timeout=60.0, check=check)
+		except asyncio.TimeoutError:
+			pass
+		else:
+			cmds = {i:j for i,j in zip(stateEmoji,('--filter downloading', '--filter seeding', '--filter stopped', '--filter finished', ''))}
+			await list(context, content=cmds[str(reaction.emoji)])
+@client.command(name='s', pass_context=True)
+async def s(context, *, content=""):
+	await summary(context, content=content)
+
+def strListToList(strList):
+	if not re.match('^[0-9\,\-]+$', strList):
+		return False
+	outList = []
+	for seg in strList.strip().split(","):
+		subseg = seg.split("-")
+		if len(subseg) == 1 and int(subseg[0]) not in outList:
+			outList.append(int(subseg[0]))
+		elif len(subseg) == 2:
+			subseg = sorted([int(i) for i in subseg])
+			outList += range(subseg[0],subseg[1]+1)
+	if len(outList) == 0:
+		return False
+	
+	return outList
+
+@client.command(name='modify', pass_context=True)
+async def modify(context, *, content=""):
+	if await CommandPrecheck(context):
+		allOnly = content.strip() == ""
+		torrents = []
+		if not allOnly:
+			id_list = strListToList(content)
+			filter_by = None
+			sort_by = None
+			filter_regex = None
+			if not id_list:
+				filter_by, sort_by, filter_regex = torGetListOpsFromStr(content)
+				if filter_by == -1:
+					await context.message.channel.send("Invalid filter specified. Choose one of {}".format(str(filter_names)))
+					return
+				if sort_by == -1:
+					await context.message.channel.send("Invalid sort specified. Choose one of {}".format(str(sort_names)))
+					return
+			# await context.message.channel.send("{} {} {} {}".format())
+			# return
+			torrents = TSCLIENT.get_torrents_by(filter_by=filter_by, sort_by=sort_by, filter_regex=filter_regex, id_list=id_list)
+
+			if len(torrents) > 0:
+				ops = ["pause","resume","remove","removedelete"]
+				opNames = ["pause","resume","remove","remove and delete"]
+				opEmoji = ['⏸','▶️','❌','🗑']
+				opStr = "⏸pause ▶️resume ❌remove 🗑remove  and  delete"
+				embeds = torList(torrents,author_name="Click a reaction to choose modification".format(len(torrents), '' if len(torrents)==1 else 's'),title="{} transfer{} matching '`{}`' will be modified".format(len(torrents), '' if len(torrents)==1 else 's', content))
+				embeds[-1].set_footer(text=torListLegend+"\n• Options:\n"+opStr)
+				embeds[-1].timestamp = datetime.datetime.now(tz=pytz.timezone('America/Denver'))
+			else:
+				embed=discord.Embed(title="Modify transfers",color=0xb51a00)
+				embed.set_author(name="No matching transfers found!", icon_url=LOGO_URL)
+				embeds = [embed]
+		else:
+			ops = ["pauseall","resumeall"]
+			opNames = ["pause all","resume all"]
+			opEmoji = ['⏸','▶️']
+			opStr = "⏸ pause or ▶️ resume all"
+			embed=discord.Embed(title="React to choose modification",color=0xb51a00)
+			embed.set_author(name="All transfers will be affected!", icon_url=LOGO_URL)
+			embed.set_footer(text=opStr)
+			embed.timestamp = datetime.datetime.now(tz=pytz.timezone('America/Denver'))
+			embeds = [embed]
+		msgs = [await context.message.channel.send(embed=e) for e in embeds]
+		
+		if not allOnly and len(torrents) == 0:
+			return
+	
+		for i in opEmoji:
+			await msgs[-1].add_reaction(i)
+	
+		def check(reaction, user):
+			return user == context.message.author and str(reaction.emoji) in opEmoji
+	
+		try:
+			reaction, user = await client.wait_for('reaction_add', timeout=60.0, check=check)
+		except asyncio.TimeoutError:
+			return
+		else:
+			cmds = {i:j for i,j in zip(opEmoji,ops)}
+			cmd = cmds[str(reaction.emoji)]
+			
+			doContinue = True
+			if "remove" in cmds[str(reaction.emoji)]:
+				embed=discord.Embed(title="Are you sure you wish to remove{} {} transfer{}?".format(' and DELETE' if 'delete' in cmds[str(reaction.emoji)] else '', len(torrents), '' if len(torrents)==1 else 's'),description="**This action is irreversible!**",color=0xb51a00)
+				embed.set_footer(text="react ✅ to continue or ❌ to cancel")
+				msg = await context.message.channel.send(embed=embed)
+	
+				for i in ['✅','❌']:
+					await msg.add_reaction(i)
+					
+				def check1(reaction, user):
+					return user == context.message.author and str(reaction.emoji) in ['✅','❌']
+				try:
+					reaction, user = await client.wait_for('reaction_add', timeout=60.0, check=check1)
+				except asyncio.TimeoutError:
+					doContinue = False
+				else:
+					doContinue = str(reaction.emoji) == '✅'
+			if doContinue:
+				if "pause" in cmd:
+					stop_torrents(torrents)
+				elif "resume" in cmd:
+					resume_torrents(torrents)
+				else:
+					remove_torrents(torrents,delete_files="delete" in cmd)
+					
+				ops = ["pause","resume","remove","removedelete","pauseall","resumeall"]
+				opNames = ["paused","resumed","removed","removed and deleted","paused","resumed"]
+				opEmoji = ["⏸","▶️","❌","🗑","⏸","▶️"]
+				ops = {i:j for i,j in zip(ops,opNames)}
+				opEmoji = {i:j for i,j in zip(ops,opEmoji)}
+				await context.message.channel.send("{} Transfer{} {}".format(str(reaction.emoji),'s' if allOnly or len(torrents) > 1 else '', ops[cmd]))
+			else:
+				await context.message.channel.send("❌ Cancelled!")
+@client.command(name='m', pass_context=True)
+async def m(context, *, content=""):
+	await modify(context, content=content)
+
+client.remove_command('help')
+
+@client.command(name='help', description='Help HUD.', brief='HELPOOOO!!!', pass_context=True)
+async def help(context, *, content=""):
+	if await CommandPrecheck(context):
+		if content != "":
+			if content in ["l","list"]:
+				embed = discord.Embed(title='List transfers', color=0xb51a00)
+				embed.set_author(name="List current transfers with sorting, filtering, and search options", icon_url=LOGO_URL)
+				embed.add_field(name="Usage", value='`{0}list [--filter FILTER] [--sort SORT] [NAME]`'.format(BOT_PREFIX), inline=False)
+				embed.add_field(name="Filtering", value='`--filter FILTER` or `-f FILTER`\n`FILTER` is one of `{}`'.format(str(filter_names)), inline=False)
+				embed.add_field(name="Sorting", value='`--sort SORT` or `-s SORT`\n`SORT` is one of `{}`'.format(str(sort_names)), inline=False)
+				embed.add_field(name="Searching by name", value='`NAME` is a regular expression used to search transfer names (no enclosing quotes; may contain spaces)', inline=False)
+				embed.add_field(name="Examples", value="*List all transfers:* `{0}list`\n*Search using phrase 'ubuntu':* `{0}l ubuntu`\n*List downloading transfers:* `{0}l -f downloading`\n*Sort transfers by age:* `{0}list --sort age`".format(BOT_PREFIX), inline=False)
+				await context.message.channel.send(embed=embed)
+			elif content in ["a","add"]:
+				embed = discord.Embed(title='Add transfer', description="If multiple torrents are added, separate them by spaces", color=0xb51a00)
+				embed.set_author(name="Add one or more specified torrents by magnet link or url to torrent file", icon_url=LOGO_URL)
+				embed.add_field(name="Usage", value='`{0}add TORRENT_FILE_URL_OR_MAGNET_LINK ...`\n`{0}a TORRENT_FILE_URL_OR_MAGNET_LINK ...`'.format(BOT_PREFIX), inline=False)
+				embed.add_field(name="Examples", value="*Add download of ubuntu OS:* `{0}add https://releases.ubuntu.com/20.04/ubuntu-20.04.1-desktop-amd64.iso.torrent`".format(BOT_PREFIX), inline=False)
+				await context.message.channel.send(embed=embed)
+			elif content in ["m","modify"]:
+				embed = discord.Embed(title='Modify existing transfer(s)', color=0xb51a00)
+				embed.set_author(name="Pause, resume, remove, or remove and delete specified transfer(s)", icon_url=LOGO_URL)
+				embed.add_field(name="Usage", value='`{0}modify [LIST_OPTIONS] [TORRENT_ID_SPECIFIER]`'.format(BOT_PREFIX), inline=False)
+				embed.add_field(name="Pause or resume ALL transfers", value="Simply run `{0}modify` to pause or resume all existing transfers".format(BOT_PREFIX), inline=False)
+				embed.add_field(name="By list options", value='`LIST_OPTIONS` is a valid set of options to the `{0}list` command (see `{0}help list` for details)'.format(BOT_PREFIX), inline=False)
+				embed.add_field(name="By ID specifier", value='`TORRENT_ID_SPECIFIER` is a valid transfer ID specifier—*e.g.* `1,3-5,9` to specify transfers 1, 3, 4, 5, and 9\n*Transfer IDs are the left-most number in the list of transfers (use* `{0}list` *to print full list)*'.format(BOT_PREFIX), inline=False)
+				embed.add_field(name="Examples", value="`{0}modify`\n`{0}m seinfeld`\n`{0}m 23,34,36-42`\n`{0}m --filter downloading seinfeld`".format(BOT_PREFIX), inline=False)
+				await context.message.channel.send(embed=embed)
+		else:
+			embed = discord.Embed(title='List of commands:', color=0xb51a00)
+			embed.set_author(name='Transmission Bot: Manage torrent file transfers', icon_url=LOGO_URL)
+			embed.add_field(name="Print summary of transfers", value="*print summary from all transfers, with followup options to list transfers*\n*ex.* `{0}summary` or `{0}s`".format(BOT_PREFIX), inline=False)
+			embed.add_field(name="List torrent transfers", value="*list current transfers with sorting, filtering, and search options*\n*ex.* `{0}list [OPTIONS]` or `{0}l [OPTIONS]`".format(BOT_PREFIX), inline=False)
+			embed.add_field(name="Add new torrent transfers", value="*add one or more specified torrents by magnet link or url to torrent file*\n*ex.* `{0}add TORRENT ...` or `{0}a TORRENT ...`".format(BOT_PREFIX), inline=False)
+			embed.add_field(name="Modify existing transfers", value="*pause, resume, remove, or remove and delete specified transfers*\n*ex.* `{0}modify [TORRENT]` or `{0}m [TORRENT]`".format(BOT_PREFIX), inline=False)
+			embed.add_field(name='Help - Gives this menu', value='*with optional details of specified command*\n*ex.* `{0}help` or `{0}help COMMAND`'.format(BOT_PREFIX), inline=False)
+		
+			await context.message.channel.send(embed=embed)
+
+@client.event
+async def on_command_error(context, error):
+	if isinstance(error, commands.CommandOnCooldown):
+		await context.message.delete()
+		embed = discord.Embed(title="Error!", description='This command is on a {:.2f}s cooldown'.format(error.retry_after), color=0xb51a00)
+		message = await context.message.channel.send(embed=embed)
+		await asyncio.sleep(5)
+		await message.delete()
+	elif isinstance(error, commands.CommandNotFound):
+		await context.message.delete()
+		embed = discord.Embed(title="Error!", description="I don't know that command!", color=0xb51a00)
+		message = await context.message.channel.send(embed=embed)
+		await asyncio.sleep(2)
+		await help(context)
+	raise error
+
+client.run(TOKEN)