Parse XML once into hash index; build in background thread (no event loop blocking)

app.py

@@ -26,6 +26,19 @@ app = FastAPI(title="BF-Realtime")
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
 
+@app.on_event("startup")
+async def _startup_warmup():
+    """XML cache + parse index'i thread'de baslat — event loop'u bloklama."""
+    async def loop():
+        while True:
+            try:
+                await asyncio.to_thread(_ensure_index)
+            except Exception:
+                logger.exception('xml/index refresh hatasi')
+            await asyncio.sleep(1800)  # 30 dakika
+    asyncio.create_task(loop())
+
+
 @app.get("/")
 async def root():
     return FileResponse("static/index.html")
@@ -271,129 +284,208 @@ async def handle_tool_call(name: str, arguments: dict) -> str:
         return f"Hata: {e}"
 
 
-def _item_to_product(it: str) -> dict:
-    """XML item bloku -> {name, image, images[], link, color, size, sku} dict."""
+_TR_MAP = {'İ': 'i', 'I': 'i', 'ı': 'i', 'Ğ': 'g', 'ğ': 'g',
+           'Ü': 'u', 'ü': 'u', 'Ş': 's', 'ş': 's',
+           'Ö': 'o', 'ö': 'o', 'Ç': 'c', 'ç': 'c'}
+
+def _norm(s: str) -> str:
+    if not s:
+        return ''
+    for tr, en in _TR_MAP.items():
+        s = s.replace(tr, en)
+    return s.lower()
+
+
+# Parse-once index — XML her degistiginde yeniden build edilir.
+# Realtime aramalarda 7MB regex re-parse yapilmaz, hash lookup'lar kullanilir.
+_INDEX = {
+    "xml_id": None,            # ham XML'in id'si — degisirse yeniden parse
+    "products": [],            # list of parsed product dicts
+    "by_link": {},             # productLink -> product
+    "by_sku": {},              # stockCode -> product
+    "main_skus": set(),        # ana urunlerin stockCode set'i
+    "variants_by_root": {},    # root_sku -> [variant products]
+    "main_links": [],          # sadece ana urunlerin linkleri (hizli iterasyon)
+}
+
+_VARIANT_LABEL_PARTS_RE = None
+_ITEM_RE = None
+_FIELD_RES = None
+
+
+def _compile_regexes():
+    """Modul ilk yuklemede regex'leri compile et."""
+    global _VARIANT_LABEL_PARTS_RE, _ITEM_RE, _FIELD_RES
+    if _ITEM_RE is not None:
+        return
     import re
-    label_m = re.search(r'<rootlabel><!\[CDATA\[(.*?)\]\]></rootlabel>', it)
-    var_label_m = re.search(r'<label><!\[CDATA\[(.*?)\]\]></label>', it)
-    link_m = re.search(r'<productLink><!\[CDATA\[(.*?)\]\]></productLink>', it)
-    sku_m = re.search(r'<stockCode><!\[CDATA\[(.*?)\]\]></stockCode>', it)
-    iv_m = re.search(r'<isOptionOfAProduct>(\d+)</isOptionOfAProduct>', it)
+    _ITEM_RE = re.compile(r'<item>(.*?)</item>', re.DOTALL)
+    _VARIANT_LABEL_PARTS_RE = re.compile(r'\s*[-/]\s*')
+    _FIELD_RES = {
+        'rootlabel': re.compile(r'<rootlabel><!\[CDATA\[(.*?)\]\]></rootlabel>'),
+        'label': re.compile(r'<label><!\[CDATA\[(.*?)\]\]></label>'),
+        'productLink': re.compile(r'<productLink><!\[CDATA\[(.*?)\]\]></productLink>'),
+        'stockCode': re.compile(r'<stockCode><!\[CDATA\[(.*?)\]\]></stockCode>'),
+        'isOptionOfAProduct': re.compile(r'<isOptionOfAProduct>(\d+)</isOptionOfAProduct>'),
+        'rootProductStockCode': re.compile(r'<rootProductStockCode><!\[CDATA\[(.*?)\]\]></rootProductStockCode>'),
+    }
+    # picture1Path - picture8Path
+    for i in range(1, 9):
+        _FIELD_RES[f'picture{i}'] = re.compile(
+            rf'<picture{i}Path><!\[CDATA\[(.*?)\]\]></picture{i}Path>'
+        )
+
+_compile_regexes()
+
+
+def _parse_item(it: str) -> dict:
+    """Tek bir XML item'ini dict'e cevir + arama icin token cache'i hazirla."""
+    import re as _re
+    fr = _FIELD_RES
+
+    def grab(name):
+        m = fr[name].search(it)
+        return m.group(1).strip() if m else ''
+
+    rootlabel = grab('rootlabel')
+    var_label = grab('label')
+    link = grab('productLink')
+    sku = grab('stockCode')
+    iv_m = fr['isOptionOfAProduct'].search(it)
+    is_variant = bool(iv_m and iv_m.group(1) == '1')
+    root_sku = grab('rootProductStockCode')
 
-    # Galeri: picture1Path .. picture8Path
     images = []
     for i in range(1, 9):
-        m = re.search(rf'<picture{i}Path><!\[CDATA\[(.*?)\]\]></picture{i}Path>', it)
+        m = fr[f'picture{i}'].search(it)
         if m and m.group(1).strip():
             images.append(m.group(1).strip())
 
-    # Varyant ise label'dan color/size parse et: "XS - YEŞİL", "M - SİYAH 56", "RED 56" vb.
     color = None
     size = None
-    is_variant = bool(iv_m and iv_m.group(1) == '1')
-    if is_variant and var_label_m:
-        vlabel = var_label_m.group(1).strip()
-        # Format: "BOY - RENK" veya "RENK - BOY" veya tek alan
-        parts = [p.strip() for p in re.split(r'\s*[-/]\s*', vlabel) if p.strip()]
-        # Boy: XS/S/M/L/XL/XXL veya 50/52/54/56/58 cm benzeri sayılar
-        size_pat = re.compile(r'^(?:XX?S|XS|S|M|L|XL|XXL|XXXL|\d{2}(?:\.\d)?(?:\s*CM)?)$', re.I)
+    if is_variant and var_label:
+        parts = [p.strip() for p in _VARIANT_LABEL_PARTS_RE.split(var_label) if p.strip()]
+        size_pat = _re.compile(
+            r'^(?:XX?S|XS|S|M|L|XL|XXL|XXXL|\d{2}(?:\.\d)?(?:\s*CM)?)$', _re.I
+        )
         for p in parts:
             if size_pat.match(p) and not size:
                 size = p.upper()
-            else:
-                # color olabilir
-                if not color:
-                    color = p.upper()
+            elif not color:
+                color = p.upper()
+
+    # Arama icin onceden hazirlanmis token'lar
+    label_norm = _norm(rootlabel)
+    tokens = [t for t in _re.findall(r'[a-z0-9+]+', label_norm) if len(t) >= 2]
 
     return {
-        'name': label_m.group(1) if label_m else '',
+        'name': rootlabel,
         'image': images[0] if images else None,
         'images': images,
-        'link': link_m.group(1) if link_m else None,
-        'sku': sku_m.group(1) if sku_m else None,
+        'link': link,
+        'sku': sku,
         'color': color,
         'size': size,
         'is_variant': is_variant,
+        'root_sku': root_sku if root_sku and root_sku != '0' else None,
+        '_tokens': tokens,
+        '_label_norm': label_norm,
     }
 
 
-def find_product_by_link(product_link: str) -> dict | None:
-    """productLink ile eslesen urunu bul. Varyant ise ana urune cik (rootProductStockCode)."""
+def _build_index(xml_text: str) -> dict:
+    """7MB XML'i bir kez parse et, lookup index'leri hazirla."""
+    products = []
+    by_link = {}
+    by_sku = {}
+    main_skus = set()
+    variants_by_root = {}
+    main_links = []
+
+    items = _ITEM_RE.findall(xml_text)
+    for it in items:
+        p = _parse_item(it)
+        products.append(p)
+        if p['link']:
+            by_link[p['link']] = p
+        if p['sku']:
+            by_sku[p['sku']] = p
+        if not p['is_variant']:
+            if p['sku']:
+                main_skus.add(p['sku'])
+            if p['link']:
+                main_links.append(p['link'])
+        else:
+            if p['root_sku']:
+                variants_by_root.setdefault(p['root_sku'], []).append(p)
+
+    logger.info(f"[index] parsed {len(products)} items, {len(main_skus)} main, "
+                f"{sum(len(v) for v in variants_by_root.values())} variants")
+    return {
+        "products": products,
+        "by_link": by_link,
+        "by_sku": by_sku,
+        "main_skus": main_skus,
+        "variants_by_root": variants_by_root,
+        "main_links": main_links,
+    }
+
+
+def _ensure_index() -> dict | None:
+    """Cache'deki XML icin (id() degisirse) index'i guncelle."""
     try:
         from smart_warehouse_with_price import get_cached_trek_xml
-        import re
-
         xml = get_cached_trek_xml()
         if not xml:
             return None
-        text = xml.decode('utf-8', errors='replace') if isinstance(xml, bytes) else str(xml)
-        items = re.findall(r'<item>(.*?)</item>', text, re.DOTALL)
-
-        matched = None
-        for it in items:
-            link_m = re.search(r'<productLink><!\[CDATA\[(.*?)\]\]></productLink>', it)
-            if link_m and link_m.group(1).strip() == product_link.strip():
-                matched = it
-                break
-        if matched is None:
-            return None
-
-        # Varyant mi? -> ana urune cik
-        is_variant_m = re.search(r'<isOptionOfAProduct>(\d+)</isOptionOfAProduct>', matched)
-        if is_variant_m and is_variant_m.group(1) == '1':
-            root_m = re.search(r'<rootProductStockCode><!\[CDATA\[(.*?)\]\]></rootProductStockCode>', matched)
-            if root_m and root_m.group(1).strip() and root_m.group(1).strip() != '0':
-                root_code = root_m.group(1).strip()
-                for it in items:
-                    sc_m = re.search(r'<stockCode><!\[CDATA\[(.*?)\]\]></stockCode>', it)
-                    iv_m = re.search(r'<isOptionOfAProduct>(\d+)</isOptionOfAProduct>', it)
-                    if (sc_m and sc_m.group(1).strip() == root_code
-                            and iv_m and iv_m.group(1) == '0'):
-                        return _item_to_product(it)
-
-        return _item_to_product(matched)
+        xml_id = id(xml)
+        if _INDEX["xml_id"] != xml_id:
+            text = xml.decode('utf-8', errors='replace') if isinstance(xml, bytes) else str(xml)
+            built = _build_index(text)
+            _INDEX["xml_id"] = xml_id
+            _INDEX["products"] = built["products"]
+            _INDEX["by_link"] = built["by_link"]
+            _INDEX["by_sku"] = built["by_sku"]
+            _INDEX["main_skus"] = built["main_skus"]
+            _INDEX["variants_by_root"] = built["variants_by_root"]
+            _INDEX["main_links"] = built["main_links"]
+        return _INDEX
     except Exception:
-        logger.exception('find_product_by_link hatasi')
+        logger.exception('_ensure_index hatasi')
         return None
 
 
-def find_variants_of_product(main_link: str) -> list[dict]:
-    """Verilen ana urunun tum varyantlarini dondur (renk, boy vb. icin)."""
-    try:
-        from smart_warehouse_with_price import get_cached_trek_xml
-        import re
+def _public_view(p: dict | None) -> dict | None:
+    """Index'teki internal field'lari (_tokens, _label_norm) cikar — client'a gonderilebilir."""
+    if not p:
+        return None
+    return {k: v for k, v in p.items() if not k.startswith('_')}
 
-        xml = get_cached_trek_xml()
-        if not xml:
-            return []
-        text = xml.decode('utf-8', errors='replace') if isinstance(xml, bytes) else str(xml)
-        items = re.findall(r'<item>(.*?)</item>', text, re.DOTALL)
-
-        # Once main'i bul, stockCode'unu al
-        main_code = None
-        for it in items:
-            link_m = re.search(r'<productLink><!\[CDATA\[(.*?)\]\]></productLink>', it)
-            iv_m = re.search(r'<isOptionOfAProduct>(\d+)</isOptionOfAProduct>', it)
-            if (link_m and link_m.group(1).strip() == main_link.strip()
-                    and iv_m and iv_m.group(1) == '0'):
-                sc_m = re.search(r'<stockCode><!\[CDATA\[(.*?)\]\]></stockCode>', it)
-                if sc_m:
-                    main_code = sc_m.group(1).strip()
-                break
-        if not main_code:
-            return []
-
-        variants = []
-        for it in items:
-            iv_m = re.search(r'<isOptionOfAProduct>(\d+)</isOptionOfAProduct>', it)
-            root_m = re.search(r'<rootProductStockCode><!\[CDATA\[(.*?)\]\]></rootProductStockCode>', it)
-            if (iv_m and iv_m.group(1) == '1'
-                    and root_m and root_m.group(1).strip() == main_code):
-                variants.append(_item_to_product(it))
-        return variants
-    except Exception:
-        logger.exception('find_variants_of_product hatasi')
+
+def find_product_by_link(product_link: str) -> dict | None:
+    """O(1) lookup. Varyant ise ana urune cik."""
+    idx = _ensure_index()
+    if not idx:
+        return None
+    p = idx["by_link"].get(product_link.strip())
+    if not p:
+        return None
+    if p['is_variant'] and p['root_sku']:
+        main = idx["by_sku"].get(p['root_sku'])
+        if main and not main['is_variant']:
+            return _public_view(main)
+    return _public_view(p)
+
+
+def find_variants_of_product(main_link: str) -> list[dict]:
+    """Bir ana urunun tum varyantlari (hash lookup)."""
+    idx = _ensure_index()
+    if not idx:
+        return []
+    main = idx["by_link"].get(main_link.strip())
+    if not main or main['is_variant'] or not main['sku']:
         return []
+    return [_public_view(v) for v in idx["variants_by_root"].get(main['sku'], [])]
 
 
 def extract_product_link_from_result(result: str) -> str | None:
@@ -405,16 +497,6 @@ def extract_product_link_from_result(result: str) -> str | None:
     return m.group(0) if m else None
 
 
-_TR_MAP = {'İ': 'i', 'I': 'i', 'ı': 'i', 'Ğ': 'g', 'ğ': 'g',
-           'Ü': 'u', 'ü': 'u', 'Ş': 's', 'ş': 's',
-           'Ö': 'o', 'ö': 'o', 'Ç': 'c', 'ç': 'c'}
-
-def _norm(s: str) -> str:
-    for tr, en in _TR_MAP.items():
-        s = s.replace(tr, en)
-    return s.lower()
-
-
 # Renk eşanlam haritası (TR söylüyorlar, XML'de TR/EN karışık olabilir)
 _COLOR_SYNONYMS = {
     'siyah': ['siyah', 'black', 'noir', 'negro'],
@@ -459,47 +541,27 @@ def _detect_sizes_in_text(text_norm: str) -> set[str]:
 
 
 def find_product_in_text(text: str, current_main_link: str | None = None) -> dict | None:
-    """Transkriptte gecen urunu/varyanti bul.
-    - Default: ana urunu tercih eder (skor esitse main).
-    - Renk/boy gibi ek tokenlar varyantta eslesirse varyant skor olarak ana urunu gecer ve varyant gosterilir.
-    - current_main_link verilmisse, sadece o ana urunun varyantlarina ve kendisine bakilir (context-aware)."""
+    """Transkriptte gecen urunu/varyanti index uzerinden bul (regex re-parse YOK).
+    - Default: ana urunu tercih eder.
+    - Variant token bonus'u sadece renk/boy hint'i varsa devreye girer.
+    - current_main_link: o ana urun + varyantlari ile scope'u kisitla."""
     try:
-        from smart_warehouse_with_price import get_cached_trek_xml
-        import re
-
-        xml = get_cached_trek_xml()
-        if not xml:
+        idx = _ensure_index()
+        if not idx:
             return None
-        xml_text = xml.decode('utf-8', errors='replace') if isinstance(xml, bytes) else str(xml)
         text_norm = _norm(text)
-        items = re.findall(r'<item>(.*?)</item>', xml_text, re.DOTALL)
 
-        # Eger context (mevcut ana urun) varsa, scope'u o ana urun + varyantlariyla sinirla
-        scoped_items = items
+        # Scope: ya tum ana urunler + varyantlari, ya da sadece context'tekiler
         if current_main_link:
-            main_code = None
-            for it in items:
-                link_m = re.search(r'<productLink><!\[CDATA\[(.*?)\]\]></productLink>', it)
-                iv_m = re.search(r'<isOptionOfAProduct>(\d+)</isOptionOfAProduct>', it)
-                if (link_m and link_m.group(1).strip() == current_main_link.strip()
-                        and iv_m and iv_m.group(1) == '0'):
-                    sc_m = re.search(r'<stockCode><!\[CDATA\[(.*?)\]\]></stockCode>', it)
-                    if sc_m:
-                        main_code = sc_m.group(1).strip()
-                    break
-            if main_code:
-                scoped = []
-                for it in items:
-                    link_m = re.search(r'<productLink><!\[CDATA\[(.*?)\]\]></productLink>', it)
-                    root_m = re.search(r'<rootProductStockCode><!\[CDATA\[(.*?)\]\]></rootProductStockCode>', it)
-                    is_self = link_m and link_m.group(1).strip() == current_main_link.strip()
-                    is_variant_of = root_m and root_m.group(1).strip() == main_code
-                    if is_self or is_variant_of:
-                        scoped.append(it)
-                if scoped:
-                    scoped_items = scoped
-
-        # Metinde gecen renk/beden hint'leri
+            main = idx["by_link"].get(current_main_link.strip())
+            if main and not main['is_variant'] and main['sku']:
+                scoped = [main] + idx["variants_by_root"].get(main['sku'], [])
+            else:
+                scoped = idx["products"]
+        else:
+            scoped = idx["products"]
+
+        # Renk/beden hint'leri
         text_colors = _detect_colors_in_text(text_norm)
         text_sizes = _detect_sizes_in_text(text_norm)
         has_variant_hint = bool(text_colors or text_sizes)
@@ -507,29 +569,19 @@ def find_product_in_text(text: str, current_main_link: str | None = None) -> dic
         best = None
         best_score = 0
         best_is_main = False
-        for it in scoped_items:
-            label_m = re.search(r'<rootlabel><!\[CDATA\[(.*?)\]\]></rootlabel>', it)
-            if not label_m:
-                continue
-            label = label_m.group(1)
-            label_norm = _norm(label)
-            tokens = [t for t in re.findall(r'[a-z0-9+]+', label_norm) if len(t) >= 2]
+        for p in scoped:
+            tokens = p.get('_tokens') or []
             if not tokens:
                 continue
             match = sum(1 for t in tokens if t in text_norm)
             threshold = max(2, int(len(tokens) * 0.5))
             if match < threshold:
                 continue
-            iv_m = re.search(r'<isOptionOfAProduct>(\d+)</isOptionOfAProduct>', it)
-            is_main = not (iv_m and iv_m.group(1) == '1')
-
-            # Renk/beden bonus: variant ise label'inden parse edip metinle eslestir
+            is_main = not p['is_variant']
             bonus = 0
             if not is_main and has_variant_hint:
-                product = _item_to_product(it)
-                v_color = (product.get('color') or '').lower()
-                v_size = (product.get('size') or '').upper()
-                # Renk eslesmesi: variant rengi metindeki rekleri sinonim'le karsilastir
+                v_color = (p.get('color') or '').lower()
+                v_size = (p.get('size') or '').upper()
                 if v_color:
                     for key, syns in _COLOR_SYNONYMS.items():
                         if key in text_colors and any(_norm(s) in _norm(v_color) for s in syns):
@@ -537,18 +589,13 @@ def find_product_in_text(text: str, current_main_link: str | None = None) -> dic
                             break
                 if v_size and v_size in text_sizes:
                     bonus += 3
-
             score = match + bonus
-            # Daha yuksek skor kazanir; esitlikte ana urun tercih edilir
             if (score > best_score
                     or (score == best_score and is_main and not best_is_main)):
                 best_score = score
-                best = it
+                best = p
                 best_is_main = is_main
-
-        if not best:
-            return None
-        return _item_to_product(best)
+        return _public_view(best)
     except Exception:
         logger.exception('find_product_in_text hatasi')
         return None