Revert to backup - removing AI modifications

ai_product_analyzer.py

@@ -1,328 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-GPT-5 Powered Product & Query Analyzer
-Tüm manuel kontrolleri AI ile otomatikleştirir
-"""
-
-import os
-import json
-import requests
-import logging
-from typing import Dict, Optional, List, Tuple
-
-logger = logging.getLogger(__name__)
-
-# OpenAI API
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-API_URL = "https://api.openai.com/v1/chat/completions"
-
-def analyze_product_query(
-    message: str,
-    products_data: Optional[List[Dict]] = None,
-    context: Optional[Dict] = None
-) -> Dict:
-    """
-    GPT-5 ile ürün sorgusunu analiz et
-    
-    Args:
-        message: Kullanıcı mesajı
-        products_data: Mevcut ürün listesi
-        context: Sohbet bağlamı
-        
-    Returns:
-        {
-            "is_product_query": bool,  # Ürün sorusu mu?
-            "product_name": str,  # Aranan ürün adı
-            "exact_matches": [],  # Tam eşleşen ürünler
-            "partial_matches": [],  # Kısmi eşleşen ürünler
-            "category": str,  # Bisiklet kategorisi (dağ/yol/şehir/elektrikli)
-            "price_range": {
-                "min": float,
-                "max": float,
-                "condition": str  # "altında", "üstünde", "arası"
-            },
-            "store_preference": str,  # Tercih edilen mağaza
-            "is_greeting": bool,  # Selamlama mı?
-            "intent": str,  # Kullanıcı niyeti
-            "confidence": float
-        }
-    """
-    
-    if not OPENAI_API_KEY:
-        logger.error("OpenAI API key missing")
-        return {"is_product_query": False, "confidence": 0}
-    
-    # Sistem promptu
-    system_prompt = """Sen bir bisiklet ürün analiz uzmanısın. Trek bisiklet mağazası için sorguları analiz ediyorsun.
-
-GÖREV: Kullanıcı mesajını analiz et ve JSON formatında döndür.
-
-ÜRÜN EŞLEŞTİRME KURALLARI:
-1. Tam eşleşme: Kullanıcı "FX 2" derse, sadece "FX 2"yi döndür, "FX Sport 6"yı değil
-2. Model numarası önemli: "Marlin 5" ve "Marlin 7" farklı ürünlerdir
-3. Seri adı yeterli değilse tüm modelleri listele
-
-KATEGORİ TESPİTİ:
-- "dağ bisikleti", "mountain bike" → category: "dağ"
-- "yol bisikleti", "road bike" → category: "yol"
-- "şehir bisikleti", "urban" → category: "şehir"
-- "elektrikli", "e-bike" → category: "elektrikli"
-
-FİYAT ARALIKLARI:
-- "50 bin altı", "50000 altında" → max: 50000
-- "100 bin üstü" → min: 100000
-- "50-100 bin arası" → min: 50000, max: 100000
-
-NON-PRODUCT KELİMELER (ürün sorgusu değil):
-- "süper", "harika", "teşekkürler", "güzel", "tamam", "olur", "evet", "hayır"
-- Bu kelimeler tek başına gelirse is_product_query: false
-
-SELAMLAMA TESPİTİ:
-- "merhaba", "selam", "günaydın", "iyi akşamlar" → is_greeting: true
-
-JSON FORMATI:
-{
-    "is_product_query": true/false,
-    "product_name": "FX 2",  // Eğer ürün adı varsa
-    "category": "şehir",  // dağ/yol/şehir/elektrikli/gravel
-    "price_range": {
-        "min": 0,
-        "max": 100000,
-        "condition": "altında"
-    },
-    "store_preference": "caddebostan",  // Eğer mağaza belirtildiyse
-    "is_greeting": false,
-    "intent": "product_info",  // product_info, price_check, stock_check, general_question
-    "confidence": 0.95,
-    "search_terms": ["fx", "2"],  // Arama için kullanılacak terimler
-    "requires_exact_match": true  // Tam eşleşme gerekli mi?
-}"""
-
-    # Ürün listesi varsa ekle
-    product_info = ""
-    if products_data and len(products_data) > 0:
-        # Sadece ilk 20 ürünü göster (token limiti için)
-        sample_products = products_data[:20]
-        product_names = [p.get("name", "") for p in sample_products]
-        product_info = f"\n\nMEVCUT ÜRÜNLER (örnek): {', '.join(product_names)}"
-    
-    # GPT-5'e gönder
-    try:
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": f"Kullanıcı mesajı: \"{message}\"{product_info}\n\nJSON formatında analiz et:"}
-        ]
-        
-        payload = {
-            "model": "gpt-5-chat-latest",
-            "messages": messages,
-            "temperature": 0,
-            "max_tokens": 500,
-            "response_format": {"type": "json_object"}
-        }
-        
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {OPENAI_API_KEY}"
-        }
-        
-        response = requests.post(API_URL, headers=headers, json=payload, timeout=10)
-        
-        if response.status_code == 200:
-            result = response.json()
-            analysis = json.loads(result['choices'][0]['message']['content'])
-            
-            logger.info(f"🤖 Product Analysis: {analysis}")
-            return analysis
-        else:
-            logger.error(f"GPT-5 API error: {response.status_code}")
-            return {"is_product_query": False, "confidence": 0}
-            
-    except Exception as e:
-        logger.error(f"Product analysis error: {e}")
-        return {"is_product_query": False, "confidence": 0}
-
-def smart_product_search(
-    analysis: Dict,
-    products_data: List[Dict]
-) -> List[Dict]:
-    """
-    AI analiz sonucuna göre akıllı ürün arama
-    
-    Args:
-        analysis: GPT-5 analiz sonucu
-        products_data: Tüm ürün listesi
-        
-    Returns:
-        Eşleşen ürünler listesi
-    """
-    
-    if not analysis.get("is_product_query"):
-        return []
-    
-    results = []
-    
-    # Arama terimlerini al
-    search_terms = analysis.get("search_terms", [])
-    product_name = analysis.get("product_name", "").lower()
-    category = analysis.get("category", "").lower()
-    price_range = analysis.get("price_range", {})
-    requires_exact = analysis.get("requires_exact_match", False)
-    
-    for product in products_data:
-        item_name = product.get("name", "").lower()
-        item_category = product.get("category", "").lower()
-        item_price = product.get("price", 0)
-        
-        # Skor hesaplama
-        score = 0
-        
-        # Tam eşleşme kontrolü
-        if requires_exact and product_name:
-            if item_name == product_name:
-                score += 100
-            elif not item_name.startswith(product_name + " "):
-                continue  # Tam eşleşme isteniyorsa ve yoksa atla
-        
-        # Kategori eşleşmesi
-        if category:
-            if category in item_category or category in item_name:
-                score += 20
-            else:
-                continue  # Kategori belirtildiyse ve eşleşmiyorsa atla
-        
-        # Fiyat aralığı kontrolü
-        if price_range:
-            min_price = price_range.get("min", 0)
-            max_price = price_range.get("max", float('inf'))
-            
-            if min_price <= item_price <= max_price:
-                score += 10
-            else:
-                continue  # Fiyat aralığı dışındaysa atla
-        
-        # Arama terimleri kontrolü
-        if search_terms:
-            matches = sum(1 for term in search_terms if term.lower() in item_name)
-            score += matches * 15
-        
-        # Sonuçlara ekle
-        if score > 0:
-            product["match_score"] = score
-            results.append(product)
-    
-    # Skora göre sırala
-    results.sort(key=lambda x: x.get("match_score", 0), reverse=True)
-    
-    return results[:10]  # En iyi 10 sonucu döndür
-
-def analyze_complete_query(
-    message: str,
-    products_data: Optional[List[Dict]] = None,
-    context: Optional[Dict] = None
-) -> Dict:
-    """
-    Komple sorgu analizi - tüm manuel kontrolleri birleştirir
-    
-    Returns:
-        {
-            "analysis": {...},  # GPT-5 analiz sonucu
-            "products": [...],  # Bulunan ürünler
-            "action": "show_products/greet/answer/notify_store",
-            "response_hint": "Önerilen yanıt yaklaşımı"
-        }
-    """
-    
-    # 1. AI analizi yap
-    analysis = analyze_product_query(message, products_data, context)
-    
-    # 2. Ürün araması yap
-    products = []
-    if analysis.get("is_product_query") and products_data:
-        products = smart_product_search(analysis, products_data)
-    
-    # 3. Aksiyon belirle
-    action = "answer"  # Varsayılan
-    response_hint = ""
-    
-    if analysis.get("is_greeting"):
-        action = "greet"
-        response_hint = "Samimi bir selamlama yap"
-    elif analysis.get("is_product_query"):
-        if products:
-            action = "show_products"
-            response_hint = f"Bulunan {len(products)} ürünü göster"
-        else:
-            action = "no_products"
-            response_hint = "Ürün bulunamadı, alternatif öner"
-    elif analysis.get("intent") == "price_check":
-        action = "show_price"
-        response_hint = "Fiyat bilgisi ver"
-    elif analysis.get("intent") == "stock_check":
-        action = "check_stock"
-        response_hint = "Stok durumunu kontrol et"
-    
-    return {
-        "analysis": analysis,
-        "products": products,
-        "action": action,
-        "response_hint": response_hint,
-        "confidence": analysis.get("confidence", 0)
-    }
-
-# Test fonksiyonu
-def test_ai_analyzer():
-    """Test senaryoları"""
-    
-    test_messages = [
-        "FX 2 var mı?",
-        "Marlin 5'in fiyatı nedir?",
-        "50 bin altı dağ bisikleti var mı?",
-        "süper",
-        "merhaba",
-        "caddebostan mağazasında elektrikli bisiklet var mı?",
-        "100-200 bin arası yol bisikleti önerir misiniz?",
-        "teşekkürler"
-    ]
-    
-    # Örnek ürün listesi
-    sample_products = [
-        {"name": "FX 2", "price": 65000, "category": "şehir"},
-        {"name": "FX Sport 6", "price": 183000, "category": "şehir"},
-        {"name": "Marlin 5", "price": 53000, "category": "dağ"},
-        {"name": "Marlin 7", "price": 72000, "category": "dağ"},
-        {"name": "Domane AL 2", "price": 110000, "category": "yol"},
-        {"name": "Powerfly 4", "price": 220000, "category": "elektrikli dağ"}
-    ]
-    
-    print("\n" + "="*60)
-    print("AI PRODUCT ANALYZER TEST")
-    print("="*60)
-    
-    for msg in test_messages:
-        print(f"\n📝 Mesaj: \"{msg}\"")
-        result = analyze_complete_query(msg, sample_products)
-        
-        analysis = result["analysis"]
-        print(f"🤖 Ürün Sorgusu: {'EVET' if analysis.get('is_product_query') else 'HAYIR'}")
-        print(f"🎯 Niyet: {analysis.get('intent', 'unknown')}")
-        print(f"📊 Güven: {analysis.get('confidence', 0):.2%}")
-        
-        if analysis.get("product_name"):
-            print(f"🚲 Aranan: {analysis['product_name']}")
-        
-        if result["products"]:
-            print(f"✅ Bulunan: {len(result['products'])} ürün")
-            for p in result["products"][:3]:
-                print(f"   - {p['name']}: {p['price']:,} TL")
-        
-        print(f"🎬 Aksiyon: {result['action']}")
-        if result["response_hint"]:
-            print(f"💡 Öneri: {result['response_hint']}")
-    
-    print("\n" + "="*60)
-
-if __name__ == "__main__":
-    test_ai_analyzer()

app.py

@@ -32,23 +32,14 @@ USE_IMPROVED_SEARCH = False
 #     print("Improved WhatsApp chatbot not available, using basic search")
 #     USE_IMPROVED_SEARCH = False
 
-# Import GPT-5 powered smart warehouse search - AI-powered version
+# Import GPT-5 powered smart warehouse search - complete BF algorithm
 try:
-    from smart_warehouse_with_price_ai import search_products_smart_ai, format_stock_message
     from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
     USE_GPT5_SEARCH = True
-    USE_AI_SEARCH = True
-    logger.info("✅ AI-powered smart warehouse loaded")
+    logger.info("✅ GPT-5 complete smart warehouse with price (BF algorithm) loaded")
 except ImportError:
-    try:
-        from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
-        USE_GPT5_SEARCH = True
-        USE_AI_SEARCH = False
-        logger.info("✅ GPT-5 complete smart warehouse with price (BF algorithm) loaded")
-    except ImportError:
-        USE_GPT5_SEARCH = False
-        USE_AI_SEARCH = False
-        logger.info("❌ GPT-5 search not available")
+    USE_GPT5_SEARCH = False
+    logger.info("❌ GPT-5 search not available")
 
 warnings.simplefilter('ignore')
 
@@ -116,15 +107,9 @@ else:
         twilio_client = None
 
 # Mağaza stok bilgilerini çekme fonksiyonu
-def get_warehouse_stock(product_name, context=None):
-    """B2B API'den mağaza stok bilgilerini çek - AI-enhanced"""
-    # Try AI-powered search first
-    if USE_AI_SEARCH:
-        ai_result = search_products_smart_ai(product_name, context)
-        if ai_result and isinstance(ai_result, list):
-            return ai_result
-    
-    # Fallback to GPT-5 complete smart search (BF algorithm)
+def get_warehouse_stock(product_name):
+    """B2B API'den mağaza stok bilgilerini çek - GPT-5 enhanced"""
+    # Try GPT-5 complete smart search (BF algorithm)
     if USE_GPT5_SEARCH:
         gpt5_result = get_warehouse_stock_smart_with_price(product_name)
         if gpt5_result and isinstance(gpt5_result, list):

debug_xml_fields.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-"""Debug XML field names"""
-
-import requests
-import xml.etree.ElementTree as ET
-
-def debug_xml_structure():
-    """Check XML structure and field names"""
-    print("\n=== XML STRUCTURE DEBUG ===")
-    
-    try:
-        # Get Trek XML
-        url = 'https://www.trekbisiklet.com.tr/output/8582384479'
-        response = requests.get(url, verify=False, timeout=10)
-        
-        if response.status_code == 200:
-            root = ET.fromstring(response.content)
-            
-            # Find first Marlin 5 and show all fields
-            for item in root.findall('.//item'):
-                title_elem = item.find('rootlabel')
-                if title_elem is not None and title_elem.text:
-                    if 'marlin 5' in title_elem.text.lower():
-                        print(f"\nProduct: {title_elem.text}")
-                        print("Available fields:")
-                        
-                        # Show all child elements
-                        for child in item:
-                            value = child.text if child.text else 'None'
-                            if len(value) > 100:
-                                value = value[:100] + '...'
-                            print(f"  - {child.tag}: {value}")
-                        
-                        # Only show first one
-                        break
-            
-            # Also check different product for comparison
-            print("\n" + "="*50)
-            print("Checking a product with known price (FX 2):")
-            for item in root.findall('.//item'):
-                title_elem = item.find('rootlabel')
-                if title_elem is not None and title_elem.text:
-                    if 'fx 2' in title_elem.text.lower() and 'sport' not in title_elem.text.lower():
-                        print(f"\nProduct: {title_elem.text}")
-                        print("Available fields:")
-                        
-                        for child in item:
-                            value = child.text if child.text else 'None'
-                            if len(value) > 100:
-                                value = value[:100] + '...'
-                            print(f"  - {child.tag}: {value}")
-                        
-                        break
-                        
-    except Exception as e:
-        print(f"Error: {e}")
-
-if __name__ == "__main__":
-    debug_xml_structure()

