Kanium-PUBLIC/KaniumCogs
5
0
Fork 0
Code Issues 6 Pull Requests Packages Projects 1 Releases Wiki Activity

Commented out send_long_message method and auto PEP-8 reginald.py

Browse Source
This commit is contained in:
T-BENZIN 2025-07-18 14:31:51 +05:00
parent 9209cc568d
commit a64a07511d
1 changed files with 33 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
reginaldCog/reginald.py
View File

@ -16,7 +16,6 @@ from .weather import time_now, get_current_weather, get_weather_forecast
from .tools_description import TOOLS from .tools_description import TOOLS
from .debug_stuff import debug from .debug_stuff import debug
CALLABLE_FUNCTIONS = { CALLABLE_FUNCTIONS = {
# Dictionary with functions to call. # Dictionary with functions to call.
# You can use globals()[func_name](**args) instead, but that's too implicit. # You can use globals()[func_name](**args) instead, but that's too implicit.
@ -71,7 +70,7 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
async def on_message(self, message): async def on_message(self, message):
if message.author.bot or not message.guild: if message.author.bot or not message.guild:
return # Ignore bots and DMs return # Ignore bots and DMs
# ✅ Check if user is blacklisted # ✅ Check if user is blacklisted
if await self.is_blacklisted(message.author): if await self.is_blacklisted(message.author):
return # Ignore message if user is explicitly blacklisted return # Ignore message if user is explicitly blacklisted
@ -80,7 +79,6 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
if not (await self.is_admin(message) or await self.has_access(message.author)): if not (await self.is_admin(message) or await self.has_access(message.author)):
return # Ignore message if user has no permissions return # Ignore message if user has no permissions
guild = message.guild guild = message.guild
channel_id = str(message.channel.id) channel_id = str(message.channel.id)
user_id = str(message.author.id) user_id = str(message.author.id)
@ -115,8 +113,8 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
await message.channel.send(random.choice(["Yes?", "How may I assist?", "You rang?"])) await message.channel.send(random.choice(["Yes?", "How may I assist?", "You rang?"]))
return return
explicit_invocation = True explicit_invocation = True
# ✅ Passive Listening: Check if the message contains relevant keywords # ✅ Passive Listening: Check if the message contains relevant keywords
elif self.should_reginald_interject(message_content): elif self.should_reginald_interject(message_content):
prompt = message_content prompt = message_content
explicit_invocation = False explicit_invocation = False
@ -124,11 +122,11 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
else: else:
return # Ignore irrelevant messages return # Ignore irrelevant messages
# ✅ Context Handling: Maintain conversation flow # ✅ Context Handling: Maintain conversation flow
if memory and memory[-1]["user"] == user_name: if memory and memory[-1]["user"] == user_name:
prompt = f"Continuation of the discussion:\n{prompt}" prompt = f"Continuation of the discussion:\n{prompt}"
# ✅ Prepare context messages # ✅ Prepare context messages
formatted_messages = [{"role": "system", "content": self.get_reginald_persona()}] formatted_messages = [{"role": "system", "content": self.get_reginald_persona()}]
if user_profile: if user_profile:
@ -145,10 +143,10 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
"content": f"[{summary['timestamp']}] Topics: {', '.join(summary['topics'])}\n{summary['summary']}" "content": f"[{summary['timestamp']}] Topics: {', '.join(summary['topics'])}\n{summary['summary']}"
}) })
formatted_messages += [{"role": "user", "content": f"{entry['user']}: {entry['content']}"} for entry in memory] formatted_messages += [{"role": "user", "content": f"{entry['user']}: {entry['content']}"} for entry in
memory]
formatted_messages.append({"role": "user", "content": f"{user_name}: {prompt}"}) formatted_messages.append({"role": "user", "content": f"{user_name}: {prompt}"})
################################################## ##################################################
# # # #
## Generate AI Response, put into response_text ## ## Generate AI Response, put into response_text ##
@ -166,7 +164,8 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
memory.append({"user": "Reginald", "content": response_text}) memory.append({"user": "Reginald", "content": response_text})
if len(memory) > self.short_term_memory_limit: if len(memory) > self.short_term_memory_limit:
summary = await self.summarize_memory(message, memory[:int(self.short_term_memory_limit * self.summary_retention_ratio)]) summary = await self.summarize_memory(message, memory[:int(
self.short_term_memory_limit * self.summary_retention_ratio)])
mid_memory.setdefault(channel_id, []).append({ mid_memory.setdefault(channel_id, []).append({
"timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M"), "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M"),
"topics": self.extract_topics_from_summary(summary), "topics": self.extract_topics_from_summary(summary),
@ -174,20 +173,20 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
}) })
if len(mid_memory[channel_id]) > self.summary_retention_limit: if len(mid_memory[channel_id]) > self.summary_retention_limit:
mid_memory[channel_id].pop(0) mid_memory[channel_id].pop(0)
memory = memory[-(self.short_term_memory_limit - int(self.short_term_memory_limit * self.summary_retention_ratio)):] memory = memory[-(self.short_term_memory_limit - int(
self.short_term_memory_limit * self.summary_retention_ratio)):]
short_memory[channel_id] = memory short_memory[channel_id] = memory
await self.send_split_message(message.channel, response_text) await self.send_split_message(message.channel, response_text)
def should_reginald_interject(self, message_content: str) -> bool: def should_reginald_interject(self, message_content: str) -> bool:
"""Determines if Reginald should respond to a message based on keywords.""" """Determines if Reginald should respond to a message based on keywords."""
direct_invocation = { direct_invocation = {
"reginald," "reginald,"
} }
message_lower = message_content.lower() message_lower = message_content.lower()
return any(message_lower.startswith(invocation) for invocation in direct_invocation) return any(message_lower.startswith(invocation) for invocation in direct_invocation)
@debug @debug
@ -227,8 +226,8 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
'content': func_result, 'content': func_result,
'tool_call_id': tool_call_id, 'tool_call_id': tool_call_id,
}) })
completion_args["messages"] = messages completion_args["messages"] = messages
# Second completion required if functions has been called to interpret the result into user-friendly # Second completion required if functions has been called to interpret the result into user-friendly
# chat message. # chat message.
response = await client.chat.completions.create(**completion_args) response = await client.chat.completions.create(**completion_args)
@ -261,11 +260,12 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
await self.config.guild(ctx.guild).openai_api_key.set(api_key) await self.config.guild(ctx.guild).openai_api_key.set(api_key)
await ctx.send("OpenAI API key set successfully.") await ctx.send("OpenAI API key set successfully.")
@commands.command(name="reginald_set_listening_channel", help="Set the channel where Reginald listens for messages.") @commands.command(name="reginald_set_listening_channel",
help="Set the channel where Reginald listens for messages.")
@commands.has_permissions(administrator=True) @commands.has_permissions(administrator=True)
async def set_listening_channel(self, ctx, channel: discord.TextChannel): async def set_listening_channel(self, ctx, channel: discord.TextChannel):
"""Sets the channel where Reginald will listen for passive responses.""" """Sets the channel where Reginald will listen for passive responses."""
if not channel: if not channel:
await ctx.send("❌ Invalid channel. Please mention a valid text channel.") await ctx.send("❌ Invalid channel. Please mention a valid text channel.")
return return
@ -273,12 +273,13 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
await self.config.guild(ctx.guild).listening_channel.set(channel.id) await self.config.guild(ctx.guild).listening_channel.set(channel.id)
await ctx.send(f"✅ Reginald will now listen only in {channel.mention}.") await ctx.send(f"✅ Reginald will now listen only in {channel.mention}.")
@commands.command(name="reginald_get_listening_channel", help="Check which channel Reginald is currently listening in.") @commands.command(name="reginald_get_listening_channel",
help="Check which channel Reginald is currently listening in.")
@commands.has_permissions(administrator=True) @commands.has_permissions(administrator=True)
async def get_listening_channel(self, ctx): async def get_listening_channel(self, ctx):
"""Displays the current listening channel.""" """Displays the current listening channel."""
channel_id = await self.config.guild(ctx.guild).listening_channel() channel_id = await self.config.guild(ctx.guild).listening_channel()
if channel_id: if channel_id:
channel = ctx.guild.get_channel(channel_id) channel = ctx.guild.get_channel(channel_id)
if channel: # ✅ Prevents crash if channel was deleted if channel: # ✅ Prevents crash if channel was deleted
@ -288,18 +289,17 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
else: else:
await ctx.send("❌ No listening channel has been set.") await ctx.send("❌ No listening channel has been set.")
# async def send_long_message(self, ctx, message, prefix: str = ""):
# """Splits and sends a long message to avoid Discord's 2000-character limit."""
# chunk_size = 1900 # Leave some space for formatting
# if prefix:
# prefix_length = len(prefix)
# chunk_size -= prefix_length
#
# for i in range(0, len(message), chunk_size):
# chunk = message[i:i + chunk_size]
# await ctx.send(f"{prefix}{chunk}")
async def send_long_message(self, ctx, message, prefix: str = ""):
"""Splits and sends a long message to avoid Discord's 2000-character limit."""
chunk_size = 1900 # Leave some space for formatting
if prefix:
prefix_length = len(prefix)
chunk_size -= prefix_length
for i in range(0, len(message), chunk_size):
chunk = message[i:i + chunk_size]
await ctx.send(f"{prefix}{chunk}")
async def send_split_message(self, ctx, content: str, prefix: str = ""): async def send_split_message(self, ctx, content: str, prefix: str = ""):
""" """
Sends a long message to Discord while ensuring it does not exceed the 2000-character limit. Sends a long message to Discord while ensuring it does not exceed the 2000-character limit.
@ -351,4 +351,4 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
async def setup(bot): async def setup(bot):
"""✅ Correct async cog setup for Redbot""" """✅ Correct async cog setup for Redbot"""
await bot.add_cog(ReginaldCog(bot)) await bot.add_cog(ReginaldCog(bot))