query/query_parser.py

"""
Query parser - main module for query processing.
Handles query rewriting, translation, and embedding generation.
"""
from typing import Dict, List, Optional, Any
import numpy as np
import logging
from embeddings import BgeEncoder
from search.query_config import (
    ENABLE_TEXT_EMBEDDING,
    ENABLE_TRANSLATION,
    REWRITE_DICTIONARY,
    TRANSLATION_API_KEY,
    TRANSLATION_SERVICE
)
from .language_detector import LanguageDetector
from .translator import Translator
from .query_rewriter import QueryRewriter, QueryNormalizer
logger = logging.getLogger(__name__)
class ParsedQuery:
    """Container for parsed query results."""
    def __init__(
        self,
        original_query: str,
        normalized_query: str,
        rewritten_query: Optional[str] = None,
        detected_language: str = "unknown",
        translations: Dict[str, str] = None,
        query_vector: Optional[np.ndarray] = None,
        domain: str = "default"
    ):
        self.original_query = original_query
        self.normalized_query = normalized_query
        self.rewritten_query = rewritten_query or normalized_query
        self.detected_language = detected_language
        self.translations = translations or {}
        self.query_vector = query_vector
        self.domain = domain
    def to_dict(self) -> Dict[str, Any]:
        """Convert to dictionary representation."""
        result = {
            "original_query": self.original_query,
            "normalized_query": self.normalized_query,
            "rewritten_query": self.rewritten_query,
            "detected_language": self.detected_language,
            "translations": self.translations,
            "domain": self.domain,
            "has_vector": self.query_vector is not None
        }
        return result
class QueryParser:
    """
    Main query parser that processes queries through multiple stages:
    1. Normalization
    2. Query rewriting (brand/category mappings, synonyms)
    3. Language detection
    4. Translation to target languages
    5. Text embedding generation (for semantic search)
    """
    def __init__(
        self,
        text_encoder: Optional[BgeEncoder] = None,
        translator: Optional[Translator] = None
    ):
        """
        Initialize query parser.
        Args:
            text_encoder: Text embedding encoder (lazy loaded if not provided)
            translator: Translator instance (lazy loaded if not provided)
        """
        self._text_encoder = text_encoder
        self._translator = translator
        # Initialize components
        self.normalizer = QueryNormalizer()
        self.language_detector = LanguageDetector()
        self.rewriter = QueryRewriter(REWRITE_DICTIONARY)
    @property
    def text_encoder(self) -> BgeEncoder:
        """Lazy load text encoder."""
        if self._text_encoder is None and ENABLE_TEXT_EMBEDDING:
            logger.info("Initializing text encoder (lazy load)...")
            self._text_encoder = BgeEncoder()
        return self._text_encoder
    @property
    def translator(self) -> Translator:
        """Lazy load translator."""
        if self._translator is None and ENABLE_TRANSLATION:
            logger.info("Initializing translator (lazy load)...")
            self._translator = Translator(
                api_key=TRANSLATION_API_KEY,
                use_cache=True,
                glossary_id=None,  # Can be added to query_config if needed
                translation_context='e-commerce product search'
            )
        return self._translator
    def parse(self, query: str, generate_vector: bool = True, context: Optional[Any] = None) -> ParsedQuery:
        """
        Parse query through all processing stages.
        Args:
            query: Raw query string
            generate_vector: Whether to generate query embedding
            context: Optional request context for tracking and logging
        Returns:
            ParsedQuery object with all processing results
        """
        # Initialize logger if context provided
        logger = context.logger if context else None
        if logger:
            logger.info(
                f"开始查询解析 | 原查询: '{query}' | 生成向量: {generate_vector}",
                extra={'reqid': context.reqid, 'uid': context.uid}
            )
        def log_info(msg):
            if context and hasattr(context, 'logger'):
                context.logger.info(msg, extra={'reqid': context.reqid, 'uid': context.uid})
            else:
                logger.info(msg)
        def log_debug(msg):
            if context and hasattr(context, 'logger'):
                context.logger.debug(msg, extra={'reqid': context.reqid, 'uid': context.uid})
            else:
                logger.debug(msg)
        # Stage 1: Normalize
        normalized = self.normalizer.normalize(query)
        log_debug(f"标准化完成 | '{query}' -> '{normalized}'")
        if context:
            context.store_intermediate_result('normalized_query', normalized)
        # Extract domain if present (e.g., "brand:Nike" -> domain="brand", query="Nike")
        domain, query_text = self.normalizer.extract_domain_query(normalized)
        log_debug(f"域提取 | 域: '{domain}', 查询: '{query_text}'")
        if context:
            context.store_intermediate_result('extracted_domain', domain)
            context.store_intermediate_result('domain_query', query_text)
        # Stage 2: Query rewriting
        rewritten = None
        if REWRITE_DICTIONARY:  # Enable rewrite if dictionary exists
            rewritten = self.rewriter.rewrite(query_text)
            if rewritten != query_text:
                log_info(f"查询重写 | '{query_text}' -> '{rewritten}'")
                query_text = rewritten
                if context:
                    context.store_intermediate_result('rewritten_query', rewritten)
                    context.add_warning(f"查询被重写: {query_text}")
        # Stage 3: Language detection
        detected_lang = self.language_detector.detect(query_text)
        log_info(f"语言检测 | 检测到语言: {detected_lang}")
        if context:
            context.store_intermediate_result('detected_language', detected_lang)
        # Stage 4: Translation
        translations = {}
        if ENABLE_TRANSLATION:
            try:
                # Determine target languages for translation
                # Simplified: always translate to Chinese and English
                target_langs_for_translation = ['zh', 'en']
                target_langs = self.translator.get_translation_needs(
                    detected_lang,
                    target_langs_for_translation
                )
                if target_langs:
                    log_info(f"开始翻译 | 源语言: {detected_lang} | 目标语言: {target_langs}")
                    # Use e-commerce context for better disambiguation
                    translation_context = 'e-commerce product search'
                    translations = self.translator.translate_multi(
                        query_text,
                        target_langs,
                        source_lang=detected_lang,
                        context=translation_context
                    )
                    log_info(f"翻译完成 | 结果: {translations}")
                    if context:
                        context.store_intermediate_result('translations', translations)
                        for lang, translation in translations.items():
                            if translation:
                                context.store_intermediate_result(f'translation_{lang}', translation)
            except Exception as e:
                error_msg = f"翻译失败 | 错误: {str(e)}"
                log_info(error_msg)
                if context:
                    context.add_warning(error_msg)
        # Stage 5: Text embedding
        query_vector = None
        if (generate_vector and
            ENABLE_TEXT_EMBEDDING and
            domain == "default"):  # Only generate vector for default domain
            try:
                log_debug("开始生成查询向量")
                query_vector = self.text_encoder.encode([query_text])[0]
                log_debug(f"查询向量生成完成 | 形状: {query_vector.shape}")
                if context:
                    context.store_intermediate_result('query_vector_shape', query_vector.shape)
            except Exception as e:
                error_msg = f"查询向量生成失败 | 错误: {str(e)}"
                log_info(error_msg)
                if context:
                    context.add_warning(error_msg)
        # Build result
        result = ParsedQuery(
            original_query=query,
            normalized_query=normalized,
            rewritten_query=rewritten,
            detected_language=detected_lang,
            translations=translations,
            query_vector=query_vector,
            domain=domain
        )
        if context and hasattr(context, 'logger'):
            context.logger.info(
                f"查询解析完成 | 原查询: '{query}' | 最终查询: '{rewritten or query_text}' | "
                f"语言: {detected_lang} | 域: {domain} | "
                f"翻译数量: {len(translations)} | 向量: {'是' if query_vector is not None else '否'}",
                extra={'reqid': context.reqid, 'uid': context.uid}
            )
        else:
            logger.info(
                f"查询解析完成 | 原查询: '{query}' | 最终查询: '{rewritten or query_text}' | "
                f"语言: {detected_lang} | 域: {domain}"
            )
        return result
    def get_search_queries(self, parsed_query: ParsedQuery) -> List[str]:
        """
        Get list of queries to search (original + translations).
        Args:
            parsed_query: Parsed query object
        Returns:
            List of query strings to search
        """
        queries = [parsed_query.rewritten_query]
        # Add translations
        for lang, translation in parsed_query.translations.items():
            if translation and translation != parsed_query.rewritten_query:
                queries.append(translation)
        return queries
    def update_rewrite_rules(self, rules: Dict[str, str]) -> None:
        """
        Update query rewrite rules.
        Args:
            rules: Dictionary of pattern -> replacement mappings
        """
        for pattern, replacement in rules.items():
            self.rewriter.add_rule(pattern, replacement)
    def get_rewrite_rules(self) -> Dict[str, str]:
        """Get current rewrite rules."""
        return self.rewriter.get_rules()