Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+bazi_training_data.jsonl filter=lfs diff=lfs merge=lfs -text

bazi_training_data.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:77ab7c88badabeabf1c9141ccfcd0377a1746abcadf87c16a9420c68c0f9c591
+size 1186265441

dataset_generator.py

@@ -0,0 +1,1072 @@
+#!/usr/bin/env python3
+"""
+Dataset Generator for BaZi Fortune Telling
+Uses Google Gemini Pro 2.5 with thinking to generate high-quality training data
+Supports multithreaded processing for faster generation
+"""
+
+import json
+import random
+import time
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import os
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from threading import Lock
+import threading
+
+# Add parent directory to path to import modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from bazi_calculator import BaziCalculator, compute_birth_pillars
+from bazi_favorable_elements import calculate_favorable_elements
+
+# Import Google Gemini
+try:
+    from google import genai
+    from google.genai import types
+except ImportError:
+    print("Please install google-genai: pip install google-genai")
+    sys.exit(1)
+
+# Gemini API Configuration
+GEMINI_API_KEY = "AIzaSyCqe3vjvPlo1lt_hpQ4nqAC0-_1omva1oc"
+os.environ["GEMINI_API_KEY"] = GEMINI_API_KEY
+
+# Configuration for multithreading
+MAX_WORKERS = 10  # Number of concurrent threads for API calls
+RATE_LIMIT_DELAY = 0.5  # Delay between API calls to avoid rate limiting
+
+# Thread-safe locks
+file_lock = Lock()
+progress_lock = Lock()
+print_lock = Lock()
+api_call_lock = Lock()
+last_api_call_time = 0
+
+# Global context cache for system prompt
+context_cache = None
+cache_lock = Lock()
+
+
+def format_bazi_production_style(person: Dict, bazi_data: Dict) -> str:
+    """Format BaZi data in production website style"""
+    lines = []
+    birth_date = bazi_data['birth_date']
+    pillars = bazi_data['birth_pillars']
+    fav_elems = bazi_data['favorable_elements']
+    future_data = bazi_data['future_data']
+    calculator = bazi_data['calculator']
+    
+    # Current date for query
+    current_date = datetime.now()
+    
+    # Header
+    lines.append("=== BaZi Data ===")
+    lines.append(f"Name: {person['name']}")
+    lines.append(f"Birth: {birth_date.strftime('%Y-%m-%d %H:%M:%S')}")
+    lines.append(f"Gender: {person['gender']}")
+    lines.append(f"Query: {current_date.strftime('%Y-%m-%d %H:%M')}")
+    
+    # Calculate age
+    age = current_date.year - birth_date.year
+    if current_date.month < birth_date.month or (current_date.month == birth_date.month and current_date.day < birth_date.day):
+        age -= 1
+    lines.append(f"Age: {age}")
+    
+    # Life Stem (Day Master)
+    day_stem = pillars['day'][0]
+    # Determine strength (simplified)
+    stem_strength = "Strong" if len(fav_elems['favorable']) > len(fav_elems['unfavorable']) else "Weak"
+    lines.append(f"Life Stem: {day_stem} ({stem_strength})")
+    
+    # Favorable/Unfavorable elements
+    lines.append(f"Favorable: {', '.join(fav_elems['favorable'])}")
+    lines.append(f"Unfavorable: {', '.join(fav_elems['unfavorable'])}")
+    
+    # Four Pillars with hidden stems
+    lines.append("\n=== Four Pillars ===")
+    
+    # Get hidden stems
+    from bazi_calculator import BaziCalculator
+    calc_temp = BaziCalculator(birth_date, person['gender'].lower(), pillars)
+    
+    # Year pillar
+    year_hidden = calc_temp.BRANCH_HIDDEN_STEMS.get(pillars['year'][1], [])
+    lines.append(f"Year : {pillars['year'][0]}{pillars['year'][1]} (hidden: {', '.join(year_hidden)})")
+    
+    # Month pillar
+    month_hidden = calc_temp.BRANCH_HIDDEN_STEMS.get(pillars['month'][1], [])
+    lines.append(f"Month: {pillars['month'][0]}{pillars['month'][1]} (hidden: {', '.join(month_hidden)})")
+    
+    # Day pillar
+    day_hidden = calc_temp.BRANCH_HIDDEN_STEMS.get(pillars['day'][1], [])
+    lines.append(f"Day  : {pillars['day'][0]}{pillars['day'][1]} (hidden: {', '.join(day_hidden)})")
+    
+    # Hour pillar
+    hour_hidden = calc_temp.BRANCH_HIDDEN_STEMS.get(pillars['hour'][1], [])
+    lines.append(f"Hour : {pillars['hour'][0]}{pillars['hour'][1]} (hidden: {', '.join(hour_hidden)})")
+    
+    # Current Luck Pillar
+    lines.append("\n=== Current Luck Pillar ===")
+    for lp in future_data['luck_pillars']:
+        if lp['start_age'] <= age <= lp['end_age']:
+            lines.append(f"Age {age}: {lp['heaven']}{lp['earth']}")
+            break
+    
+    # Current Period
+    lines.append("\n=== Current Period ===")
+    
+    # Annual
+    for ap in future_data['annual_pillars']:
+        if ap['year'] == current_date.year:
+            lines.append(f"Annual:  {ap['heaven']}{ap['earth']}")
+            break
+    
+    # Monthly
+    current_month_key = f"{current_date.year}-{current_date.month:02d}"
+    if current_month_key in future_data['monthly_pillars']:
+        mp = future_data['monthly_pillars'][current_month_key]
+        lines.append(f"Monthly: {mp['heaven']}{mp['earth']}")
+    
+    # Daily
+    current_day_key = current_date.strftime("%Y-%m-%d")
+    if current_day_key in future_data['daily_pillars']:
+        dp = future_data['daily_pillars'][current_day_key]
+        lines.append(f"Daily:   {dp['heaven']}{dp['earth']}")
+    
+    # Hourly
+    current_hour = current_date.hour
+    # Map to Chinese hour
+    if current_hour == 0:
+        chinese_hour = 23
+    elif current_hour % 2 == 0:
+        chinese_hour = current_hour - 1
+    else:
+        chinese_hour = current_hour
+    
+    if chinese_hour in future_data['hourly_pillars']:
+        hp = future_data['hourly_pillars'][chinese_hour]
+        lines.append(f"Hourly:  {hp['heaven']}{hp['earth']}")
+    
+    # Future 100 Years
+    lines.append("\n=== Future 100 Years ===")
+    
+    # Luck Pillars
+    lines.append("\n[Luck Pillars]")
+    for lp in future_data['luck_pillars']:
+        lines.append(f"Age {lp['start_age']}-{lp['end_age']}: {lp['heaven']}{lp['earth']}")
+    
+    # Annual Pillars - ALL 100 years
+    lines.append("\n[Annual Pillars]")
+    for ap in future_data['annual_pillars']:
+        lines.append(f"{ap['year']}: {ap['heaven']}{ap['earth']}")
+    
+    # Monthly Pillars - Show many months
+    lines.append("\n[Monthly Pillars]")
+    monthly_keys = sorted(list(future_data['monthly_pillars'].keys()))
+    for key in monthly_keys:
+        mp = future_data['monthly_pillars'][key]
+        lines.append(f"{key}: {mp['heaven']}{mp['earth']}")
+    
+    # Daily Pillars - Show many days 
+    lines.append("\n[Daily Pillars]")
+    daily_keys = sorted(list(future_data['daily_pillars'].keys()))
+    for key in daily_keys:
+        dp = future_data['daily_pillars'][key]
+        lines.append(f"{key}: {dp['heaven']}{dp['earth']}")
+    
+    lines.append("\n[Loaded with AiMing v3]")
+    
+    return '\n'.join(lines)
+
+# Load system prompt
+def load_system_prompt() -> str:
+    """Load the system prompt from prompt-v3.txt"""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    parent_dir = os.path.dirname(script_dir)
+    prompt_path = os.path.join(parent_dir, 'prompt-v3.txt')
+    with open(prompt_path, 'r', encoding='utf-8') as f:
+        return f.read()
+
+def generate_random_birthdays(count: int = 10) -> List[Dict]:
+    """Generate random birthdays with varied demographics
+    
+    Args:
+        count: Number of random birthdays to generate
+    """
+    birthdays = []
+    
+    # Define name pools - expanded for more variety
+    male_names = ["สมชาย", "วิชัย", "ประยุทธ์", "สมศักดิ์", "วีระ", "ณัฐวุฒิ", "ธนากร", "พงษ์ศักดิ์", "อภิชาติ", "จักรพันธ์",
+                  "สุรชัย", "ประสิทธิ์", "สมพงษ์", "วิทยา", "นิพนธ์", "สุทธิพงษ์", "อนันต์", "ชัยวัฒน์", "ธีระ", "พิชัย"]
+    female_names = ["สมหญิง", "มาลี", "สุดาพร", "วิไลวรรณ", "พรทิพย์", "นันทนา", "จิราภรณ์", "ศิริพร", "อรวรรณ", "ปิยะนุช",
+                    "วรรณา", "สุภาพร", "รัตนา", "อารีย์", "ปาริชาติ", "สุนิสา", "กาญจนา", "ดวงใจ", "ชนิดา", "พิมพ์ใจ"]
+    
+    # Generate diverse birth years (1960-2005)
+    # If count > 46 (years available), allow duplicates
+    year_range = list(range(1960, 2006))
+    if count <= len(year_range):
+        years = random.sample(year_range, count)
+    else:
+        # For counts > 46, we allow some duplicate years
+        years = random.choices(year_range, k=count)
+    
+    for i in range(count):
+        gender = random.choice(["Male", "Female"])
+        name = random.choice(male_names if gender == "Male" else female_names)
+        
+        # Random month and day
+        month = random.randint(1, 12)
+        if month in [1, 3, 5, 7, 8, 10, 12]:
+            day = random.randint(1, 31)
+        elif month in [4, 6, 9, 11]:
+            day = random.randint(1, 30)
+        else:  # February
+            day = random.randint(1, 28)
+        
+        # Random time (distributed across all 12 Chinese hours)
+        hour = random.randint(0, 23)
+        minute = random.randint(0, 59)
+        
+        birthdays.append({
+            "name": f"{name}_{i+1}",
+            "gender": gender,
+            "year": years[i],
+            "month": month,
+            "day": day,
+            "hour": hour,
+            "minute": minute,
+            "is_twin": False
+        })
+    
+    return birthdays
+
+def generate_questions() -> List[str]:
+    """Generate 10 diverse questions for BaZi consultation"""
+    question_templates = [
+        # General fortune (expanded)
+        "ดวงนี้เป็นอย่างไร",
+        "ช่วงไหนในชีวิตจะประสบความสำเร็จ",
+        "มีอุปสรรคอะไรที่ต้องระวังบ้าง",
+        "ดวงชะตาโดยรวมปีนี้เป็นอย่างไร",
+        "ชีวิตโดยรวมจะเป็นอย่างไร",
+        "อนาคตของฉันจะเป็นอย่างไร",
+        "ปีนี้จะเป็นปีที่ดีไหม",
+        "ช่วงชีวิตไหนจะเจอปัญหามาก",
+        "จะมีชีวิตที่ดีขึ้นเมื่อไหร่",
+        "ดวงชะตาในระยะยาวเป็นอย่างไร",
+        "ชีวิตจะมีความสุขไหม",
+        "จะพบเจอสิ่งดีๆ เมื่อไหร่",
+        "มีเคราะห์อะไรรออยู่ไหม",
+        "ดวงจะดีขึ้นเมื่อไหร่",
+        "ชีวิตจะราบรื่นไหม",
+        "ปีไหนจะเป็นปีทอง",
+        "จะมีโชคเมื่อไหร่",
+        "ควรระวังอะไรในชีวิต",
+        "จะมีอะไรเปลี่ยนแปลงไหม",
+        "ดวงชะตาตอนแก่เป็นอย่างไร",
+        
+        # Career questions (expanded)
+        "ช่วงนี้งานการเป็นอย่างไรบ้าง มีโอกาสก้าวหน้าไหม",
+        "อยากเปลี่ยนงานใหม่ ช่วงไหนเหมาะสม",
+        "อยากทำธุรกิจส่วนตัว เหมาะไหม ควรทำธุรกิจประเภทไหน",
+        "จะได้เลื่อนตำแหน่งไหม",
+        "งานที่ทำอยู่จะมั่นคงไหม",
+        "ควรลาออกจากงานไหม",
+        "จะตกงานไหม",
+        "อาชีพอะไรเหมาะกับดวงนี้",
+        "ทำงานกับคนอื่นดีหรือทำงานคนเดียวดี",
+        "จะประสบความสำเร็จในอาชีพไหม",
+        "เจ้านายเมตตาไหม",
+        "ควรทำงานรับราชการหรือเอกชน",
+        "จะมีคนอิจฉาในที่ทำงานไหม",
+        "ควรเปลี่ยนสายงานไหม",
+        "จะได้ทำงานที่ชอบไหม",
+        "หุ้นส่วนธุรกิจจะซื่อสัตย์ไหม",
+        "ควรทำงานในประเทศหรือต่างประเทศ",
+        "จะมีปัญหาในที่ทำงานไหม",
+        "ควรรับงานฟรีแลนซ์ไหม",
+        "ธุรกิจจะอยู่รอดไหม",
+        "ควรขยายธุรกิจไหม",
+        "จะมีคู่แข่งทางธุรกิจไหม",
+        "ลูกค้าจะพอใจไหม",
+        "ควรร่วมทุนกับใครไหม",
+        "จะได้โบนัสไหม",
+        "งานที่สมัครจะได้ไหม",
+        "ควรทำอาชีพเสริมไหม",
+        "จะเป็นผู้บริหารไหม",
+        "ควรลงทุนในธุรกิจอะไร",
+        "จะมีรายได้เสริมไหม",
+        
+        # Love and relationships (expanded)
+        "เรื่องความรักเป็นอย่างไรบ้าง จะเจอคนที่ใช่เมื่อไหร่",
+        "ความรักกับแฟนปัจจุบันจะไปได้ไกลไหม",
+        "ปีนี้มีโอกาสแต่งงานไหม",
+        "จะได้เจอแฟนไหม เมื่อไหร่",
+        "แฟนจะนอกใจไหม",
+        "จะมีคนมาชอบไหม",
+        "จะเลิกกับแฟนไหม",
+        "ความรักจะลงเอยด้วยดีไหม",
+        "คู่ที่เหมาะสมเป็นคนแบบไหน",
+        "จะมีกี่ครั้งในชีวิตที่รักจริง",
+        "จะโสดไปตลอดชีวิตไหม",
+        "ควรแต่งงานกับคนนี้ไหม",
+        "จะหย่าร้างไหม",
+        "จะกลับมาคืนดีกันไหม",
+        "คนที่แอบชอบจะมาบอกรักไหม",
+        "จะมีคนที่สามไหม",
+        "ควรรอคนเก่าไหม",
+        "จะเ��อรักแท้ไหม",
+        "แฟนจะดีกับเราไหม",
+        "จะมีปัญหาเรื่องความรักไหม",
+        "ควรเปิดใจให้คนใหม่ไหม",
+        "จะอกหักไหม",
+        "คนที่ชอบจะชอบเราไหม",
+        "จะแต่งงานกี่ครั้ง",
+        "คู่ชีวิตจะมาจากไหน",
+        "จะมีลูกกับคนรักไหม",
+        "ความรักระยะไกลจะสำเร็จไหม",
+        "จะเจอคนรักที่ทำงานไหม",
+        "ควรคบคนอายุเท่าไหร่",
+        "จะมีความรักออนไลน์ไหม",
+        
+        # Health (expanded)
+        "สุขภาพช่วงนี้ต้องระวังอะไรบ้าง",
+        "มีปัญหาสุขภาพเรื้อรัง จะหายไหม",
+        "ปีนี้จะป่วยไหม",
+        "เดือนนี้อาการป่วยจะดีขึ้นไหม",
+        "ดวงนี้ป่วยเป็นโรคอะไร",
+        "จะมีอายุยืนไหม",
+        "ควรระวังโรคอะไรเป็นพิเศษ",
+        "การผ่าตัดจะสำเร็จไหม",
+        "ควรไปหาหมอไหม",
+        "สุขภาพจิตจะแข็งแรงไหม",
+        "จะมีอุบัติเหตุไหม",
+        "จะมีปัญหาเรื่องน้ำหนักไหม",
+        "ควรออกกำลังกายแบบไหน",
+        "จะมีปัญหาการนอนไหม",
+        "สายตาจะมีปัญหาไหม",
+        "ฟันจะมีปัญหาไหม",
+        "จะมีอาการแพ้ไหม",
+        "ควรกินอาหารแบบไหน",
+        "จะเครียดมากไหม",
+        "จะมีปัญหาผิวหนังไหม",
+        "ระบบย่อยอาหารจะมีปัญหาไหม",
+        "จะปวดหัวบ่อยไหม",
+        "จะมีปัญหากระดูกไหม",
+        "หัวใจจะแข็งแรงไหม",
+        "จะมีปัญหาความดันไหม",
+        "จะเป็นโรคติดต่อไหม",
+        "จะมีปัญหาฮอร์โมนไหม",
+        "ควรตรวจสุขภาพเมื่อไหร่",
+        "จะติดเชื้อไหม",
+        "จะมีปัญหาการหายใจไหม",
+        
+        # Wealth and finance (expanded)
+        "การเงินปีนี้เป็นอย่างไร จะมีโชคลาภไหม",
+        "อยากลงทุนหุ้น/คริปโต เหมาะไหม",
+        "หนี้สินเยอะ จะหมดเมื่อไหร่",
+        "ดวงนี้รวยเมื่อไหร่",
+        "ดวงนี้รวยไหม",
+        "จะถูกหวยไหม",
+        "ควรลงทุนอะไร",
+        "จะล้มละลายไหม",
+        "เงินจะพอใช้ไหม",
+        "จะมีคนมาหลอกเงินไหม",
+        "ควรให้คนอื่นยืมเงินไหม",
+        "จะได้มรดกไหม",
+        "ควรซื้อบ้านหรือเช่าบ้าน",
+        "การลงทุนจะได้ผลตอบแทนดีไหม",
+        "จะมีเงินเก็บไหม",
+        "ควรฝากเงินหรือลงทุน",
+        "จะได้เงินคืนจากลูกหนี้ไหม",
+        "ควรซื้อทองไหม",
+        "จะมีรายได้พิเศษไหม",
+        "ควรเล่นพนันไหม",
+        "จะขาดทุนไหม",
+        "ควรกู้เงินไหม",
+        "จะมีเงินใช้ตอนแก่ไหม",
+        "ควรทำประกันไหม",
+        "จะมีปัญหาภาษีไหม",
+        "ควรลงทุนอสังหาริมทรัพย์ไหม",
+        "จะได้โบนัสพิเศษไหม",
+        "ควรเก็บเงินสดไหม",
+        "จะมีหนี้นอกระบบไหม",
+        "ควรขายทรัพย์สินไหม",
+        
+        # Family (expanded)
+        "ลูกๆ จะเรียนหนังสือเก่งไหม",
+        "ความสัมพันธ์ในครอบครัวจะราบรื่นไหม",
+        "จะมีลูกไหม",
+        "พ่อแม่จะมีสุขภาพดีไหม",
+        "พี่น้องจะสามัคคีกันไหม",
+        "จะมีปัญหากับญาติไหม",
+        "ลูกจะกตัญญูไหม",
+        "ควรมีลูกกี่คน",
+        "จะได้อยู่กับครอบครัวไหม",
+        "จะมีปัญหากับพ่อตาแม่ยายไหม",
+        "ลูกจะประสบความสำเร็จไหม",
+        "จะต้องดูแลพ่อแม่ไหม",
+        "พี่น้องจะช่วยเหลือไหม",
+        "จะมีปัญหาเรื่องมรดกไหม",
+        "ครอบครัวจะอบอุ่นไหม",
+        "จะมีใครในครอบครัวป่วยไหม",
+        "ลูกจะได้เรียนสูงไหม",
+        "จะมีปัญหากับคู่สมรสของลูกไหม",
+        "หลานจะน่ารักไหม",
+        "จะได้เลี้ยงหลานไหม",
+        
+        # Education and learning (expanded)
+        "จะสอบติดไหม",
+        "ควรเรียนต่อไหม",
+        "สาขาอะไรเหมาะกับฉัน",
+        "จะจบการศึกษาไหม",
+        "จะได้ทุนการศึกษาไหม",
+        "จะเรียนเก่งไหม",
+        "ควรเรียนในประเทศหรือต่างประเทศ",
+        "จะสอบตกไหม",
+        "ควรเรียนพิเศษไหม",
+        "จะมีปัญหากับอาจารย์ไหม",
+        "จะมีเพื่อนที่ดีไหม",
+        "ควรย้ายโรงเรียนไหม",
+        "จะได้เกียรตินิยมไหม",
+        "ควรเรียนภาษาอะไร",
+        "จะมีปัญหาการเรียนไหม",
+        "ควรเรียนปริญญาโทไหม",
+        "จะได้ไปแลกเปลี่ยนไหม",
+        "ควรเรียนออนไลน์ไหม",
+        "จะมีปัญหากับเพื่อนร่วมชั้นไหม",
+        "ควรเข้ามหาวิทยาลัยไหน",
+        
+        # Specific timing (expanded)
+        "เดือนหน้าจะมีเรื่องดีๆ เข้ามาไหม",
+        "ปีหน้าควรระวังเรื่องอะไรบ้าง",
+        "วันไหนในเดือนนี้เป็นวันมงคล",
+        "พรุ่งนี้จะเป็นวันที่ดีไหม",
+        "สัปดาห์นี้จะมีข่าวดีไหม",
+        "ช่วงไหนของปีจะดีที่สุด",
+        "เดือนไหนควรระมัดระวังเป็นพิเศษ",
+        "วันนี้ควรทำอะไร",
+        "คืนนี้จะนอนหลับสบายไหม",
+        "เช้านี้จะมีเรื่องดีไหม",
+        "บ่ายนี้ควรระวังอะไร",
+        "เย็นนี้จะเจอใคร",
+        "วันจันทร์จะเป็นอย่างไร",
+        "สุดสัปดาห์นี้จะสนุกไหม",
+        "เดือนนี้จะได้เงินไหม",
+        "ปีนี้จะมีอะไรเปลี่ยนแปลง",
+        "ไตรมาสนี้ธุรกิจจะดีไหม",
+        "ฤดูนี้สุขภาพจะเป็นอย่างไร",
+        "ช่วงปิดเทอมจะไปไหนไหม",
+        "วันเกิดปีนี้จะมีความสุขไหม",
+        
+        # Decision making (expanded)
+        "กำลังตัดสินใจเรื่องสำคัญ ควรเลือกทางไหน",
+        "จะย้ายบ้านดีไหม ช่วงไหนเหมาะสม",
+        "อยากไปเรียนต่อต่างประเทศ เหมาะไหม",
+        "ควรซื้อรถไหม",
+        "ควรขาย��ี่ดินไหม",
+        "ควรเริ่มทำอะไรใหม่ๆ ไหม",
+        "ควรรับข้อเสนอนี้ไหม",
+        "ควรไปหรือไม่ไป",
+        "ควรพูดความจริงไหม",
+        "ควรให้อภัยไหม",
+        "ควรเสี่ยงไหม",
+        "ควรรอหรือรีบทำ",
+        "ควรเลือกข้อ A หรือ B",
+        "ควรลงทะเบียนไหม",
+        "ควรเซ็นสัญญาไหม",
+        "ควรไว้ใจคนนี้ไหม",
+        "ควรบอกเลิกไหม",
+        "ควรเริ่มใหม่ไหม",
+        "ควรยอมรับไหม",
+        "ควรปฏิเสธไหม",
+        
+        # Travel and relocation (expanded)
+        "จะได้ไปต่างประเทศไหม",
+        "ควรย้ายไปอยู่ที่อื่นไหม",
+        "การเดินทางจะปลอดภัยไหม",
+        "ทิศไหนเหมาะกับดวง",
+        "ควรอยู่ภาคไหนของประเทศ",
+        "จะได้ไปเที่ยวไหม",
+        "ควรไปเที่ยวประเทศไหน",
+        "จะมีปัญหาระหว่างเดินทางไหม",
+        "ควรเดินทางคนเดียวหรือกับคนอื่น",
+        "จะพลาดเที่ยวบินไหม",
+        "จะทำหนังสือเดินทางหายไหม",
+        "ควรพักโรงแรมหรือบ้านเพื่อน",
+        "จะมีอุบัติเหตุทางรถไหม",
+        "ควรขับรถเองหรือนั่งรถคนอื่น",
+        "จะติดอยู่ต่างประเทศไหม",
+        
+        # Legal and disputes (expanded)
+        "คดีความจะชนะไหม",
+        "จะมีปัญหาทางกฎหมายไหม",
+        "ควรฟ้องร้องไหม",
+        "จะเจอคนโกงไหม",
+        "จะมีปัญหากับเจ้าหน้าที่ไหม",
+        "จะถูกฟ้องไหม",
+        "ควรยอมความไหม",
+        "จะมีปัญหาเอกสารไหม",
+        "ทนายความจะช่วยได้ไหม",
+        "จะต้องขึ้นศาลไหม",
+        "จะมีปัญหาสัญญาไหม",
+        "จะถูกหลอกลวงไหม",
+        "จะมีคนมาเอาเปรียบไหม",
+        "ควรแจ้งความไหม",
+        "จะได้ความยุติธรรมไหม",
+        
+        # Spiritual and luck (expanded)
+        "ธาตุอะไรเสริมดวง ควรใส่สีอะไร",
+        "เลขอะไรเป็นเลขมงคล",
+        "ควรบูชาพระเครื่องไหม",
+        "ควรทำบุญอะไร",
+        "มีกรรมเก่าอะไรติดตัวไหม",
+        "ควรแก้ชงอย่างไร",
+        "วันไหนเป็นวันดีของฉัน",
+        "ควรตั้งชื่อลูกว่าอะไร",
+        "ควรไหว้พระวันไหน",
+        "ควรสวดมนต์ไหม",
+        "จะมีสิ่งศักดิ์สิทธิ์คุ้มครองไหม",
+        "ควรใส่เครื่องรางไหม",
+        "ควรไปวัดไหนทำบุญ",
+        "จะมีบุญจากชาติก่อนไหม",
+        "ควรถือศีลไหม",
+        "จะมีเทพเจ้าช่วยไหม",
+        "ควรบนบานไหม",
+        "จะสมหวังที่บนไว้ไหม",
+        "ควรเลี้ยงสัตว์อะไร",
+        "ต้นไม้อะไรเสริมดวง",
+        
+        # Personal development (expanded)
+        "จะพัฒนาตัวเองได้อย่างไร",
+        "จุดแข็งของฉันคืออะไร",
+        "จุดอ่อนที่ควรแก้ไขคืออะไร",
+        "จะมีชื่อเสียงไหม",
+        "จะประสบความสำเร็จในชีวิตไหม",
+        "ควรทำอะไรเพื่อเปลี่ยนชีว��ต",
+        "จะเป็นคนสำคัญไหม",
+        "จะมีคนนับถือไหม",
+        "ควรเรียนรู้อะไรเพิ่ม",
+        "จะมีความสามารถพิเศษไหม",
+        "ควรฝึกทักษะอะไร",
+        "จะเป็นผู้นำไหม",
+        "จะมีคนตามไหม",
+        "ควรเปลี่ยนนิสัยอะไร",
+        "จะมีความคิดสร้างสรรค์ไหม",
+        "ควรทำงานอดิเรกอะไร",
+        "จะเก่งด้านไหน",
+        "ควรออกจากคอมฟอร์ทโซนไหม",
+        "จะมีพรสวรรค์ด้านไหน",
+        "ควรฝึกสมาธิไหม",
+        
+        # Crisis and problems (expanded)
+        "จะผ่านวิกฤตนี้ไปได้ไหม",
+        "ปัญหาจะจบเมื่อไหร่",
+        "จะมีคนช่วยเหลือไหม",
+        "ควรขอความช่วยเหลือจากใคร",
+        "สิ่งที่กังวลจะเกิดขึ้นจริงไหม",
+        "จะแก้ปัญหาได้ไหม",
+        "ควรหนีปัญหาไหม",
+        "จะมีทางออกไหม",
+        "ปัญหาจะซ้ำไหม",
+        "จะมีปัญหาใหม่ไหม",
+        "ควรเผชิญหน้ากับปัญหาไหม",
+        "จะมีคนมาสร้างปัญหาไหม",
+        "ปัญหาจะใหญ่ขึ้นไหม",
+        "ควรปล่อยวางไหม",
+        "จะเครียดมากไหม",
+        
+        # Business specific
+        "ควรเปิดร้านอาหารไหม",
+        "ธุรกิจออนไลน์จะสำเร็จไหม",
+        "ควรขายของผ่านโซเชียลไหม",
+        "จะมีลูกค้าเยอะไหม",
+        "คู่แข่งจะมากไหม",
+        "ควรทำธุรกิจครอบครัวไหม",
+        "จะขาดทุนในปีแรกไหม",
+        "ควรขอสินเชื่อธุรกิจไหม",
+        "พนักงานจะซื่อสัตย์ไหม",
+        "ควรเปิดสาขาไหม",
+        
+        # Technology and modern life
+        "ควรเรียนเขียนโปรแกรมไหม",
+        "จะประสบความสำเร็จในสายไอทีไหม",
+        "ควรทำช่อง YouTube ไหม",
+        "จะดังในโซเชียลมีเดียไหม",
+        "ควรเป็นอินฟลูเอนเซอร์ไหม",
+        "จะถูกแฮกข้อมูลไหม",
+        "ควรลงทุนใน NFT ไหม",
+        "จะติดเกมไหม",
+        "ควรทำงาน Work from home ไหม",
+        "จะมีปัญหากับเทคโนโลยีไหม",
+        
+        # Lifestyle choices
+        "ควรเป็นมังสวิรัติไหม",
+        "ควรงดเหล้าไหม",
+        "ควรเลิกบุหรี่ไหม",
+        "ควรทำศัลยกรรมไหม",
+        "ควรลดน้ำหนักไหม",
+        "ควรย้อมผมไหม",
+        "ควรเลี้ยงสัตว์ไหม",
+        "ควรอยู่คอนโดหรือบ้าน",
+        "ควรมีรถไหม",
+        "ควรใช้ชีวิตแบบมินิมอลไหม",
+        
+        # Social relationships
+        "จะมีเพื่อนแท้ไหม",
+        "เพื่อนจะทรยศไหม",
+        "ควรตัดขาดกับเพื่อนคนนี้ไหม",
+        "จะมีศัตรูไหม",
+        "คนรอบข้างจริงใจไหม",
+        "จะถูกนินทาไหม",
+        "จะมีคนอิจฉาไหม",
+        "ควรให้โอกาสเพื่อนไหม",
+        "จะโดนหักหลังไหม",
+        "ควรไว้ใจใครไหม",
+        
+        # Special occasions
+        "งานแต่งจะสำเร็จไหม",
+        "ควรจัดงานใหญ่หรือเล็ก",
+        "จะมีคนมาร่วมงานเยอะไหม",
+        "ควรเลื��อนงานไหม",
+        "งานบวชจะราบรื่นไหม",
+        "ควรทำพิธีขึ้นบ้านใหม่ไหม",
+        "จะได้รับเชิญไปงานไหม",
+        "ควรไปงานศพไหม",
+        "วันเกิดปีนี้จะพิเศษไหม",
+        "ควรฉลองอะไรไหม",
+        
+        # Retirement and elderly
+        "จะเกษียณสุขสบายไหม",
+        "ควรเกษียณเมื่อไหร่",
+        "จะมีเงินพอใช้ตอนแก่ไหม",
+        "ลูกจะดูแลไหม",
+        "ควรอยู่บ้านพักคนชราไหม",
+        "จะแก่อย่างมีความสุขไหม",
+        "จะมีโรคประจำตัวไหม",
+        "ควรทำพินัยกรรมไหม",
+        "จะได้เห็นหลานโตไหม",
+        "ควรย้ายไปอยู่ต่างจังหวัดไหม",
+    ]
+    
+    # Randomly select 3 questions
+    return random.sample(question_templates, 4)
+
+def get_bazi_data(person: Dict) -> Dict:
+    """Calculate BaZi data manually"""
+    
+    # Prepare birth datetime
+    birth_date = datetime(
+        person['year'], person['month'], person['day'],
+        person['hour'], person['minute']
+    )
+    
+    # Calculate BaZi pillars manually
+    birth_pillars = compute_birth_pillars(birth_date)
+    
+    # Calculate favorable elements
+    fav_elements = calculate_favorable_elements(birth_pillars)
+    
+    # Generate future BaZi data
+    calculator = BaziCalculator(
+        birth_datetime=birth_date,
+        gender=person['gender'],
+        birth_pillars=birth_pillars
+    )
+    
+    # Import the generate function from api_v3
+    from api_v3 import generate_future_bazi_data
+    future_data = generate_future_bazi_data(calculator, years_ahead=100)
+    
+    return {
+        'birth_pillars': birth_pillars,
+        'favorable_elements': fav_elements,
+        'future_data': future_data,
+        'birth_date': birth_date,
+        'calculator': calculator
+    }
+
+def create_or_get_context_cache(system_prompt: str) -> str:
+    """Create or retrieve context cache for the system prompt
+    
+    Returns:
+        cache_name: The name/ID of the cached context
+    """
+    global context_cache
+    
+    with cache_lock:
+        if context_cache is not None:
+            with print_lock:
+                print("  Using existing context cache for system prompt")
+            return context_cache
+        
+        try:
+            client = genai.Client(api_key=GEMINI_API_KEY)
+            
+            # Create context cache with the system prompt
+            with print_lock:
+                print("  Creating context cache for system prompt (this saves API costs)...")
+            
+            # Create cache with system instruction using the correct API format
+            # Contents is required even when using system_instruction
+            cache = client.caches.create(
+                model="gemini-2.5-pro",  # Use explicit version with context caching support
+                config=types.CreateCachedContentConfig(
+                    display_name='bazi_system_prompt',  # Identifier for the cache
+                    system_instruction=system_prompt,  # The long system prompt to cache
+                    contents=[
+                        types.Content(
+                            role="user",
+                            parts=[types.Part(text="System prompt loaded.")],
+                        )
+                    ],  # Minimal content required by API
+                    ttl="72000s",  # Cache for 20 hour (in seconds string format)
+                )
+            )
+            
+            context_cache = cache.name
+            
+            with print_lock:
+                print(f"  Context cache created: {context_cache}")
+                print(f"  Cache will save ~{len(system_prompt)//4} tokens per request")
+            
+            return context_cache
+            
+        except Exception as e:
+            with print_lock:
+                print(f"  Warning: Could not create context cache: {e}")
+                print("  Falling back to regular API calls (higher cost)")
+            return None
+
+def call_gemini_api_with_cache(user_prompt: str, cache_name: str = None, system_prompt: str = None, max_retries: int = 3) -> Tuple[str, Optional[str]]:
+    """Call Google Gemini using context caching for cost savings
+    
+    Returns:
+        Tuple of (response_text, new_cache_name or None)
+    """
+    client = genai.Client(api_key=GEMINI_API_KEY)
+    
+    for attempt in range(max_retries):
+        try:
+            # Generate response using cached context if available
+            if cache_name:
+                try:
+                    # Use cached context - must use same model as cache
+                    model = "gemini-2.5-pro"  
+                    
+                    # Prepare content for the user prompt
+                    contents = [
+                        types.Content(
+                            role="user",
+                            parts=[types.Part(text=user_prompt)],
+                        )
+                    ]
+                    
+                    config = types.GenerateContentConfig(
+                        temperature=0.7,
+                        top_k=40,
+                        top_p=0.95,
+                        max_output_tokens=7500,
+                        cached_content=cache_name  # Reference the cached content
+                    )
+                    
+                    # Generate with cached context
+                    response = client.models.generate_content(
+                        model=model,
+                        contents=contents,  # Use Content object format
+                        config=config
+                    )
+                    
+                    # Get the text from response
+                    if response.text:
+                        return response.text, cache_name  # Return existing cache name
+                    else:
+                        raise Exception("No response text generated")
+                        
+                except Exception as cache_error:
+                    # If cache fails, try to recreate it
+                    if "PERMISSION_DENIED" in str(cache_error) or "not found" in str(cache_error).lower():
+                        with print_lock:
+                            print(f"    Cache expired or not found, recreating cache...")
+                        
+                        # Try to recreate cache if system_prompt is provided
+                        if system_prompt:
+                            new_cache = create_or_get_context_cache(system_prompt)
+                            if new_cache:
+                                cache_name = new_cache
+                                with print_lock:
+                                    print(f"    Cache recreated successfully: {new_cache}")
+                                # Retry with new cache
+                                continue
+                        
+                        # If no system_prompt or cache creation failed, use regular API
+                        cache_name = None
+                    else:
+                        raise cache_error
+            
+            # If cache_name is None or cache failed, use regular API
+            if not cache_name:
+                # Fallback to regular call without caching
+                contents = [
+                    types.Content(
+                        role="user",
+                        parts=[
+                            types.Part(text=user_prompt),
+                        ],
+                    ),
+                ]
+                
+                config = types.GenerateContentConfig(
+                    temperature=0.7,
+                    top_k=40,
+                    top_p=0.95,
+                    max_output_tokens=7500,
+                )
+                
+                # Generate response (collecting all chunks)
+                response_text = ""
+                for chunk in client.models.generate_content_stream(
+                    model="gemini-2.5-pro",  # Use 2.5 pro for non-cached
+                    contents=contents,
+                    config=config,
+                ):
+                    if chunk.text:
+                        response_text += chunk.text
+                
+                if response_text:
+                    return response_text, None  # No cache used
+                else:
+                    raise Exception("No response text generated")
+                
+        except Exception as e:
+            error_str = str(e)
+            if attempt < max_retries - 1 and ("503" in error_str or "overloaded" in error_str.lower()):
+                wait_time = (attempt + 1) * 2
+                print(f"      API overloaded. Retrying in {wait_time} seconds...")
+                import time
+                time.sleep(wait_time)
+            else:
+                raise Exception(f"Gemini API error: {e}")
+
+# Keep old function for compatibility
+def call_gemini_api(prompt: str, max_retries: int = 3) -> str:
+    """Legacy function - calls the new cached version"""
+    response, _ = call_gemini_api_with_cache(prompt, None, None, max_retries)
+    return response
+
+def generate_dataset_entry(person: Dict, question: str, system_prompt: str, entry_id: str, current: int, total: int, cache_name: str = None) -> Tuple[str, Optional[Dict]]:
+    """Generate a single dataset entry (thread-safe) with context caching
+    
+    Returns:
+        Tuple of (entry_id, entry_dict or None)
+    """
+    global last_api_call_time, context_cache
+    
+    try:
+        with print_lock:
+            print(f"  [{current}/{total}] Thread-{threading.current_thread().name}: Processing {question[:50]}...")
+        
+        # Get BaZi data (this is computational, no API call)
+        bazi_data = get_bazi_data(person)
+        
+        # Format BaZi data in production style
+        bazi_formatted = format_bazi_production_style(person, bazi_data)
+        
+        # Format user prompt in production style
+        user_prompt = f"""{bazi_formatted}
+
+Question: {question}"""
+        
+        # Rate limiting for API calls
+        with api_call_lock:
+            current_time = time.time()
+            if last_api_call_time > 0:
+                elapsed = current_time - last_api_call_time
+                if elapsed < RATE_LIMIT_DELAY:
+                    time.sleep(RATE_LIMIT_DELAY - elapsed)
+            last_api_call_time = time.time()
+        
+        # Get response from Gemini using context caching
+        if cache_name:
+            # When using cache, only send the user prompt
+            response, new_cache = call_gemini_api_with_cache(user_prompt, cache_name, system_prompt)
+            # Update global cache if it was recreated
+            if new_cache and new_cache != cache_name:
+                with cache_lock:
+                    context_cache = new_cache
+                    with print_lock:
+                        print(f"    Updated global cache to: {new_cache}")
+        else:
+            # Fallback to combined prompt
+            full_prompt = f"{system_prompt}\n\n---\n\n{user_prompt}"
+            response, _ = call_gemini_api_with_cache(full_prompt, None, None)
+        
+        with print_lock:
+            print(f"    Thread-{threading.current_thread().name}: Successfully generated response")
+        
+        # Format as OpenAI training data
+        return (entry_id, {
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+                {"role": "assistant", "content": response}
+            ]
+        })
+        
+    except Exception as e:
+        with print_lock:
+            print(f"    Thread-{threading.current_thread().name}: Error - {str(e)}")
+        return (entry_id, None)
+
+def write_entry_to_file(output_file: str, entry: Dict) -> None:
+    """Thread-safe writing to file"""
+    with file_lock:
+        with open(output_file, 'a', encoding='utf-8') as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + '\n')
+            f.flush()
+
+def save_progress(progress_file: str, processed_entries: set) -> None:
+    """Thread-safe progress saving"""
+    with progress_lock:
+        with open(progress_file, 'w') as pf:
+            json.dump({'processed': list(processed_entries)}, pf)
+
+def main():
+    """Main function to generate the dataset with multithreading and context caching"""
+    print(f"Starting dataset generation with {MAX_WORKERS} worker threads...")
+    print(f"Using Google Gemini Context Caching to reduce API costs\n")
+    
+    # Load system prompt
+    system_prompt = load_system_prompt()
+    print(f"System prompt loaded: {len(system_prompt)} characters")
+    
+    # Create context cache for the system prompt to save costs
+    cache_name = create_or_get_context_cache(system_prompt)
+    if cache_name:
+        print(f"✓ Context caching enabled - will save ~{len(system_prompt)//4} tokens per request\n")
+    else:
+        print("⚠ Context caching disabled - using regular API calls\n")
+    
+    # Output file - use absolute paths based on script location
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    output_file = os.path.join(script_dir, "bazi_training_data.jsonl")
+    progress_file = os.path.join(script_dir, ".generation_progress.json")
+    
+    # Load progress if exists
+    processed_entries = set()
+    if os.path.exists(progress_file):
+        try:
+            with open(progress_file, 'r') as f:
+                progress_data = json.load(f)
+                processed_entries = set(progress_data.get('processed', []))
+                print(f"Resuming from previous run. Already processed: {len(processed_entries)} entries")
+        except:
+            processed_entries = set()
+    
+    # Count existing entries in JSONL
+    existing_count = 0
+    if os.path.exists(output_file):
+        with open(output_file, 'r', encoding='utf-8') as f:
+            existing_count = sum(1 for line in f if line.strip())
+        print(f"Found {existing_count} existing entries in {output_file}")
+    
+    # Generate random birthdays with seed for consistency
+    random.seed(18)  # Fixed seed for reproducible birthdays
+    birthdays = generate_random_birthdays(500)
+    print(f"Generated {len(birthdays)} random birthdays")
+    
+    # Prepare all tasks
+    tasks = []
+    current = 0
+    total = len(birthdays) * 4  # 4 questions per birthday
+    
+    for person in birthdays:
+        # Use seed based on person for consistent questions
+        person_seed = hash(f"{person['name']}_{person['year']}_{person['month']}_{person['day']}")
+        random.seed(person_seed)
+        questions = generate_questions()
+        
+        for question in questions:
+            current += 1
+            # Create unique ID for this entry
+            entry_id = f"{person['name']}_{person['year']}{person['month']:02d}{person['day']:02d}_{hash(question)}"
+            
+            # Skip if already processed
+            if entry_id not in processed_entries:
+                tasks.append((person, question, system_prompt, entry_id, current, total))
+    
+    print(f"\nTotal tasks to process: {len(tasks)}")
+    print(f"Already processed: {len(processed_entries)}")
+    print(f"Remaining: {len(tasks)}")
+    
+    if not tasks:
+        print("No new tasks to process. Exiting.")
+        return
+    
+    # Process tasks with thread pool
+    generated_count = 0
+    failed_count = 0
+    
+    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+        # Submit all tasks
+        future_to_task = {}
+        for task in tasks:
+            person, question, system_prompt, entry_id, idx, total = task
+            # Use the latest cache_name (might be updated by other threads)
+            current_cache = context_cache if context_cache else cache_name
+            future = executor.submit(generate_dataset_entry, person, question, system_prompt, entry_id, idx, total, current_cache)
+            future_to_task[future] = (person, question, entry_id)
+        
+        # Process completed tasks
+        for future in as_completed(future_to_task):
+            person, question, entry_id = future_to_task[future]
+            
+            try:
+                result_entry_id, entry = future.result(timeout=600)  # 10 minute timeout per task
+                
+                if entry:
+                    # Write to file
+                    write_entry_to_file(output_file, entry)
+                    
+                    # Update progress
+                    with progress_lock:
+                        processed_entries.add(result_entry_id)
+                    generated_count += 1
+                    
+                    # Save progress after EVERY entry (not just every 10)
+                    save_progress(progress_file, processed_entries)
+                    
+                    with print_lock:
+                        print(f"✓ Saved entry #{existing_count + generated_count}: {person['name']} - {question[:30]}...")
+                else:
+                    failed_count += 1
+                    with print_lock:
+                        print(f"✗ Failed: {person['name']} - {question[:30]}...")
+                        
+            except Exception as e:
+                failed_count += 1
+                with print_lock:
+                    print(f"✗ Error processing {person['name']}: {str(e)}")
+    
+    # Final progress save
+    if generated_count > 0:
+        save_progress(progress_file, processed_entries)
+    
+    print(f"\n" + "="*60)
+    print(f"Dataset generation complete!")
+    print(f"Generated: {generated_count} new entries")
+    print(f"Failed: {failed_count} entries")
+    print(f"Total entries in file: {existing_count + generated_count}")
+    print(f"Saved to: {output_file}")
+    
+    # Clean up progress file if completed successfully
+    if len(processed_entries) >= total:
+        if os.path.exists(progress_file):
+            os.remove(progress_file)
+            print("Cleaned up progress file (generation complete)")
+
+if __name__ == "__main__":
+    main()

