Spaces:
Runtime error
Runtime error
| """ | |
| Language Context Manager for Multi-Language Chat Agent | |
| This module manages programming language context for chat sessions, | |
| including language switching, prompt templates, and validation. | |
| """ | |
| import logging | |
| from typing import Optional | |
| from sqlalchemy.exc import SQLAlchemyError | |
| from ..models.language_context import LanguageContext | |
| from ..models.base import db | |
| logger = logging.getLogger(__name__) | |
| class LanguageContextError(Exception): | |
| """Base exception for language context errors.""" | |
| pass | |
| class LanguageContextManager: | |
| """ | |
| Manages programming language context for chat sessions using database persistence. | |
| Handles language switching, prompt template generation, and validation | |
| of supported programming languages with Python as the default. | |
| """ | |
| def __init__(self): | |
| """Initialize the Language Context Manager.""" | |
| pass | |
| def validate_language(self, language: str) -> bool: | |
| """ | |
| Validate if a programming language is supported. | |
| Args: | |
| language: Programming language to validate | |
| Returns: | |
| bool: True if language is supported, False otherwise | |
| """ | |
| if not language: | |
| return False | |
| return LanguageContext.is_supported_language(language.lower().strip()) | |
| def get_context(self, session_id: str) -> LanguageContext: | |
| """ | |
| Get the language context for a session. | |
| Args: | |
| session_id: Unique session identifier | |
| Returns: | |
| LanguageContext: The language context object | |
| Raises: | |
| LanguageContextError: If context retrieval fails | |
| """ | |
| try: | |
| context = LanguageContext.get_or_create_context(session_id) | |
| return context | |
| except SQLAlchemyError as e: | |
| logger.error(f"Database error getting language context: {e}") | |
| raise LanguageContextError(f"Failed to get language context: {e}") | |
| def create_context(self, session_id: str, language: str = 'python') -> LanguageContext: | |
| """ | |
| Create a new language context for a session. | |
| Args: | |
| session_id: Unique session identifier | |
| language: Programming language to set (default: python) | |
| Returns: | |
| LanguageContext: The created language context object | |
| Raises: | |
| LanguageContextError: If context creation fails | |
| """ | |
| try: | |
| if not self.validate_language(language): | |
| supported = LanguageContext.get_supported_languages() | |
| raise LanguageContextError(f"Unsupported language: {language}. Supported: {', '.join(supported)}") | |
| context = LanguageContext.create_context(session_id, language) | |
| logger.info(f"Created language context for session {session_id} with language {language}") | |
| return context | |
| except SQLAlchemyError as e: | |
| logger.error(f"Database error creating language context: {e}") | |
| raise LanguageContextError(f"Failed to create language context: {e}") | |
| def get_language(self, session_id: str) -> str: | |
| """ | |
| Get the current programming language for a session. | |
| Args: | |
| session_id: Unique session identifier | |
| Returns: | |
| str: Current programming language (defaults to Python) | |
| """ | |
| try: | |
| context = self.get_context(session_id) | |
| return context.language | |
| except LanguageContextError: | |
| logger.warning(f"Could not get language context for session {session_id}, using default") | |
| return 'python' | |
| def set_language(self, session_id: str, language: str) -> LanguageContext: | |
| """ | |
| Set the programming language for a session. | |
| Args: | |
| session_id: Unique session identifier | |
| language: Programming language to set | |
| Returns: | |
| LanguageContext: The updated language context object | |
| Raises: | |
| LanguageContextError: If language setting fails | |
| """ | |
| try: | |
| if not self.validate_language(language): | |
| supported = LanguageContext.get_supported_languages() | |
| raise LanguageContextError(f"Unsupported language: {language}. Supported: {', '.join(supported)}") | |
| context = self.get_context(session_id) | |
| context.set_language(language.lower().strip()) | |
| db.session.commit() | |
| logger.info(f"Language set to {language} for session {session_id}") | |
| return context | |
| except SQLAlchemyError as e: | |
| db.session.rollback() | |
| logger.error(f"Database error setting language: {e}") | |
| raise LanguageContextError(f"Failed to set language: {e}") | |
| def get_language_prompt_template(self, language: Optional[str] = None, session_id: Optional[str] = None) -> str: | |
| """ | |
| Get the prompt template for a specific language or session. | |
| Args: | |
| language: Programming language (optional) | |
| session_id: Session identifier (optional) | |
| Returns: | |
| str: Language-specific prompt template | |
| """ | |
| try: | |
| if session_id: | |
| context = self.get_context(session_id) | |
| return context.get_prompt_template() | |
| if language and self.validate_language(language): | |
| normalized_language = language.lower().strip() | |
| lang_config = LanguageContext.SUPPORTED_LANGUAGES.get(normalized_language, {}) | |
| return lang_config.get('prompt_template', '') | |
| # Default to Python template | |
| return LanguageContext.SUPPORTED_LANGUAGES['python']['prompt_template'] | |
| except LanguageContextError: | |
| logger.warning("Could not get prompt template, using default") | |
| return LanguageContext.SUPPORTED_LANGUAGES['python']['prompt_template'] | |
| def get_session_context_info(self, session_id: str) -> dict: | |
| """ | |
| Get complete context information for a session. | |
| Args: | |
| session_id: Unique session identifier | |
| Returns: | |
| dict: Session context including language, template, and metadata | |
| """ | |
| try: | |
| context = self.get_context(session_id) | |
| return { | |
| 'session_id': session_id, | |
| 'language': context.language, | |
| 'prompt_template': context.get_prompt_template(), | |
| 'syntax_highlighting': context.get_syntax_highlighting(), | |
| 'language_info': context.get_language_info(), | |
| 'updated_at': context.updated_at.isoformat() | |
| } | |
| except LanguageContextError as e: | |
| logger.error(f"Error getting session context info: {e}") | |
| return { | |
| 'session_id': session_id, | |
| 'language': 'python', | |
| 'error': str(e) | |
| } | |
| def remove_session_context(self, session_id: str) -> bool: | |
| """ | |
| Remove context for a session (cleanup). | |
| Args: | |
| session_id: Unique session identifier | |
| Returns: | |
| bool: True if session was removed, False if not found | |
| """ | |
| try: | |
| context = db.session.query(LanguageContext).filter( | |
| LanguageContext.session_id == session_id | |
| ).first() | |
| if context: | |
| db.session.delete(context) | |
| db.session.commit() | |
| logger.info(f"Removed context for session {session_id}") | |
| return True | |
| return False | |
| except SQLAlchemyError as e: | |
| db.session.rollback() | |
| logger.error(f"Database error removing language context: {e}") | |
| raise LanguageContextError(f"Failed to remove language context: {e}") | |
| def get_supported_languages(self) -> list: | |
| """ | |
| Get the list of supported programming languages. | |
| Returns: | |
| list: List of supported language names | |
| """ | |
| return LanguageContext.get_supported_languages() | |
| def get_language_display_names(self) -> dict: | |
| """ | |
| Get the mapping of language codes to display names. | |
| Returns: | |
| dict: Mapping of language codes to display names | |
| """ | |
| return LanguageContext.get_language_display_names() |