Refactor branch to dev

module/BiasGame.py

@@ -41,7 +41,7 @@ async def listbg(self, ctx, user: discord.Member = None):
             msg_string = f"**Bias Game Leaderboard for {user.display_name}**:\n"
             counter = 1
             for idol_id, wins in user_wins:
-                member = await ex.get_member(idol_id)
+                member = await ex.u_group_members.get_member(idol_id)
                 msg_string += f"{counter}) {member.full_name} ({member.stage_name}) -> {wins} Win(s).\n"
                 counter += 1
         else:
@@ -131,11 +131,11 @@ async def create_new_question(self):
         for first_idol, second_idol in self.current_bracket_teams:
             if not self.force_ended:
                 try:
-                    first_idol_group = (await ex.get_group(random.choice(first_idol.groups))).name
+                    first_idol_group = (await ex.u_group_members.get_group(random.choice(first_idol.groups))).name
                 except Exception as e:
                     first_idol_group = first_idol.full_name
                 try:
-                    second_idol_group = (await ex.get_group(random.choice(second_idol.groups))).name
+                    second_idol_group = (await ex.u_group_members.get_group(random.choice(second_idol.groups))).name
                 except Exception as e:
                     second_idol_group = second_idol.full_name
 
@@ -145,7 +145,7 @@ async def create_new_question(self):
 {first_idol_group} ({first_idol.stage_name}) **VS** {second_idol_group} ({second_idol.stage_name})
 """
                 display_name = f"{first_idol.stage_name} VS {second_idol.stage_name}.png"
-                file_location = await ex.create_bias_game_image(first_idol.id, second_idol.id)
+                file_location = await ex.u_bias_game.create_bias_game_image(first_idol.id, second_idol.id)
                 image_file = discord.File(fp=file_location, filename=display_name)
                 msg = await self.channel.send(msg_body, file=image_file)
                 await msg.add_reaction(keys.previous_emoji)  # left arrow by default

module/BlackJack.py

@@ -14,33 +14,32 @@ async def blackjack(self, ctx, amount="0", versus="player"):
             amount = ex.remove_commas(amount)
             user_id = ctx.author.id
             if versus != "bot":
-                if await ex.process_bj_game(ctx, amount, user_id):
-                    await ex.add_bj_game(user_id, amount, ctx, "player")
+                if await ex.u_blackjack.process_bj_game(ctx, amount, user_id):
+                    await ex.u_blackjack.add_bj_game(user_id, amount, ctx, "player")
             else:
-                if await ex.process_bj_game(ctx, amount, user_id):
-                    await ex.add_bj_game(user_id, amount, ctx, "bot")
-                    game_id = await ex.get_game_by_player(user_id)
-                    fake_bot_id = int(f"{ex.get_int_index(bot_id, 9)}{randint(1,999999999)}")
-                    await ex.add_player_two(game_id, fake_bot_id, amount)
-                    await ex.start_game(game_id)
+                if await ex.u_blackjack.process_bj_game(ctx, amount, user_id):
+                    await ex.u_blackjack.add_bj_game(user_id, amount, ctx, "bot")
+                    game_id = await ex.u_blackjack.get_game_by_player(user_id)
+                    fake_bot_id = int(f"{ex.u_miscellaneous.get_int_index(bot_id, 9)}{randint(1,999999999)}")
+                    await ex.u_blackjack.add_player_two(game_id, fake_bot_id, amount)
+                    await ex.u_blackjack.start_game(game_id)
         except Exception as e:
             log.console(e)
-            pass
 
     @commands.command(aliases=['jg'])
     async def joingame(self, ctx, game_id=0, amount="0"):
         """Join a game [Format: %joingame (gameid) (bid)] [Aliases: jg]"""
         try:
             amount = ex.remove_commas(amount)
             user_id = ctx.author.id
-            if await ex.process_bj_game(ctx, amount, user_id):
-                game = await ex.get_game(game_id)
+            if await ex.u_blackjack.process_bj_game(ctx, amount, user_id):
+                game = await ex.u_blackjack.get_game(game_id)
                 if game is None:
                     await ctx.send(f"> **{ctx.author}, {game_id} is not a valid game.**")
                 else:
                     if game[5] == ctx.channel.id:  # Did not use already existing function due to incompatibility.
-                        await ex.add_player_two(game_id, user_id, amount)
-                        await ex.start_game(game_id)
+                        await ex.u_blackjack.add_player_two(game_id, user_id, amount)
+                        await ex.u_blackjack.start_game(game_id)
                     else:
                         await ctx.send(f"> **{ctx.author}, that game ({game_id}) is not available in this text channel.**")
         except Exception as e:
@@ -50,11 +49,11 @@ async def joingame(self, ctx, game_id=0, amount="0"):
     async def endgame(self, ctx):
         """End your current game [Format: %endgame] [Aliases: eg]"""
         try:
-            game_id = await ex.get_game_by_player(ctx.author.id)
+            game_id = await ex.u_blackjack.get_game_by_player(ctx.author.id)
             if game_id is None:
                 await ctx.send(f"> **{ctx.author}, you are not in a game.**")
             else:
-                await ex.delete_game(game_id)
+                await ex.u_blackjack.delete_game(game_id)
                 await ctx.send(f"> **{ctx.author}, your game has been deleted.**")
         except Exception as e:
             log.console(e)
@@ -83,16 +82,16 @@ async def addcards(self, ctx):
     async def hit(self, ctx):
         """Pick A Card [Format: %hit]"""
         try:
-            game_id = await ex.get_game_by_player(ctx.author.id)
+            game_id = await ex.u_blackjack.get_game_by_player(ctx.author.id)
             if not game_id:
                 await ctx.send(f"> **{ctx.author}, you are not in a game.**")
             else:
                 if await ex.compare_channels(ctx.author.id, ctx.channel):
-                    game = await ex.get_game(game_id)
-                    if ex.check_if_bot(game[2]):
-                        if await ex.get_player_total(game[2]) < 16:
-                            await ex.add_card(game[2])
-                    await ex.add_card(ctx.author.id)
+                    game = await ex.u_blackjack.get_game(game_id)
+                    if ex.u_blackjack.check_if_bot(game[2]):
+                        if await ex.u_blackjack.get_player_total(game[2]) < 16:
+                            await ex.u_blackjack.add_card(game[2])
+                    await ex.u_blackjack.add_card(ctx.author.id)
         except Exception as e:
             log.console(e)
 
@@ -102,28 +101,28 @@ async def stand(self, ctx):
         try:
             check = False
             user_id = ctx.author.id
-            game_id = await ex.get_game_by_player(user_id)
+            game_id = await ex.u_blackjack.get_game_by_player(user_id)
             if game_id is None:
                 await ctx.send(f"> **{ctx.author}, you are not in a game.**")
             else:
                 if await ex.compare_channels(user_id, ctx.channel):
                     # Do not inform other users that the player already stood by busting.
                     # Instead, just send the same message that they are standing every time this command is called.
-                    await ex.set_player_stand(user_id)
-                    game = await ex.get_game(game_id)
+                    await ex.u_blackjack.set_player_stand(user_id)
+                    game = await ex.u_blackjack.get_game(game_id)
 
-                    if ex.check_if_bot(game[2]):
+                    if ex.u_blackjack.check_if_bot(game[2]):
                         check = True
-                        await ex.finish_game(game_id, ctx.channel)
+                        await ex.u_blackjack.finish_game(game_id, ctx.channel)
 
                     if not check:
-                        total_score = str(await ex.get_player_total(user_id))
+                        total_score = str(await ex.u_blackjack.get_player_total(user_id))
                         if len(total_score) == 1:
                             total_score = '0' + total_score  # this is to prevent being able to detect the number of digits by the spoiler
-                        if not ex.check_if_bot(game[2]):
+                        if not ex.u_blackjack.check_if_bot(game[2]):
                             await ctx.send(f"> **{ctx.author} finalized their deck with ||{total_score}|| points.**")
-                        if await ex.check_game_over(game_id):
-                            await ex.finish_game(game_id, ctx.channel)
+                        if await ex.u_blackjack.check_game_over(game_id):
+                            await ex.u_blackjack.finish_game(game_id, ctx.channel)
         except Exception as e:
             log.console(e)
 
@@ -151,3 +150,4 @@ async def rules(self, ctx):
         await ctx.send(embed=embed)
 
 
+

module/BotMod.py

@@ -115,8 +115,8 @@ async def mergeidol(self, ctx, original_idol_id: int, duplicate_idol_id: int):
         all of it's connections.
         [Format: %mergeidol (original idol id) (duplicate idol id)]"""
         # check groups
