""" 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 from config import CustomerConfig, QueryConfig from embeddings import BgeEncoder from .language_detector import LanguageDetector from .translator import Translator from .query_rewriter import QueryRewriter, QueryNormalizer 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: CustomerConfig, text_encoder: Optional[BgeEncoder] = None, translator: Optional[Translator] = None ): """ Initialize query parser. Args: config: Customer configuration text_encoder: Text embedding encoder (lazy loaded if not provided) translator: Translator instance (lazy loaded if not provided) """ self.config = config self.query_config = config.query_config self._text_encoder = text_encoder self._translator = translator # Initialize components self.normalizer = QueryNormalizer() self.language_detector = LanguageDetector() self.rewriter = QueryRewriter(self.query_config.rewrite_dictionary) @property def text_encoder(self) -> BgeEncoder: """Lazy load text encoder.""" if self._text_encoder is None and self.query_config.enable_text_embedding: print("[QueryParser] Initializing text encoder...") self._text_encoder = BgeEncoder() return self._text_encoder @property def translator(self) -> Translator: """Lazy load translator.""" if self._translator is None and self.query_config.enable_translation: print("[QueryParser] Initializing translator...") self._translator = Translator( api_key=self.query_config.translation_api_key, use_cache=True ) return self._translator def parse(self, query: str, generate_vector: bool = True) -> ParsedQuery: """ Parse query through all processing stages. Args: query: Raw query string generate_vector: Whether to generate query embedding Returns: ParsedQuery object with all processing results """ print(f"\n[QueryParser] Parsing query: '{query}'") # Stage 1: Normalize normalized = self.normalizer.normalize(query) print(f"[QueryParser] Normalized: '{normalized}'") # Extract domain if present (e.g., "brand:Nike" -> domain="brand", query="Nike") domain, query_text = self.normalizer.extract_domain_query(normalized) print(f"[QueryParser] Domain: '{domain}', Query: '{query_text}'") # Stage 2: Query rewriting rewritten = None if self.query_config.enable_query_rewrite: rewritten = self.rewriter.rewrite(query_text) if rewritten != query_text: print(f"[QueryParser] Rewritten: '{rewritten}'") query_text = rewritten # Stage 3: Language detection detected_lang = self.language_detector.detect(query_text) print(f"[QueryParser] Detected language: {detected_lang}") # Stage 4: Translation translations = {} if self.query_config.enable_translation: # Determine target languages for translation # If domain has language_field_mapping, only translate to languages in the mapping # Otherwise, use all supported languages target_langs_for_translation = self.query_config.supported_languages # Check if domain has language_field_mapping domain_config = next( (idx for idx in self.config.indexes if idx.name == domain), None ) if domain_config and domain_config.language_field_mapping: # Only translate to languages that exist in the mapping available_languages = set(domain_config.language_field_mapping.keys()) target_langs_for_translation = [ lang for lang in self.query_config.supported_languages if lang in available_languages ] print(f"[QueryParser] Domain '{domain}' has language_field_mapping, " f"will translate to: {target_langs_for_translation}") target_langs = self.translator.get_translation_needs( detected_lang, target_langs_for_translation ) if target_langs: print(f"[QueryParser] Translating to: {target_langs}") translations = self.translator.translate_multi( query_text, target_langs, source_lang=detected_lang ) print(f"[QueryParser] Translations: {translations}") # Stage 5: Text embedding query_vector = None if (generate_vector and self.query_config.enable_text_embedding and domain == "default"): # Only generate vector for default domain print(f"[QueryParser] Generating query embedding...") query_vector = self.text_encoder.encode([query_text])[0] print(f"[QueryParser] Query vector shape: {query_vector.shape}") # 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 ) print(f"[QueryParser] Parsing complete") 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()