chore: fix

main.py

@@ -7,11 +7,7 @@ sys.path.insert(0, "src")
 os.environ['TRANSFORMERS_CACHE'] = '/tmp'
 
 from telegram.ext import (
-    CommandHandler,
-    CallbackContext,
     Application,
-    Updater,
-    ContextTypes,
 )
 from api import GirlfriendGPT
 from functools import partial  
@@ -27,23 +23,12 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# def show_results(response_messages):
-#     print(colored("\nResults: ", "blue", attrs=["bold"]))
-#     for message in response_messages:
-#         if message.mime_type:
-#             print(message.url, end="\n\n")
-#         else:
-#             print(message.text, end="\n\n")
 
 
 
 
 
 
-# async def echo(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
-#     """Echo the user message."""
-#     await update.message.reply_text("Enter your text")
-#     return GET_TEXT
 
 
 class LoggingDisabled:
@@ -59,11 +44,7 @@ class LoggingDisabled:
 def main():
     app = Application.builder().token(
         '6207542226:AAEoNVXw766dq8fYqVvBQW9Hve2Rovq0ERI',).build()
-    # application = Application.builder().token('6207542226:AAGXBVVxNNUKLUz17-5_sGJnhFDaVWUXTc8').build()
-    # application.add_handler(CommandHandler('start', hello))
 
