Upload chat.py

chatbot/plugins/chat.py

@@ -23,6 +23,7 @@ import traceback
 import requests
 import json
 import io
+import cohere
 from datetime import datetime as dt, timedelta
 
 from gpytranslate import SyncTranslator
@@ -64,24 +65,6 @@ DISABLED_COMMANDS =  [
     "--deletemydata --reason"
 ]
 
-blacklist_patterns = [
-    r"\bkill\s*yourself\b",
-    r"\bi['’]?ll\s*rape\s*you\b",
-    r"\bhate\s*speech\b",
-    r"\bbomb\s*threat\b",
-    r"\bterrorist\b",
-    r"\bgore\s*content\b",
-    r"\bchild\s*abuse\b",
-    r"\bracist\s*slur\b",
-    r"\bdeepfake\s*porn\b",
-    r"\bnude\s*minors\b",
-    r"\bsuicide\s*tutorial\b",
-    r"\bhow\s*to\s*make\s*a\s*bomb\b",
-    r"\billegal\s*weapon\b",
-    r"\bschool\s*shooting\b",
-    r"\bdeath\s*threat\b",
-]
-
 def aigen_check(user_id: int, text: str):
     result = {}
     try:
@@ -118,12 +101,6 @@ def is_command_disabled(text):
   else:
     return False
 
-def is_blacklisted_english(text: str) -> bool:
-    for pattern in blacklist_patterns:
-        if re.search(pattern, text, re.IGNORECASE):
-            return True
-    return False
-
 def obfuscate(word):
     return word.lower()\
         .replace("a", "[a@4]")\
@@ -199,6 +176,51 @@ Type anything to begin.
 
 gen = genai.Client(api_key=GOOGLE_API_KEY)
 
+async def search_auto_by_cohere(user_id, prompt):
+    COHERE_API_KEY = os.environ.get("COHERE_API_KEY")
+    co = cohere.Client(api_key=COHERE_API_KEY)
+    stream = co.chat_stream( 
+        model='command-r-08-2024',
+        message=prompt,
+        temperature=0.3,
+        chat_history=chat_history,
+        prompt_truncation='AUTO',
+        connectors=[{"id":"web-search"}]
+    )
+    data = []
+    output = ""
+    for event in stream:
+        if event.event_type == "search-results":
+            if event.documents:
+                data.extend(event.documents)
+        elif event.event_type == "text-generation":
+            output += event.text
+
+    if not data:
+        data = [{"title": "", "url": ""}]
+
+    reference_dict = {}
+    for item in data:
+        title = item.get("title", "").strip()
+        url = item.get("url", "").strip()
+        if not title or not url:
+            continue
+        if title not in reference_dict:
+            reference_dict[title] = url
+    references = ""
+    for i, (title, url) in enumerate(reference_dict.items()):
+        references += f"{i}. [{title}]({url})\n"
+
+    if not references.strip():
+        references = ""
+
+    if not output:
+        output = "I couldn't generate a response."
+
+    all_answer = f"{output}\n\n{references}"
+    return all_answer
+
+
 # Original: @GeminiAIDev_Bot
 # Code by @xtdevs
 def replace_with_markdown_list(text, pattern=r"^\s*\*\s*(.*)$"):
@@ -231,6 +253,43 @@ def split_message(text: str) -> List[str]:
 async def closeed(client, callback):
     await callback.message.delete()
 
+@Client.on_callback_query(filters.regex("^comode:([a-f0-9]{8})"))
+async def coheresearch(client, callback):
+    uuidstr = callback.matches[0].group(1)
+    keyboard = []
+    keyboard.append([
+        InlineKeyboardButton("Deep Search ON", callback_data=f"deeps_on_{uuidstr}"),
+        InlineKeyboardButton("Deep Search OFF", callback_data=f"deeps_off_{uuidstr}")
+    ])
+    keyboard.append([
+        InlineKeyboardButton("Back To Menu", callback_data=f"menu_back:{uuidstr}")
+    ])
+    await callback.edit_message_reply_markup(reply_markup=InlineKeyboardMarkup(keyboard))
+
+@Client.on_callback_query(filters.regex("^deeps_(on|off)_([a-f0-9]{8})$"))
+async def deepsearchmode(client, callback):
+    user_id = callback.from_user.id
+    mode, uuidstr = callback.matches[0].groups()
+    try:
+        if mode not in ("on", "off"):
+            await callback.answer("Mode invalid", show_alert=True)
+            return
+        is_deepsearch = mode == "on"
+        await db.backup_chatbot.update_one(
+            {"user_id": user_id},
+            {"$set": {"is_deepsearch": is_deepsearch}},
+            upsert=True
+        )
+        await callback.answer(f"Deep Search mode is set to {mode}.", show_alert=True)
+        keyboard = create_keyboard(
+            user_id=user_id,
+            uuid_str=uuidstr
+        )
+        await callback.edit_message_reply_markup(reply_markup=keyboard)
+    except Exception as e:
+        LOGS.error(f"Cohere Error: {e}")
+        await callback.answer("Please try again later..", show_alert=True)
+
 @Client.on_callback_query(filters.regex("^modelmenu:([a-f0-9]{8})$"))
 async def modelgeminimenu(client, callback):
     uuidstr = callback.matches[0].group(1)
