try

chatbot/plugins/chat.py

@@ -49,9 +49,9 @@ from database import db
 from database import users_collection
 from logger import LOGS
 
-import google.generativeai as genai
+from google import genai
+from google.genai import types as ty
 import akenoai.pyro_decorator as akeno
-from google.api_core.exceptions import InvalidArgument
 
 async def geni_files_delete(name: str):
     url = f"https://generativelanguage.googleapis.com/v1beta/{name}"
@@ -61,36 +61,13 @@ async def geni_files_delete(name: str):
         return None
     return response.text
 
-spam_chats = []
-
-DISABLE_COMMAND = [
-    "start",
-    "status",
-    "offchat",
-    "onchat",
-    "setmodel",
-]
-
-NOT_ALLOWED_NON_PROGRAMMER = [
-    466019692, # @myexcid,
-    1423479724, # tonic,
-    883761960, # ari
-    6824458358, # None
-    1982318761, # paman
-    5575183435, #suku
-    948247711, # akay
-]
 
 GEMINI_START_TEXT = """
-Hey! {name}
-
-I am ready to be a gemini bot developer
-
-- Command: /onchat (pm or group)
-- Command: /offchat (pm or group)
-- Command: /setmodel to change model
+Hey! {name} Welcome to Gemini AI New
 """
 
+gen = genai.Client(api_key=GOOGLE_API_KEY)
+
 class TaskManager:
     def __init__(self):
         self.running_tasks = {}
@@ -200,113 +177,6 @@ async def cancel_(client, callback_query):
     else:
         await callback_query.edit_message_text("⚠️ No active task to cancel.")
 
-async def handle_photo(client, message):
-    chat_id = message.chat.id
-    async def process_photo():
-        buttons = [
-            [
-                InlineKeyboardButton(
-                    text="Cancel",
-                    callback_data="cancels"
-                )
-            ],
-        ]
-        try:
-            spam_chats.append(chat_id)
-            await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_PHOTO)
-            await asyncio.sleep(1.5)
-            ai_reply = await message.reply_text(
-                "Uploading file..",
-                reply_markup=InlineKeyboardMarkup(buttons)
-            )
-            seconds_time = time.time()
-            file_path = await message.download(
-                progress=progress,
-                progress_args=(ai_reply, seconds_time, "Uploading..."),
-            )
-            caption = message.caption or "What's this?"
-            x = GeminiLatest(api_keys=GOOGLE_API_KEY)
-            await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_PHOTO)
-            await asyncio.sleep(1.5)
-            backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-            backup_chat.append({"role": "user", "parts": [{"text": caption}]})
-            response_reads = x.get_response_image(caption, file_path)
-            if len(response_reads) > 4096:
-                with open("chat.txt", "w+", encoding="utf8") as out_file:
-                    out_file.write(response_reads)
-                await message.reply_document(
-                    document="chat.txt",
-                    disable_notification=True
-                )
-                await ai_reply.delete()
-                os.remove("chat.txt")
-            else:
-                await ai_reply.edit_text(response_reads)
-            backup_chat.append({"role": "model", "parts": [{"text": response_reads}]})
-            await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-            await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-            os.remove(file_path)
-            return
-        except asyncio.CancelledError:
-            await ai_reply.edit_text("⚠️ Photo processing was canceled.")
-        finally:
-            spam_chats.remove(chat_id)
-            await task_manager.cancel_task(chat_id)
-
-    await task_manager.add_task(chat_id, process_photo())
-
-async def handle_video(client, message, model_):
-    chat_id = message.chat.id
-    async def process_video():
-        buttons = [
-            [
-                InlineKeyboardButton(
-                    text="Cancel",
-                    callback_data="cancels"
-                )
-            ],
-        ]
-        try:
-            spam_chats.append(chat_id)
-            await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_VIDEO)
-            await asyncio.sleep(1.5)
-            ai_reply = await message.reply_text(
-                "Uploading file..",
-                reply_markup=InlineKeyboardMarkup(buttons)
-            )
-            seconds_time = time.time()
-            video_file_name = await message.download(
-                file_name="newvideo.mp4",
-                progress=progress,
-                progress_args=(ai_reply, seconds_time, "Uploading...")
-            )
-            caption = message.caption or "What's this?"
-            backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-            backup_chat.append({"role": "user", "parts": [{"text": caption}]})
-            model = genai.GenerativeModel(model_name=model_)
-            video_file = genai.upload_file(path=video_file_name)
-            while video_file.state.name == "PROCESSING":
-                await asyncio.sleep(10)
-                video_file = genai.get_file(video_file.name)
-
-            if video_file.state.name == "FAILED":
-                return await ai_reply.edit_text(f"Error: {video_file.state.name}")
-
-            response = model.generate_content(
-                [video_file, caption],
-                request_options={"timeout": 600}
-            )
-            await ai_reply.edit_text(response.text)
-            backup_chat.append({"role": "model", "parts": [{"text": response.text}]})
-            await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-        except asyncio.CancelledError:
-            await ai_reply.edit_text("⚠️ Video processing was canceled.")
-        finally:
-            spam_chats.remove(chat_id)
-            task_manager.cancel_task(chat_id)
-
-    await task_manager.add_task(chat_id, process_video())
-
 @Client.on_message(
     ~filters.scheduled
     & filters.command(["start"])
@@ -325,87 +195,14 @@ async def startbot(client: Client, message: Message):
                 text="Channel",
                 url='https://t.me/RendyProjects'
             ),