prompts.py

@@ -9,7 +9,7 @@ SYSTEM_PROMPTS = [
     {
         "role": "system", 
         "category": "identity",
-        "content": "Sen Trek bisiklet uzmanı AI asistanısın. Trek ve Electra bisikletler konusunda uzmanısın. Stokta bulunan ürünlerin fiyat bilgilerini verebilirsin.\n\n🚨🚨🚨 KRİTİK FİYAT VE LİNK KURALI 🚨🚨🚨\n\n1. FİYAT KURALI:\n• FİYAT BİLGİSİ YALNIZCA SİSTEM MESAJINDAN GELİR!\n• Sistem mesajında fiyat yoksa: 'Güncel fiyat için mağazalarımızı arayın'\n• ASLA TAHMİNİ FİYAT VERME!\n\n2. DOĞRU FİYAT ARALIKLARI:\n• Marlin 4-5-6-7: 40.000-80.000 TL arası\n• FX 1-2-3: 50.000-100.000 TL arası\n• FX Sport 4-5-6: 120.000-200.000 TL arası\n• Domane AL: 80.000-150.000 TL\n• Domane SL: 150.000-400.000 TL\n• Rail (elektrikli): 300.000-800.000 TL\n\n3. ÜRÜN-LİNK EŞLEŞMESİ:\n• Marlin için ASLA Rail linki verme!\n• FX 2 için ASLA FX Sport 6 linki verme!\n• Link yanlışsa hiç verme!\n\n❌ YANLIŞ: Marlin 5 - 700.000 TL - Rail linki\n✅ DOĞRU: Marlin 5 - 53.000 TL - Marlin 5 linki\n\nEĞER YANLIŞ FİYAT VEYA LİNK VARSA, HİÇ VERME!"
+        "content": "Sen Trek bisiklet uzmanı AI asistanısın. Trek ve Electra bisikletler konusunda uzmanısın. Stokta bulunan ürünlerin fiyat bilgilerini verebilirsin.\n\n🚨🚨🚨 MUTLAK FİYAT KURALI 🚨🚨🚨\nFİYAT BİLGİSİ YALNIZCA 'MAĞAZA STOK BİLGİSİ' BAŞLIKLI SİSTEM MESAJINDAN GELİR!\n\nEĞER SİSTEM MESAJINDA FİYAT YOKSA:\n✅ DOĞRU CEVAP: 'Güncel fiyat bilgisi için mağazalarımızı arayın'\n❌ YANLIŞ CEVAP: Herhangi bir fiyat söylemek (700.000 TL gibi)\n\nGERÇEK FİYAT ARALIKLARI:\n• Marlin serisi: 50.000-80.000 TL\n• FX serisi: 50.000-200.000 TL\n• Domane/Émonda: 100.000-600.000 TL\n• Madone: 200.000-1.000.000 TL\n\n700.000 TL bir Marlin için ABSÜRT bir fiyattır! ASLA böyle fiyatlar verme!"
     },
     
     # 2. MAĞAZA BİLGİLERİ VE İLETİŞİM

smart_warehouse_with_price.py

@@ -6,11 +6,6 @@ import os
 import json
 import xml.etree.ElementTree as ET
 import time
-from universal_product_matcher import find_best_match, normalize_text
-try:
-    from ai_product_analyzer import analyze_complete_query
-except ImportError:
-    analyze_complete_query = None
 
 # Cache configuration - 12 hours
 CACHE_DURATION = 43200  # 12 hours
@@ -45,7 +40,7 @@ def get_cached_trek_xml():
         return None
 
 def get_product_price_and_link(product_name, variant=None):
-    """Get price and link from Trek website XML using universal matcher"""
+    """Get price and link from Trek website XML"""
     try:
         # Get cached Trek XML
         xml_content = get_cached_trek_xml()
@@ -54,37 +49,88 @@ def get_product_price_and_link(product_name, variant=None):
             
         root = ET.fromstring(xml_content)
         
-        # Convert XML to product list for matcher
-        products = []
+        # Normalize search terms
+        search_name = product_name.lower()
+        search_variant = variant.lower() if variant else ""
+        
+        # Turkish character normalization
+        tr_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c'}
+        for tr, en in tr_map.items():
+            search_name = search_name.replace(tr, en)
+            search_variant = search_variant.replace(tr, en)
+        
+        best_match = None
+        best_score = 0
+        
+        # Clean search name - remove year and parentheses
+        clean_search = re.sub(r'\s*\(\d{4}\)\s*', '', search_name).strip()
+        
         for item in root.findall('item'):
+            # Get product name
             rootlabel_elem = item.find('rootlabel')
             if rootlabel_elem is None or not rootlabel_elem.text:
                 continue
+                
+            item_name = rootlabel_elem.text.lower()
+            for tr, en in tr_map.items():
+                item_name = item_name.replace(tr, en)
             
-            # Correct field names from XML
-            price_elem = item.find('priceTaxWithCur')
-            link_elem = item.find('productLink')
+            # Clean item name too
+            clean_item = re.sub(r'\s*\(\d{4}\)\s*', '', item_name).strip()
             
-            products.append({
-                'name': rootlabel_elem.text,
-                'rootlabel': rootlabel_elem.text,
-                'price_elem': price_elem,
-                'link_elem': link_elem,
-                'xml_item': item
-            })
-        
-        # Use universal matcher to find best match
-        search_query = f"{product_name} {variant}".strip() if variant else product_name
-        best_match = find_best_match(search_query, products, threshold=30)
+            # Calculate match score with priority for exact matches
+            score = 0
+            
+            # Exact match gets highest priority
+            if clean_search == clean_item:
+                score += 100
+            # Check if starts with exact product name (e.g., "fx 2" in "fx 2 kirmizi")
+            elif clean_item.startswith(clean_search + " ") or clean_item == clean_search:
+                score += 50
+            else:
+                # Partial matching
+                name_parts = clean_search.split()
+                for part in name_parts:
+                    if part in clean_item:
+                        score += 1
+            
+            # Check variant if specified
+            if variant and search_variant in item_name:
+                score += 2  # Variant match is important
+            
+            if score > best_score:
+                best_score = score
+                best_match = item
         
-        if best_match and best_match.get('price_elem') is not None:
-            price_elem = best_match['price_elem']
-            link_elem = best_match.get('link_elem')
+        if best_match and best_score > 0:
+            # Extract price
+            price_elem = best_match.find('priceTaxWithCur')
+            price = price_elem.text if price_elem is not None and price_elem.text else None
+            
+            # Round price
+            if price:
+                try:
+                    price_float = float(price)
+                    if price_float > 200000:
+                        rounded = round(price_float / 5000) * 5000
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    elif price_float > 30000:
+                        rounded = round(price_float / 1000) * 1000
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    elif price_float > 10000:
+                        rounded = round(price_float / 100) * 100
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                    else:
+                        rounded = round(price_float / 10) * 10
+                        price = f"{int(rounded):,}".replace(',', '.') + " TL"
+                except:
+                    price = f"{price} TL"
+            
+            # Extract link (field name is productLink, not productUrl!)
+            link_elem = best_match.find('productLink')
+            link = link_elem.text if link_elem is not None and link_elem.text else None
             
-            if price_elem.text:
-                price = float(price_elem.text.replace(',', '.'))
-                link = link_elem.text if link_elem is not None else None
-                return price, link
+            return price, link
         
         return None, None
         

smart_warehouse_with_price_ai.py

@@ -1,353 +0,0 @@
-"""Smart warehouse with AI-powered product analysis"""
-
-import requests
-import re
-import os
-import json
-import xml.etree.ElementTree as ET
-import time
-from typing import List, Dict, Optional, Tuple
-from universal_product_matcher import find_best_match, normalize_text
-from ai_product_analyzer import analyze_complete_query, smart_product_search
-
-# Cache configuration - 12 hours
-CACHE_DURATION = 43200  # 12 hours
-cache = {
-    'warehouse_xml': {'data': None, 'time': 0},
-    'trek_xml': {'data': None, 'time': 0},
-    'products_summary': {'data': None, 'time': 0},
-    'search_results': {}  # Cache for specific searches
-}
-
-def get_cached_trek_xml():
-    """Get Trek XML with 12-hour caching"""
-    current_time = time.time()
-    
-    if cache['trek_xml']['data'] and (current_time - cache['trek_xml']['time'] < CACHE_DURATION):
-        print("🚴 Using cached Trek XML (12-hour cache)")
-        return cache['trek_xml']['data']
-    
-    print("📡 Fetching fresh Trek XML...")
-    try:
-        url = 'https://www.trekbisiklet.com.tr/output/8582384479'
-        response = requests.get(url, verify=False, timeout=10)
-        
-        if response.status_code == 200:
-            cache['trek_xml']['data'] = response.content
-            cache['trek_xml']['time'] = current_time
-            return response.content
-        else:
-            return None
-    except Exception as e:
-        print(f"Trek XML fetch error: {e}")
-        return None
-
-def get_cached_warehouse_xml():
-    """Get warehouse XML with 12-hour caching"""
-    current_time = time.time()
-    
-    if cache['warehouse_xml']['data'] and (current_time - cache['warehouse_xml']['time'] < CACHE_DURATION):
-        print("📦 Using cached warehouse XML (12-hour cache)")
-        return cache['warehouse_xml']['data']
-    
-    print("🔄 Fetching fresh warehouse XML...")
-    try:
-        url = 'https://veloconnect.wardin.com/v1/wardin?auth_token=97e0949096e88dd936f1bc2f0ffd3a07&auth_source=alatin.com.tr'
-        response = requests.get(url, verify=False, timeout=10)
-        
-        if response.status_code == 200:
-            cache['warehouse_xml']['data'] = response.text
-            cache['warehouse_xml']['time'] = current_time
-            return response.text
-        else:
-            return None
-    except Exception as e:
-        print(f"Warehouse XML fetch error: {e}")
-        return None
-
-def get_all_products_with_details():
-    """Get all products with details from warehouse XML"""
-    
-    # Check cache first
-    current_time = time.time()
-    if cache['products_summary']['data'] and (current_time - cache['products_summary']['time'] < CACHE_DURATION):
-        print("✅ Using cached products summary")
-        return cache['products_summary']['data']
-    
-    xml_text = get_cached_warehouse_xml()
-    if not xml_text:
-        return []
-    
-    # Parse products
-    product_pattern = r'<Product>(.*?)</Product>'
-    all_products = re.findall(product_pattern, xml_text, re.DOTALL)
-    
-    products_list = []
-    for i, product_block in enumerate(all_products):
-        # Extract product details
-        name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
-        variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
-        sku_match = re.search(r'<ProductSKU><!\[CDATA\[(.*?)\]\]></ProductSKU>', product_block)
-        
-        if not name_match:
-            continue
-        
-        product_name = name_match.group(1)
-        variant = variant_match.group(1) if variant_match else ""
-        sku = sku_match.group(1) if sku_match else ""
-        
-        # Get warehouses with stock
-        warehouses_with_stock = []
-        warehouse_regex = r'<Warehouse>.*?<Name><!\[CDATA\[(.*?)\]\]></Name>.*?<Stock>(.*?)</Stock>.*?</Warehouse>'
-        warehouses = re.findall(warehouse_regex, product_block, re.DOTALL)
-        
-        total_stock = 0
-        for wh_name, wh_stock in warehouses:
-            try:
-                stock_count = int(wh_stock.strip())
-                if stock_count > 0:
-                    warehouses_with_stock.append({
-                        "name": wh_name,
-                        "stock": stock_count
-                    })
-                    total_stock += stock_count
-            except:
-                pass
-        
-        # Determine category
-        category = "genel"
-        name_lower = product_name.lower()
-        if "marlin" in name_lower or "roscoe" in name_lower or "fuel" in name_lower or "procaliber" in name_lower:
-            category = "dağ"
-        elif "domane" in name_lower or "émonda" in name_lower or "emonda" in name_lower or "madone" in name_lower:
-            category = "yol"
-        elif "fx" in name_lower or "ds" in name_lower or "verve" in name_lower:
-            category = "şehir"
-        elif "rail" in name_lower or "powerfly" in name_lower or "+" in name_lower:
-            category = "elektrikli"
-        elif "checkpoint" in name_lower:
-            category = "gravel"
-        elif "gobik" in name_lower:
-            category = "giyim"
-        elif "bontrager" in name_lower:
-            category = "aksesuar"
-        
-        # Get price from Trek XML
-        price, link = get_product_price_and_link(product_name, variant)
-        
-        product_info = {
-            "index": i,
-            "name": product_name,
-            "variant": variant,
-            "sku": sku,
-            "category": category,
-            "warehouses": warehouses_with_stock,
-            "total_stock": total_stock,
-            "price": price,
-            "link": link,
-            "full_name": f"{product_name} {variant}".strip()
-        }
-        
-        products_list.append(product_info)
-    
-    # Cache the results
-    cache['products_summary']['data'] = products_list
-    cache['products_summary']['time'] = current_time
-    
-    return products_list
-
-def get_product_price_and_link(product_name, variant=None):
-    """Get price and link from Trek website XML using universal matcher"""
-    try:
-        xml_content = get_cached_trek_xml()
-        if not xml_content:
-            return None, None
-            
-        root = ET.fromstring(xml_content)
-        
-        # Convert XML to product list for universal matcher
-        products = []
-        for item in root.findall('.//item'):
-            title = item.find('rootlabel')
-            if title is not None and title.text:
-                # Correct field names from XML
-                price_elem = item.find('priceTaxWithCur')
-                link_elem = item.find('productLink')
-                
-                products.append({
-                    'name': title.text,
-                    'rootlabel': title.text,
-                    'price_elem': price_elem,
-                    'link_elem': link_elem
-                })
-        
-        # Use universal matcher
-        search_query = f"{product_name} {variant}".strip() if variant else product_name
-        best_match = find_best_match(search_query, products, threshold=30)
-        
-        if best_match and best_match.get('price_elem') is not None:
-            price_elem = best_match['price_elem']
-            link_elem = best_match.get('link_elem')
-            
-            if price_elem.text:
-                price = float(price_elem.text.replace(',', '.'))
-                link = link_elem.text if link_elem is not None else None
-                return price, link
-        
-        return None, None
-    except Exception as e:
-        print(f"Price lookup error: {e}")
-        return None, None
-
-def search_products_smart_ai(user_message: str, context: Optional[Dict] = None) -> List[str]:
-    """
-    AI-powered product search
-    
-    Args:
-        user_message: User's query
-        context: Conversation context
-        
-    Returns:
-        List of formatted product descriptions
-    """
-    
-    # Check cache first
-    current_time = time.time()
-    cache_key = f"ai_search_{user_message.lower()}"
-    
-    if cache_key in cache['search_results']:
-        cached = cache['search_results'][cache_key]
-        if current_time - cached['time'] < CACHE_DURATION:
-            print(f"✅ Using cached AI result for '{user_message}'")
-            return cached['data']
-    
-    # Get all products
-    all_products = get_all_products_with_details()
-    if not all_products:
-        return ["Ürün veritabanına erişilemiyor"]
-    
-    # AI analysis
-    result = analyze_complete_query(user_message, all_products, context)
-    
-    # Format response based on AI analysis
-    formatted_results = []
-    
-    if result["action"] == "greet":
-        # Selamlama tespit edildi, ürün araması yapma
-        return []
-    
-    elif result["action"] == "show_products" and result["products"]:
-        # Ürünler bulundu
-        for product in result["products"][:10]:  # Max 10 ürün göster
-            # Format product information
-            name = product.get("name", "")
-            variant = product.get("variant", "")
-            full_name = f"{name} {variant}".strip() if variant else name
-            
-            # Price info
-            price = product.get("price")
-            price_str = f"{price:,.0f} TL" if price else "Fiyat bilgisi yok"
-            
-            # Stock info
-            warehouses = product.get("warehouses", [])
-            if warehouses:
-                stock_info = []
-                for wh in warehouses:
-                    stock_info.append(f"{wh['name']}: {wh['stock']} adet")
-                stock_str = " | ".join(stock_info)
-            else:
-                stock_str = "Stok yok"
-            
-            # Link
-            link = product.get("link", "")
-            
-            # Format result
-            result_text = f"🚲 **{full_name}**\n"
-            result_text += f"💰 Fiyat: {price_str}\n"
-            result_text += f"📦 Stok: {stock_str}"
-            
-            if link:
-                result_text += f"\n🔗 Link: {link}"
-            
-            formatted_results.append(result_text)
-    
-    elif result["action"] == "no_products":
-        # Ürün bulunamadı
-        analysis = result.get("analysis", {})
-        if analysis.get("product_name"):
-            formatted_results.append(f"'{analysis['product_name']}' ürünü bulunamadı")
-        else:
-            formatted_results.append("Aradığınız kriterlere uygun ürün bulunamadı")
-    
-    # Cache the results
-    if formatted_results:
-        cache['search_results'][cache_key] = {
-            'data': formatted_results,
-            'time': current_time
-        }
-    
-    return formatted_results if formatted_results else ["Ürün bulunamadı"]
-
-def format_stock_message(user_message: str, context: Optional[Dict] = None) -> str:
-    """
-    Format stock message using AI-powered search
-    """
-    
-    results = search_products_smart_ai(user_message, context)
-    
-    if not results:
-        return ""
-    
-    # Combine results
-    if len(results) == 1 and "bulunamadı" in results[0]:
-        return results[0]
-    
-    # Format multiple results
-    message = "🔍 **MAĞAZA STOK BİLGİSİ**\n\n"
-    for i, result in enumerate(results, 1):
-        if i > 1:
-            message += "\n---\n\n"
-        message += result
-    
-    return message
-
-# Test function
-def test_ai_search():
-    """Test AI-powered search"""
-    
-    test_queries = [
-        "FX 2 var mı?",
-        "Marlin 5'in fiyatı nedir?",
-        "50 bin altı dağ bisikleti",
-        "elektrikli bisiklet var mı?",
-        "merhaba",
-        "süper",
-        "100-200 bin arası yol bisikleti",
-        "GOBIK forma var mı?",
-        "caddebostan'da hangi bisikletler var?"
-    ]
-    
-    print("\n" + "="*60)
-    print("AI-POWERED SEARCH TEST")
-    print("="*60)
-    
-    for query in test_queries:
-        print(f"\n📝 Query: \"{query}\"")
-        results = search_products_smart_ai(query)
-        
-        if results:
-            print(f"✅ Found {len(results)} result(s):")
-            for result in results[:3]:  # Show max 3
-                # Truncate long results for display
-                lines = result.split('\n')
-                for line in lines[:3]:  # Show first 3 lines
-                    print(f"   {line}")
-                if len(lines) > 3:
-                    print("   ...")
-        else:
-            print("❌ No results")
-    
-    print("\n" + "="*60)
-
-if __name__ == "__main__":
-    test_ai_search()

test_marlin_price.py

@@ -1,126 +0,0 @@
-#!/usr/bin/env python3
-"""Test Marlin 5 price lookup"""
-
-import os
-os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY', '')
-
-from smart_warehouse_with_price import get_product_price_and_link, get_warehouse_stock_smart_with_price
-from universal_product_matcher import find_best_match
-import xml.etree.ElementTree as ET
-import requests
-
-def test_direct_xml():
-    """Trek XML'den direkt Marlin 5 ara"""
-    print("\n=== DIRECT XML TEST ===")
-    
-    try:
-        # Get Trek XML
-        url = 'https://www.trekbisiklet.com.tr/output/8582384479'
-        response = requests.get(url, verify=False, timeout=10)
-        
-        if response.status_code == 200:
-            root = ET.fromstring(response.content)
-            
-            # Search for Marlin in XML
-            marlin_found = []
-            for item in root.findall('.//item'):
-                title_elem = item.find('rootlabel')
-                if title_elem is not None and title_elem.text:
-                    title = title_elem.text
-                    if 'marlin' in title.lower() and '5' in title:
-                        price_elem = item.find('fiyat')
-                        link_elem = item.find('link')
-                        marlin_found.append({
-                            'title': title,
-                            'price': price_elem.text if price_elem is not None else 'N/A',
-                            'link': link_elem.text if link_elem is not None else 'N/A'
-                        })
-            
-            print(f"Found {len(marlin_found)} Marlin 5 products in XML:")
-            for m in marlin_found[:5]:  # Show first 5
-                print(f"  - {m['title']}")
-                print(f"    Price: {m['price']}")
-                print(f"    Link: {m['link'][:50]}..." if m['link'] != 'N/A' else "    Link: N/A")
-        else:
-            print(f"Failed to fetch XML: {response.status_code}")
-            
-    except Exception as e:
-        print(f"Error: {e}")
-
-def test_price_function():
-    """Test get_product_price_and_link function"""
-    print("\n=== PRICE FUNCTION TEST ===")
-    
-    test_products = [
-        "Marlin 5",
-        "Marlin 5 (2026)",
-        "marlin 5",
-        "MARLIN 5"
-    ]
-    
-    for product in test_products:
-        price, link = get_product_price_and_link(product)
-        print(f"\nProduct: '{product}'")
-        print(f"  Price: {price}")
-        print(f"  Link: {link[:50] if link else 'None'}...")
-
-def test_warehouse_search():
-    """Test full warehouse search"""
-    print("\n=== WAREHOUSE SEARCH TEST ===")
-    
-    result = get_warehouse_stock_smart_with_price("Marlin 5")
-    print(f"Search result for 'Marlin 5':")
-    if result:
-        for item in result[:2]:  # Show first 2
-            print(f"\n{item}")
-    else:
-        print("No results found")
-
-def test_universal_matcher():
-    """Test universal matcher with Trek XML"""
-    print("\n=== UNIVERSAL MATCHER TEST ===")
-    
-    try:
-        # Get Trek XML
-        url = 'https://www.trekbisiklet.com.tr/output/8582384479'
-        response = requests.get(url, verify=False, timeout=10)
-        
-        if response.status_code == 200:
-            root = ET.fromstring(response.content)
-            
-            # Convert to product list
-            products = []
-            for item in root.findall('.//item'):
-                title_elem = item.find('rootlabel')
-                if title_elem is not None and title_elem.text:
-                    products.append({
-                        'name': title_elem.text,
-                        'rootlabel': title_elem.text
-                    })
-            
-            print(f"Total products in XML: {len(products)}")
-            
-            # Test matcher
-            result = find_best_match("Marlin 5", products, threshold=20)
-            if result:
-                print(f"\nBest match for 'Marlin 5':")
-                print(f"  Name: {result['name']}")
-                print(f"  Score: {result.get('match_score', 0)}")
-            else:
-                print("No match found")
-                
-            # Show all Marlin products
-            print("\nAll Marlin products in XML:")
-            marlin_products = [p for p in products if 'marlin' in p['name'].lower()]
-            for p in marlin_products[:10]:
-                print(f"  - {p['name']}")
-                
-    except Exception as e:
-        print(f"Error: {e}")
-
-if __name__ == "__main__":
-    print("Testing Marlin 5 price lookup...")
-    test_direct_xml()
-    test_price_function()
-    test_universal_matcher()
-    test_warehouse_search()

universal_product_matcher.py

@@ -1,241 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Universal Product Matcher
-Genel ürün eşleştirme algoritması - marka/model bağımsız
-"""
-
-import re
-from typing import List, Dict, Tuple, Optional
-import difflib
-
-def normalize_text(text: str) -> str:
-    """Metni normalize et"""
-    # Küçük harf
-    text = text.lower()
-    
-    # Türkçe karakterleri dönüştür
-    tr_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c'}
-    for tr, en in tr_map.items():
-        text = text.replace(tr, en)
-    
-    # Yıl bilgisini kaldır (2024), (2025) vb.
-    text = re.sub(r'\s*\(\d{4}\)\s*', '', text)
-    
-    # Fazla boşlukları temizle
-    text = ' '.join(text.split())
-    
-    return text.strip()
-
-def extract_product_components(product_name: str) -> Dict:
-    """
-    Ürün adını bileşenlerine ayır
-    Örnek: "Marlin 5 Kırmızı L" -> {brand: "marlin", model: "5", color: "kirmizi", size: "l"}
-    """
-    normalized = normalize_text(product_name)
-    
-    # Sayıları bul (model numaraları için)
-    numbers = re.findall(r'\b\d+\b', normalized)
-    
-    # Renkleri bul
-    colors = ['kirmizi', 'mavi', 'siyah', 'beyaz', 'gri', 'yesil', 'turuncu', 'mor', 'sari', 'pembe']
-    found_colors = [c for c in colors if c in normalized]
-    
-    # Bedenleri bul
-    sizes = ['xxs', 'xs', 's', 'm', 'ml', 'l', 'xl', 'xxl', 'small', 'medium', 'large']
-    found_sizes = [s for s in sizes if f' {s} ' in f' {normalized} ' or normalized.endswith(f' {s}')]
-    
-    # Ana kelimeler (brand/model adı - sayı, renk ve beden hariç)
-    words = normalized.split()
-    main_words = []
-    for word in words:
-        if (word not in numbers and 
-            word not in found_colors and 
-            word not in found_sizes and
-            not word.isdigit()):
-            main_words.append(word)
-    
-    return {
-        'normalized': normalized,
-        'main_words': main_words,
-        'numbers': numbers,
-        'colors': found_colors,
-        'sizes': found_sizes,
-        'word_count': len(words)
-    }
-
-def calculate_match_score(search_components: Dict, item_components: Dict) -> float:
-    """
-    İki ürün arasındaki eşleşme skorunu hesapla
-    Genel algoritma - marka bağımsız
-    """
-    score = 0.0
-    
-    # 1. Ana kelimeler eşleşmesi (brand/model adı)
-    if search_components['main_words'] and item_components['main_words']:
-        # Tüm ana kelimelerin eşleşmesi gerekiyor
-        search_main = set(search_components['main_words'])
-        item_main = set(item_components['main_words'])
-        
-        # Aranan tüm ana kelimeler üründe var mı?
-        if search_main.issubset(item_main):
-            # Tam eşleşme bonus
-            if search_main == item_main:
-                score += 50
-            else:
-                score += 30
-        else:
-            # Ana kelimeler eşleşmiyorsa, bu ürün değil
-            return 0
-    
-    # 2. Model numarası eşleşmesi (kritik!)
-    if search_components['numbers']:
-        search_nums = set(search_components['numbers'])
-        item_nums = set(item_components['numbers'])
-        
-        if search_nums:
-            if search_nums == item_nums:
-                score += 40  # Tam numara eşleşmesi
-            elif search_nums.issubset(item_nums):
-                score += 20  # Kısmi numara eşleşmesi
-            else:
-                # Aranan numara yoksa, büyük ihtimalle yanlış ürün
-                score *= 0.5
-    
-    # 3. String benzerliği (Levenshtein)
-    similarity = difflib.SequenceMatcher(
-        None, 
-        search_components['normalized'], 
-        item_components['normalized']
-    ).ratio()
-    score += similarity * 20
-    
-    # 4. Kelime sırası bonusu
-    search_start = ' '.join(search_components['normalized'].split()[:2])
-    item_start = ' '.join(item_components['normalized'].split()[:2])
-    if search_start == item_start:
-        score += 15
-    
-    # 5. Renk eşleşmesi (opsiyonel)
-    if search_components['colors'] and item_components['colors']:
-        if set(search_components['colors']) == set(item_components['colors']):
-            score += 5
-    
-    # 6. Beden eşleşmesi (opsiyonel)
-    if search_components['sizes'] and item_components['sizes']:
-        if set(search_components['sizes']) == set(item_components['sizes']):
-            score += 5
-    
-    return score
-
-def find_best_match(search_query: str, products: List[Dict], threshold: float = 30) -> Optional[Dict]:
-    """
-    En iyi eşleşen ürünü bul
-    
-    Args:
-        search_query: Aranan ürün
-        products: Ürün listesi [{name: str, ...}]
-        threshold: Minimum eşleşme skoru
-    
-    Returns:
-        En iyi eşleşen ürün veya None
-    """
-    search_components = extract_product_components(search_query)
-    
-    best_match = None
-    best_score = 0
-    
-    for product in products:
-        product_name = product.get('name', '') or product.get('rootlabel', '')
-        if not product_name:
-            continue
-        
-        item_components = extract_product_components(product_name)
-        score = calculate_match_score(search_components, item_components)
-        
-        if score > best_score and score >= threshold:
-            best_score = score
-            best_match = product
-            best_match['match_score'] = score
-    
-    return best_match
-
-def find_all_matches(search_query: str, products: List[Dict], threshold: float = 20, max_results: int = 10) -> List[Dict]:
-    """
-    Eşleşen tüm ürünleri bul ve skorla sırala
-    """
-    search_components = extract_product_components(search_query)
-    
-    matches = []
-    
-    for product in products:
-        product_name = product.get('name', '') or product.get('rootlabel', '')
-        if not product_name:
-            continue
-        
-        item_components = extract_product_components(product_name)
-        score = calculate_match_score(search_components, item_components)
-        
-        if score >= threshold:
-            product_copy = product.copy()
-            product_copy['match_score'] = score
-            matches.append(product_copy)
-    
-    # Skora göre sırala
-    matches.sort(key=lambda x: x['match_score'], reverse=True)
-    
-    return matches[:max_results]
-
-# Test fonksiyonu
-def test_matcher():
-    """Test senaryoları"""
-    
-    # Örnek ürünler
-    test_products = [
-        {"name": "Marlin 5 (2026)", "price": 53000},
-        {"name": "Marlin 7", "price": 72000},
-        {"name": "Rail 9.9 XX AXS T-Type Gen 5", "price": 700000},
-        {"name": "FX 2", "price": 65000},
-        {"name": "FX Sport 6", "price": 183000},
-        {"name": "Domane AL 2", "price": 110000},
-        {"name": "Marlin 5 Kırmızı L", "price": 53000},
-        {"name": "FX 2 Disc Mavi M", "price": 65000},
-    ]
-    
-    # Test sorguları
-    test_queries = [
-        "Marlin 5",
-        "FX 2",
-        "Rail 9",
-        "Domane",
-        "FX Sport",
-        "Marlin"
-    ]
-    
-    print("\n" + "="*60)
-    print("UNIVERSAL PRODUCT MATCHER TEST")
-    print("="*60)
-    
-    for query in test_queries:
-        print(f"\n🔍 Aranan: '{query}'")
-        best = find_best_match(query, test_products)
-        
-        if best:
-            print(f"✅ En İyi Eşleşme: {best['name']}")
-            print(f"   Skor: {best['match_score']:.1f}")
-            print(f"   Fiyat: {best['price']:,} TL")
-        else:
-            print("❌ Eşleşme bulunamadı")
-        
-        # Tüm eşleşmeleri göster
-        all_matches = find_all_matches(query, test_products, threshold=10)
-        if len(all_matches) > 1:
-            print("   Diğer eşleşmeler:")
-            for m in all_matches[1:3]:  # İlk 3
-                print(f"   - {m['name']} (Skor: {m['match_score']:.1f})")
-    
-    print("\n" + "="*60)
-
-if __name__ == "__main__":
-    test_matcher()