Upload main.py with huggingface_hub

main.py

@@ -0,0 +1,154 @@
+
+import os
+import signal
+import logging
+import threading
+import asyncio
+import time
+from fastapi import FastAPI
+import uvicorn
+from telegram import Update
+from telegram.ext import ApplicationBuilder, ContextTypes, MessageHandler, filters
+from telegram.request import HTTPXRequest
+from brain.ops_brain import OpsManagerAI
+from brain.db_handler import StoreDB
+
+# --- Configuration ---
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+def get_required_env(var_name: str) -> str:
+    """Fetch a required environment variable or raise a clear error."""
+    value = os.getenv(var_name)
+    if not value or not value.strip():
+        raise RuntimeError(
+            f"Missing required environment variable: '{var_name}'. "
+            f"Please set it in your Secrets/Environment settings."
+        )
+    return value
+
+# Load secrets
+TELEGRAM_TOKEN = get_required_env("TELEGRAM_TOKEN")
+GROQ_API_KEY   = get_required_env("GROQ_API_KEY")
+SUPABASE_URL   = get_required_env("SUPABASE_URL")
+SUPABASE_KEY   = get_required_env("SUPABASE_KEY")
+
+# --- Initialize AI & DB ---
+def init_services():
+    try:
+        ai = OpsManagerAI(api_key=GROQ_API_KEY)
+        db = StoreDB(url=SUPABASE_URL, key=SUPABASE_KEY)
+        logger.info("AI and Database services initialized successfully.")
+        return ai, db
+    except Exception as e:
+        logger.critical(f"Service Initialization failed: {e}")
+        return None, None
+
+ai_manager, db = init_services()
+
+# --- Telegram Bot Logic ---
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    text = update.message.text
+    if not text or not text.strip():
+        return
+
+    user = update.message.from_user
+    logger.info(f"Processing message from {user.first_name} (id={user.id}): {text}")
+
+    try:
+        if ai_manager is None or db is None:
+            raise RuntimeError("AI or Database services not initialized")
+
+        structured_data = ai_manager.process_telegram_message(text)
+
+        if not structured_data or not structured_data.get('store_id'):
+            logger.warning(f"AI could not extract a valid store_id from message: '{text}'")
+            await update.message.reply_text(
+                "⚠️ I couldn't extract a valid Store ID from your message. "
+                "Please make sure to mention the store location or ID in your report."
+            )
+            return
+
+        try:
+            db.save_report(structured_data)
+        except Exception as db_err:
+            logger.error(f"Database save failed: {db_err}")
+            await update.message.reply_text(
+                "❌ Critical Error: I analyzed your report, but the database rejected it.\n"
+                "The report has been queued locally, but it will NOT appear on the dashboard until the connection is fixed."
+            )
+            return
+
+        await update.message.reply_text(
+            f"✅ Report received for {structured_data.get('store_id', 'Unknown')}.\n"
+            f"Analysis: {structured_data.get('analysis', 'N/A')}\n"
+            f"Actions logged to Dashboard."
+        )
+
+    except Exception as e:
+        logger.error(f"Error in handler: {e}")
+        await update.message.reply_text(
+            "❌ Error processing report. Please ensure the format is correct."
+        )
+
+# --- HF Health Check Server ---
+app = FastAPI()
+
+@app.get("/")
+async def root():
+    bot_status = "Active" if ai_manager and db else "Degraded"
+    return {
+        "status": "Sovereign Ops Manager is Healthy",
+        "bot": bot_status
+    }
+
+# --- Unified Engine ---
+async def main():
+    stop_event = asyncio.Event()
+    
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        loop.add_signal_handler(sig, lambda: stop_event.set())
+
+    config = uvicorn.Config(app, host="0.0.0.0", port=7860, log_level="info")
+    server = uvicorn.Server(config)
+
+    server_task = asyncio.create_task(server.serve())
+    logger.info("HF Heartbeat Server initialized on port 7860.")
+    
+    await asyncio.sleep(1.0)
+
+    request_client = HTTPXRequest(
+        connect_timeout=20.0, read_timeout=20.0, write_timeout=20.0, pool_timeout=20.0
+    )
+    bot_app = (
+        ApplicationBuilder()
+        .token(TELEGRAM_TOKEN)
+        .request(request_client)
+        .build()
+    )
+    bot_app.add_handler(MessageHandler(filters.TEXT & (~filters.COMMAND), handle_message))
+
+    await bot_app.initialize()
+    await bot_app.start()
+    await bot_app.updater.start_polling()
+    logger.info("Sovereign Bot is LIVE and polling.")
+
+    await stop_event.wait()
+    
+    logger.info("Shutdown signal caught. Beginning cleanup...")
+    server.should_exit = True
+    await server_task
+    await bot_app.updater.stop()
+    await bot_app.stop()
+    await bot_app.shutdown()
+    logger.info("All services shut down gracefully.")
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass