""" 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 config import SearchConfig 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, config: SearchConfig, text_encoder: Optional[BgeEncoder] = None, translator: Optional[Translator] = None ): """ Initialize query parser. Args: config: SearchConfig instance text_encoder: Text embedding encoder (lazy loaded if not provided) translator: Translator instance (lazy loaded if not provided) """ self.config = config self._text_encoder = text_encoder self._translator = translator # Initialize components self.normalizer = QueryNormalizer() self.language_detector = LanguageDetector() self.rewriter = QueryRewriter(config.query_config.rewrite_dictionary) @property def text_encoder(self) -> BgeEncoder: """Lazy load text encoder.""" if self._text_encoder is None and self.config.query_config.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 self.config.query_config.enable_translation: logger.info("Initializing translator (lazy load)...") self._translator = Translator( api_key=self.config.query_config.translation_api_key, use_cache=True, glossary_id=self.config.query_config.translation_glossary_id, translation_context=self.config.query_config.translation_context ) 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 self.config.query_config.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 self.config.query_config.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 self.config.query_config.enable_text_embedding and domain == "default"): # Only generate vector for default domain # Get thresholds from config chinese_limit = self.config.query_config.embedding_disable_chinese_char_limit english_limit = self.config.query_config.embedding_disable_english_word_limit # Check if embedding should be disabled for short queries should_disable_embedding = False disable_reason = None if detected_lang == 'zh': # For Chinese: disable embedding if character count <= threshold char_count = len(query_text.strip()) if char_count <= chinese_limit: should_disable_embedding = True disable_reason = f"中文查询字数({char_count}) <= {chinese_limit}，禁用向量搜索" log_info(disable_reason) if context: context.store_intermediate_result('embedding_disabled_reason', disable_reason) else: # For English: disable embedding if word count <= threshold word_count = len(query_text.strip().split()) if word_count <= english_limit: should_disable_embedding = True disable_reason = f"英文查询单词数({word_count}) <= {english_limit}，禁用向量搜索" log_info(disable_reason) if context: context.store_intermediate_result('embedding_disabled_reason', disable_reason) if not should_disable_embedding: 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()