migrated game state to vercel app

config.py

@@ -39,101 +39,17 @@ class GameConfig(BaseModel):
     progression: Dict[str, Any]
 
 class Settings(BaseSettings):
-    # Add model config to resolve the warnings
     model_config = {
-        'protected_namespaces': (),  # This disables the protected namespace warning
-        'env_prefix': "SEMANTIX_"    # Move this from Config class to model_config
+        'protected_namespaces': (),
+        'env_prefix': "SEMANTIX_"
     }
 
-    # App settings
-    app_name: str = "Semantix API"
+    # Keep only ML-related settings
+    app_name: str = "Semantix ML API"
     version: str = "1.0.0"
     debug: bool = False
     model_url: str = "https://huggingface.co/Miroir/cc.fr.300.reduced/resolve/main/cc.fr.300.reduced.vec"
-  
     
-    # Game settings
-    current_difficulty: str = "medium"
-    game_config: Dict[str, Any] = {
-        "difficulty": {
-            "easy": {
-                "jokers_high_similarity": 3,
-                "jokers_medium_similarity": 3,
-                "words_per_joker": 5,
-                "similarity_threshold": 0.99,
-                "time_limit": 300,
-            },
-            "medium": {
-                "jokers_high_similarity": 2,
-                "jokers_medium_similarity": 2,
-                "words_per_joker": 3,
-                "similarity_threshold": 0.995,
-                "time_limit": 240,
-            },
-            "hard": {
-                "jokers_high_similarity": 1,
-                "jokers_medium_similarity": 1,
-                "words_per_joker": 2,
-                "similarity_threshold": 0.998,
-                "time_limit": 180,
-            }
-        },
-        "jokers": {
-            "similarity_ranges": {
-                "high": {"min": 0.7, "max": 0.8},
-                "medium": {"min": 0.6, "max": 0.7}
-            },
-            "cooldown": 3,
-        },
-        "scoring": {
-            "base_points": 1000,
-            "time_bonus": {
-                "enabled": True,
-                "points_per_second": 10,
-            },
-            "joker_penalty": {
-                "high_similarity": -100,
-                "medium_similarity": -50,
-            },
-            "streak_bonus": {
-                "enabled": True,
-                "threshold": 0.8,
-                "multiplier": 1.5,
-            }
-        },
-        "rules": {
-            "max_attempts": 0,
-            "min_word_length": 3,
-            "show_target_word": False,
-            "allow_partial_matches": True,
-        },
-        "interface": {
-            "history_size": 50,
-            "visualization_auto_toggle": True,
-            "visualization_moments": ["word_found", "joker_used"],
-            "feedback_levels": ["very_cold", "cold", "warm", "hot", "very_hot"],
-        },
-        "word_selection": {
-            "categories": ["general", "science", "nature", "technology"],
-            "difficulty_weights": {
-                "easy": {"common": 0.8, "uncommon": 0.2},
-                "medium": {"common": 0.5, "uncommon": 0.5},
-                "hard": {"common": 0.2, "uncommon": 0.8}
-            },
-        },
-        "progression": {
-            "levels_enabled": True,
-            "xp_per_game": 100,
-            "level_thresholds": [0, 1000, 2500, 5000, 10000],
-            "rewards": {
-                "level_2": {"bonus_joker": "high_similarity"},
-                "level_3": {"bonus_time": 60},
-                "level_4": {"bonus_joker": "medium_similarity"},
-                "level_5": {"unlimited_time": True}
-            }
-        }
-    }
-
     class Config:
         env_prefix = "SEMANTIX_"
 

main.py

@@ -13,88 +13,37 @@ from services.game_service import GameService
 from services.visualization_service import VisualizationService
 from services.study_service import StudyService
 
-# Configure logger
-logger.remove()
-logger.add(sys.stdout, level="INFO")
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Startup
-    logger.info("=" * 40)
-    logger.info(f"Starting {settings.app_name}")
-    logger.info(f"Version: {settings.version}")
-    logger.info(f"Python version: {platform.python_version()}")
-    logger.info(f"Host: {socket.gethostname()}")
-    logger.info(f"Debug mode: {settings.debug}")
-    logger.info(f"Current difficulty: {settings.current_difficulty}")
-    logger.info(f"Model URL: {settings.model_url}")
-    logger.info("=" * 40)
-    
-    yield
-    
-    # Shutdown
-    logger.info("Shutting down application")
-
-def init_services():
-    """Initialize all services"""
-    try:
-        word_service = WordEmbeddingService(settings.model_url)
-        game_service = GameService(word_service=word_service)  # Simplified
-        visualization_service = VisualizationService(word_service)
-        study_service = StudyService(word_service)
-        
-        logger.info("Services initialized successfully")
-        return word_service, game_service, visualization_service, study_service
-    
-    except Exception as e:
-        logger.error(f"Failed to initialize services: {str(e)}")
-        raise
-
-def create_app():
-    app = FastAPI(
-        title=settings.app_name,
-        version=settings.version,
-        description="WordVerse Semantic Word Game API",
-        lifespan=lifespan
-    )
-
-    # Configure CORS
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],  # Adjust this in production
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-
-    # Initialize services
-    word_service, game_service, visualization_service, study_service = init_services()
-
-    # Include routers
-    app.include_router(game.init_router(game_service, visualization_service))
-    app.include_router(health.init_router(word_service))
-    app.include_router(study.init_router(study_service))
-
-    @app.get("/")
-    async def root():
-        """Root endpoint with basic API information"""
-        return {
-            "app": settings.app_name,
-            "version": settings.version,
-            "status": "running",
-            "difficulty": settings.current_difficulty
-        }
-
-    return app
-
-app = create_app()
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(
-        "main:app", 
-        host="0.0.0.0", 
-        port=8000, 
-        reload=settings.debug,
-        log_level="info" if settings.debug else "error"
-    )
+from typing import List
+
+app = FastAPI()
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize services
+word_service = WordEmbeddingService(settings.model_url)
+visualization_service = VisualizationService(word_service)
+study_service = StudyService(word_service)
+
+# ML-focused endpoints
+@app.post("/api/similarity")
+async def calculate_similarity(word1: str, word2: str):
+    return {"similarity": await word_service.calculate_similarity(word1, word2)}
+
+@app.post("/api/similar-words/{word}")
+async def get_similar_words(word: str, n: int = 5):
+    return {"words": await word_service.get_most_similar_words(word, n)}
+
+@app.get("/api/visualization/{word}")
+async def get_visualization(word: str, context_words: List[str] = []):
+    return await visualization_service.prepare_3d_visualization(word, context_words)
+
+@app.post("/api/words-in-range")
+async def get_words_in_range(word: str, min_sim: float, max_sim: float, n: int = 5):
+    return {"words": await word_service.get_words_in_range(word, min_sim, max_sim, n)}

services/game_service.py