@@ -300,7 +359,7 @@ async def geminigen_prompt(client, callback):
         get_response = data.get("prompt_image", None)
         if not get_response:
             return await callback.answer("Server busy try again later", True)
-        if regex_all_blacklist(get_response) or is_blacklisted_english(get_response):
+        if regex_all_blacklist(get_response):
             return await callback.answer("Sorry your account is frozen", True)
 
         await callback.message.edit_text("....")
@@ -382,7 +441,7 @@ async def flux_prompt(client, callback):
         get_response = data.get("prompt_image", None)
         if not get_response:
             return await callback.answer("Server busy try again later", True)
-        if regex_all_blacklist(get_response) or is_blacklisted_english(get_response):
+        if regex_all_blacklist(get_response):
             return await callback.answer("Sorry your account is frozen", True)
 
         await callback.message.edit_text("....")
@@ -697,6 +756,7 @@ def create_keyboard(
                     InlineKeyboardButton(f"♾️", callback_data=f"trmulti_{uuid_str}"),
                     InlineKeyboardButton(f"🔒", callback_data=f"showchat"),
                     InlineKeyboardButton(f"⛏️", callback_data=f"modelmenu:{uuid_str}"),
+                    InlineKeyboardButton(f"💡", callback_data=f"comode:{uuid_str}"),
                     InlineKeyboardButton(f"💾", callback_data=f"memory_{uuid_str}")
                 ],
                 [
@@ -820,7 +880,7 @@ async def chatbot_talk(client: Client, message: Message):
             await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_PHOTO)
             await asyncio.sleep(1.5)
 
-            if regex_all_blacklist(caption) or is_blacklisted_english(caption):
+            if regex_all_blacklist(caption):
                 await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
                 return
 
@@ -1071,7 +1131,7 @@ async def chatbot_talk(client: Client, message: Message):
             await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_VIDEO)
             await asyncio.sleep(2.0)
             caption = message.caption or "What this?"
-            if regex_all_blacklist(caption) or is_blacklisted_english(caption):
+            if regex_all_blacklist(caption):
                 return
 
             backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
@@ -1208,7 +1268,7 @@ async def chatbot_talk(client: Client, message: Message):
                 await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
                 return
 
-            if regex_all_blacklist(query_base) or is_blacklisted_english(query_base):
+            if regex_all_blacklist(query_base):
                 unfreeze_at = dt.now() + timedelta(days=2)
                 await db.user_blacklists.update_one(
                     {"user_id": message.from_user.id},
@@ -1340,6 +1400,39 @@ async def chatbot_talk(client: Client, message: Message):
                 )
                 return
 
+            if check_is_system.get("is_deepsearch", False):
+                uuid_code = str(uuid.uuid4())[:8]
+                backup_chat = await db._get_chatbot_chat_from_db(user_id)
+                backup_chat.append({"role": "user", "parts": [{"text": prompt}]})
+                results = await search_auto_by_cohere(message.from_user.id, query_base):
+                if len(results) > 4096:
+                    text_parts = split_message(results)
+                    for part in text_parts:
+                        await message.reply_text(part)
+                else:
+                    keyboard_like = create_keyboard(
+                        user_id=message.from_user.id,
+                        uuid_str=uuid_code
+                    )
+                    await message.reply_text(
+                        results,
+                        disable_web_page_preview=True,
+                        reply_markup=keyboard_like
+                    )
+                translation_entry = {
+                    "uuid": uuid_code,
+                    "text": results,
+                    "timestamp": dt.now().isoformat()
+                }
+                await db.backup_chatbot.update_one(
+                    {"user_id": message.from_user.id},
+                    {"$push": {"translate_history": translation_entry}},
+                    upsert=True
+                )
+                backup_chat.append({"role": "model", "parts": [{"text": results}]})
+                await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
+                return
+
             if check_is_system.get("is_system", False):
                 _deletemydata_match = re.match(r"^--deletemydata\s+--reason\s+(.+)$", query_base, re.IGNORECASE)
                 if _deletemydata_match: