def choose_team(self, update: Update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
chat_id = update.message.chat.id
team = update.message.text
if not re.match(f'^({HandlerHelpers.make_teams_regex(chat_id)})$', team):
message = update.message.reply_text(f'Team "{team}" wasn\'t found, try again')
Queue.add(message.chat.id, message.message_id)
return RemoveTeam.CHOOSING_TEAM
document = App.db.get_teams().find_one_and_delete({
'chat_id': chat_id,
'name': team,
})
if document:
message = update.message.reply_text(
f'Team "{team}" was successfully removed',
reply_markup=ReplyKeyboardRemove(remove_keyboard=True),
)
Queue.add(message.chat.id, message.message_id)
else:
message = update.message.reply_text(
f'Team "{team}" wasn\'t removed due to some errors, try again later',
reply_markup=ReplyKeyboardRemove(remove_keyboard=True),
)
Queue.add(message.chat.id, message.message_id)
Queue.clean(update.message.chat.id, timeout=30)
return RemoveTeam.CHOOSING_END
def __init__(self, keyword):
self.keyword = keyword
self.processed_comments = Queue(100)
self.consecutive_timeouts = 0
self.timeout_warn_threshold = 1
self.pushshift_lag = 0
self.pushshift_lag_checked = None
def start(self, update: Update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
message = update.message.reply_text('Choose a team name')
Queue.add(message.chat.id, message.message_id)
return AddTeam.CHOOSING_NAME
def __init__(self, user, no_post):
log.info(f"Initializing reddit class: user={user} no_post={no_post}")
self.no_post = no_post
try:
self.reddit = praw.Reddit(user, user_agent=static.USER_AGENT)
except configparser.NoSectionError:
log.error("User " + user + " not in praw.ini, aborting")
raise ValueError
static.ACCOUNT_NAME = self.reddit.user.me().name
log.info("Logged into reddit as /u/" + static.ACCOUNT_NAME)
self.processed_comments = Queue(100)
self.consecutive_timeouts = 0
self.timeout_warn_threshold = 1
def mention(self, update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
chat_id = update.message.chat.id
team = update.message.text
if not re.match(f'^({HandlerHelpers.make_teams_regex(chat_id)})$', team):
message = update.message.reply_text(f'Team "{team}" wasn\'t found, try again')
Queue.add(message.chat.id, message.message_id)
return Mention.MENTION
members = HandlerHelpers.get_team_members(chat_id, team)
if members:
update.message.reply_text(
' '.join(members),
reply_markup=ReplyKeyboardRemove(remove_keyboard=True)
)
else:
message = update.message.reply_text(
'Members weren\'t found or something went wrong',
reply_markup=ReplyKeyboardRemove(remove_keyboard=True)
)
Queue.add(message.chat.id, message.message_id)
Queue.clean(update.message.chat.id, timeout=30)
return Mention.CHOOSING_END
def start(self, update: Update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
chat_id = update.message.chat.id
if not HandlerHelpers.check_teams_existence(update):
return AddMembers.CHOOSING_END
markup = ReplyKeyboardMarkup(map(lambda x: [x], HandlerHelpers.get_teams(chat_id)), one_time_keyboard=True)
message = update.message.reply_text(
f'Choose a team',
reply_markup=markup
)
Queue.add(message.chat.id, message.message_id)
return AddMembers.CHOOSING_TEAM
def __init__(self, bot):
''' Initialize the MusicPlayer object '''
self.id = bot.message.server.id
self.__loop = asyncio.get_event_loop()
self.chat = bot.message.channel
self.sender = bot.message.author
self.channel = bot.message.author.voice_channel
self.bot = bot
self.VC = None
self.Player = None
self.__queue = Queue()
self.shutting_down = False
self.allowed = ["file", "ytdl"]
self.skipvotes = []
self.paused = False
self.oldmsg = None
self.auto_dc = True
def get(self, update: Update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
chat_id = update.message.chat.id
teams = HandlerHelpers.get_teams(chat_id)
if len(teams) > 0:
message = update.message.reply_text(', '.join(teams))
Queue.add(message.chat.id, message.message_id, timeout=300)
else:
message = update.message.reply_text('No teams were found')
Queue.add(message.chat.id, message.message_id)
Queue.clean(update.message.chat.id)
return GetTeams.GETTING_END
def choose_name(self, update: Update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
name = update.message.text
if re.match(r'^[0-9a-zа-яё._-]{2,16}$', name.lower(), re.IGNORECASE):
if App.db.get_teams().find_one({
'name': re.compile(f'^{name.lower()}$', re.IGNORECASE),
'chat_id': update.message.chat.id
}):
message = update.message.reply_text(
f'Team "{name}" already exists, try another name'
)
Queue.add(message.chat.id, message.message_id)
return AddTeam.CHOOSING_NAME
else:
App.db.get_teams().insert_one({
'name': name,
'chat_id': update.message.chat.id,
'members': [],
})
message = update.message.reply_text(
f'Team "{name}" was successfully created'
)
Queue.add(message.chat.id, message.message_id)
else:
message = update.message.reply_text(
f'Team "{name}" wasn\'t created cause name contains incorrect symbols, try again'
)
Queue.add(message.chat.id, message.message_id)
return AddTeam.CHOOSING_NAME
Queue.clean(update.message.chat.id, timeout=30)
return AddTeam.CHOOSING_END
def choose_members(self, update: Update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
chat_id = update.message.chat.id
team = context.user_data['team']
# set is used to remove duplicated
members = list(
set(filter(
lambda x: re.match(r'^@[0-9a-z._-]{5,32}$', x.lower(), re.IGNORECASE) and x not in HandlerHelpers.get_team_members(chat_id, team),
update.message.text.split(' ')
))
)
if members:
App.db.get_teams().find_one_and_update({
'chat_id': chat_id,
'name': team,
}, {
'$push': {
'members': {
'$each': members,
},
},
})
message = update.message.reply_text(
f'Greeting new members of the "{team}" team: {" ".join(members)}'
)
Queue.add(message.chat.id, message.message_id)
else:
message = update.message.reply_text(
f'No members were added to the team "{team}"'
)
Queue.add(message.chat.id, message.message_id)
Queue.clean(update.message.chat.id, timeout=30)
return AddMembers.CHOOSING_END
def choose_members(self, update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
chat_id = update.message.chat.id
team = context.user_data['team']
members = list(
filter(
lambda x: x.startswith('@') and x in
HandlerHelpers.get_team_members(chat_id, team),
update.message.text.split(' ')))
if members:
App.db.get_teams().find_one_and_update(
{
'chat_id': chat_id,
'name': team,
}, {
'$pull': {
'members': {
'$in': members,
},
},
})
message = update.message.reply_text(
f'Members who were removed from "{team}" team: {" ".join(members)}'
)
Queue.add(message.chat.id, message.message_id)
else:
message = update.message.reply_text(
f'No members were removed from the team "{team}"')
Queue.add(message.chat.id, message.message_id)
Queue.clean(update.message.chat.id, timeout=30)
return RemoveMembers.CHOOSING_END
def printerSimulation(numSeconds, ppm: int):
printer = Printer(ppm)
printQueue = Queue()
waitingTimes = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
if (not printer.isBusy()) and (not printQueue.isEmpty()):
nextTask = printQueue.dequeue()
waitingTimes.append(nextTask.waitTime(currentSecond))
printer.next(nextTask)
printer.tick()
averageWaitingTime = sum(waitingTimes) / len(waitingTimes)
print(
"Average waiting time is {:.^14.2f} secs and {:.>5d} tasks remaining".
format(averageWaitingTime, printQueue.size()))
def choose_team(self, update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
chat_id = update.message.chat.id
context.user_data['team'] = team = update.message.text
if not re.match(f'^({HandlerHelpers.make_teams_regex(chat_id)})$',
team):
message = update.message.reply_text(
f'Team "{team}" wasn\'t found, try again')
Queue.add(message.chat.id, message.message_id)
return RemoveMembers.CHOOSING_TEAM
message = update.message.reply_text(
f'Now, send user @logins separated by space to remove them from the team "{team}" (with leading @)',
reply_markup=ReplyKeyboardRemove(remove_keyboard=True))
Queue.add(message.chat.id, message.message_id)
return RemoveMembers.CHOOSING_MEMBERS
def choose_team(self, update: Update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
chat_id = update.message.chat.id
context.user_data['old_team_name'] = old_team_name = update.message.text
if not re.match(f'^({HandlerHelpers.make_teams_regex(chat_id)})$', old_team_name):
message = update.message.reply_text(f'Team "{old_team_name}" wasn\'t found, try again')
Queue.add(message.chat.id, message.message_id)
return RenameTeam.CHOOSING_TEAM
message = update.message.reply_text(
f'Now send new name for the team "{old_team_name}"',
reply_markup=ReplyKeyboardRemove(remove_keyboard=True),
)
Queue.add(message.chat.id, message.message_id)
return RenameTeam.CHOOSING_NEW_NAME
def help(self, update: Update, context: CallbackContext):
timeout = 120
Queue.add(update.message.chat.id,
update.message.message_id,
timeout=timeout)
message = update.message.reply_text(
'*Commands for admins:*\n'
'/addteam – Add team\n'
'/addmembers – Add members to the chosen team\n'
'/removeteam – Remove team\n'
'/removemembers – Remove members from the chosen team\n'
'/renameteam – Rename team to the new given name\n'
'\n'
'*Commands for all members:*\n'
'/mention – Choose a team to mention\n'
'/getteams – List of all added teams\n'
'/help – Get some basic info about bot and commands\n'
'/cancel – Prevent any running command\n',
parse_mode=ParseMode.MARKDOWN)
Queue.add(message.chat.id, message.message_id, timeout=timeout)
Queue.clean(update.message.chat.id)
class Reddit:
def __init__(self, user, no_post):
log.info(f"Initializing reddit class: user={user} no_post={no_post}")
self.no_post = no_post
try:
self.reddit = praw.Reddit(user, user_agent=static.USER_AGENT)
except configparser.NoSectionError:
log.error("User " + user + " not in praw.ini, aborting")
raise ValueError
static.ACCOUNT_NAME = self.reddit.user.me().name
log.info("Logged into reddit as /u/" + static.ACCOUNT_NAME)
self.processed_comments = Queue(100)
self.consecutive_timeouts = 0
self.timeout_warn_threshold = 1
def run_function(self, function, arguments):
output = None
result = None
try:
output = function(*arguments)
except praw.exceptions.APIException as err:
for return_type in ReturnType:
if err.error_type == return_type.name:
result = return_type
break
if result is None:
raise
except prawcore.exceptions.Forbidden:
result = ReturnType.FORBIDDEN
except IndexError:
result = ReturnType.QUARANTINED
if result is None:
result = ReturnType.SUCCESS
return output, result
def is_message(self, item):
return isinstance(item, praw.models.Message)
def get_messages(self, count=500):
log.debug("Fetching unread messages")
message_list = []
for message in self.reddit.inbox.unread(limit=count):
message_list.append(message)
return message_list
def reply_message(self, message, body):
log.debug(f"Replying to message: {message.id}")
if self.no_post:
log.info(body)
return ReturnType.SUCCESS
else:
output, result = self.run_function(message.reply, [body])
return result
def mark_read(self, message):
log.debug(f"Marking message as read: {message.id}")
if not self.no_post:
message.mark_read()
def reply_comment(self, comment, body):
log.debug(f"Replying to message: {comment.id}")
if self.no_post:
log.info(body)
return "xxxxxx", ReturnType.SUCCESS
else:
output, result = self.run_function(comment.reply, [body])
if output is not None:
return output.id, result
else:
return None, result
def send_message(self, username, subject, body):
log.debug(f"Sending message to u/{username}")
if self.no_post:
log.info(body)
return ReturnType.SUCCESS
else:
redditor = self.reddit.redditor(username)
output, result = self.run_function(redditor.message,
[subject, body])
return result
def get_comment(self, comment_id):
log.debug(f"Fetching comment by id: {comment_id}")
if comment_id == "xxxxxx":
return None
else:
return self.reddit.comment(comment_id)
def edit_comment(self, body, comment=None, comment_id=None):
if comment is None:
comment = self.get_comment(comment_id)
log.debug(f"Editing comment: {comment.id}")
if self.no_post:
log.info(body)
else:
output, result = self.run_function(comment.edit, [body])
return result
def delete_comment(self, comment):
log.debug(f"Deleting comment: {comment.id}")
if not self.no_post:
try:
comment.delete()
except Exception:
log.warning(f"Error deleting comment: {comment.comment_id}")
log.warning(traceback.format_exc())
return False
return True
def quarantine_opt_in(self, subreddit_name):
log.debug(f"Opting in to subreddit: {subreddit_name}")
if not self.no_post:
try:
self.reddit.subreddit(subreddit_name).quaran.opt_in()
except Exception:
log.warning(f"Error opting in to subreddit: {subreddit_name}")
log.warning(traceback.format_exc())
return False
return True
def get_keyword_comments(self, keyword, last_seen):
if not len(self.processed_comments.list):
last_seen = last_seen + timedelta(seconds=1)
log.debug(
f"Fetching comments for keyword: {keyword} : {utils.get_datetime_string(last_seen)}"
)
url = f"https://api.pushshift.io/reddit/comment/search?q={keyword}&limit=100&sort=desc"
try:
json = requests.get(url,
headers={'User-Agent': static.USER_AGENT},
timeout=10)
if json.status_code != 200:
log.warning(
f"Could not parse data for search term: {keyword} status: {str(json.status_code)}"
)
return []
comments = json.json()['data']
if self.timeout_warn_threshold > 1:
log.warning(
f"Recovered from timeouts after {self.consecutive_timeouts} attempts"
)
self.consecutive_timeouts = 0
self.timeout_warn_threshold = 1
except requests.exceptions.ReadTimeout:
self.consecutive_timeouts += 1
if self.consecutive_timeouts >= pow(self.timeout_warn_threshold,
2) * 5:
log.warning(
f"{self.consecutive_timeouts} consecutive timeouts for search term: {keyword}"
)
self.timeout_warn_threshold += 1
return []
except Exception as err:
log.warning(f"Could not parse data for search term: {keyword}")
log.warning(traceback.format_exc())
return []
if not len(comments):
log.warning(f"No comments found for search term: {keyword}")
return []
result_comments = []
for comment in comments:
date_time = utils.datetime_from_timestamp(comment['created_utc'])
if last_seen > date_time:
break
if not self.processed_comments.contains(comment['id']):
result_comments.append(comment)
log.debug(f"Found comments: {len(result_comments)}")
return result_comments
def mark_keyword_comment_processed(self, comment_id):
self.processed_comments.put(comment_id)
def choose_new_name(self, update: Update, context: CallbackContext):
Queue.add(update.message.chat.id, update.message.message_id)
chat_id = update.message.chat.id
new_team_name = update.message.text
old_team_name = context.user_data['old_team_name']
if App.db.get_teams().find_one({'chat_id': chat_id, 'name': new_team_name}):
message = update.message.reply_text(
f'Team wasn\'t renamed, cause "{new_team_name}" already exists, send new name for team "{old_team_name}" again',
)
Queue.add(message.chat.id, message.message_id)
return RenameTeam.CHOOSING_NEW_NAME
if not re.match(r'^[0-9a-zа-яё._-]{2,16}$', new_team_name.lower(), re.IGNORECASE):
message = update.message.reply_text(
f'Team wasn\'t renamed, cause name "{new_team_name}" contains incorrect symbols, try again',
)
Queue.add(message.chat.id, message.message_id)
return RenameTeam.CHOOSING_NEW_NAME
if App.db.get_teams().find_one_and_update({'chat_id': chat_id, 'name': old_team_name}, {'$set': {'name': new_team_name}}):
message = update.message.reply_text(
f'Team "{old_team_name}" was renamed to "{new_team_name}"'
)
Queue.add(message.chat.id, message.message_id)
else:
message = update.message.reply_text(
f'Team "{old_team_name}" wasn\'t renamed to "{new_team_name}" due to some errors, try again later',
reply_markup=ReplyKeyboardRemove(remove_keyboard=True),
)
Queue.add(message.chat.id, message.message_id)
Queue.clean(update.message.chat.id, timeout=30)
return RenameTeam.CHOOSING_END
class RedditKeywordWatcher:
def __init__(self, keyword):
self.keyword = keyword
self.processed_comments = Queue(100)
self.consecutive_timeouts = 0
self.timeout_warn_threshold = 1
self.pushshift_lag = 0
self.pushshift_lag_checked = None
def get(self):
last_seen = utils.get_last_seen(self.keyword)
log.debug(
f"Fetching comments for keyword: {self.keyword} : {last_seen}")
url = f"https://api.pushshift.io/reddit/comment/search?q={self.keyword}&limit=100&sort=desc&fields=created_utc,id"
lag_url = "https://api.pushshift.io/reddit/comment/search?limit=1&sort=desc"
try:
json = requests.get(url,
headers={'User-Agent': config.USER_AGENT},
timeout=10)
if json.status_code != 200:
log.warning(
f"Could not parse data for search term: {self.keyword} status: {str(json.status_code)}"
)
return []
comments = json.json()['data']
if self.pushshift_lag_checked is None or \
utils.datetime_now() - timedelta(minutes=10) > self.pushshift_lag_checked:
log.debug("Updating pushshift comment lag")
json = requests.get(lag_url,
headers={'User-Agent': config.USER_AGENT},
timeout=10)
if json.status_code == 200:
comment_created = utils.datetime_from_timestamp(
json.json()['data'][0]['created_utc'])
self.pushshift_lag = round(
(utils.datetime_now() - comment_created).seconds / 60,
0)
self.pushshift_lag_checked = utils.datetime_now()
if self.timeout_warn_threshold > 1:
log.warning(
f"Recovered from timeouts after {self.consecutive_timeouts} attempts"
)
self.consecutive_timeouts = 0
self.timeout_warn_threshold = 1
except requests.exceptions.ReadTimeout:
self.consecutive_timeouts += 1
if self.consecutive_timeouts >= pow(self.timeout_warn_threshold,
2) * 5:
log.warning(
f"{self.consecutive_timeouts} consecutive timeouts for search term: {self.keyword}"
)
self.timeout_warn_threshold += 1
return []
except Exception as err:
log.warning(
f"Could not parse data for search term: {self.keyword}")
log.warning(traceback.format_exc())
return []
if not len(comments):
log.warning(f"No comments found for search term: {self.keyword}")
return []
result_comments = []
for comment in comments:
date_time = utils.datetime_from_timestamp(comment['created_utc'])
if last_seen > date_time:
break
if not self.processed_comments.contains(comment['id']):
result_comments.append(comment)
return result_comments
def set_processed(self, comment_id):
self.processed_comments.put(comment_id)
import msvcrt # Windows-only non-blocking input. Universal would need a lot more things
import random
from classes.espresso import Espresso
from classes.queue import Queue
from classes.coffeeenum import CoffeeEnum
from classes.order import Order
# Launch the machine
num_engineers = 1705
chance_superbusy = 25 # percent
max_time_superbusy = 120 # minutes
espresso_machine = Espresso(num_engineers, chance_superbusy, max_time_superbusy)
espresso_machine.start()
# Setup a few things
queue = Queue()
queue_id = 0
coffee_name = CoffeeEnum()
superbusy = False
# Run the show!
espresso_machine.display_coffee_choices()
while True:
if queue.has_orders() and espresso_machine.is_ready():
espresso_machine.brew(queue.get_next(), queue)
# Read input to get new orders and enter superbusy mode
if msvcrt.kbhit():
# There's a chance the engineer is superbusy!
if random.randrange(0, 100) < chance_superbusy:
print("By surprise, you are now superbusy!")
import json
from classes.logger import Logger
from classes.cart import Cart
from classes.captcha import Captcha
from classes.queue import Queue
from classes.tools import Tools
if __name__ == '__main__':
session = requests.Session()
lock = threading.Lock()
tools = Tools()
config = tools.load('config/config.json')
log = Logger().log
q = Queue()
cart = Cart(session, lock)
api_key = config['key']['2captcha']
captcha = Captcha(api_key)
queue = Queue()
if 'true' in config['settings']['browser']['US'].lower() and 'true' in config['settings']['browser']['EU'].lower():
log('You have both regions selected - please select only one.','error')
exit()
if 'true' in str(config['settings']['captcha'].lower()):
captcha.harvest(queue)
log('Initializing script..','info')
'''
cart.add_to_cart(['zollar','jacket','ice'],'medium')
def hotPotato(names, num):
q = Queue()
for name in names:
q.enqueue(name)
while q.size() > 1:
for x in range(num):
q.enqueue(q.dequeue())
q.dequeue()
return q.dequeue()
async def empty(self):
''' Clear the queue '''
if self.shutting_down:
raise PlayerException("The player already finished.")
self.__queue = Queue()
class MusicPlayer:
def __init__(self, bot):
''' Initialize the MusicPlayer object '''
self.id = bot.message.server.id
self.__loop = asyncio.get_event_loop()
self.chat = bot.message.channel
self.sender = bot.message.author
self.channel = bot.message.author.voice_channel
self.bot = bot
self.VC = None
self.Player = None
self.__queue = Queue()
self.shutting_down = False
self.allowed = ["file", "ytdl"]
self.skipvotes = []
self.paused = False
self.oldmsg = None
self.auto_dc = True
async def disconnect(self):
''' Stops the current music player and disconnects the client '''
try:
self.shutting_down = True
self.__queue = None
await self.stop()
if self.VC is not None and self.VC.is_connected():
await self.VC.disconnect()
self.VC = None
del global_vars.music_bots[self.id]
except:
logger.PrintException()
async def connect(self):
''' Connects the Client to a Voice channel '''
if not discord.opus.is_loaded():
raise PlayerException("Opus is not loaded.")
# discord.opus.load_opus("libopus-0_x86.dll")
#if not discord.opus.is_loaded():
#PlayerException("Could not load Opus dll")
#return False
if not self.VC:
try:
#logger.printtf("connecting")
self.VC = await self.bot.client.join_voice_channel(self.channel
)
print("Connected to {}".format(self.channel.name))
#logger.printtf("connected")
return True
except Exception:
logger.PrintException()
return False
else:
raise ClientException("The MusicPlayer is already connected")
async def stop(self):
''' Stops the current music player '''
if self.Player is not None:
if not self.Player.is_done():
self.Player.stop()
return True
self.Player = None
return False
async def volume(self, value):
"""Sets the volume of the currently playing song."""
if self.Player is not None:
player = self.Player
player.volume = value / 100
await config.setConf(self.id, "music_bot_volume", player.volume)
await self.bot.sendMessage('Set the volume to {:.0%}'.format(
player.volume))
async def pause(self):
''' Pauses the player '''
if self.shutting_down:
raise PlayerException("The player already finished.")
if self.paused:
raise PlayerException("The player is already paused.")
self.Player.pause()
self.paused = True
async def resume(self):
''' Resumes the player '''
if self.shutting_down:
raise PlayerException("The player already finished.")
if not self.paused:
raise PlayerException("The player is already playing.")
self.Player.resume()
self.paused = False
async def getqueue(self, position):
return self.__queue.list[position]
async def dequeue(self, position):
return await self.__queue.remove(position)
async def queuelist(self):
return await self.__queue.getQueue()
async def remaining(self):
''' Remaining songs in queue '''
if self.shutting_down:
raise PlayerException("The player already finished")
return self.__queue.size()
async def empty(self):
''' Clear the queue '''
if self.shutting_down:
raise PlayerException("The player already finished.")
self.__queue = Queue()
async def downloadSoundCloud(self, url):
''' Tries to get the download URL for soundcloud songs.
Returns None if it fails '''
try:
posturl = "http://soundflush.com/"
with aiohttp.ClientSession() as session:
async with session.post(posturl, data={"track_url_field":
url}) as r:
r = re.search('download=\".*\" href=\"(.*)\" class', await
r.text())
if r is not None:
return r.group(1)
except:
logger.PrintException()
return None
async def voteSkip(self, user):
''' Handles the skipping votes and skips the current songs
when there were enough votes
Returns: True/False depending onif the vote was successfull or not'''
if not user.voice_channel or user.voice_channel.id != self.channel.id:
await self.bot.sendMessage(
"You have to be in the bots voice channel to vote for a skip.")
return False
members = len(self.channel.voice_members) - 1
success = False
if members == 1:
await self.bot.sendMessage(
"Skip vote was successful. Skipping song.")
await self.playNext()
if members > 0:
needed = 1
if members % 2 == 0:
needed = int((members / 2) + 1)
else:
needed = int(math.ceil(members / 2))
else:
if self.auto_dc:
await self.disconnect()
return success
# If the user has not voted yet, count the vote and return True
if not user.id in self.skipvotes:
self.skipvotes.append(user.id)
if len(self.skipvotes) < needed:
await botfunc.autoDelete(
10, await self.bot.sendMessage(
"{} voted to skip the current song. ({}/{} votes)".
format(user.display_name, len(self.skipvotes),
needed)))
success = True
# We've got enough votes. Skipping.
if len(self.skipvotes) >= needed:
await botfunc.autoDelete(
10, await self.bot.sendMessage(
"{} voted to skip the current song.\r\nThe vote was successful. Skipping song."
.format(user.display_name)))
await self.playNext()
return True
elif success == False:
await botfunc.autoDelete(
10, await self.bot.sendMessage(
"You can't vote twice. ({}/{} votes)".format(
len(self.skipvotes), needed)))
return success
async def playNext(self):
''' Play the next song'''
# Delete the old message
if self.oldmsg is not None:
await botfunc.autoDelete(1, self.oldmsg)
mb_allowed = await config.getConf(self.id, "music_bot")
if mb_allowed == False:
self.shutting_down = True
await self.bot.sendMessage(
"The music bot has been stopped as it has been disabled by an administrator."
)
await self.disconnect()
if mb_allowed == True:
if not await self.stop():
if self.__queue is not None:
if not self.__queue.empty():
MusicObj = await self.__queue.next()
return await self.play(MusicObj)
else:
if self.auto_dc:
await self.disconnect()
self.shutting_down = True
return False
async def play(self, obj):
''' initial play function '''
try:
if not self.VC or not self.VC.is_connected:
raise ClientException("Not connected to a channel")
if self.Player is not None:
raise PlayerException(
"Could not play. There's another player running.")
self.skipvotes = []
obj.type = obj.type.lower()
if not obj.type in self.allowed:
raise ArgumentException("Invalid link type.")
#if obj.type == "ytdl":
await self.__yt_play(obj)
#elif obj.type == "file":
# await self.__file_play(obj)
return True
except:
logger.PrintException()
async def add(self, obj):
''' Add a song to queue '''
obj.type = obj.type.lower()
if obj.type not in self.allowed:
raise ArgumentException("Invalid link type.")
if self.shutting_down:
raise PlayerException("The player already finished.")
if not self.__queue.full():
return await self.__queue.add(obj)
else:
return False
async def is_connected(self):
''' Is the bot connected? '''
return (self.VC is not None and self.VC.is_connected())
async def is_playing(self):
''' Is the bot playing? '''
return (self.Player is not None and not self.Player.is_done())
async def playing_now(self):
try:
if not self.VC or not self.VC.is_connected:
raise ClientException("Not connected to a channel")
self.Player.volume = await config.getConf(self.id,
"music_bot_volume")
title = self.Player.title
try:
if self.Player.duration is not None:
secs = self.Player.duration
mins = math.floor(secs / 60)
secs -= (mins * 60)
mins = str(mins).zfill(2)
secs = str(secs).zfill(2)
# Change this shit so it does only generate the message. ?playing should send it so I can improve the auto deletion
if self.Player.duration is None:
await botfunc.autoDelete(
10, await self.bot.sendMessage(
"Currently playing `{}` in {}.\r\nQueue: {} left.".
format(title, self.channel.name,
self.__queue.size())))
elif self.Player.is_live:
await botfunc.autoDelete(
10, await self.bot.sendMessage(
"Currently playing `{}` (a livestream) in {}.\r\nQueue: {} left."
.format(title, self.channel.name,
self.__queue.size())))
else:
await botfunc.autoDelete(
10, await self.bot.sendMessage(
"Currently playing `{}` in {}.\r\nDuration: {}:{}\r\nQueue: {} left."
.format(title, self.channel.name, mins, secs,
self.__queue.size())))
except:
await botfunc.autoDelete(
10, await self.bot.sendMessage(
"Currently playing {} (a file).".format(title)))
except:
logger.PrintException()
async def __yt_play(self, MusicObj):
''' Plays a youtube url '''
try:
if not self.VC or not self.VC.is_connected:
raise ClientException("Not connected to a channel")
if self.Player is not None:
raise PlayerException(
"Could not play. There's another player running.")
try:
opts = {
'default_search': 'auto',
'quiet': True,
'noplaylist': True,
}
self.Player = await self.VC.create_ytdl_player(
MusicObj.url,
after=lambda: self.__loop.create_task(self.playNext()),
ytdl_options=opts)
except DownloadError:
await botfunc.autoDelete(
10, await self.bot.sendMessage(
"Could not play `{}`. This video is banned in my country. :sob:"
.format(MusicObj.url)))
await self.stop()
await self.playNext()
return False
except:
await botfunc.autoDelete(
10, await self.bot.sendMessage(
"Could not play `{}`. There's something wrong with the link."
.format(MusicObj.url)))
await self.stop()
await self.playNext()
return False
self.Player.start()
self.Player.volume = await config.getConf(self.id,
"music_bot_volume")
if self.Player.title is not None:
title = self.Player.title
if self.Player.duration is not None:
secs = self.Player.duration
mins = math.floor(secs / 60)
secs -= (mins * 60)
mins = str(mins).zfill(2)
secs = str(secs).zfill(2)
if self.Player.duration is None:
#await botfunc.autoDelete(10,await self.bot.sendMessage("Now playing `{}` in {}.\r\n**Requested by:** {}\r\n**Queue:** {} left.".format(title, self.channel.name, MusicObj.user, self.__queue.size())))
self.oldmsg = await self.bot.sendMessage(
"Now playing `{}` in {}.\r\n**Requested by:** {} || **Queue:** {} left."
.format(title, self.channel.name, MusicObj.user,
self.__queue.size()))
elif self.Player.is_live:
#await botfunc.autoDelete(10,await self.bot.sendMessage("Now playing `{}` (a livestream) in {}.\r\n**Requested by:** {}\r\n**Queue:** {} left.".format(title, self.channel.name, MusicObj.user, self.__queue.size())))
self.oldmsg = await self.bot.sendMessage(
"Now playing `{}` (a livestream) in {}.\r\n**Requested by:** {} || **Queue:** {} left."
.format(title, self.channel.name, MusicObj.user,
self.__queue.size()))
else:
#await botfunc.autoDelete(10,await self.bot.sendMessage("Now playing `{}` in {}.\r\n**Requested by:** {}\r\n**Duration:** {}:{}\r\n**Queue:** {} left.".format(title, self.channel.name, MusicObj.user, mins, secs, self.__queue.size())))
self.oldmsg = await self.bot.sendMessage(
"Now playing `{}` in {}.\r\n**Requested by:** {} || **Duration:** {}:{} || **Queue:** {} left."
.format(title, self.channel.name, MusicObj.user, mins,
secs, self.__queue.size()))
except:
logger.PrintException()