-        original_idol = await ex.get_member(original_idol_id)
-        duplicate_idol = await ex.get_member(duplicate_idol_id)
+        original_idol = await ex.u_group_members.get_member(original_idol_id)
+        duplicate_idol = await ex.u_group_members.get_member(duplicate_idol_id)
 
         if not duplicate_idol:
             return await ctx.send(f"> {duplicate_idol_id} could not find an Idol.")
@@ -129,8 +129,8 @@ async def mergeidol(self, ctx, original_idol_id: int, duplicate_idol_id: int):
         # delete idol
         await ex.conn.execute("DELETE FROM groupmembers.member WHERE id = $1", duplicate_idol.id)
         # recreate cache
-        await ex.create_idol_cache()
-        await ex.create_group_cache()
+        await ex.u_cache.create_idol_cache()
+        await ex.u_cache.create_group_cache()
         await ctx.send(f"> Merged {duplicate_idol_id} to {original_idol_id}.")
 
     @commands.command()
@@ -141,8 +141,8 @@ async def mergegroup(self, ctx, original_group_id: int, duplicate_group_id: int)
         If an idol ID is not in the original group, it will be added and then this group will be deleted along with
         all of it's connections.
         [Format: %mergegroup (original group id) (duplicate group id)]"""
-        original_group = await ex.get_group(original_group_id)
-        duplicate_group = await ex.get_group(duplicate_group_id)
+        original_group = await ex.u_group_members.get_group(original_group_id)
+        duplicate_group = await ex.u_group_members.get_group(duplicate_group_id)
         if not duplicate_group:
             return await ctx.send(f"> {duplicate_group_id} could not find a Group.")
         if not original_group:
@@ -156,8 +156,8 @@ async def mergegroup(self, ctx, original_group_id: int, duplicate_group_id: int)
         # delete group
         await ex.conn.execute("DELETE FROM groupmembers.groups WHERE groupid = $1", duplicate_group.id)
         # recreate cache
-        await ex.create_idol_cache()
-        await ex.create_group_cache()
+        await ex.u_cache.create_idol_cache()
+        await ex.u_cache.create_group_cache()
         await ctx.send(f"> Merged {duplicate_group_id} to {original_group_id}.")
 
     @commands.command()
@@ -257,7 +257,7 @@ async def deleteinteraction(self, ctx, *, url):
     async def botban(self, ctx, *, user: discord.User):
         """Bans a user from Irene. [Format: %botban (user id)]"""
         if not ex.check_if_mod(user.id, 1):
-            await ex.ban_user_from_bot(user.id)
+            await ex.u_miscellaneous.ban_user_from_bot(user.id)
             await ctx.send(f"> **<@{user.id}> has been banned from using Irene.**")
         else:
             await ctx.send(f"> **<@{ctx.author.id}>, you cannot ban a bot mod.**")
@@ -267,7 +267,7 @@ async def botban(self, ctx, *, user: discord.User):
     async def botunban(self, ctx, *, user: discord.User):
         """UnBans a user from Irene. [Format: %botunban (user id)]"""
         user_id = user.id
-        await ex.unban_user_from_bot(user_id)
+        await ex.u_miscellaneous.unban_user_from_bot(user_id)
         await ctx.send(f"> **If the user was banned, they are now unbanned.**")
 
     @commands.command()
@@ -312,12 +312,12 @@ async def removestatus(self, ctx, status_index: int):
     async def addidoltogroup(self, ctx, idol_id: int, group_id: int):
         """Adds idol to group. [Format: %addidoltogroup (idol id) (group id)"""
         try:
-            member_name = (await ex.get_member(idol_id))[1]
+            member_name = (await ex.u_group_members.get_member(idol_id))[1]
             group_name = await ex.get_group_name(group_id)
             if await ex.check_member_in_group(idol_id, group_id):
                 return await ctx.send(f'> **{member_name} ({idol_id}) is already in {group_name} ({group_id}).**')
             else:
-                await ex.add_idol_to_group(idol_id, group_id)
+                await ex.u_group_members.add_idol_to_group(idol_id, group_id)
                 await ctx.send(f"**Added {member_name} ({idol_id}) to {group_name} ({group_id}).**")
         except Exception as e:
             await ctx.send(f"Something went wrong - {e}")
@@ -328,12 +328,12 @@ async def addidoltogroup(self, ctx, idol_id: int, group_id: int):
     async def deleteidolfromgroup(self, ctx, idol_id: int, group_id: int):
         """Deletes idol from group. [Format: %deleteidolfromgroup (idol id) (group id)"""
         try:
-            member_name = (await ex.get_member(idol_id))[1]
+            member_name = (await ex.u_group_members.get_member(idol_id))[1]
             group_name = await ex.get_group_name(group_id)
             if not await ex.check_member_in_group(idol_id, group_id):
                 await ctx.send(f"> **{member_name} ({idol_id}) is not in {group_name} ({group_id}).**")
             else:
-                await ex.remove_idol_from_group(idol_id, group_id)
+                await ex.u_group_members.remove_idol_from_group(idol_id, group_id)
                 await ctx.send(f"**Removed {member_name} ({idol_id}) from {group_name} ({group_id}).**")
         except Exception as e:
             await ctx.send(f"Something went wrong - {e}")
@@ -349,7 +349,7 @@ async def addidol(self, ctx, full_name, stage_name, group_id: int):
             group_name = await ex.get_group_name(group_id)
             await ex.conn.execute("INSERT INTO groupmembers.member (fullname, stagename) VALUES($1, $2)", full_name, stage_name)
             idol_id = await ex.get_idol_id_by_both_names(full_name, stage_name)
-            await ex.add_idol_to_group(idol_id, group_id)
+            await ex.u_group_members.add_idol_to_group(idol_id, group_id)
             await ctx.send(f"{full_name} was added and is in {group_name} ({group_id}).")
         except Exception as e:
             await ctx.send(f"Something went wrong - {e}")
@@ -360,7 +360,7 @@ async def addidol(self, ctx, full_name, stage_name, group_id: int):
     async def deleteidol(self, ctx, idol_id: int):
         """Deletes an idol [Format: %deleteidol (idol id)]"""
         try:
-            idol_name = (await ex.get_member(idol_id))[1]
+            idol_name = (await ex.u_group_members.get_member(idol_id))[1]
             await ex.conn.execute("DELETE FROM groupmembers.member WHERE id = $1", idol_id)
             await ctx.send(f"{idol_name} ({idol_id}) deleted.")
         except Exception as e: