Update app.py

app.py

@@ -0,0 +1,406 @@
+import os
+import random
+import torch
+from flask import Flask, render_template, request, jsonify, session
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+import threading
+import json
+from datetime import datetime
+
+app = Flask(__name__)
+app.secret_key = os.environ.get('SESSION_SECRET', 'fortune-secret-key-2024')
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
+
+# Game configuration
+FORTUNE_TYPES = {
+    "love": ["romance", "relationships", "soulmate", "passion", "connection"],
+    "career": ["work", "job", "promotion", "business", "success"],
+    "health": ["wellness", "fitness", "energy", "vitality", "recovery"],
+    "wealth": ["money", "finance", "abundance", "prosperity", "investment"],
+    "general": ["future", "destiny", "path", "journey", "opportunities"]
+}
+
+TAROT_CARDS = [
+    "The Fool", "The Magician", "The High Priestess", "The Empress", "The Emperor",
+    "The Hierophant", "The Lovers", "The Chariot", "Strength", "The Hermit",
+    "Wheel of Fortune", "Justice", "The Hanged Man", "Death", "Temperance",
+    "The Devil", "The Tower", "The Star", "The Moon", "The Sun", "Judgement", "The World"
+]
+
+ZODIAC_SIGNS = [
+    "Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo",
+    "Libra", "Scorpio", "Sagittarius", "Capricorn", "Aquarius", "Pisces"
+]
+
+# Initialize model (loaded once at startup)
+model = None
+tokenizer = None
+generator = None
+model_lock = threading.Lock()
+
+def load_model():
+    """Load the model with GPU support"""
+    global model, tokenizer, generator
+    
+    try:
+        print("Loading model...")
+        
+        # Using a smaller model that's good for creative text generation
+        model_name = "microsoft/DialoGPT-small"
+        
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto" if torch.cuda.is_available() else None
+        )
+        
+        if torch.cuda.is_available():
+            model = model.cuda()
+            print(f"Model loaded on GPU: {torch.cuda.get_device_name(0)}")
+        else:
+            print("Model loaded on CPU")
+        
+        # Create text generation pipeline
+        generator = pipeline(
+            "text-generation",
+            model=model,
+            tokenizer=tokenizer,
+            device=0 if torch.cuda.is_available() else -1
+        )
+        
+        print("Model loaded successfully!")
+        return True
+        
+    except Exception as e:
+        print(f"Error loading model: {str(e)}")
+        return False
+
+def generate_fortune(fortune_type, user_input=""):
+    """Generate a fortune based on type and user input"""
+    
+    # Base prompts for different fortune types
+    prompts = {
+        "love": f"Generate a romantic fortune prediction about love and relationships. {user_input}",
+        "career": f"Generate a professional fortune prediction about career and success. {user_input}",
+        "health": f"Generate a health-related fortune prediction about wellness. {user_input}",
+        "wealth": f"Generate a financial fortune prediction about money and prosperity. {user_input}",
+        "general": f"Generate a general fortune prediction about life and future. {user_input}"
+    }
+    
+    # Select random tarot card and zodiac sign
+    tarot_card = random.choice(TAROT_CARDS)
+    zodiac_sign = random.choice(ZODIAC_SIGNS)
+    
+    try:
+        with model_lock:
+            if generator:
+                # Generate fortune text
+                prompt_text = prompts.get(fortune_type, prompts["general"])
+                full_prompt = f"As a fortune teller, {prompt_text} Mention {tarot_card} tarot card and {zodiac_sign} zodiac sign in the reading."
+                
+                generated = generator(
+                    full_prompt,
+                    max_length=200,
+                    num_return_sequences=1,
+                    temperature=0.9,
+                    top_p=0.95,
+                    do_sample=True,
+                    pad_token_id=tokenizer.eos_token_id
+                )
+                
+                fortune_text = generated[0]['generated_text']
+                
+                # Extract just the generated part (remove prompt)
+                if fortune_text.startswith(full_prompt):
+                    fortune_text = fortune_text[len(full_prompt):].strip()
+                
+            else:
+                # Fallback fortunes if model fails
+                fallback_fortunes = [
+                    f"The {tarot_card} card reveals new opportunities coming your way. As a {zodiac_sign}, embrace the changes ahead.",
+                    f"{tarot_card} guides your path. Your {zodiac_sign} energy brings luck in unexpected places.",
+                    f"Through {tarot_card}'s wisdom, your {zodiac_sign} spirit will find the answers you seek.",
+                    f"The stars align with {tarot_card}. As a {zodiac_sign}, trust your intuition in matters of the heart.",
+                    f"{tarot_card} whispers secrets of prosperity. Your {zodiac_sign} nature attracts abundance."
+                ]
+                fortune_text = random.choice(fallback_fortunes)
+                
+    except Exception as e:
+        print(f"Error generating fortune: {str(e)}")
+        fortune_text = f"The {tarot_card} card appears in your reading. As a {zodiac_sign}, the universe has mysterious plans for you. Trust the journey."
+    
+    # Create fortune object
+    fortune = {
+        "text": fortune_text,
+        "type": fortune_type,
+        "tarot_card": tarot_card,
+        "zodiac_sign": zodiac_sign,
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "lucky_number": random.randint(1, 99),
+        "color": random.choice(["Red", "Blue", "Green", "Gold", "Purple", "Silver"]),
+        "element": random.choice(["Fire", "Water", "Earth", "Air", "Spirit"])
+    }
+    
+    return fortune
+
+def generate_crystal_ball_reading():
+    """Generate a special crystal ball reading"""
+    crystals = ["Amethyst", "Quartz", "Emerald", "Sapphire", "Ruby", "Diamond", "Opal"]
+    visions = [
+        "A long journey brings new friendships",
+        "Financial windfall appears on the horizon",
+        "Unexpected news changes everything",
+        "A secret admirer reveals themselves",
+        "Creative projects bring great success",
+        "Family matters require your attention",
+        "Travel plans lead to enlightenment"
+    ]
+    
+    return {
+        "crystal": random.choice(crystals),
+        "vision": random.choice(visions),
+        "clarity": random.randint(1, 100),
+        "energy": random.choice(["High", "Medium", "Low", "Fluctuating"])
+    }
+
+@app.before_first_request
+def initialize():
+    """Initialize model before first request"""
+    load_model()
+
+@app.route('/')
+def index():
+    """Render the main page"""
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Fortune Teller 🔮</title>
+        <style>
+            body {
+                background: linear-gradient(135deg, #1a0b2e 0%, #0d0630 100%);
+                color: #e0d6ff;
+                font-family: Arial, sans-serif;
+                margin: 0;
+                padding: 20px;
+            }
+            .container {
+                max-width: 800px;
+                margin: 0 auto;
+                text-align: center;
+            }
+            h1 {
+                color: #ffd700;
+                margin-bottom: 30px;
+            }
+            .fortune-types {
+                display: flex;
+                flex-wrap: wrap;
+                gap: 10px;
+                justify-content: center;
+                margin: 20px 0;
+            }
+            .fortune-type {
+                padding: 10px 20px;
+                background: #6a4c93;
+                border: none;
+                color: white;
+                border-radius: 5px;
+                cursor: pointer;
+            }
+            .fortune-type:hover {
+                background: #8a6cbb;
+            }
+            #question {
+                width: 100%;
+                padding: 10px;
+                margin: 20px 0;
+                background: rgba(255,255,255,0.1);
+                border: 1px solid #6a4c93;
+                color: white;
+                border-radius: 5px;
+            }
+            #generate {
+                padding: 15px 30px;
+                background: #ffd700;
+                border: none;
+                border-radius: 5px;
+                font-size: 16px;
+                cursor: pointer;
+                margin: 10px 0;
+            }
+            #result {
+                margin-top: 30px;
+                padding: 20px;
+                background: rgba(0,0,0,0.3);
+                border-radius: 10px;
+                text-align: left;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>🔮 Mystic Fortune Teller 🔮</h1>
+            <div>Select a fortune type and ask your question:</div>
+            
+            <div class="fortune-types">
+                <button class="fortune-type" onclick="selectType('love')">💖 Love</button>
+                <button class="fortune-type" onclick="selectType('career')">💼 Career</button>
+                <button class="fortune-type" onclick="selectType('health')">🏥 Health</button>
+                <button class="fortune-type" onclick="selectType('wealth')">💰 Wealth</button>
+                <button class="fortune-type" onclick="selectType('general')">✨ General</button>
+            </div>
+            
+            <textarea id="question" placeholder="Ask your question here... (optional)" rows="3"></textarea>
+            <br>
+            <button id="generate" onclick="generateFortune()">Generate Fortune</button>
+            
+            <div id="result"></div>
+            <div id="loading" style="display:none;">Generating fortune... 🔮</div>
+        </div>
+        
+        <script>
+            let selectedType = 'general';
+            
+            function selectType(type) {
+                selectedType = type;
+                document.querySelectorAll('.fortune-type').forEach(btn => {
+                    btn.style.background = '#6a4c93';
+                });
+                event.target.style.background = '#ff6b6b';
+            }
+            
+            function generateFortune() {
+                const question = document.getElementById('question').value;
+                const loading = document.getElementById('loading');
+                const result = document.getElementById('result');
+                
+                loading.style.display = 'block';
+                result.innerHTML = '';
+                
+                fetch('/api/generate-fortune', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        type: selectedType,
+                        question: question
+                    })
+                })
+                .then(response => response.json())
+                .then(data => {
+                    loading.style.display = 'none';
+                    if (data.success) {
+                        const fortune = data.fortune;
+                        result.innerHTML = `
+                            <h3>Your Fortune 🔮</h3>
+                            <p>${fortune.text}</p>
+                            <hr>
+                            <div>
+                                <strong>Tarot Card:</strong> ${fortune.tarot_card}<br>
+                                <strong>Zodiac Sign:</strong> ${fortune.zodiac_sign}<br>
+                                <strong>Lucky Number:</strong> ${fortune.lucky_number}<br>
+                                <strong>Lucky Color:</strong> ${fortune.color}<br>
+                                <strong>Element:</strong> ${fortune.element}<br>
+                                <small>${fortune.timestamp}</small>
+                            </div>
+                        `;
+                    } else {
+                        result.innerHTML = `<p style="color:red;">Error: ${data.error}</p>`;
+                    }
+                })
+                .catch(error => {
+                    loading.style.display = 'none';
+                    result.innerHTML = `<p style="color:red;">Error: ${error}</p>`;
+                });
+            }
+        </script>
+    </body>
+    </html>
+    """
+
+@app.route('/api/generate-fortune', methods=['POST'])
+def api_generate_fortune():
+    """API endpoint to generate fortune"""
+    try:
+        data = request.get_json()
+        fortune_type = data.get('type', 'general')
+        user_question = data.get('question', '')
+        
+        if fortune_type not in FORTUNE_TYPES:
+            fortune_type = 'general'
+        
+        # Generate fortune
+        fortune = generate_fortune(fortune_type, user_question)
+        
+        # Add crystal ball reading for special effect
+        if random.random() > 0.7:  # 30% chance
+            fortune['crystal_ball'] = generate_crystal_ball_reading()
+        
+        # Store in session (last 5 fortunes)
+        if 'fortunes' not in session:
+            session['fortunes'] = []
+        
+        session['fortunes'] = [fortune] + session['fortunes'][:4]
+        session.modified = True
+        
+        return jsonify({
+            'success': True,
+            'fortune': fortune,
+            'gpu_enabled': torch.cuda.is_available()
+        })
+        
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+@app.route('/api/history', methods=['GET'])
+def api_history():
+    """Get fortune history"""
+    fortunes = session.get('fortunes', [])
+    return jsonify({
+        'success': True,
+        'fortunes': fortunes,
+        'count': len(fortunes)
+    })
+
+@app.route('/api/clear-history', methods=['POST'])
+def api_clear_history():
+    """Clear fortune history"""
+    session['fortunes'] = []
+    session.modified = True
+    return jsonify({'success': True})
+
+@app.route('/api/system-info', methods=['GET'])
+def api_system_info():
+    """Get system information"""
+    return jsonify({
+        'gpu_available': torch.cuda.is_available(),
+        'gpu_name': torch.cuda.get_device_name(0) if torch.cuda.is_available() else None,
+        'model_loaded': model is not None,
+        'python_version': os.sys.version
+    })
+
+@app.route('/health')
+def health_check():
+    """Health check endpoint"""
+    return jsonify({
+        'status': 'healthy',
+        'model_loaded': model is not None,
+        'gpu': torch.cuda.is_available()
+    })
+
+if __name__ == '__main__':
+    # Load model at startup
+    load_model()
+    
+    # Run the app
+    app.run(
+        host='0.0.0.0',
+        port=int(os.environ.get('PORT', 5000)),
+        debug=os.environ.get('DEBUG', 'False').lower() == 'true'
+    )