Create main.py

main.py

@@ -0,0 +1,264 @@
+from pyrogram import Client, filters
+from config import API_ID, API_HASH, BOT_TOKEN, HUGGINGFACE_TOKEN
+import requests
+import os
+import asyncio
+import json
+from datetime import datetime
+
+# Add these constants at the top
+API_URL = "https://api-inference.huggingface.co/models/openai/whisper-large-v3-turbo"
+AI_URL = "https://charan5775-fastest.hf.space/t2t"
+AI_HEADERS = {
+    "Content-Type": "application/json",
+    "Accept": "application/json"
+}
+
+# Initialize message history in memory only
+message_history = []
+
+# Create a new Client instance with a custom session name and no local storage
+app = Client(
+    "my_bot",
+    api_id=API_ID,
+    api_hash=API_HASH,
+    bot_token=BOT_TOKEN,
+    in_memory=True  # This prevents SQLite database locks
+)
+
+def save_message_to_history(user_id, username, message_type, content, bot_response=None):
+    message_data = {
+        "content": content,
+        "response": bot_response
+    }
+    message_history.append(message_data)
+    print("Message History Update:", json.dumps(message_data, indent=2))
+
+# Add command to print history
+@app.on_message(filters.command("history"))
+async def history_command(client, message):
+    if not message_history:
+        await message.reply_text("No message history available.")
+        return
+    
+    try:
+        # Create a formatted message
+        history_text = "📜 Message History:\n\n"
+        for idx, msg in enumerate(message_history[-10:], 1):  # Show last 10 messages
+            history_text += f"{idx}. Message: {msg['content']}\n"
+            if msg['response']:
+                history_text += f"   Response: {msg['response']}\n"
+            history_text += "\n"
+        
+        await message.reply_text(history_text)
+        
+    except Exception as e:
+        await message.reply_text(f"Error retrieving history: {str(e)}")
+
+# Command handler for /start
+@app.on_message(filters.command("start"))
+async def start_command(client, message):
+    await message.reply_text("Hello! I'm your Telegram bot. Nice to meet you!")
+
+# Command handler for /help
+@app.on_message(filters.command("help"))
+async def help_command(client, message):
+    help_text = """
+Available commands:
+/start - Start the bot
+/help - Show this help message
+"""
+    await message.reply_text(help_text)
+
+# Message handler for regular text messages
+@app.on_message(filters.text & filters.private & ~filters.command(["start", "help", "info"]))
+async def echo(client, message):
+    try:
+        thinking_msg = await message.reply_text("🤔 Thinking about your message...")
+        ai_response = await get_ai_response(message.text)
+        await thinking_msg.delete()
+        await message.reply_text(ai_response)
+        
+        # Save message to history
+        save_message_to_history(
+            message.from_user.id,
+            message.from_user.username,
+            "text",
+            message.text,
+            ai_response
+        )
+    except Exception as e:
+        await message.reply_text(f"Sorry, I couldn't process your message: {str(e)}")
+
+# Handle photo messages
+@app.on_message(filters.photo)
+async def handle_photo(client, message):
+    response = "Nice photo!"
+    await message.reply_text(response)
+    save_message_to_history(
+        message.from_user.id,
+        message.from_user.username,
+        "photo",
+        "Photo message",
+        response
+    )
+
+# Handle sticker messages
+@app.on_message(filters.sticker)
+async def handle_sticker(client, message):
+    response = "Cool sticker!"
+    await message.reply_text(response)
+    save_message_to_history(
+        message.from_user.id,
+        message.from_user.username,
+        "sticker",
+        "Sticker message",
+        response
+    )
+
+# Custom command example
+@app.on_message(filters.command("info"))
+async def info_command(client, message):
+    user = message.from_user
+    info_text = f"""
+User Information:
+ID: {user.id}
+Name: {user.first_name}
+Username: @{user.username if user.username else 'None'}
+"""
+    await message.reply_text(info_text)
+
+# Add this function after your existing imports
+async def transcribe_audio(file_path):
+    try:
+        with open(file_path, "rb") as f:
+            data = f.read()
+        response = requests.post(API_URL, data=data)
+        return response.json().get('text', 'Could not transcribe audio')
+    except Exception as e:
+        print(f"Error in transcription: {e}")
+        return "Error transcribing audio"
+
+# Add this new function after transcribe_audio function
+async def get_ai_response(text):
+    try:
+        # Create condensed history from all messages
+        context = ""
+        if message_history:
+            # If we have more than 10 messages, summarize older ones
+            if len(message_history) > 10:
+                older_messages = message_history[:-10]
+                recent_messages = message_history[-10:]
+                
+                # Summarize older messages in pairs to save space
+                context = "Earlier conversation summary:\n"
+                for i in range(0, len(older_messages), 2):
+                    pair = older_messages[i:i+2]
+                    combined_content = " | ".join(msg['content'] for msg in pair)
+                    if len(combined_content) > 100:
+                        combined_content = combined_content[:100] + "..."
+                    context += f"Chat: {combined_content}\n"
+                
+                # Add a separator
+                context += "\nRecent conversation:\n"
+                
+                # Add recent messages in full detail
+                for msg in recent_messages:
+                    if msg['content'] and msg['response']:
+                        context += f"Human: {msg['content']}\nAssistant: {msg['response']}\n"
+            else:
+                # If less than 10 messages, include all in detail
+                context = "Conversation history:\n"
+                for msg in message_history:
+                    if msg['content'] and msg['response']:
+                        context += f"Human: {msg['content']}\nAssistant: {msg['response']}\n"
+        
+        # Combine context with current query
+        full_query = f"{context}Human: {text}"
+        
+        payload = {
+            "query": full_query,
+            "stream": False
+        }
+        
+        response = requests.post(AI_URL, json=payload)
+        print(f"Raw API Response: {response.text}")  # Debug print
+        
+        if response.status_code != 200:
+            print(f"API Error: Status {response.status_code}")
+            return f"Sorry, the AI service returned an error (Status {response.status_code})"
+            
+        response_data = response.json()
+        print(f"Parsed Response Data: {response_data}")  # Debug print
+        
+        # The API returns the response directly
+        if isinstance(response_data, dict) and 'response' in response_data:
+            return response_data['response']
+        else:
+            return str(response_data)
+            
+    except requests.exceptions.RequestException as e:
+        print(f"Network error: {e}")
+        return "Sorry, I'm having trouble connecting to the AI service."
+    except json.JSONDecodeError as e:
+        print(f"JSON parsing error: {e}\nResponse text: {response.text}")
+        return "Sorry, I received an invalid response from the AI service."
+    except Exception as e:
+        print(f"Error getting AI response: {str(e)}\nFull error: {repr(e)}")
+        return "Sorry, I couldn't process your message."
+
+# Update the voice message handler with retry logic
+@app.on_message(filters.voice | filters.audio)
+async def handle_voice(client, message):
+    try:
+        # Send a processing message
+        processing_msg = await message.reply_text("🎵 Processing your voice message...")
+        
+        # Download the voice message with retry logic
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                message = await app.get_messages(
+                    message.chat.id,
+                    message.id
+                )
+                voice_file = await message.download()
+                break
+            except Exception as e:
+                if attempt == max_retries - 1:
+                    raise e
+                await asyncio.sleep(1)
+        
+        transcription = await transcribe_audio(voice_file)
+        await message.reply_text(f"🗣️ Transcription:\n\n{transcription}")
+        
+        thinking_msg = await message.reply_text("🤔 Thinking about your message...")
+        ai_response = await get_ai_response(transcription)
+        await thinking_msg.delete()
+        await message.reply_text(ai_response)
+        
+        # Save voice message to history
+        save_message_to_history(
+            message.from_user.id,
+            message.from_user.username,
+            "voice",
+            transcription,
+            ai_response
+        )
+        
+        # Clean up
+        try:
+            os.remove(voice_file)
+            await processing_msg.delete()
+        except:
+            pass
+        
+    except Exception as e:
+        error_message = f"Sorry, there was an error processing your message: {str(e)}"
+        print(error_message)
+        await message.reply_text(error_message)
+
+# Run the bot
+if __name__ == "__main__":
+    print("Bot is running...")
+    app.run()