test_format.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Test BaZi format generation"""
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from datetime import datetime
+from bazi_calculator import BaziCalculator, compute_birth_pillars
+from bazi_favorable_elements import calculate_favorable_elements
+from api_v3 import generate_future_bazi_data
+
+# Test person
+person = {
+    'name': 'TestUser',
+    'gender': 'Male',
+    'year': 1990,
+    'month': 5,
+    'day': 15,
+    'hour': 10,
+    'minute': 30,
+    'is_twin': False
+}
+
+# Prepare birth datetime
+birth_date = datetime(
+    person['year'], person['month'], person['day'],
+    person['hour'], person['minute']
+)
+
+print(f"Birth date: {birth_date}")
+
+# Calculate BaZi pillars manually
+birth_pillars = compute_birth_pillars(birth_date)
+print(f"Birth pillars: {birth_pillars}")
+
+# Calculate favorable elements
+fav_elements = calculate_favorable_elements(birth_pillars)
+print(f"Favorable elements: {fav_elements}")
+
+# Generate future BaZi data
+calculator = BaziCalculator(
+    birth_datetime=birth_date,
+    gender=person['gender'],
+    birth_pillars=birth_pillars
+)
+
+print("Generating future data...")
+future_data = generate_future_bazi_data(calculator, years_ahead=100)
+
+print(f"Generated {len(future_data['luck_pillars'])} luck pillars")
+print(f"Generated {len(future_data['annual_pillars'])} annual pillars")
+print(f"Generated {len(future_data['monthly_pillars'])} monthly pillars")
+print(f"Generated {len(future_data['daily_pillars'])} daily pillars")
+
+# Now format it
+from dataset.dataset_generator import format_bazi_production_style
+
+bazi_data = {
+    'birth_pillars': birth_pillars,
+    'favorable_elements': fav_elements,
+    'future_data': future_data,
+    'birth_date': birth_date,
+    'calculator': calculator
+}
+
+formatted = format_bazi_production_style(person, bazi_data)
+print("\n\nFormatted output:")
+print("=" * 50)
+print(formatted)

test_gemini25.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Test Gemini 2.5 Pro with google-genai"""
+
+import os
+from google import genai
+from google.genai import types
+
+# Set API key
+os.environ["GEMINI_API_KEY"] = "AIzaSyCqe3vjvPlo1lt_hpQ4nqAC0-_1omva1oc"
+
+def test_generate():
+    print("Testing Gemini 2.5 Pro...")
+    
+    client = genai.Client(
+        api_key=os.environ.get("GEMINI_API_KEY"),
+    )
+
+    model = "gemini-2.5-pro"
+    contents = [
+        types.Content(
+            role="user",
+            parts=[
+                types.Part.from_text(text="Say hello in exactly 5 words"),
+            ],
+        ),
+    ]
+    
+    generate_content_config = types.GenerateContentConfig(
+        temperature=0.7,
+        max_output_tokens=100,
+    )
+
+    print(f"Calling {model}...")
+    response_text = ""
+    
+    try:
+        for chunk in client.models.generate_content_stream(
+            model=model,
+            contents=contents,
+            config=generate_content_config,
+        ):
+            if chunk.text:
+                response_text += chunk.text
+                print(f"Chunk: {chunk.text}")
+        
+        print(f"\nFull response: {response_text}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    test_generate()

test_gen.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""Test generation to see where it hangs"""
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import asyncio
+from datetime import datetime
+import json
+import httpx
+
+# Gemini API Configuration
+GEMINI_API_KEY = "AIzaSyCqe3vjvPlo1lt_hpQ4nqAC0-_1omva1oc"
+GEMINI_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp:generateContent"
+
+async def test_gemini():
+    """Test Gemini API call"""
+    print("Testing Gemini API...")
+    
+    prompt = "Say hello in 5 words"
+    
+    headers = {
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "contents": [{
+            "parts": [{
+                "text": prompt
+            }]
+        }],
+        "generationConfig": {
+            "temperature": 0.7,
+            "topK": 40,
+            "topP": 0.95,
+            "maxOutputTokens": 100,
+        },
+        "safetySettings": [
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"}
+        ]
+    }
+    
+    print(f"Calling Gemini at: {GEMINI_ENDPOINT}")
+    
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(
+                f"{GEMINI_ENDPOINT}?key={GEMINI_API_KEY}",
+                headers=headers,
+                json=data
+            )
+            
+            print(f"Response status: {response.status_code}")
+            
+            if response.status_code == 200:
+                result = response.json()
+                print(f"Full response: {json.dumps(result, indent=2)}")
+                if 'candidates' in result and len(result['candidates']) > 0:
+                    candidate = result['candidates'][0]
+                    if 'content' in candidate and 'parts' in candidate['content']:
+                        text = candidate['content']['parts'][0]['text']
+                        print(f"Extracted text: {text}")
+                    else:
+                        print(f"No content/parts in candidate: {candidate}")
+                else:
+                    print(f"No candidates in result")
+            else:
+                print(f"Error: {response.text}")
+    except Exception as e:
+        print(f"Exception: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(test_gemini())