Rest of settings, Banword and Roles fix.

Start of Markov command, maybe.

Author: MrChuw

.gitignore

@@ -164,11 +164,12 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 
 /.data
+!/.data/z_log_queries.xml
+!/.data/z_clickhouse.xml
+
 dev.txt
 .db_data
 .redis_data
 /.idea
 /.vscode
 TODOS.md
-
-*/static/node_modules/*

bot/cogs/admin/commands/admin.py

@@ -4,15 +4,23 @@
 import importlib.util
 import os
 import sys
+from dataclasses import dataclass
+from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING
 
 from bot.ext import Context, Response, commands
+from bot.models import Channel as ChannelBot
 from bot.utils import Role, SessionsCaches, StringTools
 from bot.utils.singleton import Singleton
 
 from .translations import Translations
 
+# from bot.models import User as UserBot
+# import asyncio
+# import asyncmy
+# from asyncmy.cursors import DictCursor
+
 if TYPE_CHECKING:
     from bot.bot import Gorenmu
 
@@ -35,8 +43,8 @@ async def component_command_error(self, payload: commands.CommandErrorPayload) -
     def is_dev(self, ctx: Context) -> bool:
         return Role.dev(ctx)
 
-    @commands.command(name="nada", aliases=["bonjour", "hello"])
-    async def nada(self, ctx: Context, *, args: str) -> Response:
+    @commands.command(name="nada", aliases=[])
+    async def nada(self, ctx: Context, *, args: str = "") -> Response:
         # if " " in args:
         #     command, subcommand = args.split()
         #     command = ctx.bot.get_command(command)
@@ -48,8 +56,39 @@ async def nada(self, ctx: Context, *, args: str) -> Response:
         #     teste = command.component.translations.get_decorator(ctx=command)
         #     teste2 = teste.deco_usage(ctx, prefix=ctx.prefix)
         #     await ctx.reply(teste2)
-        return self.translations.Nada.nada(ctx, args + self.StringTools.inv_char())
-        # return self.translations.Exceptions.empty(ctx, args)
+        # channel = self.bot.channels[ctx.channel.name.lower()]
+        channel = await ChannelBot.get(user_id=192923262)
+        markov = await self.bot.MarkovProcessor.generate(args, channel=channel, max_length=25)
+        await self.bot.ContextHandler.simple_response(ctx, str(self.bot.MarkovProcessor.queue.async_q.qsize()))
+
+        # return self.translations.Nada.nada(ctx, args + self.StringTools.inv_char())
+        return self.translations.Exceptions.echo(ctx, markov)
+
+    # @commands.command(name="nada2", aliases=[])
+    # async def nada2(self, ctx: Context, *, args: str) -> Response:
+    #     channel = self.bot.channels[ctx.channel.name.lower()]
+    #     user = ctx.user
+    #     rows = await fetch_message_logs(ctx)
+    #     # with open("texts.txt") as text:
+    #     #     mensagens = text.readlines()
+    #     # for msg in mensagens:
+    #     #     await self.bot.MarkovProcessor.queue.async_q.put((msg, channel, user))
+    #     for row in rows:
+    #         try:
+    #             user, success = await UserBot.get_or_create(id=row["user"].id, name=row["user"].name)
+    #             if row['channel'].id not in [411010313, 926706091, 707980467, 54966942, 744028864, ]:
+    #                 channel, success = await ChannelBot.get_or_create(user_id=row['channel'].id)
+    #                 if channel not in self.bot.channels and not channel.removed:
+    #                     channel.removed = True
+    #                     await channel.save()
+    #             else:
+    #                 channel = await ChannelBot.get(user_id=row['channel'].id)
+    #
+    #             await self.bot.MarkovProcessor.queue.async_q.put((row['message_row'].content, channel, user))
+    #         except Exception as e:
+    #             print(e)
+    #     markov = await self.bot.MarkovProcessor.generate(args, channel=channel)
+    #     return self.translations.Exceptions.echo(ctx, markov)
 
     @commands.command(name="restart", aliases=[])
     async def restart(self, ctx: Context) -> Response:
@@ -94,6 +133,18 @@ async def reload(self, ctx: Context, command: str, *, extras=False) -> Response:
                 "class": "CommandHandler",
                 "args": [self.bot],
             },
+            "context_handler": {
+                "attr": "ContextHandler",
+                "module": "bot.handlers.context_handler",
+                "class": "ContextHandler",
+                "args": [self.bot],
+            },
+            "markov_handler": {
+                "attr": "MarkovProcessor",
+                "module": "bot.utils.markov_tools",
+                "class": "MarkovProcessor",
+                "args": [self.bot],
+            },
         }
 
         if command == "commands":
@@ -161,6 +212,27 @@ async def setup(bot: Gorenmu) -> None:
 async def teardown(bot: Gorenmu) -> None: ...  # NOQA
 
 
+@dataclass
+class User:
+    id: int
+    name: str
+
+
+@dataclass
+class Channel:
+    id: int
+
+
+@dataclass
+class MessageLog:
+    id: int
+    content: str
+    type: str
+    created_at: datetime
+    channel_id: int | None
+    user_id: int
+
+
 async def reload_component(bot_obj, attr_name: str, module_name: str, class_name: str, args: list | None = None):
     from bot.utils.reload_util import reload_and_get_authorized
 
@@ -183,3 +255,50 @@ async def reload_component(bot_obj, attr_name: str, module_name: str, class_name
     except Exception as e:
         bot_obj.log.error(f"Error reloading {attr_name}: {e}")
         raise
+
+
+#
+# async def fetch_message_logs(ctx: Context):
+#     connection_config = {
+#         "host": "127.0.0.1",
+#         "port": 12398,
+#         "user": ctx.bot.config.DatabaseConfig.login,
+#         "password": ctx.bot.config.DatabaseConfig.password,
+#         "database": ctx.bot.config.DatabaseConfig.database_uri,
+#     }
+#     conn = await asyncmy.connect(**connection_config)  # NOQA
+#     try:
+#         async with conn.cursor(DictCursor) as cursor:
+#             query = """
+#                 SELECT
+#                     m.id AS m_id, m.content, m.type, m.created_at, m.channel_id, m.user_id,
+#                     u.id AS u_id, u.name AS u_name,
+#                     c.id AS c_id
+#                 FROM mensage_logs m
+#                 INNER JOIN user u ON m.user_id = u.id
+#                 LEFT JOIN channel c ON m.channel_id = c.id
+#                 ORDER BY m.id DESC
+#                 LIMIT 100000;
+#                 """
+#
+#             await cursor.execute(query)
+#             results = await cursor.fetchall()
+#
+#             rows = []
+#             for r in results:
+#                 user_obj = User(id=r["u_id"], name=r["u_name"])
+#                 channel_obj = Channel(id=r["c_id"]) if r["c_id"] else None
+#                 msg_obj = MessageLog(
+#                     id=r["m_id"],
+#                     content=r["content"],
+#                     type=r["type"],
+#                     created_at=r["created_at"],
+#                     channel_id=r["channel_id"],
+#                     user_id=r["user_id"],
+#                 )
+#                 rows.append({"message_row": msg_obj, "user": user_obj, "channel": channel_obj})
+#             return rows
+#
+#     finally:
+#         await conn.ensure_closed()
+#

bot/cogs/join/command/join.py

@@ -33,7 +33,7 @@ async def component_before_invoke(self, ctx: Context) -> None:
 
     # TODO: add more scopes later, fix get_or_none to user_id
     # TODO: also add explanations for scopes
-    @commands.command(name='join', aliases=[])
+    @commands.command(name='join', aliases=[], whispable=True)
     async def join(self, ctx: Context, args: str = "") -> Response:
         channel = await Channel.get_or_none(user_id=ctx.user.id)
         args, lang = self.StringTools.remove_prefixed_option(args, "lang")

bot/cogs/leave/command/leave.py

@@ -29,23 +29,24 @@ def guards_component(self, ctx: commands.Context) -> bool:  # NOQA
     async def component_before_invoke(self, ctx: Context) -> None:
         self.translations.ctx_set(ctx)
 
-    @commands.command(name="leave", aliases=[])
+    @commands.command(name="leave", aliases=[], whispable=True)
     async def leave(self, ctx: Context) -> Response:
         if not (channel := await Channel.get_or_none(user=ctx.user)):
             return self.translations.Leave.not_on_channel()
         if channel.removed:
             return self.translations.Leave.not_on_channel()
         await self.bot.TokensHandler.get_event_sub_subscriptions()
-        user_token = await TwitchTokens.get(user=ctx.user)
-        user_token.token = None
-        user_token.refresh = None
-        user_token.removed = True
-        await user_token.save()
+        user_token = await TwitchTokens.get_or_none(user=ctx.user)
+        if user_token:
+            user_token.token = None
+            user_token.refresh = None
+            user_token.removed = True
+            await user_token.save()
         channel.removed = True
         channel.online = False
         await channel.save()
         for sub in channel.event_subs:
-            await self.bot.delete_eventsub_subscription(sub)
+            await self.bot.delete_eventsub_subscription(channel.event_subs[sub])
         await self.bot.ChannelHandler.load_channels()
         return self.translations.Leave.channel_removed(ctx.author.name)
 

bot/cogs/set/command/set.py

@@ -5,7 +5,7 @@
 from typing import TYPE_CHECKING
 
 from bot.ext import Context, Response, commands
-from bot.utils import StringTools
+from bot.utils import Role, StringTools
 
 from .translations import Translations
 
@@ -29,11 +29,14 @@ async def component_command_error(self, payload: commands.CommandErrorPayload) -
     def guards_component(self, ctx: commands.Context) -> bool:  # NOQA
         return True
 
+    async def component_before_invoke(self, ctx: Context) -> None:
+        self.translations.ctx_set(ctx)
+
     @commands.group(name="set", aliases=[], invoke_fallback=True)
     async def set(self, ctx: Context, *, args) -> Response:
         return self.translations.Exceptions.echo(ctx, args)
 
-    @set.command(name="mention", aliases=[])
+    @set.command(name="mention", aliases=[], pipeble=False)
     async def set_mention(self, ctx: Context, *, args: str) -> Response:
         translations = self.translations.Mention
         if args.lower() not in ["on", "off"]:
@@ -58,7 +61,7 @@ async def set_city(self, ctx: Context, *, args: str) -> Response:
         await ctx.user.save()
         return translations.city_added(ctx)
 
-    @set.command(name="nick", aliases=["nickname"])
+    @set.command(name="nick", aliases=["nickname"], pipeble=False)
     async def set_nick(self, ctx: Context, *, args: str) -> Response:
         translations = self.translations.Nick
         nickname = args
@@ -74,7 +77,7 @@ async def set_nick(self, ctx: Context, *, args: str) -> Response:
         await ctx.user.save()
         return translations.nick_changed(ctx)
 
-    @set.command(name="color", aliases=[])
+    @set.command(name="color", aliases=[], pipeble=False)
     async def set_color(self, ctx: Context, *, args: str) -> Response:
         translations = self.translations.Color
         if args.lower() == "remove":
@@ -87,7 +90,7 @@ async def set_color(self, ctx: Context, *, args: str) -> Response:
         await ctx.user.save()
         return translations.color_changed(ctx, color)
 
-    @set.command(name="reminder", aliases=[])
+    @set.command(name="reminder", aliases=[], pipeble=False)
     async def set_reminder(self, ctx: Context, *, args: str) -> Response:
         translations = self.translations.Reminder
         if args.lower() not in ["on", "off"]:
@@ -101,6 +104,115 @@ async def set_reminder(self, ctx: Context, *, args: str) -> Response:
             await ctx.user.save()
             return translations.reminder_off(ctx)
 
+    @commands.guard([Role.admin])
+    @set.command(name="banword", aliases=[])
+    async def set_banword(self, ctx: Context, action: str, *, args: str) -> Response:
+        translations = self.translations.Banword
+        words = translations.add_remove_lang()
+        _words = self.StringTools.extract_words_simple(args)
+        add, remove, clean = words.get("add"), words.get("remove"), words.get("clean")
+        channel = self.bot.channels[ctx.channel.name.lower()]
+        if channel.removed:
+            return translations.who()
+        if action.lower() not in ["add", "remove", "clean", *clean, *add, *remove]:
+            await self._send_bug(ctx, ctx.channel.name)
+            return translations.add_remove(action)
+        if action.lower() in ["add", *add]:
+            for world in _words:
+                channel.banwords[world] = int(ctx.author.id)
+            await channel.save()
+            return translations.added()
+        elif action.lower() in ["remove", *remove]:
+            for world in _words:
+                channel.banwords.pop(world)
+            await channel.save()
+            return translations.removed()
+        elif action.lower() in ["clean", *clean]:
+            channel.banwords = {}
+            return translations.cleaned()
+        else:
+            return translations.what(action)
+
+    @commands.guard([Role.admin])
+    @set.command(name="enable", aliases=["disable"], pipeble=False)
+    async def set_enable_disable(self, ctx: Context, arg: str) -> Response:
+        translations = self.translations.Enable
+        channel = self.bot.channels[ctx.channel.name.lower()]
+        invoked = ctx.invoked_with.lower()
+        protected_commands = {"set", "enable", "disable", "help", "start", "stop"}
+        if arg.lower() in protected_commands:
+            return translations.why(arg)
+        if arg.lower() == "all":
+            if invoked == "set enable":
+                channel.disabled.clear()
+                await channel.save()
+                return translations.all_enabled()
+            elif invoked == "set disable":
+                for cmd in ctx.bot.commands:
+                    if ctx.bot.commands[cmd].name not in protected_commands:
+                        channel.disabled[ctx.bot.commands[cmd].name.lower()] = int(ctx.author.id)
+                await channel.save()
+                return translations.all_disabled()
+        command_to_manage = ctx.bot.get_command(arg.lower())
+        if not command_to_manage:
+            return translations.no_command(arg)
+        if invoked == "set enable":
+            if command_to_manage.name not in channel.disabled:
+                return translations.command_already_enabled(arg)
+            channel.disabled.pop(command_to_manage.name.lower(), None)
+            await channel.save()
+            return translations.command_enabled(arg)
+        elif invoked == "set disable":
+            if command_to_manage.name in protected_commands:
+                return translations.why(arg)
+            if command_to_manage.name in channel.disabled:
+                return translations.command_already_disabled(arg)
+            channel.disabled[command_to_manage.name.lower()] = int(ctx.author.id)
+            await channel.save()
+            return translations.command_disabled(arg)
+        return translations.options()
+
+    @commands.guard([Role.admin])
+    @set.command(name="prefix", aliases=[], pipeble=False)
+    async def set_prefix(self, ctx: Context, arg: str) -> Response:
+        translations = self.translations.Prefix
+        prefix_size = 2
+        if len(arg) >= prefix_size:
+            return translations.too_long(arg, prefix_size)
+        channel = self.bot.channels[ctx.channel.name.lower()]
+        channel.prefix = arg
+        await channel.save()
+        return translations.prefix_changed(arg)
+
+    @commands.guard([Role.admin])
+    @set.command(name="start", aliases=["on", "stop", "off"], pipeble=False, whispable=True)
+    async def set_start_stop(self, ctx: Context) -> Response:
+        translations = self.translations.StartStop
+        invoked = ctx.invoked_with.lower()
+        channel = self.bot.channels[ctx.channel.name.lower()]
+        if invoked.lower() in ["set start", "set on"]:
+            if channel.online:
+                return translations.already_on()
+            channel.online = True
+            await channel.save()
+            return translations.started()
+        elif invoked.lower() in ["set stop", "set off"]:
+            await channel.save()
+            if channel.online:
+                channel.online = False
+                await channel.save()
+                return translations.stopped()
+            return translations.already_off()
+        return translations.shrug()
+
+    async def _send_bug(self, ctx: Context, name: str):
+        if self.bot.mock:
+            return None
+        fake_exc = self.translations.SupportTools.fake_stacktrace(
+            f"Somehow a command has invoked for removed channel: {name}"
+        )
+        return await self.bot.CommandHandler.send_bug(ctx, fake_exc)
+
 
 async def setup(bot: Gorenmu) -> None:
     await bot.add_component(SetCmd(bot))