| """
|
| Professional Telegram Bot for Climate-Resilient Agriculture
|
| ============================================================
|
| Real-time notifications, farmer dashboard, and interactive commands
|
| """
|
|
|
| import json
|
| import logging
|
| import asyncio
|
| import os
|
| import sys
|
| from datetime import datetime, timedelta
|
| from typing import Optional, Dict, Any
|
| from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
|
| from telegram.ext import Application, CommandHandler, CallbackQueryHandler, ContextTypes
|
| from telegram.constants import ParseMode, ChatAction
|
| from farm_controller import run_farm_dashboard
|
| from database import db
|
|
|
|
|
| if sys.platform == "win32":
|
| import io
|
| try:
|
| if hasattr(sys.stdout, 'reconfigure'):
|
| sys.stdout.reconfigure(encoding='utf-8')
|
| if hasattr(sys.stderr, 'reconfigure'):
|
| sys.stderr.reconfigure(encoding='utf-8')
|
| except (AttributeError, io.UnsupportedOperation):
|
| if hasattr(sys.stdout, 'buffer'):
|
| sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
|
| if hasattr(sys.stderr, 'buffer'):
|
| sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
|
|
|
|
|
| logger = logging.getLogger("TelegramBot")
|
|
|
|
|
| TOKEN: str = os.getenv("TELEGRAM_BOT_TOKEN", "8589326773:AAERc6eyATYmb8-Dr9yttiDKK9LJGa47-0M")
|
| if os.getenv("TELEGRAM_BOT_TOKEN"):
|
| logger.info("✅ TELEGRAM_BOT_TOKEN loaded from environment variable")
|
| else:
|
| logger.warning("⚠️ TELEGRAM_BOT_TOKEN not in env, using hardcoded fallback token")
|
|
|
|
|
|
|
|
|
| WEATHER_API_URL = os.getenv("WEATHER_API_URL", "http://localhost:8001/weather")
|
| PEST_API_URL = os.getenv("PEST_API_URL", "http://localhost:8000/api/predict")
|
| WATER_API_URL = os.getenv("WATER_API_URL", "http://localhost:8002/predict")
|
|
|
|
|
|
|
|
|
|
|
| class DashboardCache:
|
| """Fast in-memory cache with TTL (Time-To-Live)"""
|
| def __init__(self, ttl_seconds: int = 120):
|
| self.data: Dict[str, Any] = {}
|
| self.timestamp: Dict[str, datetime] = {}
|
| self.ttl = ttl_seconds
|
|
|
| def get(self) -> Optional[Dict[str, Any]]:
|
| """Get cached dashboard data if available and not expired"""
|
| if "dashboard" in self.data:
|
| age = (datetime.now() - self.timestamp["dashboard"]).total_seconds()
|
| if age < self.ttl:
|
| logger.debug(f"✅ Cache HIT (age: {age:.1f}s)")
|
| return self.data["dashboard"]
|
| return None
|
|
|
| def set(self, data: Dict[str, Any]) -> None:
|
| """Cache dashboard data with timestamp"""
|
| self.data["dashboard"] = data
|
| self.timestamp["dashboard"] = datetime.now()
|
| logger.debug("💾 Dashboard cached")
|
|
|
| def clear(self) -> None:
|
| """Clear cache"""
|
| self.data.clear()
|
| self.timestamp.clear()
|
|
|
| dashboard_cache = DashboardCache(ttl_seconds=120)
|
|
|
| async def get_dashboard_data() -> Dict[str, Any]:
|
| """Get dashboard data with intelligent caching"""
|
|
|
| cached = dashboard_cache.get()
|
| if cached:
|
| return cached
|
|
|
|
|
| try:
|
| dashboard_data = await run_farm_dashboard()
|
| dashboard_cache.set(dashboard_data)
|
| return dashboard_data
|
| except Exception as e:
|
| logger.error(f"Dashboard fetch error: {e}")
|
| return {}
|
|
|
|
|
|
|
|
|
|
|
| async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
| """Bot startup - Show main dashboard (OPTIMIZED)"""
|
| user = update.effective_user
|
| chat_id = update.effective_chat.id
|
|
|
|
|
| try:
|
| with open("user.json", "r") as f:
|
| farmer = json.load(f)
|
|
|
| asyncio.create_task(asyncio.to_thread(
|
| db.save_subscription,
|
| farmer.get("farmer_id", "DEFAULT"),
|
| str(chat_id)
|
| ))
|
| except:
|
| pass
|
|
|
|
|
| dashboard_data = await get_dashboard_data()
|
|
|
| farmer_profile = dashboard_data.get("farmer_profile", {})
|
| weather_intel = dashboard_data.get("weather_intelligence", {})
|
| alerts = dashboard_data.get("alerts", [])
|
|
|
|
|
| risk_score = 0
|
| for alert in alerts:
|
| if alert.get("severity") == "CRITICAL":
|
| risk_score += 35
|
| elif alert.get("severity") == "HIGH":
|
| risk_score += 20
|
| elif alert.get("severity") == "MEDIUM":
|
| risk_score += 10
|
| risk_score = min(100, risk_score)
|
| risk_level = "🟢 STABLE" if risk_score < 30 else "🟡 ALERT" if risk_score < 70 else "🔴 CRITICAL"
|
|
|
|
|
| welcome_text = f"""
|
| 🌾 <b>CLIMATE-RESILIENT FARM DASHBOARD</b> 🌾
|
| {'═' * 50}
|
|
|
| 👨🌾 <b>Farmer:</b> {farmer_profile.get('name', 'Unknown')}
|
| 📍 <b>Location:</b> {farmer_profile.get('village', 'N/A')}
|
| 🌱 <b>Crop:</b> {farmer_profile.get('crop_type', 'N/A')} | <b>Season:</b> {farmer_profile.get('season', 'N/A')}
|
| 📐 <b>Farm Size:</b> {farmer_profile.get('farm_size_hectares', 1.0)} Ha
|
|
|
| {'─' * 50}
|
| 📊 <b>CLIMATE RESILIENCE INDEX: {risk_score:.0f}/100</b>
|
| Status: <b>{risk_level}</b>
|
| Critical Alerts: <b>{len([a for a in alerts if a.get('severity') == 'CRITICAL'])}</b>
|
| High Priority: <b>{len([a for a in alerts if a.get('severity') == 'HIGH'])}</b>
|
|
|
| {'─' * 50}
|
| 🌡️ <b>CURRENT CONDITIONS:</b>
|
| Temp: <b>{weather_intel.get('current', {}).get('temp', 'N/A')}°C</b> | Humidity: <b>{weather_intel.get('current', {}).get('humidity', 'N/A')}%</b>
|
| Wind: <b>{weather_intel.get('current', {}).get('wind', 'N/A')} km/h</b>
|
| Condition: <b>{weather_intel.get('current', {}).get('desc', 'N/A')}</b>
|
|
|
| {'─' * 50}
|
|
|
| <i>Select an option below for detailed information:</i>
|
| """
|
|
|
| keyboard = [
|
| [
|
| InlineKeyboardButton("🔴 CRITICAL ALERTS", callback_data="critical_alerts"),
|
| InlineKeyboardButton("🌦️ WEATHER INTEL", callback_data="weather_detail")
|
| ],
|
| [
|
| InlineKeyboardButton("🐛 PEST MONITORING", callback_data="pest_detail"),
|
| InlineKeyboardButton("💧 WATER MANAGEMENT", callback_data="water_detail")
|
| ],
|
| [
|
| InlineKeyboardButton("📈 RESILIENCE SCORE", callback_data="resilience_score"),
|
| InlineKeyboardButton("🌍 SUSTAINABILITY", callback_data="sustainability")
|
| ],
|
| [
|
| InlineKeyboardButton("⚙️ SETTINGS", callback_data="settings"),
|
| InlineKeyboardButton("📞 SUPPORT", callback_data="support")
|
| ]
|
| ]
|
|
|
| await update.message.reply_html(
|
| welcome_text,
|
| reply_markup=InlineKeyboardMarkup(keyboard)
|
| )
|
|
|
| logger.info(f"✅ Dashboard sent to {user.first_name} (Chat ID: {chat_id})")
|
|
|
|
|
|
|
|
|
|
|
| async def button_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
| """Handle inline button clicks (OPTIMIZED - no API calls)"""
|
| query = update.callback_query
|
| await query.answer()
|
|
|
| action = query.data
|
|
|
|
|
| dashboard_data = await get_dashboard_data()
|
|
|
| weather_intel = dashboard_data.get("weather_intelligence", {})
|
| pest_intel = dashboard_data.get("pest_intelligence", {})
|
| water_intel = dashboard_data.get("water_intelligence", {})
|
| alerts = dashboard_data.get("alerts", [])
|
|
|
|
|
| if action == "critical_alerts":
|
| critical_alerts: list[dict] = [a for a in alerts if a.get("severity") in ["CRITICAL", "HIGH"]]
|
|
|
| if not critical_alerts:
|
| text = "✅ <b>NO CRITICAL ALERTS</b>\n\nFarm conditions are stable. Continue monitoring."
|
| else:
|
| text = "🔴 <b>CRITICAL & HIGH PRIORITY ALERTS</b>\n\n"
|
| for idx, alert in enumerate(critical_alerts[:5], 1):
|
| severity_icon = "🔴" if alert.get("severity") == "CRITICAL" else "🟠"
|
| text += f"\n{severity_icon} <b>{alert.get('title', 'Alert')} (ID: {alert.get('id', 'N/A')})</b>\n"
|
| text += f"Message: {alert.get('message', 'N/A')}\n"
|
|
|
| if alert.get("action_items"):
|
| text += "<b>Action Items:</b>\n"
|
| for item in alert.get("action_items", [])[:3]:
|
| text += f" • {item}\n"
|
| text += "\n"
|
|
|
| keyboard = [[InlineKeyboardButton("⬅️ Back", callback_data="back_main")]]
|
| await query.edit_message_text(text, parse_mode=ParseMode.HTML, reply_markup=InlineKeyboardMarkup(keyboard))
|
|
|
|
|
| elif action == "weather_detail":
|
| current = weather_intel.get("current", {})
|
| forecast = weather_intel.get("forecast", [])
|
|
|
| text = f"""
|
| 🌦️ <b>DETAILED WEATHER INTELLIGENCE</b>
|
|
|
| <b>🌡️ CURRENT CONDITIONS:</b>
|
| Temperature: <b>{current.get('temp', 'N/A')}°C</b>
|
| Humidity: <b>{current.get('humidity', 'N/A')}%</b>
|
| Wind Speed: <b>{current.get('wind', 'N/A')} km/h</b>
|
| Condition: <b>{current.get('desc', 'N/A')}</b>
|
| Last Updated: <b>{current.get('updated', 'N/A')}</b>
|
|
|
| <b>📅 7-DAY FORECAST:</b>
|
| """
|
| for day in forecast[:7]:
|
| text += f"\n<b>{day.get('day_name', 'N/A')}:</b> "
|
| text += f"{day.get('temp_min', 'N/A')}°C - {day.get('temp_max', 'N/A')}°C | "
|
| text += f"{day.get('description', 'N/A')}"
|
|
|
| text += f"\n\n<b>🎯 RECOMMENDATION:</b>\n"
|
| text += f"{weather_intel.get('ai_recommendations', 'Monitor weather conditions regularly.')}"
|
|
|
| keyboard = [[InlineKeyboardButton("⬅️ Back", callback_data="back_main")]]
|
| await query.edit_message_text(text, parse_mode=ParseMode.HTML, reply_markup=InlineKeyboardMarkup(keyboard))
|
|
|
|
|
| elif action == "pest_detail":
|
| pest_table = pest_intel.get("pest_prediction_table", [])
|
|
|
| text = "🐛 <b>PEST & DISEASE MONITORING</b>\n\n"
|
|
|
| if not pest_table:
|
| text += "✅ <b>No significant pests predicted</b>\n\nContinue preventive measures."
|
| else:
|
| for pest in pest_table[:5]:
|
| severity_icon = "🔴" if pest.get("severity", "").upper() == "CRITICAL" else "🟡" if pest.get("severity", "").upper() == "HIGH" else "🟢"
|
| text += f"{severity_icon} <b>{pest.get('pest_name', 'Unknown')}</b>\n"
|
| text += f" Severity: <b>{pest.get('severity', 'N/A')}</b>\n"
|
| text += f" Confidence: <b>{pest.get('confidence', 'N/A')}%</b>\n"
|
| text += f" Action: {pest.get('action', 'Monitor crop regularly')}\n\n"
|
|
|
| keyboard = [[InlineKeyboardButton("⬅️ Back", callback_data="back_main")]]
|
| await query.edit_message_text(text, parse_mode=ParseMode.HTML, reply_markup=InlineKeyboardMarkup(keyboard))
|
|
|
|
|
| elif action == "water_detail":
|
| water = water_intel.get("water_m3_sqm", 0)
|
| irrigation_mins = water_intel.get("irrigation_minutes", 0)
|
|
|
| text = f"""
|
| 💧 <b>IRRIGATION & WATER MANAGEMENT</b>
|
|
|
| <b>📊 WATER REQUIREMENTS:</b>
|
| Water Needed: <b>{water:.4f} m³/m²</b>
|
| Irrigation Duration: <b>{irrigation_mins:.1f} minutes</b>
|
| Weather Condition: <b>{water_intel.get('weather', {}).get('cond', 'N/A')}</b>
|
| Temperature: <b>{water_intel.get('weather', {}).get('temp', 'N/A')}°C</b>
|
|
|
| <b>💡 RECOMMENDATIONS:</b>
|
| • Irrigate using <b>drip irrigation</b> for 50% water savings
|
| • Best time: <b>5-7 AM</b> or <b>6-8 PM</b> (minimal evaporation)
|
| • Apply mulch to reduce water loss by 30-40%
|
| • Monitor soil moisture with meter
|
|
|
| <b>🌱 OPTIMAL SCHEDULE:</b>
|
| • Morning irrigation: 5-7 AM
|
| • Evening irrigation: 6-8 PM
|
| • Avoid midday (high evaporation)
|
| """
|
|
|
| keyboard = [[InlineKeyboardButton("⬅️ Back", callback_data="back_main")]]
|
| await query.edit_message_text(text, parse_mode=ParseMode.HTML, reply_markup=InlineKeyboardMarkup(keyboard))
|
|
|
|
|
| elif action == "resilience_score":
|
| critical_days = weather_intel.get("critical_days", [])
|
| warning_days = weather_intel.get("warning_days", [])
|
|
|
| risk_score = len(critical_days) * 25 + len(warning_days) * 15
|
| risk_score = min(100, risk_score)
|
| resilience_level = "🟢 GREEN" if risk_score < 30 else "🟡 YELLOW" if risk_score < 70 else "🔴 RED"
|
|
|
| text = f"""
|
| 📈 <b>CLIMATE RESILIENCE INDEX: {risk_score:.0f}/100</b>
|
| Status: <b>{resilience_level}</b>
|
|
|
| <b>🔍 RISK ANALYSIS:</b>
|
| Critical Weather Days: <b>{len(critical_days)}</b>
|
| Warning Days: <b>{len(warning_days)}</b>
|
|
|
| <b>🛡️ RESILIENCE STRATEGIES:</b>
|
| 1. <b>Diversify Crops:</b> Reduces single pest risk by 40%
|
| 2. <b>Mulching:</b> Reduces water loss 30-40%
|
| 3. <b>Intercropping:</b> Fixes nitrogen naturally
|
| 4. <b>Windbreaks:</b> Protects against extreme wind
|
| 5. <b>Drip Irrigation:</b> Saves 50% water vs. flood irrigation
|
| 6. <b>Soil Testing:</b> Optimize fertilizer use
|
|
|
| <b>📊 NEXT ACTIONS:</b>
|
| • Implement at least 2 strategies this month
|
| • Monitor soil health monthly
|
| • Update crop rotation annually
|
| """
|
|
|
| keyboard = [[InlineKeyboardButton("⬅️ Back", callback_data="back_main")]]
|
| await query.edit_message_text(text, parse_mode=ParseMode.HTML, reply_markup=InlineKeyboardMarkup(keyboard))
|
|
|
|
|
| elif action == "sustainability":
|
| text = """
|
| 🌍 <b>SUSTAINABLE AGRICULTURE PRACTICES</b>
|
|
|
| <b>💧 WATER CONSERVATION:</b>
|
| ✓ Mulching: Reduce evaporation 30-40%
|
| ✓ Drip Irrigation: Save 50% water vs. flood
|
| ✓ Rainwater Harvesting: Capture monsoon excess
|
| ✓ Early morning irrigation: Minimize evaporation
|
|
|
| <b>🌱 SOIL HEALTH:</b>
|
| ✓ Intercropping with legumes: Fix nitrogen naturally
|
| ✓ Crop rotation: Prevent soil depletion
|
| ✓ Compost: Make from crop residue (don't burn)
|
| ✓ No-till farming: Preserve soil structure
|
|
|
| <b>🐛 PEST MANAGEMENT:</b>
|
| ✓ Beneficial insects: Ladybugs, parasitoid wasps
|
| ✓ Biopesticides: Neem oil over synthetic chemicals
|
| ✓ Crop monitoring: Scout weekly for pests
|
| ✓ Companion planting: Marigolds, mint deter pests
|
|
|
| <b>♻️ CIRCULAR BIOECONOMY:</b>
|
| ✓ Crop residue composting
|
| ✓ Biogas from farm waste
|
| ✓ Integrated livestock farming
|
| ✓ On-farm seed saving
|
|
|
| <b>🔋 RENEWABLE ENERGY:</b>
|
| ✓ Solar pumps: 0 fuel cost, reliable
|
| ✓ Biogas generators: Waste → Energy
|
| ✓ Wind power: If available in region
|
|
|
| <b>💰 ECONOMIC BENEFITS:</b>
|
| • 30-40% reduction in input costs
|
| • 15-20% yield increase with soil health
|
| • Premium market prices for organic/sustainable
|
| • Government subsidies for green agriculture
|
| """
|
|
|
| keyboard = [[InlineKeyboardButton("⬅️ Back", callback_data="back_main")]]
|
| await query.edit_message_text(text, parse_mode=ParseMode.HTML, reply_markup=InlineKeyboardMarkup(keyboard))
|
|
|
|
|
| elif action == "settings":
|
| text = """
|
| ⚙️ <b>SETTINGS & PREFERENCES</b>
|
|
|
| 📱 <b>CURRENT CONFIGURATION:</b>
|
| • Bot Status: <b>ACTIVE</b>
|
| • Alert Frequency: <b>REAL-TIME</b>
|
| • Weather Alerts: <b>ENABLED</b>
|
| • Pest Alerts: <b>ENABLED</b>
|
| • Water Alerts: <b>ENABLED</b>
|
|
|
| <b>📝 CUSTOMIZE (Coming Soon):</b>
|
| • Set alert thresholds
|
| • Choose notification times
|
| • Select alert types
|
| • Language preference
|
|
|
| <b>💡 TIPS:</b>
|
| • Check dashboard every morning
|
| • Respond to critical alerts within 1 hour
|
| • Keep your profile updated
|
| • Share feedback to improve alerts
|
| """
|
|
|
| keyboard = [
|
| [InlineKeyboardButton("🔔 Alert Settings", callback_data="alert_settings")],
|
| [InlineKeyboardButton("📍 Location", callback_data="location_settings")],
|
| [InlineKeyboardButton("⬅️ Back", callback_data="back_main")]
|
| ]
|
| await query.edit_message_text(text, parse_mode=ParseMode.HTML, reply_markup=InlineKeyboardMarkup(keyboard))
|
|
|
|
|
| elif action == "support":
|
| text = """
|
| 📞 <b>SUPPORT & RESOURCES</b>
|
|
|
| <b>❓ FREQUENTLY ASKED QUESTIONS:</b>
|
|
|
| <b>Q: When should I irrigate?</b>
|
| A: Early morning (5-7 AM) or evening (6-8 PM) when evaporation is low.
|
|
|
| <b>Q: How do I reduce water usage?</b>
|
| A: Use drip irrigation, mulching, and monitor rainfall to skip irrigation.
|
|
|
| <b>Q: What does High Pest Risk mean?</b>
|
| A: Conditions are favorable for pest reproduction. Scout crops and spray if needed.
|
|
|
| <b>Q: How often should I update my profile?</b>
|
| A: Update crop age monthly and location if you change fields.
|
|
|
| <b>📚 USEFUL RESOURCES:</b>
|
| • Agritech Documentation
|
| • Pest Management Guidelines
|
| • Sustainable Farming Manual
|
| • Government Agricultural Schemes
|
|
|
| <b>🎯 EMERGENCY CONTACTS:</b>
|
| • Agricultural Officer: +91-XX-XXXXX
|
| • Extension Services: AGRI-HELPLINE
|
| • Pest Control Hotline: PEST-HOTLINE
|
|
|
| <b>💬 FEEDBACK:</b>
|
| Have suggestions? Reply to any message with "feedback"
|
| """
|
|
|
| keyboard = [[InlineKeyboardButton("⬅️ Back", callback_data="back_main")]]
|
| await query.edit_message_text(text, parse_mode=ParseMode.HTML, reply_markup=InlineKeyboardMarkup(keyboard))
|
|
|
|
|
| elif action == "back_main":
|
|
|
| dashboard_data = await get_dashboard_data()
|
|
|
| farmer_profile = dashboard_data.get("farmer_profile", {})
|
| weather_intel = dashboard_data.get("weather_intelligence", {})
|
| alerts = dashboard_data.get("alerts", [])
|
|
|
| risk_score = 0
|
| for alert in alerts:
|
| if alert.get("severity") == "CRITICAL":
|
| risk_score += 35
|
| elif alert.get("severity") == "HIGH":
|
| risk_score += 20
|
| elif alert.get("severity") == "MEDIUM":
|
| risk_score += 10
|
| risk_score = min(100, risk_score)
|
| risk_level = "🟢 STABLE" if risk_score < 30 else "🟡 ALERT" if risk_score < 70 else "🔴 CRITICAL"
|
|
|
| welcome_text = f"""
|
| 🌾 <b>CLIMATE-RESILIENT FARM DASHBOARD</b> 🌾
|
| {'═' * 50}
|
|
|
| 👨🌾 <b>Farmer:</b> {farmer_profile.get('name', 'Unknown')}
|
| 📍 <b>Location:</b> {farmer_profile.get('village', 'N/A')}
|
| 🌱 <b>Crop:</b> {farmer_profile.get('crop_type', 'N/A')} | <b>Season:</b> {farmer_profile.get('season', 'N/A')}
|
| 📐 <b>Farm Size:</b> {farmer_profile.get('farm_size_hectares', 1.0)} Ha
|
|
|
| {'─' * 50}
|
| 📊 <b>CLIMATE RESILIENCE INDEX: {risk_score:.0f}/100</b>
|
| Status: <b>{risk_level}</b>
|
| Critical Alerts: <b>{len([a for a in alerts if a.get('severity') == 'CRITICAL'])}</b>
|
| High Priority: <b>{len([a for a in alerts if a.get('severity') == 'HIGH'])}</b>
|
|
|
| {'─' * 50}
|
| 🌡️ <b>CURRENT CONDITIONS:</b>
|
| Temp: <b>{weather_intel.get('current', {}).get('temp', 'N/A')}°C</b> | Humidity: <b>{weather_intel.get('current', {}).get('humidity', 'N/A')}%</b>
|
| Wind: <b>{weather_intel.get('current', {}).get('wind', 'N/A')} km/h</b>
|
| Condition: <b>{weather_intel.get('current', {}).get('desc', 'N/A')}</b>
|
|
|
| {'─' * 50}
|
|
|
| <i>Select an option below for detailed information:</i>
|
| """
|
|
|
| keyboard = [
|
| [
|
| InlineKeyboardButton("🔴 CRITICAL ALERTS", callback_data="critical_alerts"),
|
| InlineKeyboardButton("🌦️ WEATHER INTEL", callback_data="weather_detail")
|
| ],
|
| [
|
| InlineKeyboardButton("🐛 PEST MONITORING", callback_data="pest_detail"),
|
| InlineKeyboardButton("💧 WATER MANAGEMENT", callback_data="water_detail")
|
| ],
|
| [
|
| InlineKeyboardButton("📈 RESILIENCE SCORE", callback_data="resilience_score"),
|
| InlineKeyboardButton("🌍 SUSTAINABILITY", callback_data="sustainability")
|
| ],
|
| [
|
| InlineKeyboardButton("⚙️ SETTINGS", callback_data="settings"),
|
| InlineKeyboardButton("📞 SUPPORT", callback_data="support")
|
| ]
|
| ]
|
|
|
| await query.edit_message_text(welcome_text, parse_mode=ParseMode.HTML, reply_markup=InlineKeyboardMarkup(keyboard))
|
|
|
|
|
|
|
|
|
|
|
| async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
| """Show help information"""
|
| help_text = """
|
| 🤖 <b>BOT COMMANDS:</b>
|
|
|
| /start - Show main dashboard
|
| /help - Show this help message
|
| /alerts - Get current alerts
|
| /weather - Quick weather check
|
| /water - Irrigation status
|
| /pest - Pest monitoring
|
| /farm - Farm profile
|
| /feedback - Send feedback
|
|
|
| <b>💡 TIPS:</b>
|
| • Use inline buttons for quick navigation
|
| • Check alerts at least twice daily
|
| • Act on CRITICAL alerts within 1 hour
|
| • Share this bot with neighboring farmers
|
| """
|
|
|
| await update.message.reply_html(help_text)
|
|
|
| async def alerts_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
| """Quick alerts summary (OPTIMIZED)"""
|
| dashboard_data = await get_dashboard_data()
|
| alerts = dashboard_data.get("alerts", [])
|
|
|
| if not alerts:
|
| await update.message.reply_text("✅ No alerts at this time!")
|
| return
|
|
|
| text = "🚨 <b>CURRENT ALERTS SUMMARY:</b>\n\n"
|
|
|
| for alert in alerts[:10]:
|
| severity = alert.get("severity", "INFO")
|
| icon = "🔴" if severity == "CRITICAL" else "🟠" if severity == "HIGH" else "🟡" if severity == "MEDIUM" else "ℹ️"
|
| text += f"{icon} <b>{alert.get('title', 'Alert')}</b>\n"
|
| text += f" {alert.get('message', '')}\n\n"
|
|
|
| await update.message.reply_html(text)
|
|
|
| async def feedback_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
| """Feedback handler"""
|
| await update.message.reply_text(
|
| "📝 <b>FEEDBACK RECEIVED!</b>\n\n"
|
| "Thank you for your feedback. Our team will review and improve the bot.\n\n"
|
| "👉 Reply with your suggestions and we'll implement them!",
|
| parse_mode=ParseMode.HTML
|
| )
|
|
|
|
|
|
|
|
|
|
|
| async def send_daily_alerts(context: ContextTypes.DEFAULT_TYPE):
|
| """Send daily alerts to all subscribed farmers (OPTIMIZED)"""
|
| subscriptions = db.get_active_subscriptions()
|
| dashboard_data = await get_dashboard_data()
|
|
|
| critical_count = len([a for a in dashboard_data.get("alerts", []) if a.get("severity") == "CRITICAL"])
|
|
|
| for sub in subscriptions:
|
| chat_id = sub.get("telegram_chat_id")
|
| try:
|
|
|
| if critical_count > 0:
|
| await context.bot.send_message(
|
| chat_id,
|
| f"🚨 <b>CRITICAL ALERT DETECTED!</b>\n\n"
|
| f"You have <b>{critical_count}</b> critical alerts.\n"
|
| f"Use /start to view your dashboard immediately.",
|
| parse_mode=ParseMode.HTML
|
| )
|
| else:
|
| await context.bot.send_message(
|
| chat_id,
|
| "✅ <b>FARM STATUS NORMAL</b>\n\n"
|
| "All conditions are within safe parameters..\n"
|
| "Check dashboard with /start for full details.",
|
| parse_mode=ParseMode.HTML
|
| )
|
| except Exception as e:
|
| logger.debug(f"Alert delivery to {chat_id}: {e}")
|
|
|
|
|
|
|
|
|
|
|
| def main():
|
| """Start the bot (OPTIMIZED)"""
|
| app = Application.builder().token(TOKEN).build()
|
|
|
|
|
| app.add_handler(CommandHandler("start", start))
|
| app.add_handler(CommandHandler("help", help_command))
|
| app.add_handler(CommandHandler("alerts", alerts_command))
|
| app.add_handler(CommandHandler("feedback", feedback_command))
|
| app.add_handler(CallbackQueryHandler(button_handler))
|
|
|
|
|
| job_queue = app.job_queue
|
| job_queue.run_daily(send_daily_alerts, time=datetime.strptime("06:00", "%H:%M").time(), name="daily_alerts")
|
|
|
|
|
| async def refresh_cache(context):
|
| dashboard_cache.clear()
|
| await get_dashboard_data()
|
| logger.debug("🔄 Cache refreshed")
|
|
|
| job_queue.run_repeating(refresh_cache, interval=120, first=60, name="cache_refresh")
|
|
|
| logger.info("🤖 Climate-Resilient Agriculture Bot Started!")
|
| logger.info(f"✅ Dashboard caching enabled (2-min TTL)")
|
| logger.info(f"✅ Auto-cache refresh every 2 minutes")
|
|
|
| safe_token = str(TOKEN)[:20] if TOKEN else "MISSING"
|
| logger.info(f"Token: {safe_token}...")
|
|
|
|
|
|
|
| try:
|
| app.run_polling(allowed_updates=["message", "callback_query"], close_loop=False)
|
| except ValueError as e:
|
| if "add_signal_handler()" in str(e):
|
| logger.warning("⚠️ Running in non-main thread (Docker), using fallback polling")
|
|
|
| import asyncio
|
| try:
|
| loop = asyncio.get_running_loop()
|
| except RuntimeError:
|
| loop = asyncio.new_event_loop()
|
| asyncio.set_event_loop(loop)
|
|
|
| retry_count = 0
|
| max_retries = 3
|
| while retry_count < max_retries:
|
| try:
|
| loop.run_until_complete(app.initialize())
|
| loop.run_until_complete(app.start())
|
| logger.info("🤖 Bot polling started (non-signal mode)")
|
| try:
|
| loop.run_until_complete(app.updater.start_polling(allowed_updates=["message", "callback_query"]))
|
| except KeyboardInterrupt:
|
| pass
|
| finally:
|
| loop.run_until_complete(app.stop())
|
| break
|
| except Exception as init_error:
|
| retry_count += 1
|
| if retry_count >= max_retries:
|
| error_type = type(init_error).__name__
|
| logger.error(f"Bot initialization failed ({error_type})")
|
| logger.info("This is expected if there's no internet/network access.")
|
| logger.info("REST APIs will continue working without the Telegram bot.")
|
| raise
|
| wait_time = min(2 ** retry_count, 16)
|
| logger.warning(f"⚠️ Bot init failed (attempt {retry_count}/{max_retries}), retrying in {wait_time}s...")
|
| import time
|
| time.sleep(wait_time)
|
| else:
|
| raise
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
