Update app.py

app.py

@@ -1,401 +1,348 @@
-from flask import Flask, render_template, request, jsonify
-from flask_socketio import SocketIO, emit
-import os
-import requests
-import json
-import uuid
-from datetime import datetime
-from dotenv import load_dotenv
-import logging
-from werkzeug.utils import secure_filename
-import random
-import asyncio
-
-# Initialize Flask and configure core settings
-app = Flask(__name__)
-app.config['SECRET_KEY'] = os.urandom(24)  # Generate a random secret key for security
-app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # Limit file uploads to 16MB
-
-# Initialize SocketIO with CORS support for development
-socketio = SocketIO(app, cors_allowed_origins="*")
-
-# Load environment variables from .env file
-load_dotenv()
-MISTRAL_API_KEY = os.getenv('MISTRAL_API_KEY')
-ELEVENLABS_API_KEY = os.getenv('ELEVENLABS_API_KEY')
-
-# Configure logging to track application behavior
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class GameState:
-    """Manages the state of all active game sessions."""
-    
-    def __init__(self):
-        """Initialize the game state manager."""
-        self.games = {}  # Dictionary to store all active games
-        self.cleanup_interval = 3600  # Cleanup inactive games every hour
-        
-    def create_game(self):
-        """Create a new game session with a unique identifier."""
-        game_id = str(uuid.uuid4())
-        self.games[game_id] = {
-            'players': [],
-            'current_phase': 'setup',
-            'recordings': {},
-            'impostor': None,
-            'votes': {},
-            'question': None,
-            'impostor_answer': None,
-            'modified_recording': None,
-            'round_number': 1,
-            'start_time': datetime.now().isoformat(),
-            'completed_rounds': [],
-            'score': {'impostor_wins': 0, 'player_wins': 0}
-        }
-        return game_id
-
-    def cleanup_inactive_games(self):
-        """Remove inactive game sessions older than 2 hours."""
-        current_time = datetime.now()
-        inactive_threshold = 7200  # 2 hours in seconds
-        
-        for game_id, game in list(self.games.items()):
-            start_time = datetime.fromisoformat(game['start_time'])
-            if (current_time - start_time).total_seconds() > inactive_threshold:
-                del self.games[game_id]
-
-# Initialize global game state
-game_state = GameState()
-
-async def generate_question():
-    """Generate an engaging question using Mistral AI."""
-    try:
-        headers = {
-            'Authorization': f'Bearer {MISTRAL_API_KEY}',
-            'Content-Type': 'application/json'
-        }
-        
-        # Craft a prompt that encourages interesting, personal questions
-        payload = {
-            'messages': [{
-                'role': 'user',
-                'content': '''Generate an engaging personal question for a social game.
-                The question should:
-                1. Encourage creative and unique responses
-                2. Be open-ended but not too philosophical
-                3. Be answerable in 15-30 seconds
-                4. Be appropriate for all ages
-                5. Spark interesting conversation
-
-                Generate only the question, without any additional text.'''
-            }]
-        }
-        
-        response = requests.post(
-            'https://api.mistral.ai/v1/chat/completions',
-            headers=headers,
-            json=payload,
-            timeout=10  # Set timeout to handle slow responses
-        )
-        
-        if response.status_code == 200:
-            question = response.json()['choices'][0]['message']['content'].strip()
-            logger.info(f"Generated question: {question}")
-            return question
-        else:
-            logger.error(f"Mistral API error: {response.status_code}")
-            # Fallback questions if API fails
-            fallback_questions = [
-                "What is your favorite childhood memory?",
-                "What's the most interesting place you've ever visited?",
-                "What's a skill you'd love to master and why?",
-                "What's the best piece of advice you've ever received?"
-            ]
-            return random.choice(fallback_questions)
-            
-    except Exception as e:
-        logger.error(f"Error generating question: {str(e)}")
-        return "What is your favorite memory from your childhood?"
-
-async def generate_impostor_answer(question):
-    """Generate a convincing impostor response using Mistral AI."""
-    try:
-        headers = {
-            'Authorization': f'Bearer {MISTRAL_API_KEY}',
-            'Content-Type': 'application/json'
-        }
-        
-        # Craft a detailed prompt for generating a natural response
-        prompt = f'''Given the question "{question}", generate a detailed and convincing personal response.
-        The response should:
-        1. Sound natural and conversational
-        2. Be 2-3 sentences long
-        3. Include specific details to sound authentic
-        4. Be suitable for text-to-speech conversion
-        5. Avoid complex words or punctuation that might affect voice synthesis
-        
-        Generate only the response, without any additional context.'''
-        
-        payload = {
-            'messages': [{
-                'role': 'user',
-                'content': prompt
-            }]
-        }
-        
-        response = requests.post(
-            'https://api.mistral.ai/v1/chat/completions',
-            headers=headers,
-            json=payload,
-            timeout=10
-        )
-        
-        if response.status_code == 200:
-            answer = response.json()['choices'][0]['message']['content'].strip()
-            logger.info(f"Generated impostor answer: {answer}")
-            return answer
-        else:
-            logger.error(f"Mistral API error generating answer: {response.status_code}")
-            return "I have an interesting story about that, but I'd need more time to explain it properly."
-            
-    except Exception as e:
-        logger.error(f"Error generating impostor answer: {str(e)}")
-        return "I have an interesting story about that, but I'd need more time to explain it properly."
-
-async def clone_voice(audio_file):
-    """Clone a voice using ElevenLabs API."""
-    try:
-        headers = {
-            'xi-api-key': ELEVENLABS_API_KEY
-        }
-        
-        with open(audio_file, 'rb') as f:
-            files = {
-                'files': ('recording.wav', f, 'audio/wav')
-            }
-            
-            response = requests.post(
-                'https://api.elevenlabs.io/v1/voices/add',
-                headers=headers,
-                files=files,
-                timeout=30
-            )
-            
-        if response.status_code == 200:
-            voice_id = response.json().get('voice_id')
-            logger.info(f"Successfully cloned voice: {voice_id}")
-            return voice_id
-        else:
-            logger.error(f"ElevenLabs voice cloning error: {response.status_code}")
-            return None
-            
-    except Exception as e:
-        logger.error(f"Error cloning voice: {str(e)}")
-        return None
-
-async def generate_cloned_speech(voice_id, text):
-    """Generate speech using ElevenLabs with a cloned voice."""
-    try:
-        headers = {
-            'xi-api-key': ELEVENLABS_API_KEY,
-            'Content-Type': 'application/json'
-        }
-        
-        payload = {
-            'text': text,
-            'voice_settings': {
-                'stability': 0.75,
-                'similarity_boost': 0.75
-            }
-        }
-        
-        response = requests.post(
-            f'https://api.elevenlabs.io/v1/text-to-speech/{voice_id}',
-            headers=headers,
-            json=payload,
-            timeout=30
-        )
-        
-        if response.status_code == 200:
-            filename = f"temp/impostor_audio_{uuid.uuid4()}.mp3"
-            with open(filename, 'wb') as f:
-                f.write(response.content)
-            logger.info(f"Generated cloned speech: {filename}")
-            return filename
-        else:
-            logger.error(f"ElevenLabs speech generation error: {response.status_code}")
-            return None
-            
-    except Exception as e:
-        logger.error(f"Error generating cloned speech: {str(e)}")
-        return None
-
-@app.route('/')
-def home():
-    """Serve the main game page."""
-    return render_template('index.html')
-
-@app.route('/api/start_game', methods=['POST'])
-async def start_game():
-    """Initialize a new game session."""
-    try:
-        data = request.get_json()
-        game_id = data.get('game_id')
-        
-        if game_id not in game_state.games:
-            return jsonify({'error': 'Game not found'}), 404
-            
-        game = game_state.games[game_id]
-        
-        # Generate question for the round
-        question = await generate_question()
-        game['question'] = question
-        game['current_phase'] = 'recording'
-        
-        return jsonify({
-            'status': 'success',
-            'question': question
-        })
-        
-    except Exception as e:
-        logger.error(f"Error starting game: {str(e)}")
-        return jsonify({'error': 'Internal server error'}), 500
-
-@app.route('/api/submit_recording', methods=['POST'])
-async def submit_recording():
-    """Handle voice recording submissions."""
-    try:
-        game_id = request.form.get('game_id')
-        player_id = request.form.get('player_id')
-        audio_file = request.files.get('audio')
-        
-        if not all([game_id, player_id, audio_file]):
-            return jsonify({'error': 'Missing required data'}), 400
-            
-        if game_id not in game_state.games:
-            return jsonify({'error': 'Game not found'}), 404
-            
-        # Save the recording
-        filename = secure_filename(f"recording_{game_id}_{player_id}.wav")
-        filepath = os.path.join('temp', filename)
-        audio_file.save(filepath)
-        
-        game_state.games[game_id]['recordings'][player_id] = filepath
-        
-        return jsonify({'status': 'success'})
-        
-    except Exception as e:
-        logger.error(f"Error submitting recording: {str(e)}")
-        return jsonify({'error': 'Internal server error'}), 500
-
-@app.route('/api/process_impostor', methods=['POST'])
-async def process_impostor():
-    """Handle the complete impostor voice generation process."""
-    try:
-        data = request.get_json()
-        game_id = data.get('game_id')
-        impostor_id = data.get('impostor_id')
-        
-        if game_id not in game_state.games:
-            return jsonify({'error': 'Game not found'}), 404
-            
-        game = game_state.games[game_id]
-        
-        # Generate impostor's answer
-        impostor_answer = await generate_impostor_answer(game['question'])
-        game['impostor_answer'] = impostor_answer
-        
-        # Get impostor's original recording
-        original_recording = game['recordings'].get(impostor_id)
-        if not original_recording:
-            return jsonify({'error': 'Original recording not found'}), 404
-        
-        # Clone voice
-        voice_id = await clone_voice(original_recording)
-        if not voice_id:
-            return jsonify({'error': 'Voice cloning failed'}), 500
-            
-        # Generate modified speech
-        audio_file = await generate_cloned_speech(voice_id, impostor_answer)
-        if not audio_file:
-            return jsonify({'error': 'Speech generation failed'}), 500
-            
-        game['modified_recording'] = audio_file
-        
-        return jsonify({
-            'status': 'success',
-            'audio_url': audio_file
-        })
-        
-    except Exception as e:
-        logger.error(f"Error processing impostor: {str(e)}")
-        return jsonify({'error': 'Internal server error'}), 500
-
-@socketio.on('join_game')
-def handle_join_game(data):
-    """Handle a player joining the game."""
-    game_id = data.get('game_id')
-    player_name = data.get('player_name')
-    
-    if game_id in game_state.games:
-        game = game_state.games[game_id]
-        if len(game['players']) < 5:
-            player_id = len(game['players']) + 1
-            game['players'].append({
-                'id': player_id,
-                'name': player_name
-            })
-            emit('player_joined', {
-                'player_id': player_id,
-                'player_name': player_name
-            }, broadcast=True, room=game_id)
-
-@socketio.on('submit_vote')
-def handle_vote(data):
-    """Process player votes and determine round outcome."""
-    game_id = data.get('game_id')
-    voter_id = data.get('voter_id')
-    vote_for = data.get('vote_for')
-    
-    if game_id in game_state.games:
-        game = game_state.games[game_id]
-        game['votes'][voter_id] = vote_for
-        
-        # Check if all players have voted
-        if len(game['votes']) == len(game['players']):
-            # Calculate results
-            votes_count = {}
-            for vote in game['votes'].values():
-                votes_count[vote] = votes_count.get(vote, 0) + 1
-            
-            most_voted = max(votes_count.items(), key=lambda x: x[1])[0]
-            
-            # Update scores
-            if most_voted == game['impostor']:
-                game['score']['player_wins'] += 1
-            else:
-                game['score']['impostor_wins'] += 1
-            
-            # Store round results
-            game['completed_rounds'].append({
-                'round_number': game['round_number'],
-                'impostor': game['impostor'],
-                'votes': game['votes'].copy(),
-                'most_voted': most_voted
-            })
-            
-            # Emit results
-            emit('round_result', {
-                'impostor': game['impostor'],
-                'most_voted': most_voted,
-                'votes': game['votes'],
-                'score': game['score']
-            }, broadcast=True, room=game_id)
-
-if __name__ == '__main__':
-    # Create temporary directory for recordings if it doesn't exist
-    os.makedirs('temp', exist_ok=True)
-    
-    # Start the server
+from flask import Flask, render_template, request, jsonify
+from flask_socketio import SocketIO, emit, join_room, leave_room
+import os
+import requests
+import json
+import uuid
+from datetime import datetime
+from dotenv import load_dotenv
+import logging
+from werkzeug.utils import secure_filename
+import random
+import asyncio
+
+# Initialize Flask and configure core settings
+app = Flask(__name__)
+app.config['SECRET_KEY'] = os.urandom(24)
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
+
+# Initialize SocketIO with CORS support and logging
+socketio = SocketIO(app, cors_allowed_origins="*", logger=True, engineio_logger=True, async_mode='eventlet')
+
+# Load environment variables
+load_dotenv()
+MISTRAL_API_KEY = os.getenv('MISTRAL_API_KEY')
+ELEVENLABS_API_KEY = os.getenv('ELEVENLABS_API_KEY')
+
+# Configure logging with more detailed format
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class GameState:
+    """Manages the state of all active game sessions."""
+    
+    def __init__(self):
+        self.games = {}
+        self.cleanup_interval = 3600
+        
+    def create_game(self):
+        """Creates a new game session with proper initialization."""
+        try:
+            game_id = str(uuid.uuid4())
+            self.games[game_id] = {
+                'players': [],
+                'current_phase': 'setup',
+                'recordings': {},
+                'impostor': None,
+                'votes': {},
+                'question': None,
+                'impostor_answer': None,
+                'modified_recording': None,
+                'round_number': 1,
+                'start_time': datetime.now().isoformat(),
+                'completed_rounds': [],
+                'score': {'impostor_wins': 0, 'player_wins': 0},
+                'room': game_id  # Add room for socket management
+            }
+            logger.info(f"Successfully created game with ID: {game_id}")
+            return game_id
+        except Exception as e:
+            logger.error(f"Error creating game: {str(e)}")
+            raise
+
+    def get_game(self, game_id):
+        """Safely retrieves a game by ID."""
+        game = self.games.get(game_id)
+        if not game:
+            logger.error(f"Game not found: {game_id}")
+            raise ValueError("Game not found")
+        return game
+
+    def cleanup_inactive_games(self):
+        """Removes inactive game sessions."""
+        current_time = datetime.now()
+        for game_id, game in list(self.games.items()):
+            start_time = datetime.fromisoformat(game['start_time'])
+            if (current_time - start_time).total_seconds() > 7200:  # 2 hours
+                del self.games[game_id]
+                logger.info(f"Cleaned up inactive game: {game_id}")
+
+# Initialize global game state
+game_state = GameState()
+
+@app.route('/')
+def home():
+    """Serves the main game page."""
+    return render_template('index.html')
+
+@socketio.on('connect')
+def handle_connect():
+    """Handles client connection."""
+    logger.info(f"Client connected: {request.sid}")
+    emit('connection_success', {'status': 'connected'})
+
+@socketio.on('disconnect')
+def handle_disconnect():
+    """Handles client disconnection."""
+    logger.info(f"Client disconnected: {request.sid}")
+
+@socketio.on('create_game')
+def handle_create_game():
+    """Handles game creation request."""
+    try:
+        game_id = game_state.create_game()
+        join_room(game_id)  # Create socket room for the game
+        logger.info(f"Created and joined game room: {game_id}")
+        emit('game_created', {
+            'gameId': game_id,
+            'status': 'success'
+        })
+    except Exception as e:
+        logger.error(f"Error in game creation: {str(e)}")
+        emit('game_error', {
+            'error': 'Failed to create game',
+            'details': str(e)
+        })
+
+@socketio.on('join_game')
+def handle_join_game(data):
+    """Handles player joining a game."""
+    try:
+        game_id = data.get('gameId')
+        player_name = data.get('playerName')
+
+        if not game_id or not player_name:
+            raise ValueError("Missing game ID or player name")
+
+        game = game_state.get_game(game_id)
+        
+        # Validate player count
+        if len(game['players']) >= 5:
+            raise ValueError("Game is full")
+
+        # Add player to game
+        player_id = len(game['players']) + 1
+        player = {
+            'id': player_id,
+            'name': player_name,
+            'socket_id': request.sid
+        }
+        game['players'].append(player)
+        
+        # Join socket room
+        join_room(game_id)
+        logger.info(f"Player {player_name} (ID: {player_id}) joined game {game_id}")
+
+        # Broadcast to all players in the game
+        emit('player_joined', {
+            'playerId': player_id,
+            'playerName': player_name,
+            'status': 'success'
+        }, room=game_id)
+
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"Error in handle_join_game: {error_msg}")
+        emit('game_error', {'error': error_msg})
+
+@app.route('/api/start_game', methods=['POST'])
+async def start_game():
+    """Initializes a new game round."""
+    try:
+        data = request.get_json()
+        game_id = data.get('gameId')
+
+        if not game_id:
+            raise ValueError("Missing game ID")
+
+        game = game_state.get_game(game_id)
+        
+        # Validate player count
+        if len(game['players']) < 3:
+            raise ValueError("Need at least 3 players to start")
+
+        # Generate question using Mistral AI
+        question = await generate_question()
+        game['question'] = question
+        game['current_phase'] = 'recording'
+        
+        logger.info(f"Started game {game_id} with question: {question}")
+        
+        # Notify all players in the game room
+        socketio.emit('round_started', {
+            'question': question
+        }, room=game_id)
+
+        return jsonify({
+            'status': 'success',
+            'question': question
+        })
+
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"Error starting game: {error_msg}")
+        return jsonify({
+            'status': 'error',
+            'error': error_msg
+        }), 500
+
+async def generate_question():
+    """Generates an engaging question using Mistral AI."""
+    try:
+        headers = {
+            'Authorization': f'Bearer {MISTRAL_API_KEY}',
+            'Content-Type': 'application/json'
+        }
+        
+        payload = {
+            'messages': [{
+                'role': 'user',
+                'content': '''Generate an engaging personal question for a social game.
+                The question should:
+                1. Encourage creative and unique responses
+                2. Be open-ended but not too philosophical
+                3. Be answerable in 15-30 seconds
+                4. Be appropriate for all ages
+                5. Spark interesting conversation
+
+                Generate only the question, without any additional text.'''
+            }]
+        }
+        
+        response = requests.post(
+            'https://api.mistral.ai/v1/chat/completions',
+            headers=headers,
+            json=payload,
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            question = response.json()['choices'][0]['message']['content'].strip()
+            logger.info(f"Generated question: {question}")
+            return question
+            
+        logger.error(f"Mistral API error: {response.status_code}")
+        return random.choice([
+            "What's your favorite childhood memory?",
+            "What's the most interesting place you've ever visited?",
+            "What's a skill you'd love to master and why?",
+            "What's the best piece of advice you've ever received?"
+        ])
+            
+    except Exception as e:
+        logger.error(f"Error generating question: {str(e)}")
+        return "What is your favorite memory from your childhood?"
+
+@app.route('/api/submit_recording', methods=['POST'])
+async def submit_recording():
+    """Handles voice recording submissions."""
+    try:
+        game_id = request.form.get('gameId')
+        player_id = request.form.get('playerId')
+        audio_file = request.files.get('audio')
+        
+        if not all([game_id, player_id, audio_file]):
+            raise ValueError("Missing required data")
+            
+        game = game_state.get_game(game_id)
+        
+        # Save the recording
+        filename = secure_filename(f"recording_{game_id}_{player_id}.wav")
+        filepath = os.path.join('temp', filename)
+        audio_file.save(filepath)
+        
+        game['recordings'][player_id] = filepath
+        logger.info(f"Saved recording for player {player_id} in game {game_id}")
+        
+        # Notify all players about the new recording
+        socketio.emit('recording_submitted', {
+            'playerId': player_id,
+            'status': 'success'
+        }, room=game_id)
+        
+        return jsonify({'status': 'success'})
+        
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"Error submitting recording: {error_msg}")
+        return jsonify({
+            'status': 'error',
+            'error': error_msg
+        }), 500
+
+@socketio.on('submit_vote')
+def handle_vote(data):
+    """Processes player votes and determines round outcome."""
+    try:
+        game_id = data.get('gameId')
+        voter_id = data.get('voterId')
+        vote_for = data.get('voteFor')
+        
+        if not all([game_id, voter_id, vote_for]):
+            raise ValueError("Missing vote data")
+        
+        game = game_state.get_game(game_id)
+        game['votes'][voter_id] = vote_for
+        
+        # Check if all players have voted
+        if len(game['votes']) == len(game['players']):
+            # Calculate results
+            votes_count = {}
+            for vote in game['votes'].values():
+                votes_count[vote] = votes_count.get(vote, 0) + 1
+            
+            most_voted = max(votes_count.items(), key=lambda x: x[1])[0]
+            
+            # Update scores
+            if most_voted == game['impostor']:
+                game['score']['player_wins'] += 1
+                result = 'players_win'
+            else:
+                game['score']['impostor_wins'] += 1
+                result = 'impostor_wins'
+            
+            # Store round results
+            game['completed_rounds'].append({
+                'round_number': game['round_number'],
+                'impostor': game['impostor'],
+                'votes': game['votes'].copy(),
+                'most_voted': most_voted,
+                'result': result
+            })
+            
+            # Emit results to all players
+            emit('round_result', {
+                'impostor': game['impostor'],
+                'most_voted': most_voted,
+                'votes': game['votes'],
+                'score': game['score'],
+                'result': result
+            }, room=game_id)
+            
+            logger.info(f"Round completed for game {game_id}. Result: {result}")
+
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"Error processing vote: {error_msg}")
+        emit('game_error', {'error': error_msg})
+
+if __name__ == '__main__':
+    # Create temporary directory for recordings
+    os.makedirs('temp', exist_ok=True)
+    
+    # Start the server
+    logger.info("Starting server...")
     socketio.run(app, host='0.0.0.0', port=7860, debug=True)