Spaces:
Sleeping
Sleeping
| """ | |
| SkyGuardian AI v2.0 – Multi-Model Agentic Flight Intelligence System | |
| India ⇄ Singapore Corridor | Primary: TRZ ⇄ SIN | Secondary: MAA ⇄ SIN | |
| Architecture: ReAct Agent + 4-Model Ensemble (Heuristic + sklearn RF/GB + HF Sentiment + Chronos Forecast) | |
| HuggingFace Models: ProsusAI/finbert (sentiment) · amazon/chronos-t5-tiny (time-series forecast) | |
| """ | |
| import os | |
| import sqlite3 | |
| import json | |
| import time | |
| import pickle | |
| import requests | |
| import math | |
| from dataclasses import dataclass, field | |
| from datetime import datetime, timedelta | |
| from typing import List, Optional, Tuple, Dict, Any, Callable | |
| from enum import Enum | |
| from dotenv import load_dotenv | |
| # Load environment variables from .env file | |
| load_dotenv() | |
| # ============================================================================ | |
| # LAYER 1 - DATA MODELS | |
| # ============================================================================ | |
| class FlightPrice: | |
| route: str | |
| price: float | |
| currency: str | |
| airline: str | |
| departure_time: str | |
| arrival_time: str | |
| duration_min: int | |
| stops: int | |
| provider: str | |
| deep_link: str | |
| flights_found: int | |
| value_score: float = field(init=False) | |
| def __post_init__(self): | |
| self.value_score = self.price + (self.stops * 1500) + max(0, self.duration_min - 300) * 2 | |
| class SurgeLevel(Enum): | |
| BELOW_AVERAGE = "BELOW_AVERAGE 💚" | |
| NORMAL = "NORMAL 🟢" | |
| ELEVATED = "ELEVATED 🟡" | |
| EXTREME = "EXTREME 🔴" | |
| class SurgeResult: | |
| level: SurgeLevel | |
| z_score: float | |
| current_price: float | |
| avg_price: float | |
| std_dev: float | |
| pct_vs_avg: float | |
| class ModelPrediction: | |
| model_name: str | |
| drop_probability: float | |
| drop_pct: float | |
| confidence: float | |
| reasoning: str | |
| class EnsemblePrediction: | |
| models: List["ModelPrediction"] | |
| final_drop_probability: float | |
| final_drop_pct: float | |
| final_confidence: float | |
| dominant_model: str | |
| explanation: str | |
| urgency: str | |
| class AgentStep: | |
| step_num: int | |
| thought: str | |
| action: str | |
| observation: str | |
| timestamp: str = field(default_factory=lambda: datetime.now().strftime("%H:%M:%S")) | |
| class AgentTrace: | |
| steps: List["AgentStep"] | |
| final_reasoning: str | |
| models_used: int | |
| duration_ms: int | |
| class ArbitrageResult: | |
| best_airport: str | |
| best_price: float | |
| domestic_cost: float | |
| total_cost: float | |
| savings: float | |
| worth_it: bool | |
| class ActionType(Enum): | |
| BOOK_NOW = "BOOK_NOW" | |
| WAIT_24H = "WAIT_24H" | |
| WAIT_WEEK = "WAIT_WEEK" | |
| TRY_NEARBY = "TRY_NEARBY" | |
| EMERGENCY_BOOK = "EMERGENCY_BOOK" | |
| class Urgency(Enum): | |
| LOW = "LOW" | |
| MEDIUM = "MEDIUM" | |
| HIGH = "HIGH" | |
| class Decision: | |
| action: ActionType | |
| urgency: Urgency | |
| explanation: str | |
| confidence_score: float = 0.0 | |
| arbitrage: Optional[ArbitrageResult] = None | |
| auto_book_triggered: bool = False | |
| telegram_sent: bool = False | |
| class BookingResult: | |
| success: bool | |
| screenshot_path: Optional[str] | |
| error: Optional[str] | |
| manual_instructions: str | |
| class PassengerProfile: | |
| full_name: str | |
| email: str | |
| phone: str | |
| class IntelligenceReport: | |
| flight: FlightPrice | |
| history_days: int | |
| rolling_avg: float | |
| std_dev: float | |
| trend_slope: float | |
| volatility: float | |
| surge: SurgeResult | |
| ensemble: EnsemblePrediction | |
| agent_trace: AgentTrace | |
| arbitrage: Optional[ArbitrageResult] | |
| decision: Decision | |
| booking: Optional[BookingResult] | |
| forecast_prices: List[float] = field(default_factory=list) | |
| sentiment_score: float = 0.5 | |
| # ============================================================================ | |
| # LAYER 2 - PRICE PROVIDERS | |
| # ============================================================================ | |
| class KiwiProvider: | |
| BASE_URL = "https://api.tequila.kiwi.com" | |
| def __init__(self, api_key: str): | |
| self.api_key = api_key | |
| self.headers = {"apikey": api_key} | |
| def search(self, origin: str, destination: str, departure_date: str, | |
| return_date: Optional[str], adults: int) -> List[FlightPrice]: | |
| if not self.api_key: | |
| return [] | |
| try: | |
| params = { | |
| "fly_from": origin, | |
| "fly_to": destination, | |
| "date_from": departure_date, | |
| "date_to": departure_date, | |
| "adults": adults, | |
| "curr": "INR", | |
| "limit": 50, | |
| "sort": "price" | |
| } | |
| if return_date: | |
| params["return_from"] = return_date | |
| params["return_to"] = return_date | |
| response = requests.get( | |
| f"{self.BASE_URL}/v2/search", | |
| headers=self.headers, | |
| params=params, | |
| timeout=15 | |
| ) | |
| if response.status_code != 200: | |
| return [] | |
| data = response.json() | |
| flights = [] | |
| for item in data.get("data", []): | |
| route_str = f"{item.get('flyFrom', origin)} → {item.get('flyTo', destination)}" | |
| if return_date: | |
| route_str += f" → {item.get('flyFrom', origin)}" | |
| flights.append(FlightPrice( | |
| route=route_str, | |
| price=float(item.get("price", 0)), | |
| currency="INR", | |
| airline=item.get("airlines", ["Unknown"])[0] if item.get("airlines") else "Unknown", | |
| departure_time=item.get("local_departure", ""), | |
| arrival_time=item.get("local_arrival", ""), | |
| duration_min=int(item.get("duration", {}).get("total", 0) / 60) if item.get("duration") else 0, | |
| stops=len(item.get("route", [])) - 1, | |
| provider="Kiwi", | |
| deep_link=item.get("deep_link", ""), | |
| flights_found=len(data.get("data", [])) | |
| )) | |
| return flights | |
| except Exception as e: | |
| print(f"Kiwi API error: {e}") | |
| return [] | |
| class AmadeusProvider: | |
| BASE_URL = "https://test.api.amadeus.com" | |
| def __init__(self, api_key: str, api_secret: str): | |
| self.api_key = api_key | |
| self.api_secret = api_secret | |
| self.token = None | |
| self.token_expiry = None | |
| def _get_token(self) -> bool: | |
| if not self.api_key or not self.api_secret: | |
| return False | |
| if self.token and self.token_expiry and datetime.now() < self.token_expiry: | |
| return True | |
| try: | |
| response = requests.post( | |
| f"{self.BASE_URL}/v1/security/oauth2/token", | |
| headers={"Content-Type": "application/x-www-form-urlencoded"}, | |
| data={ | |
| "grant_type": "client_credentials", | |
| "client_id": self.api_key, | |
| "client_secret": self.api_secret | |
| }, | |
| timeout=10 | |
| ) | |
| if response.status_code == 200: | |
| data = response.json() | |
| self.token = data.get("access_token") | |
| self.token_expiry = datetime.now() + timedelta(seconds=data.get("expires_in", 1800) - 60) | |
| return True | |
| return False | |
| except Exception as e: | |
| print(f"Amadeus auth error: {e}") | |
| return False | |
| def search(self, origin: str, destination: str, departure_date: str, | |
| return_date: Optional[str], adults: int) -> List[FlightPrice]: | |
| if not self._get_token(): | |
| return [] | |
| try: | |
| params = { | |
| "originLocationCode": origin, | |
| "destinationLocationCode": destination, | |
| "departureDate": departure_date, | |
| "adults": adults, | |
| "currencyCode": "INR", | |
| "max": 50 | |
| } | |
| if return_date: | |
| params["returnDate"] = return_date | |
| response = requests.get( | |
| f"{self.BASE_URL}/v2/shopping/flight-offers", | |
| headers={"Authorization": f"Bearer {self.token}"}, | |
| params=params, | |
| timeout=15 | |
| ) | |
| if response.status_code != 200: | |
| return [] | |
| data = response.json() | |
| flights = [] | |
| for offer in data.get("data", []): | |
| price = float(offer.get("price", {}).get("total", 0)) | |
| itineraries = offer.get("itineraries", []) | |
| if not itineraries: | |
| continue | |
| first_segment = itineraries[0].get("segments", [{}])[0] | |
| last_segment = itineraries[-1].get("segments", [{}])[-1] | |
| total_duration = sum( | |
| self._parse_duration(itin.get("duration", "PT0M")) | |
| for itin in itineraries | |
| ) | |
| total_stops = sum( | |
| len(itin.get("segments", [])) - 1 | |
| for itin in itineraries | |
| ) | |
| route_str = f"{origin} → {destination}" | |
| if return_date: | |
| route_str += f" → {origin}" | |
| flights.append(FlightPrice( | |
| route=route_str, | |
| price=price, | |
| currency="INR", | |
| airline=first_segment.get("carrierCode", "Unknown"), | |
| departure_time=first_segment.get("departure", {}).get("at", ""), | |
| arrival_time=last_segment.get("arrival", {}).get("at", ""), | |
| duration_min=total_duration, | |
| stops=total_stops, | |
| provider="Amadeus", | |
| deep_link="", | |
| flights_found=len(data.get("data", [])) | |
| )) | |
| return flights | |
| except Exception as e: | |
| print(f"Amadeus API error: {e}") | |
| return [] | |
| def _parse_duration(self, duration_str: str) -> int: | |
| try: | |
| duration_str = duration_str.replace("PT", "") | |
| hours = 0 | |
| minutes = 0 | |
| if "H" in duration_str: | |
| parts = duration_str.split("H") | |
| hours = int(parts[0]) | |
| duration_str = parts[1] if len(parts) > 1 else "" | |
| if "M" in duration_str: | |
| minutes = int(duration_str.replace("M", "")) | |
| return hours * 60 + minutes | |
| except: | |
| return 0 | |
| class PriceAggregator: | |
| def __init__(self, kiwi_key: str, amadeus_key: str, amadeus_secret: str): | |
| self.kiwi = KiwiProvider(kiwi_key) | |
| self.amadeus = AmadeusProvider(amadeus_key, amadeus_secret) | |
| def get_best_price(self, origin: str, destination: str, departure_date: str, | |
| return_date: Optional[str], adults: int) -> Optional[FlightPrice]: | |
| all_flights = [] | |
| kiwi_flights = self.kiwi.search(origin, destination, departure_date, return_date, adults) | |
| all_flights.extend(kiwi_flights) | |
| amadeus_flights = self.amadeus.search(origin, destination, departure_date, return_date, adults) | |
| all_flights.extend(amadeus_flights) | |
| if not all_flights: | |
| return None | |
| deduplicated = {} | |
| for flight in all_flights: | |
| key = (flight.airline, round(flight.price, -2), flight.stops) | |
| if key not in deduplicated or flight.value_score < deduplicated[key].value_score: | |
| deduplicated[key] = flight | |
| unique_flights = list(deduplicated.values()) | |
| unique_flights.sort(key=lambda f: f.value_score) | |
| return unique_flights[0] if unique_flights else None | |
| # ============================================================================ | |
| # LAYER 3 - HISTORICAL STORAGE | |
| # ============================================================================ | |
| class PriceLogger: | |
| def __init__(self, db_path: str): | |
| self.db_path = db_path | |
| self._init_db() | |
| def _init_db(self): | |
| conn = sqlite3.connect(self.db_path) | |
| cursor = conn.cursor() | |
| cursor.execute(""" | |
| CREATE TABLE IF NOT EXISTS price_logs ( | |
| id INTEGER PRIMARY KEY AUTOINCREMENT, | |
| timestamp TEXT NOT NULL, | |
| route TEXT NOT NULL, | |
| price REAL NOT NULL, | |
| currency TEXT NOT NULL, | |
| airline TEXT, | |
| duration_min INTEGER, | |
| stops INTEGER, | |
| provider TEXT, | |
| departure_date TEXT | |
| ) | |
| """) | |
| cursor.execute(""" | |
| CREATE TABLE IF NOT EXISTS bookings ( | |
| id INTEGER PRIMARY KEY AUTOINCREMENT, | |
| timestamp TEXT NOT NULL, | |
| route TEXT NOT NULL, | |
| price REAL NOT NULL, | |
| action TEXT NOT NULL, | |
| success INTEGER NOT NULL, | |
| details TEXT | |
| ) | |
| """) | |
| conn.commit() | |
| conn.close() | |
| def log_price(self, flight: FlightPrice, departure_date: str): | |
| conn = sqlite3.connect(self.db_path) | |
| cursor = conn.cursor() | |
| cursor.execute(""" | |
| INSERT INTO price_logs (timestamp, route, price, currency, airline, | |
| duration_min, stops, provider, departure_date) | |
| VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) | |
| """, ( | |
| datetime.now().isoformat(), | |
| flight.route, | |
| flight.price, | |
| flight.currency, | |
| flight.airline, | |
| flight.duration_min, | |
| flight.stops, | |
| flight.provider, | |
| departure_date | |
| )) | |
| conn.commit() | |
| conn.close() | |
| def log_booking(self, route: str, price: float, action: str, success: bool, details: str): | |
| conn = sqlite3.connect(self.db_path) | |
| cursor = conn.cursor() | |
| cursor.execute(""" | |
| INSERT INTO bookings (timestamp, route, price, action, success, details) | |
| VALUES (?, ?, ?, ?, ?, ?) | |
| """, ( | |
| datetime.now().isoformat(), | |
| route, | |
| price, | |
| action, | |
| 1 if success else 0, | |
| details | |
| )) | |
| conn.commit() | |
| conn.close() | |
| def fetch_history(self, route: str, days: int) -> List[Tuple[str, float]]: | |
| conn = sqlite3.connect(self.db_path) | |
| cursor = conn.cursor() | |
| cutoff = (datetime.now() - timedelta(days=days)).isoformat() | |
| cursor.execute(""" | |
| SELECT timestamp, price FROM price_logs | |
| WHERE route = ? AND timestamp >= ? | |
| ORDER BY timestamp DESC | |
| """, (route, cutoff)) | |
| results = cursor.fetchall() | |
| conn.close() | |
| return results | |
| def rolling_avg(self, route: str, days: int) -> float: | |
| history = self.fetch_history(route, days) | |
| if not history: | |
| return 0.0 | |
| prices = [price for _, price in history] | |
| return sum(prices) / len(prices) | |
| def std_dev(self, route: str, days: int) -> float: | |
| history = self.fetch_history(route, days) | |
| if len(history) < 2: | |
| return 0.0 | |
| prices = [price for _, price in history] | |
| avg = sum(prices) / len(prices) | |
| variance = sum((p - avg) ** 2 for p in prices) / len(prices) | |
| return math.sqrt(variance) | |
| def trend_slope(self, route: str, days: int) -> float: | |
| history = self.fetch_history(route, days) | |
| if len(history) < 2: | |
| return 0.0 | |
| prices = [price for _, price in history] | |
| n = len(prices) | |
| x_values = list(range(n)) | |
| x_mean = sum(x_values) / n | |
| y_mean = sum(prices) / n | |
| numerator = sum((x_values[i] - x_mean) * (prices[i] - y_mean) for i in range(n)) | |
| denominator = sum((x - x_mean) ** 2 for x in x_values) | |
| if denominator == 0: | |
| return 0.0 | |
| return numerator / denominator | |
| def recent_bookings(self, route: str, days: int) -> List[Dict]: | |
| conn = sqlite3.connect(self.db_path) | |
| cursor = conn.cursor() | |
| cutoff = (datetime.now() - timedelta(days=days)).isoformat() | |
| cursor.execute(""" | |
| SELECT timestamp, price, action, success, details FROM bookings | |
| WHERE route = ? AND timestamp >= ? | |
| ORDER BY timestamp DESC | |
| """, (route, cutoff)) | |
| results = [] | |
| for row in cursor.fetchall(): | |
| results.append({ | |
| "timestamp": row[0], | |
| "price": row[1], | |
| "action": row[2], | |
| "success": bool(row[3]), | |
| "details": row[4] | |
| }) | |
| conn.close() | |
| return results | |
| # ============================================================================ | |
| # LAYER 4 - INTELLIGENCE | |
| # ============================================================================ | |
| class SurgeAnalyzer: | |
| def analyze(current_price: float, avg_price: float, std_dev: float) -> SurgeResult: | |
| if avg_price == 0 or std_dev == 0: | |
| return SurgeResult( | |
| level=SurgeLevel.NORMAL, | |
| z_score=0.0, | |
| current_price=current_price, | |
| avg_price=avg_price, | |
| std_dev=std_dev, | |
| pct_vs_avg=0.0 | |
| ) | |
| z_score = (current_price - avg_price) / std_dev | |
| pct_vs_avg = ((current_price - avg_price) / avg_price) * 100 | |
| if z_score < -0.5: | |
| level = SurgeLevel.BELOW_AVERAGE | |
| elif z_score < 0.5: | |
| level = SurgeLevel.NORMAL | |
| elif z_score < 1.5: | |
| level = SurgeLevel.ELEVATED | |
| else: | |
| level = SurgeLevel.EXTREME | |
| return SurgeResult( | |
| level=level, | |
| z_score=z_score, | |
| current_price=current_price, | |
| avg_price=avg_price, | |
| std_dev=std_dev, | |
| pct_vs_avg=pct_vs_avg | |
| ) | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| # MODEL 0 – Volatility helper (shared) | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| def _volatility(std_dev: float, avg_price: float) -> float: | |
| if avg_price == 0: | |
| return 0.0 | |
| return (std_dev / avg_price) * 100 | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| # MODEL UTILITY – HuggingFace Inference API client (no torch required) | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| class HFInferenceClient: | |
| BASE_URL = "https://api-inference.huggingface.co/models" | |
| def __init__(self, hf_token: str = ""): | |
| self.hf_token = hf_token or os.getenv("HF_TOKEN", "") | |
| self.headers = {"Authorization": f"Bearer {self.hf_token}"} if self.hf_token else {} | |
| def query(self, model_id: str, payload: Dict, timeout: int = 20) -> Optional[Any]: | |
| try: | |
| resp = requests.post( | |
| f"{self.BASE_URL}/{model_id}", | |
| headers=self.headers, | |
| json=payload, | |
| timeout=timeout | |
| ) | |
| if resp.status_code == 200: | |
| return resp.json() | |
| return None | |
| except Exception: | |
| return None | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| # MODEL 1 – Heuristic rule-based predictor (always available, baseline) | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| class HeuristicPredictor: | |
| def predict(self, days_to_departure: int, surge_z: float, | |
| volatility: float, trend_slope: float) -> ModelPrediction: | |
| base = 50.0 | |
| if days_to_departure <= 3: base -= 30 | |
| elif days_to_departure <= 7: base -= 15 | |
| elif days_to_departure <= 14: base += 5 | |
| elif days_to_departure <= 30: base += 15 | |
| else: base += 10 | |
| if surge_z > 1.5: base += 25 | |
| elif surge_z > 0.5: base += 10 | |
| elif surge_z < -0.5: base -= 20 | |
| if volatility > 20: base += 15 | |
| elif volatility > 10: base += 5 | |
| if trend_slope > 50: base += 20 | |
| elif trend_slope > 0: base += 10 | |
| elif trend_slope < -50: base -= 15 | |
| prob = max(0.0, min(100.0, base)) | |
| drop_pct = 12.0 if prob >= 70 else 8.0 if prob >= 50 else 4.0 | |
| conf = 0.55 | |
| return ModelPrediction( | |
| model_name="Heuristic-V2", | |
| drop_probability=prob, | |
| drop_pct=drop_pct, | |
| confidence=conf, | |
| reasoning=( | |
| f"days={days_to_departure}, Z={surge_z:.2f}, " | |
| f"vol={volatility:.1f}%, slope={trend_slope:+.1f}" | |
| ) | |
| ) | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| # MODEL 2 – sklearn RandomForest + GradientBoosting ensemble | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| class SklearnEnsemblePredictor: | |
| def __init__(self, model_path: Optional[str] = None): | |
| self.rf = None | |
| self.gb = None | |
| self._init(model_path) | |
| def _init(self, model_path: Optional[str]): | |
| if model_path and os.path.exists(model_path): | |
| try: | |
| with open(model_path, "rb") as f: | |
| saved = pickle.load(f) | |
| self.rf = saved.get("rf") | |
| self.gb = saved.get("gb") | |
| return | |
| except Exception: | |
| pass | |
| self._train_synthetic() | |
| def _train_synthetic(self): | |
| try: | |
| from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier | |
| import numpy as np | |
| rng = np.random.default_rng(42) | |
| n = 600 | |
| days = rng.integers(1, 91, n).astype(float) | |
| sz = rng.uniform(-2.5, 3.0, n) | |
| vol = rng.uniform(0, 45, n) | |
| slope = rng.uniform(-120, 200, n) | |
| labels = ( | |
| ((days > 7) & (sz > 0.5) & (slope > 0)) | | |
| (sz > 1.5) | | |
| ((vol > 20) & (slope > 30)) | |
| ).astype(int) | |
| X = np.column_stack([days, sz, vol, slope]) | |
| self.rf = RandomForestClassifier(n_estimators=80, max_depth=6, random_state=42) | |
| self.rf.fit(X, labels) | |
| self.gb = GradientBoostingClassifier(n_estimators=80, max_depth=4, random_state=42) | |
| self.gb.fit(X, labels) | |
| except Exception as e: | |
| self.rf = None | |
| self.gb = None | |
| def predict(self, days_to_departure: int, surge_z: float, | |
| volatility: float, trend_slope: float) -> ModelPrediction: | |
| if self.rf is None: | |
| return ModelPrediction( | |
| model_name="sklearn-RF+GB", | |
| drop_probability=50.0, drop_pct=6.0, | |
| confidence=0.30, reasoning="sklearn unavailable – using fallback" | |
| ) | |
| try: | |
| import numpy as np | |
| X = np.array([[float(days_to_departure), surge_z, volatility, trend_slope]]) | |
| rf_p = float(self.rf.predict_proba(X)[0][1]) * 100 | |
| gb_p = float(self.gb.predict_proba(X)[0][1]) * 100 | |
| avg_p = (rf_p + gb_p) / 2.0 | |
| return ModelPrediction( | |
| model_name="sklearn-RF+GB", | |
| drop_probability=avg_p, | |
| drop_pct=10.0 if avg_p >= 60 else 6.0, | |
| confidence=0.72, | |
| reasoning=f"RF={rf_p:.1f}%, GB={gb_p:.1f}%, ensemble={avg_p:.1f}%" | |
| ) | |
| except Exception as e: | |
| return ModelPrediction( | |
| model_name="sklearn-RF+GB", | |
| drop_probability=50.0, drop_pct=6.0, | |
| confidence=0.30, reasoning=f"predict error: {e}" | |
| ) | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| # MODEL 3 – HuggingFace Sentiment (ProsusAI/finbert → financial NLP) | |
| # Converts numeric signals → text → sentiment → buy/wait probability | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| class SentimentAnalyzer: | |
| PRIMARY_MODEL = "ProsusAI/finbert" | |
| FALLBACK_MODEL = "distilbert-base-uncased-finetuned-sst-2-english" | |
| def __init__(self, hf_client: HFInferenceClient): | |
| self.hf = hf_client | |
| def analyze(self, flight: FlightPrice, surge: SurgeResult, | |
| trend_slope: float, days_to_departure: int) -> ModelPrediction: | |
| text = self._build_text(flight, surge, trend_slope, days_to_departure) | |
| raw = self.hf.query(self.PRIMARY_MODEL, {"inputs": text}) | |
| if not raw: | |
| raw = self.hf.query(self.FALLBACK_MODEL, {"inputs": text}) | |
| buy_signal = self._extract_buy_signal(raw) if raw else self._heuristic_buy(surge, trend_slope) | |
| drop_prob = 100.0 - (buy_signal * 100.0) | |
| return ModelPrediction( | |
| model_name="HF-Sentiment(finbert)", | |
| drop_probability=drop_prob, | |
| drop_pct=7.0 if drop_prob > 60 else 3.5, | |
| confidence=0.58 if raw else 0.40, | |
| reasoning=( | |
| f"buy_signal={buy_signal:.2f}, text='{text[:60]}...'" | |
| if raw else f"heuristic_buy={buy_signal:.2f} (HF API unavailable)" | |
| ) | |
| ) | |
| def _build_text(self, flight: FlightPrice, surge: SurgeResult, | |
| trend_slope: float, days_to_departure: int) -> str: | |
| trend_dir = "rising" if trend_slope > 0 else "declining" | |
| level = surge.level.name.replace("_", " ").lower() | |
| return ( | |
| f"Airline ticket price {flight.price:.0f} INR on {flight.route}. " | |
| f"Price is {level} at {surge.pct_vs_avg:+.1f}% deviation from average. " | |
| f"14-day trend is {trend_dir} by {abs(trend_slope):.1f} INR per day. " | |
| f"Departure in {days_to_departure} days. " | |
| f"{'Last minute urgent booking.' if days_to_departure <= 5 else ''}" | |
| ) | |
| def _extract_buy_signal(result: Any) -> float: | |
| try: | |
| items = result[0] if isinstance(result[0], list) else result | |
| for item in items: | |
| label = item.get("label", "").lower() | |
| score = float(item.get("score", 0.5)) | |
| if "positive" in label or label == "pos": | |
| return score | |
| if "negative" in label or label == "neg": | |
| return 1.0 - score | |
| return 0.5 | |
| except Exception: | |
| return 0.5 | |
| def _heuristic_buy(surge: SurgeResult, trend_slope: float) -> float: | |
| s = 0.5 | |
| if surge.level == SurgeLevel.BELOW_AVERAGE: s += 0.3 | |
| elif surge.level == SurgeLevel.EXTREME: s -= 0.3 | |
| if trend_slope < 0: s += 0.1 | |
| elif trend_slope > 0: s -= 0.1 | |
| return max(0.0, min(1.0, s)) | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| # MODEL 4 – Chronos / Linear time-series forecaster | |
| # Uses amazon/chronos-t5-tiny via HF Inference API; falls back to OLS | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| class ChronosForecaster: | |
| MODEL_ID = "amazon/chronos-t5-tiny" | |
| HORIZON = 7 | |
| def __init__(self, hf_client: HFInferenceClient): | |
| self.hf = hf_client | |
| def forecast(self, history: List[float]) -> List[float]: | |
| if len(history) < 4: | |
| return [] | |
| raw = self.hf.query( | |
| self.MODEL_ID, | |
| {"inputs": history[-20:], "parameters": {"prediction_length": self.HORIZON}}, | |
| timeout=25 | |
| ) | |
| if raw and isinstance(raw, list) and len(raw) >= self.HORIZON: | |
| try: | |
| return [float(v) for v in raw[:self.HORIZON]] | |
| except Exception: | |
| pass | |
| return self._ols_forecast(history, self.HORIZON) | |
| def predict_model(self, history: List[float], current_price: float) -> ModelPrediction: | |
| fc = self.forecast(history) | |
| if not fc: | |
| return ModelPrediction( | |
| model_name="Chronos-Forecast", | |
| drop_probability=50.0, drop_pct=5.0, | |
| confidence=0.35, reasoning="Insufficient history for forecast" | |
| ) | |
| fc_avg = sum(fc) / len(fc) | |
| fc_min = min(fc) | |
| proj_drop_pct = ((current_price - fc_avg) / current_price * 100) if current_price > 0 else 0.0 | |
| drop_prob = max(0.0, min(100.0, 50.0 + proj_drop_pct * 2.0)) | |
| return ModelPrediction( | |
| model_name="Chronos-Forecast", | |
| drop_probability=drop_prob, | |
| drop_pct=abs(proj_drop_pct) if proj_drop_pct > 0 else 3.0, | |
| confidence=0.65, | |
| reasoning=( | |
| f"7-day avg=₹{fc_avg:.0f}, min=₹{fc_min:.0f}, " | |
| f"now=₹{current_price:.0f}, proj_drop={proj_drop_pct:.1f}%" | |
| ) | |
| ) | |
| def _ols_forecast(prices: List[float], horizon: int) -> List[float]: | |
| n = len(prices) | |
| x_mean = (n - 1) / 2.0 | |
| y_mean = sum(prices) / n | |
| num = sum((i - x_mean) * (prices[i] - y_mean) for i in range(n)) | |
| den = sum((i - x_mean) ** 2 for i in range(n)) | |
| slope = num / den if den != 0 else 0.0 | |
| intercept = y_mean - slope * x_mean | |
| return [intercept + slope * (n + i) for i in range(horizon)] | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| # ENSEMBLE – Weighted combination of all 4 models | |
| # ──────────────────────────────────────────────────────────────────────────── | |
| class MultiModelEnsemble: | |
| WEIGHTS: Dict[str, float] = { | |
| "Heuristic-V2": 0.15, | |
| "sklearn-RF+GB": 0.35, | |
| "HF-Sentiment(finbert)": 0.20, | |
| "Chronos-Forecast": 0.30, | |
| } | |
| def __init__(self, hf_token: str = "", model_path: Optional[str] = None): | |
| self.hf_client = HFInferenceClient(hf_token) | |
| self.heuristic = HeuristicPredictor() | |
| self.sklearn_mdl = SklearnEnsemblePredictor(model_path) | |
| self.sentiment = SentimentAnalyzer(self.hf_client) | |
| self.chronos = ChronosForecaster(self.hf_client) | |
| def predict(self, flight: FlightPrice, surge: SurgeResult, | |
| days_to_departure: int, trend_slope: float, | |
| volatility: float, history_prices: List[float]) -> EnsemblePrediction: | |
| models: List[ModelPrediction] = [] | |
| m1 = self.heuristic.predict(days_to_departure, surge.z_score, volatility, trend_slope) | |
| models.append(m1) | |
| m2 = self.sklearn_mdl.predict(days_to_departure, surge.z_score, volatility, trend_slope) | |
| models.append(m2) | |
| m3 = self.sentiment.analyze(flight, surge, trend_slope, days_to_departure) | |
| models.append(m3) | |
| m4 = self.chronos.predict_model(history_prices, flight.price) | |
| models.append(m4) | |
| total_w = sum(self.WEIGHTS.get(m.model_name, 0.25) for m in models) | |
| w_prob = sum(m.drop_probability * self.WEIGHTS.get(m.model_name, 0.25) for m in models) / total_w | |
| w_drop = sum(m.drop_pct * self.WEIGHTS.get(m.model_name, 0.25) for m in models) / total_w | |
| w_conf = sum(m.confidence * self.WEIGHTS.get(m.model_name, 0.25) for m in models) / total_w | |
| dominant = max(models, key=lambda m: m.confidence) | |
| urgency = "HIGH" if w_prob >= 70 else "MEDIUM" if w_prob >= 50 else "LOW" | |
| return EnsemblePrediction( | |
| models=models, | |
| final_drop_probability=round(w_prob, 1), | |
| final_drop_pct=round(w_drop, 1), | |
| final_confidence=round(w_conf, 3), | |
| dominant_model=dominant.model_name, | |
| explanation=( | |
| f"4-model ensemble → H={m1.drop_probability:.0f}%, " | |
| f"SK={m2.drop_probability:.0f}%, " | |
| f"Sent={m3.drop_probability:.0f}%, " | |
| f"Chron={m4.drop_probability:.0f}%" | |
| ), | |
| urgency=urgency | |
| ) | |
| # ============================================================================ | |
| # LAYER 5 - AGENTIC CORE (ReAct: Reason + Act loop) | |
| # ============================================================================ | |
| class AgentMemory: | |
| def __init__(self): | |
| self.facts: Dict[str, Any] = {} | |
| self.observations: List[str] = [] | |
| def remember(self, key: str, value: Any): | |
| self.facts[key] = value | |
| def recall(self, key: str) -> Optional[Any]: | |
| return self.facts.get(key) | |
| def observe(self, text: str): | |
| self.observations.append(text) | |
| def context(self) -> str: | |
| return " | ".join(self.observations[-5:]) | |
| class ReActAgent: | |
| """ | |
| Deterministic ReAct (Reasoning + Acting) agent. | |
| Iterates through structured tool-call steps, records Thought/Action/Observation | |
| triples, and synthesises a final natural-language recommendation. | |
| No LLM API required — fully deterministic and explainable. | |
| """ | |
| MAX_STEPS = 8 | |
| def __init__(self): | |
| self.memory: AgentMemory = AgentMemory() | |
| self.steps: List[AgentStep] = [] | |
| self._n = 0 | |
| def _step(self, thought: str, action: str, observation: str) -> AgentStep: | |
| self._n += 1 | |
| s = AgentStep(step_num=self._n, thought=thought, action=action, observation=observation) | |
| self.steps.append(s) | |
| self.memory.observe(observation) | |
| return s | |
| def analyze(self, | |
| flight: FlightPrice, | |
| surge: SurgeResult, | |
| ensemble: EnsemblePrediction, | |
| arbitrage: Optional[ArbitrageResult], | |
| days_to_departure: int, | |
| history_prices: List[float], | |
| trend_slope: float, | |
| volatility: float, | |
| sentiment_score: float, | |
| forecast: List[float]) -> AgentTrace: | |
| t0 = time.time() | |
| self.steps = [] | |
| self.memory = AgentMemory() | |
| self._n = 0 | |
| # ── Step 1: Price vs History ────────────────────────────────────────── | |
| self._step( | |
| thought=f"I need to evaluate ₹{flight.price:,.0f} for {flight.route} against historical baseline.", | |
| action="assess_price_vs_history", | |
| observation=( | |
| f"Price is {surge.pct_vs_avg:+.1f}% vs 14-day avg ₹{surge.avg_price:,.0f}. " | |
| f"Surge level: {surge.level.name} (Z={surge.z_score:.2f}). " | |
| f"Std-dev: ₹{surge.std_dev:,.0f}." | |
| ) | |
| ) | |
| self.memory.remember("surge_level", surge.level) | |
| # ── Step 2: Trend analysis ──────────────────────────────────────────── | |
| trend_label = "RISING ↑" if trend_slope > 20 else "FALLING ↓" if trend_slope < -20 else "STABLE →" | |
| self._step( | |
| thought="Trend direction tells me whether waiting could yield lower prices.", | |
| action="analyze_14day_trend", | |
| observation=( | |
| f"Slope: {trend_slope:+.1f} INR/day → {trend_label}. " | |
| f"Volatility (CoV): {volatility:.1f}%. " | |
| f"{'High volatility — market is unpredictable.' if volatility > 15 else 'Low volatility — stable pricing.'}" | |
| ) | |
| ) | |
| self.memory.remember("trend", trend_label) | |
| # ── Step 3: Ensemble model results ─────────────────────────────────── | |
| dom_reasoning = next( | |
| (m.reasoning for m in ensemble.models if m.model_name == ensemble.dominant_model), "" | |
| ) | |
| self._step( | |
| thought=f"Running {len(ensemble.models)} ML models to estimate price-drop probability.", | |
| action="run_4model_ensemble", | |
| observation=( | |
| f"Ensemble: {ensemble.final_drop_probability:.0f}% drop probability, " | |
| f"est. drop {ensemble.final_drop_pct:.1f}%, confidence {ensemble.final_confidence:.0%}. " | |
| f"Dominant: {ensemble.dominant_model} → {dom_reasoning}." | |
| ) | |
| ) | |
| self.memory.remember("drop_prob", ensemble.final_drop_probability) | |
| # ── Step 4: Sentiment signal ───────────────────────────────────────── | |
| sent_label = ( | |
| "BULLISH 🟢 (good time to buy)" if sentiment_score > 0.6 | |
| else "BEARISH 🔴 (prices may drop)" if sentiment_score < 0.4 | |
| else "NEUTRAL 🟡" | |
| ) | |
| self._step( | |
| thought="HuggingFace finbert sentiment on numeric-to-text conversion provides market feel.", | |
| action="query_hf_sentiment_model", | |
| observation=f"Sentiment score: {sentiment_score:.2f} → {sent_label}." | |
| ) | |
| self.memory.remember("sentiment", sent_label) | |
| # ── Step 5: 7-day price forecast ───────────────────────────────────── | |
| if forecast: | |
| fc_min = min(forecast) | |
| fc_trend = "declining 📉" if forecast[-1] < forecast[0] else "rising 📈" | |
| self._step( | |
| thought="Chronos OLS 7-day forecast reveals expected price direction.", | |
| action="fetch_chronos_forecast", | |
| observation=( | |
| f"7-day forecast {fc_trend}. Lowest projected: ₹{fc_min:,.0f}. " | |
| f"Current: ₹{flight.price:,.0f}. " | |
| f"{'Waiting may save money.' if fc_min < flight.price * 0.95 else 'Minimal savings expected from waiting.'}" | |
| ) | |
| ) | |
| # ── Step 6: Arbitrage check ─────────────────────────────────────────── | |
| if arbitrage and arbitrage.worth_it: | |
| self._step( | |
| thought=f"Arbitrage option found via {arbitrage.best_airport}. Evaluating true net saving.", | |
| action="evaluate_arbitrage_opportunity", | |
| observation=( | |
| f"Flight from {arbitrage.best_airport}: ₹{arbitrage.best_price:,.0f} + " | |
| f"domestic ₹{arbitrage.domestic_cost:,.0f} = ₹{arbitrage.total_cost:,.0f}. " | |
| f"Net saving: ₹{arbitrage.savings:,.0f} ({arbitrage.savings/flight.price*100:.1f}%). " | |
| f"{'Strong arbitrage — recommend alternate route.' if arbitrage.savings > 5000 else 'Moderate arbitrage — consider if flexible.'}" | |
| ) | |
| ) | |
| # ── Step 7: Time-pressure assessment ───────────────────────────────── | |
| urgency_label = ( | |
| "🚨 CRITICAL (<7 days) — prices spike sharply near departure" if days_to_departure <= 7 | |
| else "⚠️ MODERATE (1-4 weeks) — decide soon" if days_to_departure <= 28 | |
| else "✅ RELAXED (>4 weeks) — monitor for better price" | |
| ) | |
| self._step( | |
| thought=f"Time window ({days_to_departure} days) is a key factor in urgency.", | |
| action="assess_departure_window", | |
| observation=f"{days_to_departure} days to departure → {urgency_label}." | |
| ) | |
| # ── Step 8: Synthesize ──────────────────────────────────────────────── | |
| signals = [] | |
| if surge.level in (SurgeLevel.BELOW_AVERAGE, SurgeLevel.NORMAL): | |
| signals.append(f"✅ Price at/below average ({surge.level.name})") | |
| else: | |
| signals.append(f"⚠️ Price elevated ({surge.level.name})") | |
| if ensemble.final_drop_probability > 60: | |
| signals.append(f"⚠️ {ensemble.final_drop_probability:.0f}% drop probability — consider waiting") | |
| else: | |
| signals.append(f"✅ Low drop probability ({ensemble.final_drop_probability:.0f}%)") | |
| if trend_slope < -20: | |
| signals.append("⚠️ Price trend declining — waiting may save money") | |
| elif trend_slope > 20: | |
| signals.append("✅ Prices rising — book now beats higher future cost") | |
| if days_to_departure <= 7: | |
| signals.append("🚨 Departure imminent — book immediately") | |
| final_reasoning = ( | |
| f"After consulting {len(ensemble.models)} AI models (sklearn RF/GB, HF finbert, " | |
| f"Chronos forecast, heuristic), analysing {days_to_departure}-day horizon, " | |
| f"trend '{trend_label}', and market sentiment '{sent_label}': " | |
| + " | ".join(signals) | |
| ) | |
| self._step( | |
| thought="All signals gathered. Synthesising final recommendation.", | |
| action="synthesize_recommendation", | |
| observation=final_reasoning | |
| ) | |
| return AgentTrace( | |
| steps=self.steps, | |
| final_reasoning=final_reasoning, | |
| models_used=len(ensemble.models), | |
| duration_ms=int((time.time() - t0) * 1000) | |
| ) | |
| # ============================================================================ | |
| # LAYER 6 - ARBITRAGE AGENT | |
| # ============================================================================ | |
| class ArbitrageAgent: | |
| AIRPORTS = { | |
| "TRZ": {"name": "Trichy", "domestic_cost": 0}, | |
| "MAA": {"name": "Chennai", "domestic_cost": 1200}, | |
| "CJB": {"name": "Coimbatore", "domestic_cost": 800}, | |
| "BLR": {"name": "Bangalore", "domestic_cost": 2800}, | |
| "HYD": {"name": "Hyderabad", "domestic_cost": 3500} | |
| } | |
| MIN_SAVINGS = 2000 | |
| def __init__(self, aggregator: PriceAggregator): | |
| self.aggregator = aggregator | |
| def find_best_route(self, origin: str, destination: str, departure_date: str, | |
| return_date: Optional[str], adults: int, | |
| current_price: float) -> Optional[ArbitrageResult]: | |
| best_result = None | |
| for airport_code, airport_info in self.AIRPORTS.items(): | |
| if airport_code == origin: | |
| continue | |
| alt_flight = self.aggregator.get_best_price( | |
| airport_code, destination, departure_date, return_date, adults | |
| ) | |
| if not alt_flight: | |
| continue | |
| domestic_cost = airport_info["domestic_cost"] | |
| total_cost = alt_flight.price + domestic_cost | |
| savings = current_price - total_cost | |
| if savings >= self.MIN_SAVINGS: | |
| if not best_result or savings > best_result.savings: | |
| best_result = ArbitrageResult( | |
| best_airport=airport_code, | |
| best_price=alt_flight.price, | |
| domestic_cost=domestic_cost, | |
| total_cost=total_cost, | |
| savings=savings, | |
| worth_it=True | |
| ) | |
| return best_result | |
| # ============================================================================ | |
| # LAYER 7 - DECISION ENGINE | |
| # ============================================================================ | |
| class DecisionEngine: | |
| def decide(flight: FlightPrice, surge: SurgeResult, ensemble: EnsemblePrediction, | |
| arbitrage: Optional[ArbitrageResult], days_to_departure: int, | |
| emergency_mode: bool, rolling_avg: float) -> Decision: | |
| drop_prob = ensemble.final_drop_probability | |
| conf = ensemble.final_confidence | |
| if emergency_mode: | |
| return Decision( | |
| action=ActionType.EMERGENCY_BOOK, urgency=Urgency.HIGH, | |
| confidence_score=1.0, | |
| explanation="Emergency mode activated — booking immediately regardless of price.", | |
| arbitrage=arbitrage | |
| ) | |
| if days_to_departure <= 5: | |
| return Decision( | |
| action=ActionType.BOOK_NOW, urgency=Urgency.HIGH, | |
| confidence_score=0.95, | |
| explanation=( | |
| f"Only {days_to_departure} days to departure — last-minute prices typically spike. " | |
| f"Ensemble confidence: {conf:.0%}." | |
| ), | |
| arbitrage=arbitrage | |
| ) | |
| if arbitrage and arbitrage.worth_it and arbitrage.savings / flight.price > 0.10: | |
| return Decision( | |
| action=ActionType.TRY_NEARBY, urgency=Urgency.HIGH, | |
| confidence_score=0.88, | |
| explanation=( | |
| f"Arbitrage: save ₹{arbitrage.savings:,.0f} ({arbitrage.savings/flight.price*100:.1f}%) " | |
| f"flying from {arbitrage.best_airport} instead." | |
| ), | |
| arbitrage=arbitrage | |
| ) | |
| if rolling_avg > 0 and flight.price < rolling_avg * 0.95: | |
| return Decision( | |
| action=ActionType.BOOK_NOW, urgency=Urgency.HIGH, | |
| confidence_score=round(0.80 + conf * 0.15, 3), | |
| explanation=( | |
| f"Price is {abs(surge.pct_vs_avg):.1f}% below 14-day avg — " | |
| f"excellent deal confirmed by {ensemble.dominant_model} (drop_prob={drop_prob:.0f}%)." | |
| ), | |
| arbitrage=arbitrage | |
| ) | |
| if surge.level == SurgeLevel.EXTREME and drop_prob >= 60: | |
| return Decision( | |
| action=ActionType.WAIT_WEEK, urgency=Urgency.MEDIUM, | |
| confidence_score=round(conf * drop_prob / 100, 3), | |
| explanation=( | |
| f"Extreme surge (Z={surge.z_score:.2f}) + {drop_prob:.0f}% ensemble drop probability " | |
| f"→ wait for correction. Dominant signal: {ensemble.dominant_model}." | |
| ), | |
| arbitrage=arbitrage | |
| ) | |
| if surge.level == SurgeLevel.ELEVATED and drop_prob >= 45: | |
| return Decision( | |
| action=ActionType.WAIT_24H, urgency=Urgency.LOW, | |
| confidence_score=round(conf * 0.7, 3), | |
| explanation=( | |
| f"Elevated price + {drop_prob:.0f}% drop probability " | |
| f"→ monitor for 24 hours. {ensemble.explanation}." | |
| ), | |
| arbitrage=arbitrage | |
| ) | |
| if surge.level == SurgeLevel.BELOW_AVERAGE: | |
| return Decision( | |
| action=ActionType.BOOK_NOW, urgency=Urgency.HIGH, | |
| confidence_score=round(0.75 + conf * 0.20, 3), | |
| explanation=( | |
| f"Below-average price ({surge.pct_vs_avg:+.1f}%) — strong buy signal. " | |
| f"All models agree: drop_prob only {drop_prob:.0f}%." | |
| ), | |
| arbitrage=arbitrage | |
| ) | |
| return Decision( | |
| action=ActionType.BOOK_NOW, urgency=Urgency.MEDIUM, | |
| confidence_score=round(conf * 0.6, 3), | |
| explanation=( | |
| f"Normal market conditions. Ensemble: {ensemble.explanation}. " | |
| f"Book when ready." | |
| ), | |
| arbitrage=arbitrage | |
| ) | |
| # ============================================================================ | |
| # LAYER 8 - AUTONOMOUS BOOKING | |
| # ============================================================================ | |
| class BookingAgent: | |
| def __init__(self): | |
| self.playwright_available = self._check_playwright() | |
| def _check_playwright(self) -> bool: | |
| try: | |
| from playwright.sync_api import sync_playwright | |
| return True | |
| except ImportError: | |
| return False | |
| def book(self, flight: FlightPrice, passenger: PassengerProfile) -> BookingResult: | |
| if not self.playwright_available: | |
| return BookingResult( | |
| success=False, | |
| screenshot_path=None, | |
| error="Playwright not installed", | |
| manual_instructions=self.instructions(flight, passenger) | |
| ) | |
| try: | |
| from playwright.sync_api import sync_playwright | |
| with sync_playwright() as p: | |
| browser = p.chromium.launch(headless=True) | |
| page = browser.new_page() | |
| page.goto(flight.deep_link if flight.deep_link else "https://www.google.com/flights") | |
| page.wait_for_timeout(3000) | |
| selectors_first_name = [ | |
| "input[name='firstName']", | |
| "input[placeholder*='First']", | |
| "input[id*='first']", | |
| "input.first-name" | |
| ] | |
| selectors_last_name = [ | |
| "input[name='lastName']", | |
| "input[placeholder*='Last']", | |
| "input[id*='last']", | |
| "input.last-name" | |
| ] | |
| selectors_email = [ | |
| "input[type='email']", | |
| "input[name='email']", | |
| "input[placeholder*='email']" | |
| ] | |
| selectors_phone = [ | |
| "input[type='tel']", | |
| "input[name='phone']", | |
| "input[placeholder*='phone']" | |
| ] | |
| name_parts = passenger.full_name.split(maxsplit=1) | |
| first_name = name_parts[0] if name_parts else passenger.full_name | |
| last_name = name_parts[1] if len(name_parts) > 1 else "" | |
| for selector in selectors_first_name: | |
| try: | |
| page.fill(selector, first_name, timeout=2000) | |
| break | |
| except: | |
| continue | |
| for selector in selectors_last_name: | |
| try: | |
| page.fill(selector, last_name, timeout=2000) | |
| break | |
| except: | |
| continue | |
| for selector in selectors_email: | |
| try: | |
| page.fill(selector, passenger.email, timeout=2000) | |
| break | |
| except: | |
| continue | |
| for selector in selectors_phone: | |
| try: | |
| page.fill(selector, passenger.phone, timeout=2000) | |
| break | |
| except: | |
| continue | |
| screenshot_path = f"booking_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png" | |
| page.screenshot(path=screenshot_path) | |
| browser.close() | |
| return BookingResult( | |
| success=True, | |
| screenshot_path=screenshot_path, | |
| error=None, | |
| manual_instructions=self.instructions(flight, passenger) | |
| ) | |
| except Exception as e: | |
| return BookingResult( | |
| success=False, | |
| screenshot_path=None, | |
| error=str(e), | |
| manual_instructions=self.instructions(flight, passenger) | |
| ) | |
| def instructions(self, flight: FlightPrice, passenger: PassengerProfile) -> str: | |
| instructions = f""" | |
| MANUAL BOOKING INSTRUCTIONS | |
| {'=' * 50} | |
| 1. Open booking link: | |
| {flight.deep_link if flight.deep_link else 'Search manually on flight booking site'} | |
| 2. Fill passenger details: | |
| Name: {passenger.full_name} | |
| Email: {passenger.email} | |
| Phone: {passenger.phone} | |
| 3. Review flight details: | |
| Route: {flight.route} | |
| Price: ₹{flight.price:,.0f} | |
| Airline: {flight.airline} | |
| Departure: {flight.departure_time} | |
| 4. Proceed to payment (MANUAL STEP - system stops here) | |
| 5. Complete payment using your preferred method | |
| {'=' * 50} | |
| """ | |
| return instructions | |
| # ============================================================================ | |
| # LAYER 9 - TELEGRAM NOTIFIER | |
| # ============================================================================ | |
| class TelegramNotifier: | |
| def __init__(self, token: str, chat_id: str): | |
| self.token = token | |
| self.chat_id = chat_id | |
| self.enabled = bool(token and chat_id) | |
| def should_alert(self, decision: Decision, surge: SurgeResult, | |
| arbitrage: Optional[ArbitrageResult], monitoring: bool) -> bool: | |
| if not self.enabled: | |
| return False | |
| if monitoring: | |
| return True | |
| if decision.action in [ActionType.BOOK_NOW, ActionType.EMERGENCY_BOOK, ActionType.TRY_NEARBY]: | |
| return True | |
| if surge.level == SurgeLevel.EXTREME: | |
| return True | |
| if arbitrage and arbitrage.savings >= 5000: | |
| return True | |
| if surge.level == SurgeLevel.BELOW_AVERAGE: | |
| return True | |
| return False | |
| def send(self, report: IntelligenceReport) -> bool: | |
| if not self.enabled: | |
| return False | |
| try: | |
| message = self._format_message(report) | |
| url = f"https://api.telegram.org/bot{self.token}/sendMessage" | |
| payload = { | |
| "chat_id": self.chat_id, | |
| "text": message, | |
| "parse_mode": "Markdown" | |
| } | |
| response = requests.post(url, json=payload, timeout=10) | |
| return response.status_code == 200 | |
| except Exception as e: | |
| print(f"Telegram error: {e}") | |
| return False | |
| def _format_message(self, report: IntelligenceReport) -> str: | |
| f = report.flight | |
| s = report.surge | |
| e = report.ensemble | |
| d = report.decision | |
| model_lines = "\n".join( | |
| f" • {m.model_name}: {m.drop_probability:.0f}% drop | conf {m.confidence:.0%}" | |
| for m in e.models | |
| ) | |
| message = ( | |
| f"\U0001f6eb *SkyGuardian AI v2.0 Alert*\n\n" | |
| f"*Flight Found*\n" | |
| f"{f.route}\n" | |
| f"\U0001f4b0 \u20b9{f.price:,.0f} | {f.airline}\n" | |
| f"\u23f1 {f.duration_min // 60}h {f.duration_min % 60}m | {f.stops} stop(s)\n\n" | |
| f"*Surge Analysis*\n" | |
| f"{s.level.value} (Z={s.z_score:.2f}, {s.pct_vs_avg:+.1f}% vs avg)\n\n" | |
| f"*4-Model Ensemble*\n" | |
| f"{model_lines}\n" | |
| f"\U0001f9e0 Final: {e.final_drop_probability:.0f}% drop probability " | |
| f"(conf {e.final_confidence:.0%})\n\n" | |
| f"*Decision*\n" | |
| f"\U0001f3af {d.action.value} ({d.urgency.value}) | confidence {d.confidence_score:.0%}\n" | |
| f"{d.explanation}\n" | |
| ) | |
| if d.arbitrage and d.arbitrage.worth_it: | |
| message += f"\n\U0001f4a1 Arbitrage: Save \u20b9{d.arbitrage.savings:,.0f} via {d.arbitrage.best_airport}" | |
| if d.auto_book_triggered: | |
| message += "\n\n\u2705 Auto-booking triggered" | |
| return message | |
| # ============================================================================ | |
| # LAYER 10 - MASTER ORCHESTRATOR | |
| # ============================================================================ | |
| class Orchestrator: | |
| def __init__(self, kiwi_key: str, amadeus_key: str, amadeus_secret: str, | |
| telegram_token: str, telegram_chat_id: str, db_path: str, | |
| hf_token: str = "", model_path: Optional[str] = None): | |
| self.aggregator = PriceAggregator(kiwi_key, amadeus_key, amadeus_secret) | |
| self.logger = PriceLogger(db_path) | |
| self.arbitrage_agent = ArbitrageAgent(self.aggregator) | |
| self.ensemble = MultiModelEnsemble(hf_token, model_path) | |
| self.react_agent = ReActAgent() | |
| self.booking_agent = BookingAgent() | |
| self.notifier = TelegramNotifier(telegram_token, telegram_chat_id) | |
| def run(self, origin: str, destination: str, departure_date: str, | |
| return_date: Optional[str], adults: int, emergency_mode: bool, | |
| monitoring_mode: bool, passenger: Optional[PassengerProfile], | |
| auto_book_threshold: float) -> IntelligenceReport: | |
| # ── Step 1: Validate ────────────────────────────────────────────────── | |
| if not origin or not destination or not departure_date: | |
| raise ValueError("Origin, destination, and departure date are required") | |
| # ── Step 2: Fetch live prices ───────────────────────────────────────── | |
| flight = self.aggregator.get_best_price( | |
| origin, destination, departure_date, return_date, adults | |
| ) | |
| if not flight: | |
| raise ValueError("No flights found — check API keys and route availability") | |
| # ── Step 3: Log to SQLite ───────────────────────────────────────────── | |
| self.logger.log_price(flight, departure_date) | |
| # ── Step 4: Compute 14-day history stats ────────────────────────────── | |
| history = self.logger.fetch_history(flight.route, 14) | |
| rolling_avg = self.logger.rolling_avg(flight.route, 14) | |
| std_dev_val = self.logger.std_dev(flight.route, 14) | |
| trend_slope = self.logger.trend_slope(flight.route, 14) | |
| vol = _volatility(std_dev_val, rolling_avg) | |
| history_prices = [p for _, p in history] | |
| # ── Step 5: Surge analysis ──────────────────────────────────────────── | |
| surge = SurgeAnalyzer.analyze(flight.price, rolling_avg, std_dev_val) | |
| # ── Step 6: Days to departure ───────────────────────────────────────── | |
| try: | |
| days_to_departure = (datetime.strptime(departure_date, "%Y-%m-%d") - datetime.now()).days | |
| except Exception: | |
| days_to_departure = 30 | |
| # ── Step 7: Multi-model ensemble prediction ─────────────────────────── | |
| ensemble_result = self.ensemble.predict( | |
| flight=flight, | |
| surge=surge, | |
| days_to_departure=days_to_departure, | |
| trend_slope=trend_slope, | |
| volatility=vol, | |
| history_prices=history_prices | |
| ) | |
| # ── Step 7b: Get forecast + sentiment score for agent ───────────────── | |
| forecast = self.ensemble.chronos.forecast(history_prices) | |
| sent_model = next( | |
| (m for m in ensemble_result.models if "Sentiment" in m.model_name), None | |
| ) | |
| sentiment_score = (100.0 - (sent_model.drop_probability if sent_model else 50.0)) / 100.0 | |
| # ── Step 8: Arbitrage check ─────────────────────────────────────────── | |
| arbitrage = self.arbitrage_agent.find_best_route( | |
| origin, destination, departure_date, return_date, adults, flight.price | |
| ) | |
| # ── Step 9: ReAct agent reasoning trace ────────────────────────────── | |
| agent_trace = self.react_agent.analyze( | |
| flight=flight, | |
| surge=surge, | |
| ensemble=ensemble_result, | |
| arbitrage=arbitrage, | |
| days_to_departure=days_to_departure, | |
| history_prices=history_prices, | |
| trend_slope=trend_slope, | |
| volatility=vol, | |
| sentiment_score=sentiment_score, | |
| forecast=forecast | |
| ) | |
| # ── Step 10: Decision engine ────────────────────────────────────────── | |
| decision = DecisionEngine.decide( | |
| flight, surge, ensemble_result, arbitrage, | |
| days_to_departure, emergency_mode, rolling_avg | |
| ) | |
| # ── Step 11: Auto-booking ───────────────────────────────────────────── | |
| booking_result = None | |
| if (auto_book_threshold > 0 | |
| and flight.price <= auto_book_threshold | |
| and decision.action in [ActionType.BOOK_NOW, ActionType.EMERGENCY_BOOK, ActionType.TRY_NEARBY] | |
| and passenger is not None): | |
| booking_result = self.booking_agent.book(flight, passenger) | |
| decision.auto_book_triggered = True | |
| self.logger.log_booking( | |
| route=flight.route, price=flight.price, | |
| action=decision.action.value, success=booking_result.success, | |
| details=booking_result.error or "Auto-booking attempted" | |
| ) | |
| # ── Step 12: Build report ───────────────────────────────────────────── | |
| report = IntelligenceReport( | |
| flight=flight, | |
| history_days=len(history), | |
| rolling_avg=rolling_avg, | |
| std_dev=std_dev_val, | |
| trend_slope=trend_slope, | |
| volatility=vol, | |
| surge=surge, | |
| ensemble=ensemble_result, | |
| agent_trace=agent_trace, | |
| arbitrage=arbitrage, | |
| decision=decision, | |
| booking=booking_result, | |
| forecast_prices=forecast, | |
| sentiment_score=sentiment_score | |
| ) | |
| # ── Step 13: Telegram alert ─────────────────────────────────────────── | |
| if self.notifier.should_alert(decision, surge, arbitrage, monitoring_mode): | |
| decision.telegram_sent = self.notifier.send(report) | |
| return report | |
| # ============================================================================ | |
| # OUTPUT FORMATTERS | |
| # ============================================================================ | |
| def _fmt_status(report: IntelligenceReport) -> str: | |
| e = report.ensemble | |
| d = report.decision | |
| return ( | |
| f"✈️ ₹{report.flight.price:,.0f} | {report.surge.level.value} | " | |
| f"Ensemble drop: {e.final_drop_probability:.0f}% (conf {e.final_confidence:.0%}) | " | |
| f"Decision: {d.action.value} [{d.urgency.value}] | " | |
| f"Confidence: {d.confidence_score:.0%} | " | |
| f"Alert: {'✅' if d.telegram_sent else '❌'} | " | |
| f"Auto-book: {'✅' if d.auto_book_triggered else '❌'} | " | |
| f"Agent steps: {len(report.agent_trace.steps)} " | |
| f"({report.agent_trace.duration_ms}ms)" | |
| ) | |
| def _fmt_price(flight: FlightPrice) -> str: | |
| return ( | |
| f"## ✈️ Best Flight Found\n\n" | |
| f"| Field | Value |\n|-------|-------|\n" | |
| f"| **Route** | {flight.route} |\n" | |
| f"| **Price** | ₹{flight.price:,.0f} {flight.currency} |\n" | |
| f"| **Airline** | {flight.airline} |\n" | |
| f"| **Duration** | {flight.duration_min // 60}h {flight.duration_min % 60}m |\n" | |
| f"| **Stops** | {flight.stops} |\n" | |
| f"| **Provider** | {flight.provider} |\n" | |
| f"| **Flights Found** | {flight.flights_found} |\n" | |
| f"| **Departure** | {flight.departure_time} |\n" | |
| f"| **Value Score** | {flight.value_score:,.0f} |\n" | |
| ) | |
| def _fmt_intel(report: IntelligenceReport) -> str: | |
| trend_emoji = "📈" if report.trend_slope > 0 else "📉" if report.trend_slope < 0 else "➡️" | |
| e = report.ensemble | |
| fc_line = "" | |
| if report.forecast_prices: | |
| fc_vals = ", ".join(f"₹{p:,.0f}" for p in report.forecast_prices[:5]) | |
| fc_line = f"| **7-Day Forecast** | {fc_vals}... |\n" | |
| return ( | |
| f"## 📊 Market Intelligence\n\n" | |
| f"| Metric | Value |\n|--------|-------|\n" | |
| f"| **14-Day Average** | ₹{report.rolling_avg:,.0f} |\n" | |
| f"| **Std Deviation** | ₹{report.std_dev:,.0f} |\n" | |
| f"| **Price vs Avg** | {report.surge.pct_vs_avg:+.1f}% |\n" | |
| f"| **Trend** | {trend_emoji} {report.trend_slope:+.1f} INR/day |\n" | |
| f"| **Volatility (CoV)** | {report.volatility:.1f}% |\n" | |
| f"| **History Points** | {report.history_days} |\n" | |
| f"| **Surge Level** | {report.surge.level.value} (Z={report.surge.z_score:.2f}) |\n" | |
| f"| **Sentiment Score** | {report.sentiment_score:.2f} " | |
| f"({'BULLISH 🟢' if report.sentiment_score > 0.6 else 'BEARISH 🔴' if report.sentiment_score < 0.4 else 'NEUTRAL 🟡'}) |\n" | |
| f"| **Ensemble Drop Prob** | {e.final_drop_probability:.0f}% " | |
| f"(conf {e.final_confidence:.0%}, {e.urgency}) |\n" | |
| f"| **Estimated Drop** | {e.final_drop_pct:.1f}% |\n" | |
| f"| **Dominant Model** | {e.dominant_model} |\n" | |
| f"{fc_line}" | |
| ) | |
| def _fmt_models(report: IntelligenceReport) -> str: | |
| e = report.ensemble | |
| rows = "\n".join( | |
| f"| **{m.model_name}** | {m.drop_probability:.1f}% | {m.drop_pct:.1f}% | " | |
| f"{m.confidence:.0%} | {m.reasoning[:80]}{'…' if len(m.reasoning) > 80 else ''} |" | |
| for m in e.models | |
| ) | |
| weight_map = { | |
| "Heuristic-V2": "15%", "sklearn-RF+GB": "35%", | |
| "HF-Sentiment(finbert)": "20%", "Chronos-Forecast": "30%" | |
| } | |
| wrows = "\n".join( | |
| f"| {m.model_name} | {weight_map.get(m.model_name, '—')} | {m.drop_probability:.1f}% |" | |
| for m in e.models | |
| ) | |
| return ( | |
| f"## 🧠 4-Model Ensemble Intelligence\n\n" | |
| f"| Model | Drop Prob | Drop Est | Confidence | Reasoning |\n" | |
| f"|-------|-----------|----------|------------|----------|\n" | |
| f"{rows}\n\n" | |
| f"### Weighted Ensemble Result\n\n" | |
| f"| Model | Weight | Individual Prob |\n" | |
| f"|-------|--------|-----------------|\n" | |
| f"{wrows}\n\n" | |
| f"**Final: {e.final_drop_probability:.1f}% drop probability** | " | |
| f"Drop est: {e.final_drop_pct:.1f}% | " | |
| f"Confidence: {e.final_confidence:.0%} | " | |
| f"Dominant: **{e.dominant_model}**\n\n" | |
| f"> {e.explanation}" | |
| ) | |
| def _fmt_agent_trace(report: IntelligenceReport) -> str: | |
| trace = report.agent_trace | |
| lines = [ | |
| f"## 🤖 ReAct Agent Trace\n", | |
| f"> **{len(trace.steps)} reasoning steps** | " | |
| f"**{trace.models_used} models consulted** | " | |
| f"**{trace.duration_ms}ms**\n", | |
| ] | |
| for step in trace.steps: | |
| lines.append( | |
| f"---\n" | |
| f"**Step {step.step_num}** `[{step.timestamp}]`\n\n" | |
| f"🧠 **Thought:** {step.thought}\n\n" | |
| f"⚙️ **Action:** `{step.action}`\n\n" | |
| f"👁️ **Observation:** {step.observation}\n" | |
| ) | |
| lines.append(f"\n---\n### 🎯 Final Agent Reasoning\n\n> {trace.final_reasoning}") | |
| return "\n".join(lines) | |
| def _fmt_decision(report: IntelligenceReport) -> str: | |
| d = report.decision | |
| output = ( | |
| f"## 🎯 Decision: **{d.action.value}** ({d.urgency.value})\n\n" | |
| f"**Confidence:** {d.confidence_score:.0%}\n\n" | |
| f"{d.explanation}\n" | |
| ) | |
| if d.arbitrage and d.arbitrage.worth_it: | |
| output += ( | |
| f"\n### 💡 Arbitrage Opportunity\n\n" | |
| f"Fly from **{d.arbitrage.best_airport}** instead:\n" | |
| f"- Flight price: ₹{d.arbitrage.best_price:,.0f}\n" | |
| f"- Domestic cost: ₹{d.arbitrage.domestic_cost:,.0f}\n" | |
| f"- Total cost: ₹{d.arbitrage.total_cost:,.0f}\n" | |
| f"- **Savings: ₹{d.arbitrage.savings:,.0f}**\n" | |
| ) | |
| if d.auto_book_triggered: | |
| output += "\n### ✅ Auto-Booking Triggered\nCheck booking instructions below.\n" | |
| if d.telegram_sent: | |
| output += "\n### 📱 Telegram Alert Sent\n" | |
| return output | |
| # ============================================================================ | |
| # GRADIO UI (6 tabs) | |
| # ============================================================================ | |
| def create_ui(): | |
| import gradio as gr | |
| css = """ | |
| @import url('https://fonts.googleapis.com/css2?family=Familjen+Grotesk:wght@400;600;700&family=JetBrains+Mono:wght@400;500&display=swap'); | |
| body, .gradio-container { background:#060810!important; font-family:'Familjen Grotesk',sans-serif!important; color:#e0e0e0!important; } | |
| .hero-title { background:linear-gradient(135deg,#f0a500 0%,#00c2ff 100%); -webkit-background-clip:text; -webkit-text-fill-color:transparent; font-size:2.8rem; font-weight:700; margin-bottom:.4rem; } | |
| .hero-sub { color:#00e87a; font-size:1.1rem; margin-bottom:.8rem; } | |
| .pill { display:inline-block; background:rgba(240,165,0,.18); border:1px solid #f0a500; color:#f0a500; padding:.25rem .75rem; border-radius:20px; font-size:.8rem; margin:.15rem; font-weight:600; } | |
| .pill2 { border-color:#00c2ff; color:#00c2ff; background:rgba(0,194,255,.1); } | |
| .pill3 { border-color:#00e87a; color:#00e87a; background:rgba(0,232,122,.1); } | |
| h1,h2,h3 { font-weight:700!important; } | |
| code,pre,.mono { font-family:'JetBrains Mono',monospace!important; } | |
| """ | |
| hero = """ | |
| <div style="text-align:center;padding:1.5rem 0 1rem"> | |
| <div class="hero-title">SkyGuardian AI v2.0</div> | |
| <div class="hero-sub">Trichy ⇄ Singapore · Multi-Model Agentic Flight Intelligence</div> | |
| <div> | |
| <span class="pill">🤖 ReAct Agent</span> | |
| <span class="pill">📊 4-Model Ensemble</span> | |
| <span class="pill2">🧬 HF finbert</span> | |
| <span class="pill2">⏳ Chronos Forecast</span> | |
| <span class="pill3">🌲 sklearn RF+GB</span> | |
| <span class="pill3">💰 Arbitrage</span> | |
| <span class="pill">🎯 Auto-Booking</span> | |
| <span class="pill">📱 Telegram</span> | |
| </div> | |
| </div>""" | |
| with gr.Blocks(css=css, title="SkyGuardian AI v2.0", theme=gr.themes.Base()) as app: | |
| gr.HTML(hero) | |
| with gr.Tabs(): | |
| # ── Tab 1 ─ Search & Analyze ────────────────────────────────────── | |
| with gr.Tab("🔍 Search & Analyze"): | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| gr.Markdown("### Search Parameters") | |
| origin = gr.Dropdown( | |
| choices=["TRZ","MAA","CJB","BLR","HYD"], value="TRZ", | |
| label="Origin Airport" | |
| ) | |
| destination = gr.Dropdown( | |
| choices=["SIN"], value="SIN", label="Destination Airport" | |
| ) | |
| departure_date = gr.Textbox( | |
| label="Departure Date (YYYY-MM-DD)", | |
| value=(datetime.now()+timedelta(days=30)).strftime("%Y-%m-%d") | |
| ) | |
| return_date = gr.Textbox(label="Return Date (Optional)", value="") | |
| adults = gr.Slider(1, 9, value=1, step=1, label="Adults") | |
| emergency = gr.Checkbox(label="🚨 Emergency Mode (Book Immediately)", value=False) | |
| monitoring = gr.Checkbox(label="📡 Monitoring Mode (Always Alert)", value=False) | |
| analyze_btn = gr.Button("🚀 Run Full Intelligence Pipeline", variant="primary") | |
| with gr.Column(scale=2): | |
| gr.Markdown("### Intelligence Summary") | |
| status_out = gr.Textbox(label="Pipeline Status", lines=2, elem_classes=["mono"]) | |
| flight_out = gr.Markdown(label="Best Flight") | |
| intel_out = gr.Markdown(label="Market Intelligence") | |
| decision_out = gr.Markdown(label="Decision") | |
| booking_out = gr.Textbox(label="Booking Instructions", lines=8) | |
| warnings_out = gr.Textbox(label="Warnings", lines=2) | |
| # ── Tab 2 ─ Agent Reasoning Trace ──────────────────────────────── | |
| with gr.Tab("🤖 Agent Trace"): | |
| gr.Markdown("### ReAct Agent – Step-by-Step Reasoning") | |
| gr.Markdown( | |
| "_Each step shows the agent's **Thought → Action → Observation** loop. " | |
| "Powered by deterministic multi-signal reasoning (no LLM API cost)._" | |
| ) | |
| agent_trace_out = gr.Markdown(label="Agent Trace") | |
| # ── Tab 3 ─ Model Intelligence ─────────────────────────────────── | |
| with gr.Tab("📊 Model Intelligence"): | |
| gr.Markdown("### 4-Model Ensemble Breakdown") | |
| gr.Markdown( | |
| "| Model | Type | Source | Weight |\n" | |
| "|-------|------|--------|--------|\n" | |
| "| **Heuristic-V2** | Rule-based | Local | 15% |\n" | |
| "| **sklearn-RF+GB** | RandomForest + GradientBoosting | Local | 35% |\n" | |
| "| **HF-Sentiment(finbert)** | Financial NLP (ProsusAI/finbert) | HF Inference API | 20% |\n" | |
| "| **Chronos-Forecast** | Time-series (amazon/chronos-t5-tiny) | HF Inference API + OLS fallback | 30% |\n" | |
| ) | |
| models_out = gr.Markdown(label="Model Comparison") | |
| # ── Tab 4 ─ API Keys ───────────────────────────────────────────── | |
| with gr.Tab("🔑 API Keys"): | |
| gr.Markdown("### Configure API Credentials") | |
| gr.Markdown("💡 Set as environment variables for production — never commit keys to code.") | |
| kiwi_key = gr.Textbox(label="Kiwi/Tequila API Key", type="password", | |
| value=os.getenv("KIWI_API_KEY","")) | |
| amadeus_key = gr.Textbox(label="Amadeus API Key", type="password", | |
| value=os.getenv("AMADEUS_API_KEY","")) | |
| amadeus_secret = gr.Textbox(label="Amadeus API Secret", type="password", | |
| value=os.getenv("AMADEUS_API_SECRET","")) | |
| hf_token = gr.Textbox( | |
| label="HuggingFace Token (for finbert + Chronos API — optional but improves rate limits)", | |
| type="password", value=os.getenv("HF_TOKEN","") | |
| ) | |
| telegram_token = gr.Textbox(label="Telegram Bot Token", type="password", | |
| value=os.getenv("TELEGRAM_TOKEN","")) | |
| telegram_chat = gr.Textbox(label="Telegram Chat ID", type="password", | |
| value=os.getenv("TELEGRAM_CHAT_ID","")) | |
| # ── Tab 5 ─ Auto-Booking ───────────────────────────────────────── | |
| with gr.Tab("🤖 Auto-Booking"): | |
| gr.Markdown("### Autonomous Booking Configuration") | |
| gr.Markdown("⚠️ **Payment is MANUAL** — system fills forms and takes screenshot, stops before payment.") | |
| passenger_name = gr.Textbox(label="Passenger Full Name", value="") | |
| passenger_email = gr.Textbox(label="Email", value="") | |
| passenger_phone = gr.Textbox(label="Phone", value="") | |
| auto_threshold = gr.Number( | |
| label="Auto-Book Price Threshold (INR, 0 = disabled)", value=0, minimum=0 | |
| ) | |
| gr.Markdown(""" | |
| **Trigger condition:** | |
| `price ≤ threshold AND action ∈ {BOOK_NOW, EMERGENCY_BOOK, TRY_NEARBY} AND passenger filled` | |
| **What happens:** | |
| 1. Playwright opens booking deep-link | |
| 2. Fills name / email / phone with multiple CSS-selector fallbacks | |
| 3. Takes screenshot → **stops before payment page** | |
| 4. You complete payment manually | |
| """) | |
| # ── Tab 6 ─ How It Works ───────────────────────────────────────── | |
| with gr.Tab("📖 How It Works"): | |
| gr.Markdown(f""" | |
| # SkyGuardian AI v2.0 – Full Pipeline | |
| ``` | |
| STEP 1 Validate inputs | |
| STEP 2 Fetch prices → Kiwi/Tequila + Amadeus (dedup by value_score) | |
| STEP 3 Log to SQLite → price_logs table | |
| STEP 4 14-day history → rolling_avg, std_dev, trend_slope, volatility | |
| STEP 5 Surge analysis → Z-score (BELOW / NORMAL / ELEVATED / EXTREME) | |
| STEP 6 Days to departure | |
| STEP 7 4-Model Ensemble | |
| Model 1: Heuristic-V2 (rule-based, 15% weight) | |
| Model 2: sklearn RF+GB (80 trees each, 35% weight) | |
| Model 3: HF finbert (financial NLP via API, 20%) | |
| Model 4: Chronos-Forecast (time-series OLS/API, 30%) | |
| → Weighted ensemble → EnsemblePrediction | |
| STEP 8 Arbitrage check → 5 airports, min ₹2,000 savings | |
| STEP 9 ReAct Agent → 8-step Thought/Action/Observation loop | |
| STEP 10 Decision Engine → 7-rule priority tree | |
| STEP 11 Auto-booking → Playwright (if threshold met) | |
| STEP 12 Build IntelligenceReport | |
| STEP 13 Telegram alert | |
| ``` | |
| ## Route & Arbitrage Table | |
| | Airport | IATA | Domestic Cost to TRZ | | |
| |---------|------|---------------------| | |
| | Trichy | TRZ | ₹0 (home base) | | |
| | Chennai | MAA | ₹1,200 | | |
| | Coimbatore | CJB | ₹800 | | |
| | Bangalore | BLR | ₹2,800 | | |
| | Hyderabad | HYD | ₹3,500 | | |
| ## Value Score Formula | |
| ``` | |
| value_score = price + (stops × 1500) + max(0, duration_min − 300) × 2 | |
| ``` | |
| ## Decision Rules (Priority Order) | |
| | Priority | Condition | Action | Urgency | | |
| |----------|-----------|--------|---------| | |
| | 1 | Emergency mode | EMERGENCY_BOOK | HIGH | | |
| | 2 | ≤ 5 days to departure | BOOK_NOW | HIGH | | |
| | 3 | Arbitrage savings > 10% | TRY_NEARBY | HIGH | | |
| | 4 | Price < 95% of avg | BOOK_NOW | HIGH | | |
| | 5 | EXTREME surge + 60% drop prob | WAIT_WEEK | MEDIUM | | |
| | 6 | ELEVATED surge + 45% drop prob | WAIT_24H | LOW | | |
| | 7 | BELOW_AVERAGE surge | BOOK_NOW | HIGH | | |
| | 8 | Default | BOOK_NOW | MEDIUM | | |
| ## Environment Variables | |
| ```bash | |
| KIWI_API_KEY = your_kiwi_key | |
| AMADEUS_API_KEY = your_amadeus_key | |
| AMADEUS_API_SECRET = your_amadeus_secret | |
| HF_TOKEN = your_huggingface_token # for finbert + Chronos | |
| TELEGRAM_TOKEN = your_telegram_bot_token | |
| TELEGRAM_CHAT_ID = your_chat_id | |
| SKYGUARDIAN_DB = skyguardian.db # optional | |
| SKYGUARDIAN_MODEL = drop_model.pkl # optional sklearn model | |
| ``` | |
| ## HuggingFace Models Used | |
| | Model | Task | API Endpoint | | |
| |-------|------|-------------| | |
| | `ProsusAI/finbert` | Financial sentiment → buy/wait signal | HF Inference API | | |
| | `distilbert-base-uncased-finetuned-sst-2-english` | SST-2 sentiment fallback | HF Inference API | | |
| | `amazon/chronos-t5-tiny` | Time-series price forecasting | HF Inference API + OLS fallback | | |
| ## Deployment (HuggingFace Spaces – CPU Free Tier) | |
| ```bash | |
| # Local | |
| pip install -r requirements.txt | |
| python app.py | |
| # Access: http://localhost:7860 | |
| ``` | |
| """) | |
| # ── Wiring ──────────────────────────────────────────────────────────── | |
| def analyze_flight(origin, dest, dep_date, ret_date, adults, emergency, monitoring, | |
| kiwi, amadeus_k, amadeus_s, hf_tok, telegram_t, telegram_c, | |
| pass_name, pass_email, pass_phone, threshold): | |
| try: | |
| db_path = os.getenv("SKYGUARDIAN_DB", "skyguardian.db") | |
| model_path = os.getenv("SKYGUARDIAN_MODEL", "drop_model.pkl") | |
| orch = Orchestrator( | |
| kiwi_key=kiwi, amadeus_key=amadeus_k, amadeus_secret=amadeus_s, | |
| telegram_token=telegram_t, telegram_chat_id=telegram_c, | |
| db_path=db_path, hf_token=hf_tok, | |
| model_path=model_path if os.path.exists(model_path) else None | |
| ) | |
| passenger = None | |
| if pass_name and pass_email and pass_phone: | |
| passenger = PassengerProfile( | |
| full_name=pass_name, email=pass_email, phone=pass_phone | |
| ) | |
| report = orch.run( | |
| origin=origin, destination=dest, | |
| departure_date=dep_date, return_date=ret_date if ret_date else None, | |
| adults=int(adults), emergency_mode=emergency, | |
| monitoring_mode=monitoring, passenger=passenger, | |
| auto_book_threshold=float(threshold) | |
| ) | |
| status = _fmt_status(report) | |
| flight = _fmt_price(report.flight) | |
| intel = _fmt_intel(report) | |
| decision = _fmt_decision(report) | |
| models = _fmt_models(report) | |
| trace = _fmt_agent_trace(report) | |
| if report.booking: | |
| if report.booking.success: | |
| booking_out = ( | |
| f"✅ Auto-booking completed!\n" | |
| f"Screenshot: {report.booking.screenshot_path}\n\n" | |
| f"{report.booking.manual_instructions}" | |
| ) | |
| else: | |
| booking_out = ( | |
| f"⚠️ Auto-booking failed: {report.booking.error}\n\n" | |
| f"{report.booking.manual_instructions}" | |
| ) | |
| elif passenger and threshold > 0: | |
| booking_out = "Auto-booking not triggered (price above threshold or non-booking decision)." | |
| else: | |
| booking_out = "Auto-booking disabled — fill passenger details and set a threshold." | |
| warnings = "" | |
| if not kiwi and not amadeus_k: | |
| warnings = "⚠️ No flight API keys configured — no live data fetched." | |
| elif report.flight.flights_found == 0: | |
| warnings = "⚠️ Limited flight data — check API key validity." | |
| return status, flight, intel, decision, booking_out, warnings, models, trace | |
| except Exception as exc: | |
| err = str(exc) | |
| return ( | |
| f"❌ ERROR: {err}", "", "", "", "", f"⚠️ {err}", "", "" | |
| ) | |
| analyze_btn.click( | |
| fn=analyze_flight, | |
| inputs=[ | |
| origin, destination, departure_date, return_date, adults, emergency, monitoring, | |
| kiwi_key, amadeus_key, amadeus_secret, hf_token, telegram_token, telegram_chat, | |
| passenger_name, passenger_email, passenger_phone, auto_threshold | |
| ], | |
| outputs=[ | |
| status_out, flight_out, intel_out, decision_out, | |
| booking_out, warnings_out, models_out, agent_trace_out | |
| ] | |
| ) | |
| return app | |
| if __name__ == "__main__": | |
| app = create_ui() | |
| app.launch(server_name="0.0.0.0", server_port=7860) | |