def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Retourne les préfixes du message du serveur si défini.
Si aucun n'est défini ou si le message du server est None
cela renverra les préfixes globaux à la place.
Nécessite une instance Bot et un objet Message
passé en arguments.
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow() # Refreshed before login
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self._shutdown_mode = None
self.logger = set_logger(self)
self._last_exception = None
self.oauth_url = ""
self.printdebug = True
if 'self_bot' in kwargs:
self.settings.self_bot = kwargs['self_bot']
else:
kwargs['self_bot'] = self.settings.self_bot
if self.settings.self_bot:
kwargs['pm_help'] = False
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Zwraca prefixy serverowe, a jeśli nie istnieją, globalne
wymaga instancji bota i wiadomości
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow(
) # Odświerzane przed logowaniem
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self._shutdown_mode = None
self.logger = set_logger(self)
self._last_exception = None
self.oauth_url = ""
if 'self_bot' in kwargs:
self.settings.self_bot = kwargs['self_bot']
else:
kwargs['self_bot'] = self.settings.self_bot
if self.settings.self_bot:
kwargs['pm_help'] = False
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Returns prefixes of the message's server if set.
If none are set or if the message's server is None
it will return the global prefixes instead.
Requires a Bot instance and a Message object to be
passed as arguments.
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow() # Refreshed before login
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self._shutdown_mode = None
self.logger = set_logger(self)
self._last_exception = None
self.oauth_url = ""
self.version = VERSION
try:
self._cog_registry = dataIO.load_json("data/bot/cogs.json")
except Exception:
self._cog_registry = {}
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
# Unable to find a better way to fully override
# the default help cmd, so had to do this instead. :C
self.remove_command('help')
self.command(**self.help_attrs)(_help_command)
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Returns prefixes of the message's server if set.
If none are set or if the message's server is None
it will return the global prefixes instead.
Requires a Bot instance and a Message object to be
passed as arguments.
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow() # Refreshed before login
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self._shutdown_mode = None
self.logger = set_logger(self)
self._last_exception = None
self.oauth_url = ""
if 'self_bot' in kwargs:
self.settings.self_bot = kwargs['self_bot']
else:
kwargs['self_bot'] = self.settings.self_bot
if self.settings.self_bot:
kwargs['pm_help'] = False
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
def __init__(self, *args, **kwargs):
self.logger = Logger("bot")
self.settings = Settings()
super().__init__(*args,
command_prefix=self.prefix_manager,
pm_help=False,
**kwargs)
def __init__(self):
super(MainWindow, self).__init__()
self.large_font = QtGui.QFont("Arial", 12)
self.reg_font = QtGui.QFont("Arial", 10)
self.small_font = QtGui.QFont("Arial", 8)
self.settings = Settings()
self.init_ui()
def check_env(args):
from cogs.utils.settings import Settings
email = os.environ.get('RED_EMAIL', args.email)
password = os.environ.get('RED_PASSWORD', args.password)
token = os.environ.get('RED_TOKEN', args.token)
if token and email:
print("ERROR: You can only specify one of token or email")
exit(1)
elif token and ("@" in token or len(token) < 50):
print("ERROR: Invalid token provided")
exit(1)
elif email and "@" not in email:
print("ERROR: Invalid email provided")
exit(1)
elif email and not password:
print("ERROR: Email authentication requires password")
exit(1)
s = Settings()
# Set credentials if provided
if token:
if s.email not in [s.default_settings['EMAIL'], token]:
print('WARNING: New token provided, overwriting old one')
s.email = token
s.login_type = 'token'
elif email:
if (s.email not in [s.default_settings['EMAIL'], email] or
s.password not in [s.default_settings['PASSWORD'], password]):
print('WARNING: New credentials provided, overwriting old ones')
s.email = email
s.password = password
s.login_type = 'email'
elif s.email == s.default_settings['EMAIL']:
print("ERROR: No credentials set or provided.")
exit(1)
if s.prefixes == s.default_settings['PREFIXES']:
default_prefix = os.environ.get('RED_PREFIX', args.prefix)
if default_prefix:
s.prefixes = [default_prefix]
if s.bot_settings['default'] == s.default_settings['default']:
admin = os.environ.get('RED_ADMIN', args.admin)
mod = os.environ.get('RED_MOD', args.mod)
if admin:
s.default_admin = admin
if mod:
s.default_mod = mod
userpath = os.path.expanduser('~')
userbin = os.path.join(userpath, '.local/bin')
currentpath = os.environ['PATH'].split(':')
if userbin not in currentpath:
currentpath.append(userbin)
os.environ['PATH'] = ':'.join(currentpath)
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Returns prefixes of the message's server if set.
If none are set or if the message's server is None
it will return the global prefixes instead.
Requires a Bot instance and a Message object to be
passed as arguments.
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow() # Refreshed before login
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self._shutdown_mode = None
self.logger = set_logger(self)
self._last_exception = None
self.oauth_url = ""
try:
self._cog_registry = dataIO.load_json("data/red/cogs.json")
except Exception:
self._cog_registry = {}
if 'self_bot' in kwargs:
self.settings.self_bot = kwargs['self_bot']
else:
kwargs['self_bot'] = self.settings.self_bot
if self.settings.self_bot:
kwargs['pm_help'] = False
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Returns Prefixs of the server if set.
If None are set or is none on server, returns global prefixs
Requires an instance of Bot and Message Object to be passed as args.
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow() # Refreshed before bot Logins
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self._shutdown_mode = None
self.logger = set_logger(self)
if 'self_bot' in kwargs:
self.settings.self_bot = kwargs['self_bot']
else:
kwargs['self_bot'] = self.settings.self_bot
if self.settings.self_bot:
kwargs['pm_help'] = False
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
def __init__(self, debug: bool = False):
super().__init__(command_prefix=_get_prefix,
description=conf['bot']['description'])
self.settings = Settings(**conf['default server settings'])
self.debug = debug
for extension in initial_extensions:
try:
self.load_extension(extension)
except Exception as e:
print(e)
def __init__(self):
super().__init__(command_prefix=_get_prefix)
# This is kinda stupid, TODO: make not stupid
with codecs.open("config.json", 'r', encoding='utf8') as f:
self.config = json.load(f)
self.settings = Settings(self.config['default_prefix'])
# Load all cogs
for file in os.listdir("cogs"):
if file.endswith(".py"):
name = file[:-3]
self.load_extension(f"cogs.{name}")
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Returns prefixes of the message's server if set.
If none are set or if the message's server is None
it will return the global prefixes instead.
Requires a Bot instance and a Message object to be
passed as arguments.
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.now()
self._message_modifiers = []
self.settings = Settings()
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
class Bot(commands.Bot):
def __init__(self, *args, **kwargs):
self.logger = Logger("bot")
self.settings = Settings()
super().__init__(*args,
command_prefix=self.prefix_manager,
pm_help=False,
**kwargs)
def prefix_manager(self, bot: commands.Bot, message: Message) -> list:
guild = message.guild
if not guild:
guild = None
else:
guild = guild.id
return self.settings.getprefix(guild)
#
#
# red.py and cogs/utils/checks.py both contain some modified functions originally made by Rapptz
# https://github.com/Rapptz/RoboDanny/tree/async
#
description = "Fish - A fully modular Discord Bot forked from Red!"
formatter = commands.HelpFormatter(show_check_failure=False)
bot = commands.Bot(command_prefix=["_"],
formatter=formatter,
description=description,
pm_help=None)
settings = Settings()
@bot.event
async def on_ready():
owner_cog = bot.get_cog('Owner')
total_cogs = len(owner_cog._list_cogs())
users = len(set(bot.get_all_members()))
servers = len(bot.servers)
channels = len([c for c in bot.get_all_channels()])
if not hasattr(bot, "uptime"):
bot.uptime = int(time.perf_counter())
if settings.login_type == "token" and settings.owner == "id_here":
await set_bot_owner()
print('------')
print("{} is now online.".format(bot.user.name))
help="Sets debug to true")
parser.add_argument(
"-l",
"--level",
help="Sets debug level",
choices=["critical", "error", "warning", "info", "debug"],
default="warning")
parser.add_argument("-d",
"--data-directory",
help="Define an alternate data directory location",
default="data")
parser.add_argument("-f",
"--log-to-file",
action="store_true",
help="Save log to file",
default=True)
args = parser.parse_args()
data_dir = os.environ.get("BOT_DATA_DIR", args.data_directory)
level = os.environ.get("BOT_LOG_LEVEL", args.level)
to_file = os.environ.get("BOT_LOG_TO_FILE", args.log_to_file)
if os.environ.get("BOT_DEBUG", args.debug):
level = "debug"
logger = Logger(location=data_dir, level=level, to_file=to_file).logger
logger.debug("Data folder: %s" % data_dir)
settings = Settings(data_dir=data_dir)
Bot().run()
class Bot(commands.Bot):
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Returns prefixes of the message's server if set.
If none are set or if the message's server is None
it will return the global prefixes instead.
Requires a Bot instance and a Message object to be
passed as arguments.
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow() # Refreshed before login
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self.logger = set_logger(self)
if 'self_bot' in kwargs:
self.settings.self_bot = kwargs['self_bot']
else:
kwargs['self_bot'] = self.settings.self_bot
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
async def send_message(self, *args, **kwargs):
if self._message_modifiers:
if "content" in kwargs:
pass
elif len(args) == 2:
args = list(args)
kwargs["content"] = args.pop()
else:
return await super().send_message(*args, **kwargs)
content = kwargs['content']
for m in self._message_modifiers:
try:
content = str(m(content))
except: # Faulty modifiers should not
pass # break send_message
kwargs['content'] = content
return await super().send_message(*args, **kwargs)
def add_message_modifier(self, func):
"""
Adds a message modifier to the bot
A message modifier is a callable that accepts a message's
content as the first positional argument.
Before a message gets sent, func will get called with
the message's content as the only argument. The message's
content will then be modified to be the func's return
value.
Exceptions thrown by the callable will be catched and
silenced.
"""
if not callable(func):
raise TypeError("The message modifier function "
"must be a callable.")
self._message_modifiers.append(func)
def remove_message_modifier(self, func):
"""Removes a message modifier from the bot"""
if func not in self._message_modifiers:
raise RuntimeError("Function not present in the message "
"modifiers.")
self._message_modifiers.remove(func)
def clear_message_modifiers(self):
"""Removes all message modifiers from the bot"""
self._message_modifiers.clear()
async def send_cmd_help(self, ctx):
if ctx.invoked_subcommand:
pages = self.formatter.format_help_for(ctx, ctx.invoked_subcommand)
for page in pages:
await self.send_message(ctx.message.channel, page)
else:
pages = self.formatter.format_help_for(ctx, ctx.command)
for page in pages:
await self.send_message(ctx.message.channel, page)
def user_allowed(self, message):
author = message.author
if author.bot:
return False
if author == self.user:
return self.settings.self_bot
mod = self.get_cog('Mod')
if mod is not None:
if self.settings.owner == author.id:
return True
if not message.channel.is_private:
server = message.server
names = (self.settings.get_server_admin(server),
self.settings.get_server_mod(server))
results = map(
lambda name: discord.utils.get(author.roles, name=name),
names)
for r in results:
if r is not None:
return True
if author.id in mod.blacklist_list:
return False
if mod.whitelist_list:
if author.id not in mod.whitelist_list:
return False
if not message.channel.is_private:
if message.server.id in mod.ignore_list["SERVERS"]:
return False
if message.channel.id in mod.ignore_list["CHANNELS"]:
return False
return True
else:
return True
# The following have to be imported and initialized in the correct order
from cogs.utils.settings import Settings
settings = Settings()
from cogs.utils.botdata import BotData
botdata = BotData()
import cogs.utils.loggingdb as loggingdb
loggingdb_session = loggingdb.create_session(settings.resource("loggingdb.db"))
from cogs.utils.httpgetter import HttpGetter
httpgetter = HttpGetter()
from cogs.utils.helpers import *
import discord
import traceback
import asyncio
import string
from discord.ext import commands
import logging
import datetime
from cogs.utils.helpcommand import MangoHelpCommand
from cogs.utils.clip import *
from cogs.utils.commandargs import *
logging.basicConfig(level=logging.INFO)
description = """The juiciest unsigned 8 bit integer you is eva gonna see.
For more information about me, try `{cmdpfx}info`"""
class Bot(commands.Bot):
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Zwraca prefixy serverowe, a jeśli nie istnieją, globalne
wymaga instancji bota i wiadomości
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow(
) # Odświerzane przed logowaniem
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self._shutdown_mode = None
self.logger = set_logger(self)
self._last_exception = None
self.oauth_url = ""
if 'self_bot' in kwargs:
self.settings.self_bot = kwargs['self_bot']
else:
kwargs['self_bot'] = self.settings.self_bot
if self.settings.self_bot:
kwargs['pm_help'] = False
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
async def send_message(self, *args, **kwargs):
if self._message_modifiers:
if "content" in kwargs:
pass
elif len(args) == 2:
args = list(args)
kwargs["content"] = args.pop()
else:
return await super().send_message(*args, **kwargs)
content = kwargs['content']
for m in self._message_modifiers:
try:
content = str(m(content))
except: # złe modyfikatory
pass # nie zepsują wiadomości
kwargs['content'] = content
return await super().send_message(*args, **kwargs)
async def shutdown(self, *, restart=False):
"""wyłącza bota z kodem 1
jeśli restart=true bot spróbuje się zrestartować z kodem 26"""
self._shutdown_mode = not restart
await self.logout()
def add_message_modifier(self, func):
"""
Dodaje modyfikator do wiadomości
Można wywołać coś zawartością wiadomości
przed wysłaniem wiadmości funkcja zostanie zawołana z treścią jako argumentem
Excepcje wyrzucone zostaną wyciszone
"""
if not callable(func):
raise TypeError("Funkcja modyfikatora wiadmości "
"musi bć zdolna do bycia wywołaną.")
self._message_modifiers.append(func)
def remove_message_modifier(self, func):
"""Usuwa modyfikator wiadomości"""
if func not in self._message_modifiers:
raise RuntimeError(
"Funkcja nie istnieje w modyfikatorach wiadomości")
self._message_modifiers.remove(func)
def clear_message_modifiers(self):
"""Usuwa wszystkie modyfikatory wiadmości"""
self._message_modifiers.clear()
async def send_cmd_help(self, ctx):
if ctx.invoked_subcommand:
pages = self.formatter.format_help_for(ctx, ctx.invoked_subcommand)
for page in pages:
await self.send_message(ctx.message.channel, page)
else:
pages = self.formatter.format_help_for(ctx, ctx.command)
for page in pages:
await self.send_message(ctx.message.channel, page)
def user_allowed(self, message):
author = message.author
if author.bot:
return False
if author == self.user:
return self.settings.self_bot
mod_cog = self.get_cog('Mod')
global_ignores = self.get_cog('Owner').global_ignores
if self.settings.owner == author.id:
return True
if author.id in global_ignores["blacklist"]:
return False
if global_ignores["whitelist"]:
if author.id not in global_ignores["whitelist"]:
return False
if not message.channel.is_private:
server = message.server
names = (self.settings.get_server_admin(server),
self.settings.get_server_mod(server))
results = map(
lambda name: discord.utils.get(author.roles, name=name), names)
for r in results:
if r is not None:
return True
if mod_cog is not None:
if not message.channel.is_private:
if message.server.id in mod_cog.ignore_list["SERVERS"]:
return False
if message.channel.id in mod_cog.ignore_list["CHANNELS"]:
return False
return True
async def pip_install(self, name, *, timeout=None):
"""
Bezpiecznie instaluje pakiet pip w folderze lib
Zwraca boolean jeśli się powiodło
"""
IS_MAC = sys.platform == "darwin"
interpreter = sys.executable
if interpreter is None:
raise RuntimeError("Nie moge znaleźć interpretatora Pythona")
args = [
interpreter, "-m", "pip", "install", "--upgrade", "--target",
"lib", name
]
if IS_MAC: # --target is a problem on Homebrew. See PR #552
args.remove("--target")
args.remove("lib")
def install():
code = subprocess.call(args)
sys.path_importer_cache = {}
return not bool(code)
response = self.loop.run_in_executor(None, install)
return await asyncio.wait_for(response, timeout=timeout)
class Bot(commands.Bot):
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Retourne les préfixes du message du serveur si défini.
Si aucun n'est défini ou si le message du server est None
cela renverra les préfixes globaux à la place.
Nécessite une instance Bot et un objet Message
passé en arguments.
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow() # Refreshed before login
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self._shutdown_mode = None
self.logger = set_logger(self)
self._last_exception = None
self.oauth_url = ""
self.printdebug = True
if 'self_bot' in kwargs:
self.settings.self_bot = kwargs['self_bot']
else:
kwargs['self_bot'] = self.settings.self_bot
if self.settings.self_bot:
kwargs['pm_help'] = False
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
async def check_is_command(self, message):
_internal_channel = message.channel
_internal_author = message.author
view = commands.view.StringView(message.content)
prefix = await bot._get_prefix(message)
invoked_prefix = prefix
if not isinstance(prefix, (tuple, list)):
if not view.skip_string(prefix):
return False
else:
invoked_prefix = discord.utils.find(view.skip_string, prefix)
if invoked_prefix is None:
return False
invoker = view.get_word()
# tmp = {
# 'bot': self,
# 'invoked_with': invoker,
# 'message': message,
# 'view': view,
# 'prefix': invoked_prefix
# }
# ctx = commands.Context(**tmp)
# del tmp
if invoker in self.commands:
return True
# command = self.commands[invoker]
# self.dispatch('command', command, ctx)
# try:
# yield from command.invoke(ctx)
# except CommandError as e:
# ctx.command.dispatch_error(e, ctx)
# else:
# self.dispatch('command_completion', command, ctx)
elif invoker:
return False
# exc = CommandNotFound('Command "{}" is not found'.format(invoker))
# self.dispatch('command_error', exc, ctx)
async def check_for_passthru_command(self, message):
allowed_passthru_cmd = ('cleanup', 'mute', 'unmute', 'candidate')
view = commands.view.StringView(message.content)
# if self._skip_check(message.author, self.user):
# return
prefix = await bot._get_prefix(message)
invoked_prefix = prefix
if not isinstance(prefix, (tuple, list)):
if not view.skip_string(prefix):
return
else:
invoked_prefix = discord.utils.find(view.skip_string, prefix)
if invoked_prefix is None:
return
invoker = view.get_word()
if invoker in allowed_passthru_cmd:
return True
else:
return False
async def send_message(self, *args, **kwargs):
if self._message_modifiers:
if "content" in kwargs:
pass
elif len(args) == 2:
args = list(args)
kwargs["content"] = args.pop()
else:
return await super().send_message(*args, **kwargs)
content = kwargs['content']
for m in self._message_modifiers:
try:
content = str(m(content))
except: # Faulty modifiers should not
pass # break send_message
kwargs['content'] = content
return await super().send_message(*args, **kwargs)
async def shutdown(self, *, restart=False):
"""Quitte le Bot gracieusement avec le code de sortie 0
Si restart a la valeur True, le code de sortie sera 26
Le lanceur redémarre automatiquement le Bot lorsque cela se produit"""
self._shutdown_mode = not restart
await self.logout()
def add_message_modifier(self, func):
"""
Ajoute un modificateur de message au bot
Un modificateur de message est un appelable qui accepte un message
contenu comme premier argument positionnel.
Avant qu'un message ne soit envoyé, la fonction sera appelé avec
le contenu du message comme seul argument. Le contenu du message
sera ensuite modifé pour être la seule valeur de retour de la
fonction.
Les exceptions lancées par l'appelable seront captées et
réduites au silence.
"""
if not callable(func):
raise TypeError("La fonction de modificataeur de message "
"doit être un appelable.")
self._message_modifiers.append(func)
def remove_message_modifier(self, func):
"""Supprime un modificateur de message du bot"""
if func not in self._message_modifiers:
raise RuntimeError("Fonction non présente dans le "
"modificateur de message.")
self._message_modifiers.remove(func)
def clear_message_modifiers(self):
"""Supprime tous les modificateurs de message du bot"""
self._message_modifiers.clear()
async def send_cmd_help(self, ctx):
print("went here 1")
if ctx.invoked_subcommand:
print("went here 2")
pages = self.formatter.format_help_for(ctx, ctx.invoked_subcommand)
for page in pages:
await self.send_message(ctx.message.channel, page)
else:
print("went here 3")
pages = self.formatter.format_help_for(ctx, ctx.command)
for page in pages:
await self.send_message(ctx.message.channel, page)
def user_allowed(self, message):
author = message.author
if author.bot:
return False
if author == self.user:
return self.settings.self_bot
mod_cog = self.get_cog('Mod')
global_ignores = self.get_cog('Owner').global_ignores
if self.settings.owner == author.id:
return True
if author.id in global_ignores["blacklist"]:
return False
if global_ignores["whitelist"]:
if author.id not in global_ignores["whitelist"]:
return False
if not message.channel.is_private:
server = message.server
names = (self.settings.get_server_cocap(server),
self.settings.get_server_admin(server),
self.settings.get_server_mod(server),
self.settings.get_server_sel(server))
results = map(
lambda name: discord.utils.get(author.roles, name=name), names)
for r in results:
if r is not None:
return True
if mod_cog is not None:
if not message.channel.is_private:
if message.server.id in mod_cog.ignore_list["SERVERS"]:
return False
if message.channel.id in mod_cog.ignore_list["CHANNELS"]:
return False
return True
async def pip_install(self, name, *, timeout=None):
"""
Installe un paquet pip dans le dossier local 'lib' dans un thread sécurisé.
Sur les systèmes Mac, le dossier 'lib' n'est pas utilisé.
Peut spécifier les secondes maximum à attendre pour que la tâche soit terminée
Retourne un booléen indiquant si l'installation a réussi
"""
IS_MAC = sys.platform == "darwin"
interpreter = sys.executable
if interpreter is None:
raise RuntimeError(
"Impossible de trouver l'interpréteur de Python")
args = [
interpreter, "-m", "pip", "install", "--upgrade", "--target",
"lib", name
]
if IS_MAC: # --target is a problem on Homebrew. See PR #552
args.remove("--target")
args.remove("lib")
def install():
code = subprocess.call(args)
sys.path_importer_cache = {}
return not bool(code)
response = self.loop.run_in_executor(None, install)
return await asyncio.wait_for(response, timeout=timeout)
# The following have to be imported and initialized in the correct order
from cogs.utils.settings import Settings
settings = Settings()
from cogs.utils.botdata import BotData
botdata = BotData()
from cogs.utils.loggingdb import LoggingDb
loggingdb = LoggingDb(settings.resource("loggingdb.db"))
from cogs.utils.httpgetter import HttpGetter
httpgetter = HttpGetter()
from cogs.utils.helpers import *
import discord
import traceback
import asyncio
import string
from discord.ext import commands
import logging
import datetime
from cogs.utils.helpcommand import MangoHelpCommand
from cogs.utils.clip import *
from cogs.utils.commandargs import *
import json
import sys
import inspect
class Bot(commands.Bot):
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Returns prefixes of the message's server if set.
If none are set or if the message's server is None
it will return the global prefixes instead.
Requires a Bot instance and a Message object to be
passed as arguments.
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow() # Refreshed before login
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self._shutdown_mode = None
self.logger = set_logger(self)
self._last_exception = None
self.oauth_url = ""
try:
self._cog_registry = dataIO.load_json("data/red/cogs.json")
except Exception:
self._cog_registry = {}
if 'self_bot' in kwargs:
self.settings.self_bot = kwargs['self_bot']
else:
kwargs['self_bot'] = self.settings.self_bot
if self.settings.self_bot:
kwargs['pm_help'] = False
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
async def send_message(self, *args, **kwargs):
if self._message_modifiers:
if "content" in kwargs:
pass
elif len(args) == 2:
args = list(args)
kwargs["content"] = args.pop()
else:
return await super().send_message(*args, **kwargs)
content = kwargs['content']
for m in self._message_modifiers:
try:
content = str(m(content))
except: # Faulty modifiers should not
pass # break send_message
kwargs['content'] = content
return await super().send_message(*args, **kwargs)
async def shutdown(self, *, restart=False):
"""Gracefully quits Red with exit code 0
If restart is True, the exit code will be 26 instead
The launcher automatically restarts Red when that happens"""
self._shutdown_mode = not restart
await self.logout()
def add_message_modifier(self, func):
"""
Adds a message modifier to the bot
A message modifier is a callable that accepts a message's
content as the first positional argument.
Before a message gets sent, func will get called with
the message's content as the only argument. The message's
content will then be modified to be the func's return
value.
Exceptions thrown by the callable will be catched and
silenced.
"""
if not callable(func):
raise TypeError("The message modifier function "
"must be a callable.")
self._message_modifiers.append(func)
def remove_message_modifier(self, func):
"""Removes a message modifier from the bot"""
if func not in self._message_modifiers:
raise RuntimeError("Function not present in the message "
"modifiers.")
self._message_modifiers.remove(func)
def clear_message_modifiers(self):
"""Removes all message modifiers from the bot"""
self._message_modifiers.clear()
async def send_cmd_help(self, ctx):
if ctx.invoked_subcommand:
pages = self.formatter.format_help_for(ctx, ctx.invoked_subcommand)
for page in pages:
await self.send_message(ctx.message.channel, page)
else:
pages = self.formatter.format_help_for(ctx, ctx.command)
for page in pages:
await self.send_message(ctx.message.channel, page)
def user_allowed(self, message):
author = message.author
if author.bot:
return False
if author == self.user:
return self.settings.self_bot
mod_cog = self.get_cog('Mod')
global_ignores = self.get_cog('Owner').global_ignores
if self.settings.owner == author.id:
return True
if author.id in global_ignores["blacklist"]:
return False
if global_ignores["whitelist"]:
if author.id not in global_ignores["whitelist"]:
return False
if not message.channel.is_private:
server = message.server
names = (self.settings.get_server_admin(
server), self.settings.get_server_mod(server))
results = map(
lambda name: discord.utils.get(author.roles, name=name),
names)
for r in results:
if r is not None:
return True
if mod_cog is not None:
if not message.channel.is_private:
if message.server.id in mod_cog.ignore_list["SERVERS"]:
return False
if message.channel.id in mod_cog.ignore_list["CHANNELS"]:
return False
return True
async def pip_install(self, name, *, timeout=None):
"""
Installs a pip package in the local 'lib' folder in a thread safe
way. On Mac systems the 'lib' folder is not used.
Can specify the max seconds to wait for the task to complete
Returns a bool indicating if the installation was successful
"""
IS_MAC = sys.platform == "darwin"
interpreter = sys.executable
if interpreter is None:
raise RuntimeError("Couldn't find Python's interpreter")
args = [
interpreter, "-m",
"pip", "install",
"--upgrade",
"--target", "lib",
name
]
if IS_MAC: # --target is a problem on Homebrew. See PR #552
args.remove("--target")
args.remove("lib")
def install():
code = subprocess.call(args)
sys.path_importer_cache = {}
return not bool(code)
response = self.loop.run_in_executor(None, install)
return await asyncio.wait_for(response, timeout=timeout)
def set_cog(self, cog, value, save=True):
self._cog_registry[cog] = value
if save:
self.save_cogs()
def save_cogs(self):
dataIO.save_json("data/red/cogs.json", self._cog_registry)
@property
def first_run(self):
return self.settings.bot_settings == self.settings.default_settings
def __init__(self, *args, **kwargs):
self.counter = Counter()
self.uptime = datetime.datetime.now()
self._message_modifiers = []
self.settings = Settings()
super().__init__(*args, **kwargs)
from discord.ext import commands
# User Defined Libraries/Modules/Packages
from cogs.utils.settings import Settings
intents = Intents.all()
# Initialsing bot with the prefix as `!` and
# removing the default Help Command
bot = commands.Bot(command_prefix="!", help_command=None, intents=intents)
# To import and Load all Modules
def loadTheCogs(bot):
cogs_dir = "cogs"
# Getting all the python files present in `cogs` to a List
pythonFiles = [File for File in listdir(cogs_dir) if File.endswith(".py")]
for File in pythonFiles:
extension = File.replace('.py', '')
try:
bot.load_extension(cogs_dir + "." + extension)
except (ClientException, ModuleNotFoundError):
print(f'Failed to load extension {extension}.')
traceback.print_exc()
if __name__ == "__main__":
loadTheCogs(bot)
bot.run(Settings().SECRETS['DISCORD_TOKEN'])
class Bot(commands.Bot):
def __init__(self, *args, **kwargs):
def prefix_manager(bot, message):
"""
Returns prefixes of the message's server if set.
If none are set or if the message's server is None
it will return the global prefixes instead.
Requires a Bot instance and a Message object to be
passed as arguments.
"""
return bot.settings.get_prefixes(message.server)
self.counter = Counter()
self.uptime = datetime.datetime.utcnow() # Refreshed before login
self._message_modifiers = []
self.settings = Settings()
self._intro_displayed = False
self._shutdown_mode = None
self.logger = set_logger(self)
self._last_exception = None
self.oauth_url = ""
if 'self_bot' in kwargs:
self.settings.self_bot = kwargs['self_bot']
else:
kwargs['self_bot'] = self.settings.self_bot
if self.settings.self_bot:
kwargs['pm_help'] = False
super().__init__(*args, command_prefix=prefix_manager, **kwargs)
async def send_message(self, *args, **kwargs):
if self._message_modifiers:
if "content" in kwargs:
pass
elif len(args) == 2:
args = list(args)
kwargs["content"] = args.pop()
else:
return await super().send_message(*args, **kwargs)
content = kwargs['content']
for m in self._message_modifiers:
try:
content = str(m(content))
except: # Faulty modifiers should not
pass # break send_message
kwargs['content'] = content
return await super().send_message(*args, **kwargs)
async def shutdown(self, *, restart=False):
"""Gracefully quits Red with exit code 0
If restart is True, the exit code will be 26 instead
The launcher automatically restarts Red when that happens"""
self._shutdown_mode = not restart
await self.logout()
def add_message_modifier(self, func):
"""
Adds a message modifier to the bot
A message modifier is a callable that accepts a message's
content as the first positional argument.
Before a message gets sent, func will get called with
the message's content as the only argument. The message's
content will then be modified to be the func's return
value.
Exceptions thrown by the callable will be catched and
silenced.
"""
if not callable(func):
raise TypeError("The message modifier function "
"must be a callable.")
self._message_modifiers.append(func)
def remove_message_modifier(self, func):
"""Removes a message modifier from the bot"""
if func not in self._message_modifiers:
raise RuntimeError("Function not present in the message "
"modifiers.")
self._message_modifiers.remove(func)
def clear_message_modifiers(self):
"""Removes all message modifiers from the bot"""
self._message_modifiers.clear()
async def send_cmd_help(self, ctx):
if ctx.invoked_subcommand:
pages = self.formatter.format_help_for(ctx, ctx.invoked_subcommand)
for page in pages:
await self.send_message(ctx.message.channel, page)
else:
pages = self.formatter.format_help_for(ctx, ctx.command)
for page in pages:
await self.send_message(ctx.message.channel, page)
def user_allowed(self, message):
author = message.author
if author.bot:
return False
if author == self.user:
return self.settings.self_bot
mod_cog = self.get_cog('Mod')
global_ignores = self.get_cog('Owner').global_ignores
if self.settings.owner == author.id:
return True
if author.id in global_ignores["blacklist"]:
return False
if global_ignores["whitelist"]:
if author.id not in global_ignores["whitelist"]:
return False
if not message.channel.is_private:
server = message.server
names = (self.settings.get_server_admin(server),
self.settings.get_server_mod(server))
results = map(
lambda name: discord.utils.get(author.roles, name=name), names)
for r in results:
if r is not None:
return True
if mod_cog is not None:
if not message.channel.is_private:
if message.server.id in mod_cog.ignore_list["SERVERS"]:
return False
if message.channel.id in mod_cog.ignore_list["CHANNELS"]:
return False
return True
async def pip_install(self, name, *, timeout=None):
"""
Installs a pip package in the local 'lib' folder in a thread safe
way. On Mac systems the 'lib' folder is not used.
Can specify the max seconds to wait for the task to complete
Returns a bool indicating if the installation was successful
"""
IS_MAC = sys.platform == "darwin"
interpreter = sys.executable
if interpreter is None:
raise RuntimeError("Couldn't find Python's interpreter")
args = [
interpreter, "-m", "pip", "install", "--upgrade", "--target",
"lib", name
]
if IS_MAC: # --target is a problem on Homebrew. See PR #552
args.remove("--target")
args.remove("lib")
def install():
code = subprocess.call(args)
sys.path_importer_cache = {}
return not bool(code)
response = self.loop.run_in_executor(None, install)
return await asyncio.wait_for(response, timeout=timeout)
self.logger.error(traceback.extract_tb(tb))
print(e)
if __name__ == "__main__":
parser = ArgumentParser(prog="Roxedus' ProgBott",
description="Programmeringsbot for Norsk programmering",
formatter_class=RawTextHelpFormatter)
parser.add_argument("-D", "--debug", action="store_true", help="Sets debug to true")
parser.add_argument("-l", "--level", help="Sets debug level",
choices=["critical", "error", "warning", "info", "debug"], default="warning")
parser.add_argument("-d", "--data-directory",
help="Define an alternate data directory location", default="data", type=str)
parser.add_argument("-f", "--log-to-file", action="store_true", help="Save log to file", default=True)
args = parser.parse_args()
level = args.level
data_dir = args.data_directory
if args.debug:
level = "DEBUG"
settings = Settings(data_dir=data_dir, log_level=level, log_to_file=args.log_to_file)
logger = Logger(location=settings.data_dir, level=settings.log_level, to_file=settings.log_to_file).logger
logger.debug("Data folder: %s", settings.data_dir)
Bot().run()
class MainWindow(QWidget):
def __init__(self):
super(MainWindow, self).__init__()
self.large_font = QtGui.QFont("Arial", 12)
self.reg_font = QtGui.QFont("Arial", 10)
self.small_font = QtGui.QFont("Arial", 8)
self.settings = Settings()
self.init_ui()
def init_ui(self):
# v.box
gbox = QtWidgets.QGridLayout()
box = QtWidgets.QVBoxLayout()
self.rbox = QtWidgets.QVBoxLayout()
self.hbox = QtWidgets.QHBoxLayout()
# padding/margins
gbox.setContentsMargins(0, 0, 0, 0)
self.rbox.setContentsMargins(0, 0, 10, 10)
self.hbox.setContentsMargins(0, 0, 10, 10)
box.addStretch()
self.hbox.addStretch()
gbox.setSpacing(10)
box.setSpacing(0)
self.rbox.setSpacing(5)
self.hbox.setSpacing(0)
image = QtGui.QImage()
image.loadFromData(
urllib.request.urlopen('http://i.imgur.com/04DUqa3.png').read())
png = QLabel(self)
pixmap = QtGui.QPixmap(image)
png.setPixmap(pixmap)
gbox.addWidget(png, 0, 0, 1, 1, Qt.AlignTop)
box.insertSpacing(1, 10)
self.l1 = QLabel(self)
self.l1.setWordWrap(True)
self.large_font.setBold(True)
self.l1.setFont(self.large_font)
box.addWidget(self.l1, 0, Qt.AlignTop)
hline = QtWidgets.QFrame()
hline.setFrameShape(QtWidgets.QFrame.HLine)
hline.setFrameShadow(QtWidgets.QFrame.Sunken)
gbox.addWidget(hline, 0, 0, 1, 3, Qt.AlignBottom)
# start form
self.req_ui()
self.rbox.setAlignment(Qt.AlignTop)
box.addLayout(self.rbox, 1)
gbox.addLayout(box, 0, 1, 1, 2)
gbox.addLayout(self.hbox, 1, 0, 1, 3)
self.setLayout(gbox)
# window
self.setFixedSize(490, 400)
self.setWindowIcon(QtGui.QIcon('red.ico'))
self.setWindowTitle('Red Discord Bot - Setup')
self.show()
def buttons_panel(self):
self.b1 = QPushButton("Back", self)
self.b1.setMaximumWidth(75)
self.hbox.addWidget(self.b1, 0, Qt.AlignRight)
self.b2 = QPushButton("Next >", self)
self.b2.setMaximumWidth(75)
self.hbox.addWidget(self.b2, 0, Qt.AlignRight)
self.hbox.insertSpacing(20, 20)
self.b3 = QPushButton("Cancel", self)
self.b3.setMaximumWidth(75)
self.hbox.addWidget(self.b3, 0, Qt.AlignRight)
def req_ui(self):
self.clear_layout(self.rbox)
self.clear_layout(self.hbox)
self.hbox.addStretch()
self.l1.setText('Select which requirements to install')
self.rbox.insertSpacing(1, 35)
self.r1 = QRadioButton(
"Install basic + audio requirements (recommended)")
self.r1.setChecked(True)
self.r1.setFont(self.reg_font)
self.rbox.addWidget(self.r1, 0, Qt.AlignTop)
self.r2 = QRadioButton("Install basic requirements")
self.r2.setFont(self.reg_font)
self.rbox.addWidget(self.r2, 0, Qt.AlignLeft)
if os.path.exists("lib"):
l5 = QLabel(self)
l5.setText(
'<font color="#ff0000">Requirements already installed.</font>')
self.rbox.addWidget(l5, 1, Qt.AlignBottom)
b5 = QPushButton("Skip", self)
b5.setMaximumWidth(50)
self.rbox.addWidget(b5, 0, Qt.AlignBottom)
b5.clicked.connect(self.token_ui)
# buttons
self.buttons_panel()
# binds
self.b1.setEnabled(False)
self.b2.clicked.connect(self.if_req)
self.b3.clicked.connect(self.close_prompt)
def if_req(self):
if self.r1.isChecked():
self.console_ui(audio=True)
elif self.r2.isChecked():
self.console_ui(audio=False)
def console_ui(self, audio):
self.clear_layout(self.rbox)
self.clear_layout(self.hbox)
self.hbox.addStretch()
self.l1.setText("Installing requirements")
self.process = QProcess()
self.output = QTextEdit()
self.percent = 0
self.rbox.insertSpacing(1, 10)
l2 = QLabel(
'Press Next when the last line says "Successfully Installed--"')
self.rbox.addWidget(l2, 0, Qt.AlignTop)
# this can be uncommented whenever I actually figure out Progress Bars
# self.pbar = QtWidgets.QProgressBar()
# self.pbar.setGeometry(30, 40, 200, 25)
# self.rbox.addWidget(self.pbar)
b5 = QPushButton("Dialog", self)
b5.setMaximumWidth(75)
self.rbox.addWidget(b5)
self.rbox.addWidget(self.output)
self.process.readyRead.connect(self.console_data)
self.output.hide()
# data flow
remove_reqs_readonly()
interpreter = sys.executable
if interpreter is None:
QMessageBox.warning(self, "404", "Python interpreter not found.")
self.close()
txt = REQS_TXT if audio else REQS_NO_AUDIO_TXT
args = [
"-m", "pip", "install", "--upgrade", "--target", REQS_DIR, "-r",
txt
]
if IS_MAC: # --target is a problem on Homebrew. See PR #552
args.remove("--target")
args.remove(REQS_DIR)
# do call
self.process.start(interpreter, args)
# buttons
self.buttons_panel()
# binds
self.b1.setEnabled(True)
# self.b2.setEnabled(False)
self.b1.clicked.connect(self.req_ui)
self.b1.clicked.connect(self.process.close)
self.b2.clicked.connect(self.token_ui)
self.b3.clicked.connect(self.close_prompt)
b5.clicked.connect(self.console_hide)
def console_hide(self):
if self.output.isVisible():
self.output.hide()
else:
self.output.show()
def console_data(self):
js = str(self.process.readAll(), 'utf-8')
cursor = self.output.textCursor()
cursor.movePosition(cursor.End)
cursor.insertText(js)
self.output.ensureCursorVisible()
# self.percent += 3
# if self.percent > 90:
# self.percent = 100
# self.pbar.setValue(self.percent)
#
# if self.percent == 100:
# QMessageBox.information(self, "Done!", "Requirements setup completed.")
# self.b2.setEnabled(True)
def token_ui(self):
self.clear_layout(self.rbox)
self.clear_layout(self.hbox)
self.hbox.addStretch()
self.l1.setText("Input your bot's token")
self.rbox.insertSpacing(1, 30)
self.token_print = QLabel(self)
self.token_print.setText("Token: ")
self.rbox.addWidget(self.token_print, 0, Qt.AlignTop)
self.token_edit = QLineEdit(self)
self.token_edit.setMaximumWidth(300)
self.rbox.addWidget(self.token_edit, 0, Qt.AlignTop)
l2 = QLabel(
"Your token can be found in Discord's "
"<a href='https://discordapp.com/developers/applications/me'>App Page</a>"
)
l2.setOpenExternalLinks(True)
l2.setFont(self.small_font)
self.rbox.addWidget(l2, 0, Qt.AlignBottom)
if self.settings.token is not None:
l5 = QLabel(self)
l5.setText('<font color="#ff0000">"' + self.settings.token[0:10] +
'--"</font>\nis your current token')
self.rbox.addWidget(l5, 1, Qt.AlignBottom)
b5 = QPushButton("Skip", self)
b5.setMaximumWidth(50)
self.rbox.addWidget(b5, 0, Qt.AlignBottom)
b5.clicked.connect(self.prefix_ui)
# buttons
self.buttons_panel()
# token1 = token_edit.text()
# binds
self.b1.setEnabled(False)
self.token_edit.textChanged[str].connect(self.token_on_change)
self.b1.clicked.connect(self.req_ui)
self.b2.clicked.connect(self.token_save)
self.b3.clicked.connect(self.close_prompt)
def token_save(self):
token = str(self.token_edit.text())
if "@" in token or len(token) < 50:
QMessageBox.information(self, "Error!", "Invalid token provided.",
QMessageBox.Ok)
return
else:
self.settings.token = token
self.prefix_ui()
def token_on_change(self, text):
self.token_print.setText("Token: " + text.replace('.', '.\n'))
self.token_print.adjustSize()
self.token_print.setWordWrap(True)
def prefix_ui(self):
self.clear_layout(self.rbox)
self.clear_layout(self.hbox)
self.hbox.addStretch()
self.l1.setText("Input your desired prefix")
self.rbox.insertSpacing(1, 30)
self.prefix_print = QLabel(self)
self.prefix_print.setText(
'Prefix will be set to: <font color="#ff0000">!</font>'
'<br>You would execute the help command by typing: '
'<font color="#ff0000">!help</font>')
self.prefix_print.setWordWrap(True)
self.rbox.addWidget(self.prefix_print, 0, Qt.AlignTop)
self.prefix_edit = QLineEdit(self)
self.prefix_edit.setPlaceholderText("!")
self.prefix_edit.setMaximumWidth(300)
self.rbox.addWidget(self.prefix_edit, 0, Qt.AlignTop)
l2 = QLabel(self)
l2.setText('\nPrefixes are referred to in the bot with [p]. '
'\nAny time you see [p], replace it with your prefix.')
self.rbox.addWidget(l2, 0, Qt.AlignCenter)
matches = [a for a in self.settings.prefixes]
if len(matches) > 0:
prefixes = ', '.join(self.settings.prefixes)
if len(matches) == 1:
plural = "</font>\nis your current prefix."
elif len(matches) > 1:
plural = "</font>\nare your current prefixes."
l5 = QLabel(self)
l5.setText('<font color="#ff0000">' + prefixes + plural)
self.rbox.addWidget(l5, 1, Qt.AlignBottom)
b5 = QPushButton("Skip", self)
b5.setMaximumWidth(50)
self.rbox.addWidget(b5, 0, Qt.AlignBottom)
b5.clicked.connect(self.admin_ui)
# buttons
self.buttons_panel()
# binds
self.prefix_edit.textChanged[str].connect(self.prefix_on_change)
self.b1.setEnabled(True)
self.b1.clicked.connect(self.token_ui)
self.b2.clicked.connect(self.prefix_save)
self.b3.clicked.connect(self.close_prompt)
def prefix_save(self):
prefix = str(self.prefix_edit.text())
if prefix is "":
prefix = "!"
self.settings.prefixes.append(prefix)
self.admin_ui()
def prefix_on_change(self, text):
if text is "":
text = "!"
self.prefix_print.setText(
'Prefix will be set to: <font color="#ff0000">' + text +
'</font><br>You would execute the help command by typing: <font color="#ff0000">'
+ text + 'help</font>')
def admin_ui(self):
self.clear_layout(self.rbox)
self.clear_layout(self.hbox)
self.hbox.addStretch()
self.l1.setText("Set your Administrator roles")
# admin
self.rbox.insertSpacing(1, 30)
self.admin_print = QLabel(self)
self.admin_print.setText("Admin: ")
self.admin_print.setWordWrap(True)
self.rbox.addWidget(self.admin_print, 0, Qt.AlignTop)
self.admin_edit = QLineEdit(self)
self.admin_edit.setPlaceholderText("Blank for default")
self.admin_edit.setMaximumWidth(300)
self.rbox.addWidget(self.admin_edit, 0, Qt.AlignTop)
# mod
self.rbox.insertSpacing(1, 30)
self.mod_print = QLabel(self)
self.mod_print.setText("Mod: ")
self.mod_print.setWordWrap(True)
self.rbox.addWidget(self.mod_print, 0, Qt.AlignTop)
self.mod_edit = QLineEdit(self)
self.mod_edit.setPlaceholderText("Blank for default")
self.mod_edit.setMaximumWidth(300)
self.rbox.addWidget(self.mod_edit, 0, Qt.AlignTop)
# buttons
self.buttons_panel()
# binds
self.b2.setText("Finish")
self.b1.clicked.connect(self.prefix_ui)
self.b2.clicked.connect(self.admin_save)
self.b3.clicked.connect(self.close_prompt)
def admin_save(self):
admin = self.admin_edit.text()
mod = self.mod_edit.text()
if admin is "":
admin = "Transistor"
if mod is "":
mod = "Process"
self.settings.default_admin = admin
self.settings.default_mod = mod
self.finish_prompt()
def clear_layout(self, layout):
if layout is not None:
while layout.count():
item = layout.takeAt(0)
widget = item.widget()
if widget is not None:
widget.deleteLater()
else:
self.clear_layout(item.layout())
def close_prompt(self):
cbox = QMessageBox.warning(
self, "Info", "Are you sure you want to cancel Red setup?",
QMessageBox.Yes, QMessageBox.No)
if cbox == QMessageBox.Yes:
self.close()
else:
return
def finish_prompt(self):
QMessageBox.information(self, "Done!", "Red has been configured.",
QMessageBox.Ok)
self.settings.save_settings()
self.close()
def switch_window(self, window):
self.window = window
self.hide()
self.window.show()