-        ],
-        [
-            InlineKeyboardButton(
-                text="Donate Via Web",
-                web_app=WebAppInfo(url="https://sociabuzz.com/randydev99/tribe")
-            )
         ]
     ]
     await message.reply_text(
         text=GEMINI_START_TEXT.format(name=message.from_user.mention),
         disable_web_page_preview=True,
-        effect_id=5104841245755180586,
         reply_markup=InlineKeyboardMarkup(buttons)
     )
 
-FREE_GEMINI_TEXT = """
-• User Free : {name}
-- Text: `{check_enable}`
-- Image: `{check_enable}`
-- Video: `{check_enable}`
-- Voice: `{check_enable}`
-- Document: `{check_status}`
-
-{info}
-"""
-
-@Client.on_message(
-    ~filters.scheduled
-    & filters.command(["status"])
-    & ~filters.forwarded
-)
-@akeno.LogChannel(channel_id="KillerXSupport", is_track=True)
-async def userstatus(client: Client, message: Message):
-    if message.from_user.id in NOT_ALLOWED_NON_PROGRAMMER:
-        return
-    is_check_plan = await db.is_gemini_plan(user_id=message.from_user.id)
-    chat_user = await db.get_chatbot(message.chat.id)
-    if not is_check_plan and not chat_user:
-        return await message.reply_text(
-            FREE_GEMINI_TEXT.format(
-                name=message.from_user.first_name,
-                check_enable="Unlimited" if chat_user else "Stopped",
-                check_status="Unlimited" if is_check_plan else "Stopped",
-                info="You need email business: [register](https://forms.gle/egRciGY39mmhNyScA)\nRemember: **can't ownership**"
-            ),
-            disable_web_page_preview=True
-        )
-    return await message.reply_text(
-        FREE_GEMINI_TEXT.format(
-            name=message.from_user.first_name,
-            check_enable="Unlimited" if chat_user else "Stopped",
-            check_status="Unlimited" if is_check_plan else "Stopped",
-            info="**All unlimited good!**"
-        )
-    )
-
-
-@Client.on_message(
-    ~filters.scheduled
-    & filters.command(["onchat"])
-    & ~filters.forwarded
-)
-async def addchatbot_user(client: Client, message: Message):
-    if message.from_user.id in NOT_ALLOWED_NON_PROGRAMMER:
-        return
-    await db.add_chatbot(message.chat.id, client.me.id)
-    await message.reply_text("Added chatbot user")
-
-
-@Client.on_message(
-    ~filters.scheduled
-    & filters.command(["offchat"])
-    & ~filters.forwarded
-)
-@akeno.LogChannel(channel_id="KillerXSupport", is_track=True)
-async def rmchatbot_user(client: Client, message: Message):
-    if message.from_user.id in NOT_ALLOWED_NON_PROGRAMMER:
-        return
-    await db.remove_chatbot(message.chat.id)
-    await message.reply_text("ok stopped gemini")
-
 @Client.on_message(
     filters.incoming
     & (
@@ -415,95 +212,21 @@ async def rmchatbot_user(client: Client, message: Message):
         | filters.audio
         | filters.voice
         | filters.document
-        | filters.regex(r"\b(Randy|Rendi)\b(.*)", flags=re.IGNORECASE)
     )
-    & (filters.private | filters.group)
-    & filters.reply
-    & ~filters.command(DISABLE_COMMAND)
-    & ~filters.bot
-    & ~filters.via_bot
-    & ~filters.forwarded,
-    group=2,
+    & filters.private
+    & ~filters.command(["start"])
+    & ~filters.forwarded
 )
-@akeno.ForceSubscribe(where_from="RendyProjects", owner_id="xtdevs")
 async def chatbot_talk(client: Client, message: Message):
-    if message.from_user.id in NOT_ALLOWED_NON_PROGRAMMER:
-        return
     user = await users_collection.find_one({"user_id": message.from_user.id})
-    model_ = user.get("model") if user else "gemini-1.5-pro"
-    genai.configure(api_key=GOOGLE_API_KEY)
+    model_ = user.get("model") if user else "gemini-2.0-flash-001"
     chat_user = await db.get_chatbot(message.chat.id)
     if not chat_user:
         return
     if message.reply_to_message and message.reply_to_message.from_user:
         if message.reply_to_message.from_user.id != client.me.id:
             return
-    if message.photo:
-        await handle_photo(client, message)
-    if message.audio or message.voice:
-        await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_AUDIO)
-        await asyncio.sleep(1.5)
-        if client.me.is_premium:
-            ai_reply = await message.reply_text(f"{custom_loading}Processing...")
-        else:
-            ai_reply = await message.reply_text(f"Processing...")
-        if message.audio:
-            audio_file_name = await message.download()
-        if message.voice:
-            audio_file_name = await message.download()
-        caption = message.caption or "What's this?"
-        model = genai.GenerativeModel(
-            model_name=model_,
-            safety_settings={
-                genai.types.HarmCategory.HARM_CATEGORY_HATE_SPEECH: genai.types.HarmBlockThreshold.BLOCK_NONE,
-                genai.types.HarmCategory.HARM_CATEGORY_HARASSMENT: genai.types.HarmBlockThreshold.BLOCK_NONE,
-                genai.types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: genai.types.HarmBlockThreshold.BLOCK_NONE,
-                genai.types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: genai.types.HarmBlockThreshold.BLOCK_NONE,
-            }
-        )
-        backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-        backup_chat.append({"role": "user", "parts": [{"text": caption}]})
-        if client.me.is_premium:
-            await ai_reply.edit_text(f"{custom_loading}Uploading file..")
-        else:
-            await ai_reply.edit_text("Uploading file..")
-        audio_file = genai.upload_file(path=audio_file_name)
-        while audio_file.state.name == "PROCESSING":
-            await asyncio.sleep(10)
-            audio_file = genai.get_file(audio_file.name)
-        if audio_file.state.name == "FAILED":
-            return await ai_reply.edit_text(f"Error: {audio_file.state.name}")
-        try:
-            await client.send_chat_action(message.chat.id, enums.ChatAction.TYPING)
-            await asyncio.sleep(1.5)
-            response = model.generate_content(
-                [audio_file, caption],
-                request_options={"timeout": 600}
-            )
-            if len(response.text) > 4096:
-                with open("chat.txt", "w+", encoding="utf8") as out_file:
-                    out_file.write(response.text)
-                await message.reply_document(
-                    document="chat.txt",
-                    disable_notification=True
-                )
-                await ai_reply.delete()
-                os.remove("chat.txt")
-            else:
-                await ai_reply.edit_text(response.text)
-            backup_chat.append({"role": "model", "parts": [{"text": response.text}]})
-            await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-            await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-            audio_file.delete()
-            os.remove(audio_file_name)
-            return
-        except InvalidArgument as e:
-            return await ai_reply.edit_text(f"Error: {e}")
-        except Exception as e:
-            return await ai_reply.edit_text(f"Error: {e}")
-
-    if message.video:
-        await handle_video(client, message, model_)
+    
     if message.text:
         await client.send_chat_action(message.chat.id, enums.ChatAction.TYPING)
         await asyncio.sleep(1.5)
@@ -518,13 +241,10 @@ async def chatbot_talk(client: Client, message: Message):
         command = parts[0].lower()
         pic_query = parts[1].strip() if len(parts) > 1 else ""
         try:
-            model_flash = genai.GenerativeModel(
-                model_name=model_
-            )
             backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
             backup_chat.append({"role": "user", "parts": [{"text": query_base}]})
-            chat_session = model_flash.start_chat(history=backup_chat)
-            response_data = chat_session.send_message(query_base)
+            chat_session = gen.aio.chats.create(model=model_, history=backup_chat)
+            response_data = await chat_session.send_message(query_base)
             output = response_data.text
             if len(output) > 4096:
                 with open("chat.txt", "w+", encoding="utf8") as out_file:
@@ -541,4 +261,4 @@ async def chatbot_talk(client: Client, message: Message):
             await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
             return
         except Exception as e:
-            return await message.reply_text(f"Error: {e}")
+            return await message.reply_text(f"Error: {e}")