Update main.py

main.py

@@ -1,25 +1,36 @@
 import os
 import logging
 import asyncio
+import socket  # <--- Importante para a correção
 from datetime import datetime
 from telegram import Update
 from telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler, MessageHandler, filters
-from telegram.request import HTTPXRequest # Importante para consertar o erro de rede
+from telegram.request import HTTPXRequest
 
-# Tenta carregar variáveis locais (útil se você testar no PC)
+# --- CORREÇÃO DE REDE DA BERTA (MONKEY PATCH) ---
+# Isso obriga o Python a usar apenas IPv4 (o endereço antigo da internet).
+# Resolve o erro [Errno -5] no Hugging Face.
+original_getaddrinfo = socket.getaddrinfo
+
+def ipv4_only_getaddrinfo(*args, **kwargs):
+    responses = original_getaddrinfo(*args, **kwargs)
+    return [res for res in responses if res[0] == socket.AF_INET]
+
+socket.getaddrinfo = ipv4_only_getaddrinfo
+# ------------------------------------------------
+
+# Tenta carregar variáveis locais
 try:
     from dotenv import load_dotenv
     load_dotenv()
 except ImportError:
     pass
 
-# --- IMPORTS CORRIGIDOS (SEM PONTO) ---
-# Se ainda der erro no core.py, lembre de remover o ponto lá também!
+# Imports com fallback
 try:
     from core import TelegramJadeAgent
     from tools import ReminderManager
 except ImportError:
-    # Fallback caso a estrutura de pastas mude
     import sys
     sys.path.append(os.path.dirname(os.path.abspath(__file__)))
     from core import TelegramJadeAgent
@@ -32,8 +43,6 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Global instances
-# Inicializa o gerenciador de lembretes e o agente
 reminder_manager = ReminderManager()
 agent = TelegramJadeAgent(reminder_manager=reminder_manager)
 
@@ -43,106 +52,63 @@ async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
 async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
     chat_id = update.effective_chat.id
     user_text = update.message.text
-    
-    # Envia "Digitando..." para o usuário saber que estamos processando
     await context.bot.send_chat_action(chat_id=chat_id, action="typing")
-    
-    # Chama o agente em uma thread separada para não travar o bot
     response = await asyncio.to_thread(agent.chat, chat_id, user_text)
-    
     await context.bot.send_message(chat_id=chat_id, text=response)
 
 async def send_reminder_job(context: ContextTypes.DEFAULT_TYPE):
-    """Callback function for the scheduled job."""
     job_data = context.job.data
     chat_id = job_data["chat_id"]
     reminder_message = job_data["message"]
     reminder_id = job_data["id"]
     
-    # Check if reminder is still valid (not deleted)
     current_reminders = reminder_manager.get_due_reminders()
-    # Verifica se o ID ainda existe na lista de pendentes
     exists = False
-    for r in current_reminders: # Recarrega para ter certeza
+    for r in current_reminders:
         if r["id"] == reminder_id:
             exists = True
             break
             
     if not exists:
-        logger.info(f"Reminder {reminder_id} skipped (deleted or sent).")
         return
 
-    logger.info(f"Triggering reminder {reminder_id} for chat {chat_id}")
-    
-    # Generate message via Agent
     text = await asyncio.to_thread(agent.generate_reminder_message, chat_id, reminder_message)
-    
     await context.bot.send_message(chat_id=chat_id, text=text)
-    
-    # Mark as sent
     reminder_manager.mark_as_sent(reminder_id)
 
 async def check_reminders_loop(context: ContextTypes.DEFAULT_TYPE):
-    """
-    Background task running every X seconds to check for new reminders in DB
-    and schedule them in the JobQueue.
-    """
-    # Recarrega lembretes do arquivo
     reminder_manager._load_reminders()
     pending = [r for r in reminder_manager.reminders if r["status"] == "pending"]
-    
     job_queue = context.job_queue
-    
-    # Get current scheduled jobs by name
     current_jobs = [j.name for j in job_queue.jobs()]
     
     for r in pending:
         job_name = f"reminder_{r['id']}"
-        # Se o job ainda não está na fila, agende
         if job_name not in current_jobs:
             try:
                 run_date = datetime.strptime(r["time"], "%Y-%m-%d %H:%M:%S")
-                
-                # Se for passado, agenda para agora
                 if run_date < datetime.now():
                     run_date = datetime.now()
-                    
-                # Só agenda se não for muito no passado (opcional, mas evita spam de velhos)
-                # Aqui agendamos apenas uma vez
-                job_queue.run_once(
-                    send_reminder_job, 
-                    when=run_date, 
-                    data=r, 
-                    name=job_name
-                )
-                logger.info(f"Scheduled {job_name} for {run_date}")
+                job_queue.run_once(send_reminder_job, when=run_date, data=r, name=job_name)
             except Exception as e:
                 logger.error(f"Failed to schedule {job_name}: {e}")
 
 if __name__ == '__main__':
-    # Verifica o Token
     token = os.getenv("TELEGRAM_BOT_TOKEN")
     if not token:
-        logger.error("Error: TELEGRAM_BOT_TOKEN not found in environment variables.")
+        logger.error("Error: TELEGRAM_BOT_TOKEN not found.")
         exit(1)
         
-    # --- CONFIGURAÇÃO DE REDE BLINDADA PARA HUGGING FACE ---
-    # Força HTTP/1.1 e aumenta timeouts para evitar desconexões
+    # Mantemos a requisição robusta HTTP/1.1 junto com o patch IPv4
     req = HTTPXRequest(connection_pool_size=8, http_version="1.1", read_timeout=20, write_timeout=20)
     
     application = ApplicationBuilder().token(token).request(req).build()
     
-    start_handler = CommandHandler('start', start)
-    msg_handler = MessageHandler(filters.TEXT & (~filters.COMMAND), handle_message)
-    
-    application.add_handler(start_handler)
-    application.add_handler(msg_handler)
+    application.add_handler(CommandHandler('start', start))
+    application.add_handler(MessageHandler(filters.TEXT & (~filters.COMMAND), handle_message))
     
-    # Verifica lembretes a cada 10 segundos
     if application.job_queue:
         application.job_queue.run_repeating(check_reminders_loop, interval=10, first=1)
     
     print("Jade Telegram Bot is running...")
-    
-    # drop_pending_updates=True limpa mensagens velhas ao reiniciar para não travar
     application.run_polling(drop_pending_updates=True)