@@ -1,238 +0,0 @@
-# semantix-api/services/game_service.py
-import json
-from pathlib import Path
-from loguru import logger
-import random
-from typing import Dict, List
-from config import settings
-
-class GameService:
-    def __init__(self, word_service):
-        self.data_file = Path('data/game_state.json')
-        self.words_file = Path('data/word_list.json')
-        self.word_service = word_service
-        self.config = settings.get_current_game_config()
-        self.difficulty = settings.get_current_difficulty_config()
-        self._ensure_data_file()
-
-    def _ensure_data_file(self):
-        """Initialize game state file if it doesn't exist."""
-        if not self.data_file.exists():
-            self.data_file.parent.mkdir(exist_ok=True)
-            self._save_state(self._create_initial_state())
-
-    def _create_initial_state(self) -> Dict:
-        """Create a new game state with default values from config."""
-        return {
-            'target_word': self._get_random_word(),
-            'attempts': [],
-            'word_found': False,
-            'similar_words': [],
-            'jokers': {
-                'high_similarity': {
-                    'remaining': self.difficulty.jokers_high_similarity,
-                    'words_per_use': self.difficulty.words_per_joker
-                },
-                'medium_similarity': {
-                    'remaining': self.difficulty.jokers_medium_similarity,
-                    'words_per_use': self.difficulty.words_per_joker
-                }
-            }
-        }
-
-    def reset_game(self) -> Dict:
-        """Reset the game with a new random word and fresh jokers."""
-        try:
-            new_state = self._create_initial_state()
-            self._save_state(new_state)
-            return new_state
-        except Exception:
-            logger.exception("Error resetting game")
-            raise
-
-    def use_joker(self, joker_type: str) -> Dict:
-        """Use a joker to get words within a specific similarity range."""
-        try:
-            logger.info(f"Using joker of type: {joker_type}")
-            state = self._load_state()
-
-            # Validate joker type and availability
-            if joker_type not in ['high_similarity', 'medium_similarity']:
-                logger.error(f"Invalid joker type: {joker_type}")
-                raise ValueError("Invalid joker type")
-                
-            joker = state['jokers'][joker_type]
-            if joker['remaining'] <= 0:
-                logger.warning(f"No {joker_type} jokers remaining")
-                raise ValueError("No jokers remaining of this type")
-                
-            # Get similarity range from config
-            joker_ranges = self.config.jokers.similarity_ranges
-            sim_range = (
-                joker_ranges['high'].min if joker_type == 'high_similarity' else joker_ranges['medium'].min,
-                joker_ranges['high'].max if joker_type == 'high_similarity' else joker_ranges['medium'].max
-            )
-
-            target = state['target_word']
-            logger.info(f"Target word: {target}, range: {sim_range}")
-            
-            # Get words in range
-            similar_words = self.word_service.get_words_in_range(
-                target,
-                sim_range[0],
-                sim_range[1],
-                n=joker['words_per_use']
-            )
-            
-            # Log the results
-            logger.info(f"Found {len(similar_words)} words using joker:")
-            for w in similar_words:
-                logger.info(f"- {w['word']} (similarity: {w['similarity']:.3f})")
-
-            # Update joker count
-            joker['remaining'] -= 1
-            self._save_state(state)
-            
-            logger.info(f"Remaining {joker_type} jokers: {joker['remaining']}")
-            
-            return {'joker_words': similar_words, 'jokers': state['jokers']}
-
-        except Exception:
-            logger.exception("Error using joker")
-            raise
-    
-    def get_center_word_power(self, chosen_words: List[str]) -> Dict[str, float]:
-        """Compute and return the "center word" based on the user's chosen words."""
-        try:
-            state = self._load_state()
-            target_word = state['target_word']
-
-            result = self.word_service.get_center_word(chosen_words, target_word)
-            if not result:
-                logger.warning("Center word power returned no result.")
-                return {}
-            
-            logger.info(f"Center word found: {result['word']} (sim={result['similarity']:.3f})")
-            return result
-
-        except Exception:
-            logger.exception("Error computing center word power")
-            return {}
-
-    def _get_random_word(self) -> str:
-        """Get a random word from the game's word list."""
-        try:
-            with open(self.words_file, 'r', encoding='utf-8') as f:
-                words_data = json.load(f)
-                return random.choice(words_data['words'])
-        except Exception:
-            logger.exception("Error loading word list")
-            return "mathématiques"  # fallback word
-
-    def save_attempt(self, word: str, similarity: float) -> Dict:
-        """Save a word attempt and update game state."""
-        try:
-            if not word or similarity <= 0:
-                return self._load_state()
-                
-            state = self._load_state()
-            state['attempts'].append({'word': word, 'similarity': similarity})
-            
-            # Check if word is found using config threshold
-            if similarity > self.difficulty.similarity_threshold:
-                state['word_found'] = True
-                # Get similar words when the target is found
-                state['similar_words'] = self.word_service.get_most_similar_words(
-                    state['target_word'], 
-                    n=self.config.interface['history_size']
-                )
-                
-            self._save_state(state)
-            return state
-        except Exception:
-            logger.exception("Error saving attempt")
-            raise
-
-    def _save_state(self, state: Dict) -> None:
-        """Save game state to file."""
-        try:
-            self.data_file.parent.mkdir(exist_ok=True)
-            with open(self.data_file, 'w', encoding='utf-8') as f:
-                json.dump(state, f, ensure_ascii=False, indent=2)
-        except Exception:
-            logger.exception("Error saving game state")
-            raise
-
-    def _load_state(self) -> Dict:
-        """Load game state from file."""
-        try:
-            if not self.data_file.exists():
-                self._ensure_data_file()
-            with open(self.data_file, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except Exception:
-            logger.exception("Error loading game state")
-            raise
-
-    def get_state(self) -> Dict:
-        """Get current game state."""
-        try:
-            return self._load_state()
-        except Exception:
-            logger.exception("Error getting game state")
-            raise
-
-    def get_history(self) -> List[Dict]:
-        """Get history of attempts."""
-        try:
-            state = self._load_state()
-            return state['attempts']
-        except Exception:
-            logger.exception("Error getting history")
-            return []
-
-    def set_target_word(self, word: str) -> Dict:
-        """Set a specific target word for testing."""
-        try:
-            if not self.word_service.get_vector(word):
-                raise ValueError(f"Word '{word}' not found in vocabulary")
-            
-            state = self._create_initial_state()
-            state['target_word'] = word
-            self._save_state(state)
-            
-            return self.get_state()
-        except Exception:
-            logger.exception(f"Error setting target word: {word}")
-            raise
-
-    def check_word(self, word: str) -> Dict:
-        """Check a word against the target word and save the attempt."""
-        try:
-            state = self._load_state()
-            target_word = state['target_word']
-            
-            # Calculate similarity
-            similarity = self.word_service.calculate_similarity(word, target_word)
-            logger.info(f"Word: {word}, Target: {target_word}, Similarity: {similarity:.3f}")
-            
-            # Validate word length
-            if len(word) < self.config.rules.min_word_length:
-                raise ValueError(f"Word must be at least {self.config.rules.min_word_length} characters long")
-            
-            # Save attempt and get updated state
-            updated_state = self.save_attempt(word, similarity)
-            
-            response = {
-                "similarity": similarity,
-                "history": updated_state['attempts'][-self.config.interface['history_size']:],
-                "word_found": updated_state['word_found'],
-                "similar_words": updated_state.get('similar_words', [])
-            }
-            
-            logger.info(f"Sending response: {response}")
-            return response
-                
-        except Exception:
-            logger.exception(f"Error checking word: {word}")
-            raise