Qwen

app.py

@@ -1,4 +1,68 @@
-"""
+def detect_language_heuristic(text: str) -> str:
+    """
+    Detect language using regex patterns (no external dependencies).
+    Supports: Urdu (ur), Arabic (ar), English (en)
+    """
+    if not text or not text.strip():
+        return "en"
+    
+    # Check for Urdu/Arabic script (Unicode ranges)
+    # Arabic: U+0600–U+06FF, U+0750–U+077F, U+08A0–U+08FF
+    # Urdu uses Arabic script with additional characters
+    if re.search(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]', text):
+        # Distinguish between Urdu and Arabic based on specific characters
+        # Urdu-specific: ٹ پ ڈ ڑ ژ ک گ ھ ہ ے
+        urdu_chars = r'[\u0679\u067E\u0688\u0691\u0698\u06A9\u06AF\u06BE\u06C1\u06D2]'
+        if re.search(urdu_chars, text):
+            return "ur"
+        # Check for common Urdu words in Arabic script
+        urdu_words = ['ہے', 'کا', 'کی', 'کے', 'میں', 'نے', 'سے', 'کو', 'اور', 'یہ']
+        if any(word in text for word in urdu_words):
+            return "ur"
+        return "ar"  # Default to Arabic for generic Arabic script
+    
+    # Roman Urdu detection (transliterated Urdu using Latin script)
+    roman_urdu_words = [
+        "ap", "aap", "kya", "kyun", "kyon", "kr", "kar", "karo", "kare",
+        "hain", "hai", "ho", "hun", "hoon", "tha", "thi", "the",
+        "shukriya", "masla", "bhai", "bhaiyya", "yaar", "dost",
+        "alaikum", "assalam", "walaikum", "salaam",
+        "inshallah", "mashallah", "subhanallah", "alhamdulillah",
+        "nahi", "nahin", "kuch", "kuch", "kal", "aj", "abhi",
+        "mein", "main", "ne", "ko", "se", "ka", "ki", "ke",
+        "acha", "thik", "bilkul", "zaroor", "shayad"
+    ]
+    
+    text_lower = text.lower()
+    words = re.findall(r'\b\w+\b', text_lower)
+    
+    # Count Roman Urdu word matches
+    urdu_matches = sum(1 for word in words if word in roman_urdu_words)
+    
+    # If we have significant Roman Urdu matches (at least 20% of words or 2+ matches)
+    if len(words) > 0:
+        match_ratio = urdu_matches / len(words)
+        if urdu_matches >= 2 or (match_ratio >= 0.2 and len(words) <= 20):
+            return "ur"
+    
+    # Default to English
+    return "en" "yaar", "dost",
+        "alaikum", "assalam", "walaikum", "salaam",
+        "inshallah", "mashallah", "subhanallah", "alhamdulillah",
+        "nahi", "nahin", "kuch", "kuch", "kal", "aj", "abhi",
+        "mein", "main", "ne", "ko", "se", "ka", "ki", "ke",
+        "acha", "thik", "bilkul", "zaroor", "shayad"
+    ]
+    
+    text_lower = text.lower()
+    words = re.findall(r'\b\w+\b', text_lower)
+    
+    # Count Roman Urdu word matches
+    urdu_matches = sum(1 for word in words if word in roman_urdu_words)
+    
+    # If we have significant Roman Urdu matches (at least 20% of words or 2+ matches)
+    if len(words) > 0:
+        match"""
 Enhanced Abdullah Bot API - Combining structured journey management with refined persona architecture.
 Improvements from Path of the Awaited integration:
 - Enhanced tone detection with multilingual support (Arabic/Urdu keywords)
@@ -22,10 +86,7 @@ import random
 import json
 import requests
 from db_helper import DB
-from langdetect import detect, DetectorFactory
-
-# Ensure consistent language detection
-DetectorFactory.seed = 0
+# No external language detection library needed - using regex-based detection
 
 # Logging setup
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
@@ -34,24 +95,16 @@ logger = logging.getLogger("enhanced_abdullah_bot_api")
 # DB instance
 db = DB()
 
-# Model configuration
-MODEL_ID = "large-traversaal/Alif-1.0-3B-Instruct"
-QUANTIZATION_CONFIG = BitsAndBytesConfig(
-    load_in_4bit=True,
-    bnb_4bit_compute_dtype=torch.float16,
-    bnb_4bit_use_double_quant=True,
-    bnb_4bit_quant_type="nf4"
-)
+# HF Inference API Configuration (FREE TIER COMPATIBLE - no local model)
+# Using non-gated model for instant access
+HF_API_URL = "https://api-inference.huggingface.co/models/Qwen/Qwen2-1.5B-Instruct"
+HF_TOKEN = os.getenv("HF_TOKEN", "")  # Optional for public models
 MAX_NEW_TOKENS = 256
 TEMPERATURE = 0.7
 MAX_QUERY_LENGTH = 1000
 
-# Lazy load globals
-model = None
-tokenizer = None
-pipe = None
-device = "cuda" if torch.cuda.is_available() else "cpu"
-logger.info(f"Detected device: {device}")
+# No local model loading needed - using HF serverless API
+logger.info("Using HF Inference API (Free Tier Compatible)")
 
 # Load MCQs
 with open('mcqs.json', 'r') as f:
@@ -275,45 +328,83 @@ def sanitize_user_input(text: str) -> str:
     t = re.sub(r"\s+", " ", t)
     return t
 
-def load_model():
-    """Load model with fallback mechanism"""
-    global model, tokenizer, pipe, device
-    if model is None:
+def query_hf_inference_api(prompt: str, max_retries: int = 3) -> str:
+    """
+    Query HuggingFace Inference API (Free Tier Compatible)
+    No local model loading required
+    Works with public models (no token needed) or private models (with token)
+    """
+    headers = {}
+    if HF_TOKEN:  # Only add auth header if token exists
+        headers["Authorization"] = f"Bearer {HF_TOKEN}"
+    
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "max_new_tokens": MAX_NEW_TOKENS,
+            "temperature": TEMPERATURE,
+            "do_sample": True,
+            "return_full_text": False
+        }
+    }
+    
+    for attempt in range(max_retries):
         try:
-            logger.info("Loading model with 4-bit quantization...")
-            quantization_config = QUANTIZATION_CONFIG if device == "cuda" else None
-            model = AutoModelForCausalLM.from_pretrained(
-                MODEL_ID,
-                quantization_config=quantization_config,
-                device_map="auto" if device == "cuda" else None,
-                torch_dtype=torch.float16 if device == "cuda" else torch.float32,
-                low_cpu_mem_usage=True
-            )
-            tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-            if tokenizer.pad_token is None:
-                tokenizer.pad_token = tokenizer.eos_token
-            tokenizer.padding_side = "left"
-            pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, 
-                          device_map="auto" if device == "cuda" else 0)
-            logger.info("Model loaded successfully on %s.", device)
+            response = requests.post(HF_API_URL, headers=headers, json=payload, timeout=60)
+            
+            # Handle model loading (first request after sleep)
+            if response.status_code == 503:
+                error_data = response.json()
+                if "loading" in str(error_data).lower():
+                    estimated_time = error_data.get("estimated_time", 20)
+                    logger.info(f"Model loading, waiting {estimated_time}s...")
+                    if attempt < max_retries - 1:
+                        import time
+                        time.sleep(min(estimated_time, 30))  # Cap at 30s
+                        continue
+                    return "Model is waking up. Please retry in 20 seconds, insha'Allah."
+            
+            # Handle gated model error
+            if response.status_code == 401 or response.status_code == 403:
+                logger.error("Model access denied - check if model is gated or token is valid")
+                return "Service requires authentication. Please contact administrator."
+            
+            response.raise_for_status()
+            result = response.json()
+            
+            # Handle different response formats
+            if isinstance(result, list) and len(result) > 0:
+                generated = result[0].get("generated_text", "")
+                # Clean up response (remove prompt echo if present)
+                if "<|im_start|>assistant" in generated:
+                    generated = generated.split("<|im_start|>assistant")[-1].split("<|im_end|>")[0]
+                return generated.strip()
+            elif isinstance(result, dict):
+                generated = result.get("generated_text", "")
+                if "<|im_start|>assistant" in generated:
+                    generated = generated.split("<|im_start|>assistant")[-1].split("<|im_end|>")[0]
+                return generated.strip()
+            
+            return ""
+            
+        except requests.Timeout:
+            logger.warning(f"HF API timeout on attempt {attempt + 1}")
+            if attempt < max_retries - 1:
+                import time
+                time.sleep(2)
+                continue
+            return "Response timeout. Please try again, insha'Allah."
         except Exception as e:
-            logger.error(f"Model loading failed: {str(e)}")
-            try:
-                logger.info("Attempting CPU fallback without quantization...")
-                model = AutoModelForCausalLM.from_pretrained(
-                    MODEL_ID, torch_dtype=torch.float32, low_cpu_mem_usage=True
-                )
-                tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-                if tokenizer.pad_token is None:
-                    tokenizer.pad_token = tokenizer.eos_token
-                tokenizer.padding_side = "left"
-                pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
-                logger.info("Fallback CPU model loaded.")
-            except Exception as fallback_e:
-                logger.error(f"Fallback failed: {str(fallback_e)}. Using mock for testing.")
-                model = None
-
-# Islamic reference fetching (enhanced with retry logic)
+            logger.error(f"HF API error on attempt {attempt + 1}: {e}")
+            if attempt < max_retries - 1:
+                import time
+                time.sleep(2)
+                continue
+            return f"Service temporarily unavailable. Please try again."
+    
+    return "Unable to generate response. Please try again."
+
+# Islamic reference fetching (production-ready with robust fallback)
 def fetch_islamic_reference(query: str, category: str = "General", max_retries: int = 3) -> str:
     """
     Dynamically fetch Quran / Hadith references with URL resilience and safe fallback.
@@ -440,23 +531,23 @@ def generate_friend_chat(user_id: str, category: str = None, is_reminder: bool =
     
     return " ".join([greeting, random.choice(assistance), islamic_ref, reminder]).strip()
 
-# Updated generate_mcqs (uses pending if exists)
+# MCQ generation (unchanged)
 def generate_mcqs(category: str, journey: Dict, num: int = 5) -> List[Dict]:
-    pending = db.get_pending_questions(journey["id"])
-    if pending:
-        return pending  # Resume from DB
-    base_questions = random.sample(MCQ_BY_CAT.get(category, []), min(num, len(MCQ_BY_CAT.get(category, []))))
+    """Generate MCQs from base set and loopholes"""
+    base_questions = random.sample(
+        MCQ_BY_CAT.get(category, []), 
+        min(num, len(MCQ_BY_CAT.get(category, [])))
+    )
     mcqs = [{"question": q, "options": MCQ_OPTIONS} for q in base_questions]
-    
+   
     if journey.get("main_loopholes"):
         loopholes = journey["main_loopholes"]
         for i in range(num - len(mcqs)):
             loophole = random.choice(loopholes) if loopholes else "general growth"
             mcqs.append({
-                "question": f"Follow-up on past loophole ({loophole[:30]}): Have you improved? (Broad view for complete picture)",
+                "question": f"Follow-up on past area ({loophole[:30]}): Have you improved?",
                 "options": MCQ_OPTIONS
             })
-    db.update_pending_questions(journey["id"], mcqs)  # Save new batch
     return mcqs
 
 def parse_answers(query: str) -> List[Dict]:
@@ -493,32 +584,25 @@ def parse_answers(query: str) -> List[Dict]:
 
 def compute_summary(answers: List[Dict], category: str, journey: Dict) -> Tuple[Dict, List]:
     """Compute progress summary and identify loopholes"""
-
     if not answers:
         return journey.get("cumulative_summary", {}), journey.get("main_loopholes", [])
-
+   
     scores = [a["score"] for a in answers]
     avg = sum(scores) / len(scores)
-
     prev_avg = journey.get("overall_avg_score", 0)
     new_avg = (prev_avg * 0.7 + avg * 0.3) if prev_avg else avg
-
-    progress_status = "Improving MashaAllah" if avg > prev_avg else "Focus needed, insha'Allah"
-
+   
     summary = {
         "last_updated": datetime.now().isoformat(),
         "overall_avg": round(new_avg, 2),
         "recent_answers": len(answers),
-        "progress_note": f"Recent avg: {round(avg, 2)}/5 | {progress_status}"
+        "progress_note": f"Recent avg: {round(avg, 2)}/5 | {'Improving MashaAllah' if avg > prev_avg else 'Focus needed, insha'Allah'}"
     }
-
-    low_answers = [a for a in answers if a.get("score", 0) < 3]
-    new_loopholes = [f"Low in Q{a.get('question_num')}" for a in low_answers]
-
-    all_loopholes = list(
-        set(journey.get("main_loopholes", []) + new_loopholes)
-    )
-
+   
+    low_answers = [a for a in answers if a["score"] < 3]
+    new_loopholes = [f"Low in Q{a['question_num']}" for a in low_answers]
+    all_loopholes = list(set(journey.get("main_loopholes", []) + new_loopholes))
+   
     return summary, all_loopholes
 
 # Pydantic models
@@ -546,10 +630,13 @@ app = FastAPI(title="Enhanced Abdullah Bot API")
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""
-    load_model()
-    if model is None:
-        return {"status": "Partial OK (Mock Mode)", "device": device}
-    return {"status": "OK", "device": device, "model": MODEL_ID}
+    return {
+        "status": "OK", 
+        "mode": "HF Inference API (Free Tier)",
+        "model": "Qwen/Qwen2-1.5B-Instruct (public, non-gated)",
+        "api_available": True,
+        "token_configured": bool(HF_TOKEN)
+    }
 
 @app.post("/chat", response_model=ChatResponse)
 async def chat_endpoint(request: ChatRequest, background_tasks: BackgroundTasks):
@@ -567,25 +654,6 @@ async def chat_endpoint(request: ChatRequest, background_tasks: BackgroundTasks)
     tone_key = detect_tone(query)
     intent = detect_intent(query)
     
-    if model is None:
-        background_tasks.add_task(load_model)
-        friend_msg = generate_friend_chat(user_id, category, tone=tone_key)
-        return ChatResponse(
-            status="loading_model",
-            voice_answer="Assalamu alaikum, I'm waking up now. Have patience—just like we wait for Fajr in the dark.",
-            current_mcqs=None,
-            answers_summary=None,
-            cumulative_summary=None,
-            follow_up=None,
-            references=fetch_islamic_reference("patience", category),
-            next_action_guidance={
-                "type": "wait_and_retry",
-                "message": "First load may take 30-90 seconds. Please retry in a moment, insha'Allah.",
-                "suggested_delay_hours": None,
-                "islamic_reminder": fetch_islamic_reference("patience", category)
-            }
-        )
-    
     # DB: Get user/journey
     user = db.get_or_create_user(user_id)
     db.update_user_last_seen(user_id)
@@ -595,66 +663,99 @@ async def chat_endpoint(request: ChatRequest, background_tasks: BackgroundTasks)
     # Log user message
     db.add_chat_message(user_id, query, is_from_bot=False, category_context=category)
     
+    # Case A: Start/Continue Journey
     if "start" in query.lower() or "journey" in query.lower():
-        pending = db.get_pending_questions(journey["id"])
+        pending = journey.get("pending_questions", [])
         if pending:
             mcqs = pending
         else:
-            mcqs = generate_mcqs(category, journey)
+            mcqs = generate_mcqs(category, journey, num=6)
+            db.update_journey(journey["id"], pending_questions=mcqs)
+        
+        friend_msg = generate_friend_chat(user_id, category, tone=tone_key)
         
-        friend_msg = generate_friend_chat(user_id, category)
-        response = ChatResponse(
+        return ChatResponse(
             status="asking_questions",
+            voice_answer=friend_msg,
             current_mcqs=mcqs,
             answers_summary=None,
             cumulative_summary=prev_summary,
-            friend_chat_message=friend_msg,
+            follow_up="Take your time to reflect on each question. Answer when ready, numbered format works best.",
             next_action_guidance={
                 "type": "answer_current_batch",
-                "message": "Please answer these questions when you can (you may do it in parts). Reply numbered, e.g., '1. Often, 2. Rarely'.",
+                "message": "Reply with numbered answers, e.g., '1. Often, 2. Rarely'",
                 "suggested_delay_hours": None,
                 "islamic_reminder": fetch_islamic_reference("reflection", category)
             }
         )
     
     # Case B: Submit Answers
-    elif request.answers:
+    elif request.answers or any(re.search(r'\d+\.\s*[A-Za-z]+', query) for _ in [1]):
         answers = parse_answers(query)
-        # Save
+        
+        if not answers:
+            return ChatResponse(
+                status="need_clarification",
+                voice_answer="I didn't catch your answers clearly. Please use numbered format: '1. Often, 2. Sometimes'",
+                current_mcqs=journey.get("pending_questions", [])[:6],
+                cumulative_summary=prev_summary,
+                follow_up="Would you like me to resend the questions?",
+                next_action_guidance={
+                    "type": "answer_current_batch",
+                    "message": "Use clear numbered format for answers",
+                    "suggested_delay_hours": None
+                }
+            )
+        
+        # Save answers
         for ans in answers:
-            db.add_answer(journey["id"], f"Q{ans.get('question_num', 0)}", ans["answer"], ans["score"])
+            db.add_answer(journey["id"], f"Q{ans.get('question_num', 0)}", 
+                         ans["answer"], ans["score"])
         
         new_summary, new_loopholes = compute_summary(answers, category, journey)
-        db.update_journey(journey["id"], cumulative_summary=new_summary, main_loopholes=new_loopholes, overall_avg_score=new_summary["overall_avg"])
+        db.update_journey(
+            journey["id"],
+            cumulative_summary=new_summary,
+            main_loopholes=new_loopholes,
+            overall_avg_score=new_summary["overall_avg"]
+        )
         
-        # Update pending
-        pending = db.get_pending_questions(journey["id"])
-        remaining = [q for q in pending if q["question"] not in [f"Q{a['question_num']}" for a in answers]]
-        db.update_pending_questions(journey["id"], remaining)
+        # Update pending questions
+        remaining = [q for q in journey.get("pending_questions", []) 
+                    if q["question"] not in [f"Q{a['question_num']}" for a in answers]]
+        db.update_journey(journey["id"], pending_questions=remaining)
         
         if not remaining:
             new_mcqs = []
             status = "session_complete"
             guidance_type = "wait_for_reminder"
+            voice_msg = f"Alhamdulillah, {user_id}! Session complete. Your progress: {new_summary['progress_note']}"
         else:
             new_mcqs = remaining[:6]
             status = "need_more_answers"
             guidance_type = "answer_current_batch"
+            voice_msg = f"JazakAllah khair, {user_id}. {len(answers)} answers recorded. Continue when ready."
         
-        friend_msg = generate_friend_chat(user_id, category, is_reminder=True)
-        response = ChatResponse(
+        friend_msg = generate_friend_chat(user_id, category, is_reminder=True, tone=tone_key)
+        
+        return ChatResponse(
             status=status,
+            voice_answer=voice_msg,
+            middle_section=new_summary.get('progress_note'),
+            middle_label="Progress Summary",
             current_mcqs=new_mcqs,
             answers_summary={"batch_avg": round(sum(a["score"] for a in answers) / len(answers), 2)},
             cumulative_summary=new_summary,
-            friend_chat_message=friend_msg,
+            follow_up=friend_msg if status == "session_complete" else "Continue with remaining questions when ready.",
             next_action_guidance={
                 "type": guidance_type,
-                "message": "Great progress! Reflect on this batch. Insha'Allah, continue.",
+                "message": "Great progress! Reflect on these insights, insha'Allah." if status == "session_complete" 
+                          else "Answer remaining questions at your pace.",
                 "suggested_delay_hours": 24 if status == "session_complete" else None,
                 "islamic_reminder": fetch_islamic_reference("gratitude", category)
             }
         )
+    
     # Case C: Meta-question (asking about bot's behavior)
     elif is_meta_question(query):
         meta_response = (
@@ -697,24 +798,17 @@ async def chat_endpoint(request: ChatRequest, background_tasks: BackgroundTasks)
         )
         
         try:
-            generated = pipe(
-                prompt, 
-                max_new_tokens=MAX_NEW_TOKENS, 
-                temperature=TEMPERATURE, 
-                do_sample=True
-            )
-            raw_text = generated[0]["generated_text"]
-            response_text = raw_text.split("<|im_start|>assistant")[-1].strip().split("<|im_end|>")[0].strip()
+            response_text = query_hf_inference_api(prompt)
             
-            if not response_text:
+            if not response_text or "Model is waking up" in response_text:
                 response_text = (
                     "1) Voice Answer: Insha'Allah, reflect step by step on your query. "
-                    "Could you provide more context?\n"
+                    "The service is warming up. Could you provide more context?\n"
                     "2) Practical Takeaway: Break down your question into smaller parts.\n"
                     "3) Follow-up Suggestion: What specific aspect troubles you most?"
                 )
         except Exception as e:
-            logger.error(f"LLM generation failed: {e}")
+            logger.error(f"HF API generation failed: {e}")
             response_text = (
                 "1) Voice Answer: SubhanAllah, I encountered a brief challenge. "
                 "Let me try to help anyway.\n"
@@ -932,10 +1026,9 @@ async def root():
 
 @app.on_event("startup")
 async def startup_event():
-    """Startup event - load model in background"""
-    logger.info("🚀 Enhanced Abdullah Bot API Starting...")
-    logger.info(f"📍 Device: {device}")
-    logger.info(f"🧠 Model: {MODEL_ID}")
+    """Startup event - no model loading needed for free tier"""
+    logger.info("🚀 Enhanced Abdullah Bot API Starting (Free Tier Mode)...")
+    logger.info("📡 Using HF Inference API - No local models")
     logger.info(f"📊 MCQ Categories: {len(MCQ_BY_CAT)}")
     logger.info("بِسْمِ اللهِ الرَّحْمٰنِ الرَّحِيْمِ")