-    # # Run the bot until the user presses Ctrl-C
-    # application.run_polling()
     run_agent(
         agent=GirlfriendGPT(
             token="hello",
@@ -75,16 +56,6 @@ def main():
 
 def run_agent(agent: GirlfriendGPT, as_api: bool = False) -> None:
     agent.handlers()
-    # For Debugging
-    # summary_handler = agent.conversation_summary_handler()
-    # agent.application.add_handler(summary_handler)
-    # agent.application.add_handler(CommandHandler('start', hello))
-    # # agent.application.add_handler(CommandHandler('summary', agent.conversation_summary))
-    # # agent.application.add_handler(MessageHandler(
-    # #     filters.TEXT & ~filters.COMMAND, agent.create_response))
-    # agent.application.run_polling()
-    # # agent.application.add_handler(MessageHandler(
-    # #     filters.TEXT & ~filters.COMMAND, agent.create_response))
 
 
 if __name__ == "__main__":

src/agent/base.py

@@ -10,11 +10,12 @@ from telegram.ext import (
 )
 
 from agent.tools.text_summary import ConversationSummary
+from agent.tools.conversation import Conversation
 
 SELECT_COMMAND, GET_TEXT = range(2)
 
 
-class LangChainAgentBot(ConversationSummary):
+class LangChainAgentBot(ConversationSummary,  Conversation):
     def is_verbose_logging_enabled(self):
         return True
 
@@ -39,8 +40,3 @@ class LangChainAgentBot(ConversationSummary):
         """Cancel the conversation."""
         await update.message.reply_text("Oops, glad to help you.")
         return ConversationHandler.END
-
-
-    async def create_response(self, update: Update, context: CallbackContext) -> None:
-        await update.message.chat.send_action(action=telegram.constants.ChatAction.TYPING)
-        await update.message.reply_text(update.message.text)

src/agent/tools/conversation.py

@@ -0,0 +1,43 @@
+import logging
+from telegram import Update
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+from telegram.ext import (
+    Updater,
+    CommandHandler,
+    ConversationHandler,
+    CallbackContext,
+    CallbackQueryHandler,
+    MessageHandler,
+    filters
+)
+
+NAME = "Conversation"
+
+DESCRIPTION = """
+Useful for building up conversation. 
+Input: A normal chat text
+Output: A text
+"""
+
+GET_CON = range(1)
+
+class Conversation():
+    tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-medium")
+    model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-medium")
+
+    async def talk(self, input: str):
+        logging.info(f"{input}")
+        new_user_input_ids = self.tokenizer.encode(input(f"{input}") + self.tokenizer.eos_token, return_tensors='pt')
+        bot_input_ids = torch.cat([chat_history_ids, new_user_input_ids], dim=-1)
+        chat_history_ids =self.model.generate(bot_input_ids, max_length=1000, pad_token_id=self.tokenizer.eos_token_id)
+        return "{}".format(self.tokenizer.decode(chat_history_ids[:, bot_input_ids.shape[-1]:][0], skip_special_tokens=True))
+
+    
+    async def process_conversation(self, update: Update, context: CallbackContext) -> int:
+        message = update.message.text
+        text = await self.talk(message)
+        await update.message.reply_text(f'{text}')
+
+    
+

src/agent/tools/text_summary.py

@@ -3,11 +3,9 @@ import logging
 import telegram
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 from telegram.ext import (
-    Updater,
     CommandHandler,
     ConversationHandler,
     CallbackContext,
-    CallbackQueryHandler,
     MessageHandler,
     filters
 )
@@ -33,19 +31,24 @@ class ConversationSummary():
 
     model = AutoModelForSeq2SeqLM.from_pretrained(
         "mrm8488/flan-t5-small-finetuned-samsum")
-
+    
+    # Method to summarize our comversation
     async def summarize(self, input: str, words: int):
         logging.info(f"{input} {words}")
         input_ids = self.tokenizer(input, return_tensors="pt").input_ids
         outputs = self.model.generate(input_ids, max_length=words)
         decoded_output = self.tokenizer.decode(
-            outputs[0], skip_special_tokens=True)
+            outputs[0], skip_special_tokens=True,
+        )
         return f"{decoded_output}"
 
     def conversation_summary_handler(self) -> ConversationHandler:
         handler = ConversationHandler(
-            entry_points=[CommandHandler(
-                "summary", self.conversation_summary)],
+            entry_points=[
+                CommandHandler(
+                    "summary", self.conversation_summary,
+                ),
+            ],
             states={
                 GET_TEXT: [MessageHandler(filters.TEXT & ~filters.COMMAND, self.process_conversation_summary)],
             },

src/api.py

@@ -7,24 +7,23 @@ from pydantic import Field
 from agent.base import LangChainAgentBot 
 from telegram.ext import Updater, CommandHandler, CallbackContext, Application, ContextTypes
 from telegram import Update
+from telegram.ext import (
+    CommandHandler,
+    ConversationHandler,
+    CallbackContext,
+    MessageHandler,
+    filters
+)
 
 
 VERBOSE = True
 
 
-class GirlFriendAIConfig():
-    elevenlabs_api_key: str = Field(
-        default="", description="Optional API KEY for ElevenLabs Voice Bot"
-    )
-    elevenlabs_voice_id: str = Field(
-        default="", description="Optional voice_id for ElevenLabs Voice Bot"
-    )
-
 async def hello(update: Update, context: CallbackContext) -> None:
     intro_text = f"🤖 Greetings human!🤗\nI'm a bot built by Rexthecoder\n🦾 I can do a lot of things"
     await update.message.reply_text(intro_text)
 
-class GirlfriendGPT(LangChainAgentBot):
+class GirlfriendGPT(LangChainAgentBot, ):
     """Deploy LangChain chatbots and connect them to Telegram."""
 
     token: str
@@ -40,33 +39,8 @@ class GirlfriendGPT(LangChainAgentBot):
     
     def handlers(self):
         summary_handler = self.conversation_summary_handler()
+        self.application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self.process_conversation))
         self.application.add_handler(summary_handler)
         self.application.add_handler(CommandHandler('start', hello))
-        self.application.run_polling()
-
-    # async def echo(self, update: Update, context: CallbackContext) -> None:
-    #     """Echo the user message."""
-    #     await update.message.reply_text(update.message.text)
 
-    # def voice_tool(self) -> Optional[Tool]:
-    #     """Return tool to generate spoken version of output text."""
-    #     # return None
-    #     return GenerateSpeechTool(
-    #         client=self.client,
-    #         voice_id=self.config.elevenlabs_voice_id,
-    #         elevenlabs_api_key=self.config.elevenlabs_api_key,
-    #     )
-
-    # def get_memory(self, chat_id):
-    #     if self.context and self.context.invocable_instance_handle:
-    #         my_instance_handle = self.context.invocable_instance_handle
-    #     else:
-    #         my_instance_handle = "local-instance-handle"
-    #     memory = ConversationBufferMemory(
-    #         memory_key="chat_history",
-    #         chat_memory=ChatMessageHistory(
-    #             client=self.client, key=f"history-{chat_id}-{my_instance_handle}"
-    #         ),
-    #         return_messages=True,
-    #     )
-    #     return memory
+        self.application.run_polling()