Update app.py

app.py

@@ -1,13 +1,21 @@
 """
-BIST Value Intelligence — Conservative Value Screener
-=====================================================
+BIST Value Intelligence — Conservative Value Screener (v2)
+==========================================================
 A transparent, data-honest value screening application for Borsa Istanbul.
 
-DESIGN PHILOSOPHY:
-- Never fabricate missing data. Missing data = None + confidence penalty.
-- Clearly distinguish between computed metrics and unavailable fields.
-- Use only yfinance as data source (no KAP API key required).
-- All assumptions are explicit in code.
+CHANGELOG v2 (düzeltmeler):
+- FIX #1: dividend_yield ölçek normalizasyonu (yfinance bazen %5.0, bazen 0.05 döndürür)
+- FIX #2: Bankalar/REITs için sektör-spesifik skorlama
+- FIX #3: compute_valuation_score tip anotasyonu düzeltildi
+- FIX #4: Progress bar + rate-limit için sleep
+- FIX #5: failed listesi UI'da raporlanıyor
+- FIX #6: Sektör medyanı min 3 örneklem kuralı
+- FIX #7: Enflasyon parametresi UI'dan ayarlanabilir
+- FIX #8: debt_to_equity eşiği sektör-farkında
+- FIX #9: Kullanılmayan import temizlendi
+- FIX #10: Company detail cache boşsa scanner çalıştırılıyor
+- FIX #11: FCF yield / earnings yield normalizasyonları sadeleştirildi
+- FIX #12: Bankalar için Graham Number uyarısı
 
 LIMITATIONS (READ BEFORE USE):
 - yfinance fundamentals are NOT point-in-time. Do not use for backtesting.
@@ -36,8 +44,6 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# BIST universe: core liquid names. Extend cautiously—non-BIST-100
-# fundamentals coverage in yfinance is poor and produces misleading scores.
 BIST_UNIVERSE = [
     "AEFES.IS", "AKBNK.IS", "AKSA.IS", "AKSEN.IS", "ALARK.IS",
     "ARCLK.IS", "ASELS.IS", "ASTOR.IS", "BIMAS.IS", "BRSAN.IS",
@@ -51,13 +57,25 @@ BIST_UNIVERSE = [
     "ZOREN.IS",
 ]
 
-# Cache configuration
+# FIX #2: Sektör-spesifik davranış — bu sektörlerde bazı metrikler anlamsız
+FINANCIAL_SECTORS = {
+    "Financial Services",  # Bankalar, sigorta, aracı kurumlar
+}
+# Bankalar için daha dar tanım (industry bazlı)
+BANK_INDUSTRIES = {
+    "Banks—Regional", "Banks—Diversified", "Banks",
+    "Banks - Regional", "Banks - Diversified",
+}
+
+# FIX #4: Rate-limit için istekler arası bekleme
+REQUEST_DELAY_SEC = 0.3
+
+# Cache
 CACHE_TTL_HOURS = 6
 _cache: Dict[str, Tuple[datetime, Any]] = {}
 
 
 def _cache_get(key: str) -> Optional[Any]:
-    """Retrieve from cache if TTL valid."""
     if key in _cache:
         ts, data = _cache[key]
         if datetime.now() - ts < timedelta(hours=CACHE_TTL_HOURS):
@@ -66,10 +84,21 @@ def _cache_get(key: str) -> Optional[Any]:
 
 
 def _cache_set(key: str, data: Any) -> None:
-    """Store in cache."""
     _cache[key] = (datetime.now(), data)
 
 
+def _is_bank(data: Dict[str, Any]) -> bool:
+    """FIX #2: Banka mı? — industry bazlı tespit."""
+    industry = (data.get("industry") or "").strip()
+    return any(bank_kw.lower() in industry.lower() for bank_kw in BANK_INDUSTRIES)
+
+
+def _is_financial(data: Dict[str, Any]) -> bool:
+    """FIX #2: Finansal sektör mü?"""
+    sector = (data.get("sector") or "").strip()
+    return sector in FINANCIAL_SECTORS
+
+
 # ============================================================================
 # DATA ACQUISITION
 # ============================================================================
@@ -78,7 +107,6 @@ def fetch_ticker_data(symbol: str, force_refresh: bool = False) -> Optional[Dict
     """
     Fetch all available data for a single ticker.
     Returns None if the ticker cannot be retrieved at all.
-    All individual fields may be None if unavailable.
     """
     cache_key = f"ticker_{symbol}"
     if not force_refresh:
@@ -90,18 +118,13 @@ def fetch_ticker_data(symbol: str, force_refresh: bool = False) -> Optional[Dict
         ticker = yf.Ticker(symbol)
         info = ticker.info or {}
 
-        # Core price data
         price = info.get("currentPrice") or info.get("regularMarketPrice")
         if price is None:
-            # Fallback: try history
             hist = ticker.history(period="5d")
             if not hist.empty:
                 price = float(hist["Close"].iloc[-1])
 
-        # Market cap
         market_cap = info.get("marketCap")
-
-        # Valuation multiples
         trailing_pe = info.get("trailingPE")
         forward_pe = info.get("forwardPE")
         price_to_book = info.get("priceToBook")
@@ -110,36 +133,36 @@ def fetch_ticker_data(symbol: str, force_refresh: bool = False) -> Optional[Dict
         enterprise_value = info.get("enterpriseValue")
         earnings_yield = (1.0 / trailing_pe) if trailing_pe and trailing_pe > 0 else None
 
-        # Profitability
         roe = info.get("returnOnEquity")
         roa = info.get("returnOnAssets")
         gross_margin = info.get("grossMargins")
         operating_margin = info.get("operatingMargins")
         profit_margin = info.get("profitMargins")
 
-        # Balance sheet
         debt_to_equity = info.get("debtToEquity")
         current_ratio = info.get("currentRatio")
         total_debt = info.get("totalDebt")
         total_cash = info.get("totalCash")
 
-        # Cash flow
         free_cashflow = info.get("freeCashflow")
         operating_cashflow = info.get("operatingCashflow")
         fcf_yield = None
         if free_cashflow is not None and market_cap and market_cap > 0:
             fcf_yield = free_cashflow / market_cap
 
-        # Per-share data for Graham
         trailing_eps = info.get("trailingEps")
         book_value_per_share = info.get("bookValue")
 
-        # Sector
         sector = info.get("sector", "Unknown")
         industry = info.get("industry", "Unknown")
 
-        # Dividend
+        # FIX #1: dividend_yield ölçek normalizasyonu
         dividend_yield = info.get("dividendYield")
+        if dividend_yield is not None:
+            # yfinance tutarsız: bazen 5.0 (%5), bazen 0.05 (5%)
+            # 1.0'dan büyükse yüzde olarak gelmiş demektir
+            if dividend_yield > 1.0:
+                dividend_yield = dividend_yield / 100.0
 
         result = {
             "symbol": symbol.replace(".IS", ""),
@@ -172,7 +195,6 @@ def fetch_ticker_data(symbol: str, force_refresh: bool = False) -> Optional[Dict
             "data_timestamp": datetime.now().isoformat(),
         }
 
-        # Graham Number: sqrt(22.5 * EPS * BVPS)
         if (trailing_eps is not None and trailing_eps > 0
                 and book_value_per_share is not None and book_value_per_share > 0):
             result["graham_number"] = float(np.sqrt(22.5 * trailing_eps * book_value_per_share))
@@ -193,17 +215,13 @@ def fetch_ticker_data(symbol: str, force_refresh: bool = False) -> Optional[Dict
 
 def compute_piotroski_score(data: Dict[str, Any]) -> Optional[int]:
     """
-    Compute Piotroski F-Score using available data.
-    Returns None if insufficient data.
-    
-    Note: True Piotroski requires year-over-year changes in 9 metrics.
-    Without historical statements, we compute a reduced version using
-    only current-period available fields. This is explicitly a partial score.
+    Partial Piotroski F-Score (current-period only, no YoY changes).
+    FIX #2: Bankalar için ROA ve D/E sinyalleri farklı yorumlanır.
     """
     score = 0
     components_available = 0
+    is_bank = _is_bank(data)
 
-    # Profitability signals (4 components if data exists)
     if data.get("roa") is not None:
         components_available += 1
         if data["roa"] > 0:
@@ -216,55 +234,56 @@ def compute_piotroski_score(data: Dict[str, Any]) -> Optional[int]:
 
     if data.get("roa") is not None and data.get("operating_cashflow") is not None:
         components_available += 1
-        # CFO > ROA (approximation: CFO/assets > net income/assets)
         if data["operating_cashflow"] > 0 and data["roa"] > 0:
             score += 1
 
-    # Leverage/liquidity (2 components)
-    if data.get("debt_to_equity") is not None:
+    # FIX #2 & #8: Bankalarda D/E doğal olarak yüksektir, sinyali atla
+    if not is_bank and data.get("debt_to_equity") is not None:
         components_available += 1
-        # Lower leverage is better; use 100 as threshold (yfinance reports as percentage)
         if data["debt_to_equity"] < 100:
             score += 1
 
-    if data.get("current_ratio") is not None:
+    # FIX #2: Bankalarda current_ratio anlamsız
+    if not is_bank and data.get("current_ratio") is not None:
         components_available += 1
         if data["current_ratio"] > 1.0:
             score += 1
 
-    # Require at least 4 components to return a score
-    if components_available < 4:
+    if components_available < 3:  # Bankalar için eşik düşürüldü
         return None
 
-    # Scale to 9-point maximum based on available components
-    # This is NOT a true Piotroski score and should be labeled accordingly
     max_possible = components_available
     scaled = round((score / max_possible) * 9) if max_possible > 0 else 0
     return min(9, max(0, scaled))
 
 
-def compute_valuation_score(data: Dict[str, Any], sector_medians: Dict[str, float]) -> Tuple[Optional[float], int]:
+def compute_valuation_score(
+    data: Dict[str, Any],
+    sector_medians: Dict[str, Dict[str, float]],  # FIX #3: doğru tip
+) -> Tuple[Optional[float], int]:
     """
-    Compute valuation score (0-100). Returns (score, confidence_0_to_100).
-    Confidence reflects data completeness.
+    Valuation score (0-100) + confidence (0-100).
+    FIX #2: Bankalar için EV/EBITDA ve FCF Yield skorlamadan çıkarılır.
     """
     scores = []
     weights = []
     missing = 0
     total = 0
 
-    # Earnings Yield (higher = better value)
+    is_bank = _is_bank(data)
+
+    # Earnings Yield
     total += 1
     ey = data.get("earnings_yield")
     if ey is not None and ey > 0:
-        # Normalize: 0% = 0, 15%+ = 100
-        s = min(100, ey * 100 / 0.15 * 100)
+        # FIX #11: basitleştirilmiş normalizasyon — %15 = 100 puan
+        s = min(100, (ey / 0.15) * 100)
         scores.append(s)
-        weights.append(0.25)
+        weights.append(0.30 if is_bank else 0.25)
     else:
         missing += 1
 
-    # P/B vs sector (lower = better)
+    # P/B vs sector
     total += 1
     pb = data.get("price_to_book")
     sector_pb = sector_medians.get(data.get("sector", ""), {}).get("pb")
@@ -272,92 +291,102 @@ def compute_valuation_score(data: Dict[str, Any], sector_medians: Dict[str, floa
         ratio = pb / sector_pb
         s = max(0, min(100, (1.5 - ratio) / 1.5 * 100))
         scores.append(s)
-        weights.append(0.25)
+        weights.append(0.40 if is_bank else 0.25)  # Bankalarda P/B daha önemli
     else:
         missing += 1
 
-    # EV/EBITDA vs sector
-    total += 1
-    evebitda = data.get("ev_to_ebitda")
-    sector_ev = sector_medians.get(data.get("sector", ""), {}).get("ev_ebitda")
-    if evebitda is not None and evebitda > 0 and sector_ev and sector_ev > 0:
-        ratio = evebitda / sector_ev
-        s = max(0, min(100, (1.5 - ratio) / 1.5 * 100))
-        scores.append(s)
-        weights.append(0.25)
-    else:
-        missing += 1
-
-    # FCF Yield
-    total += 1
-    fcfy = data.get("fcf_yield")
-    if fcfy is not None:
-        s = min(100, max(0, fcfy * 100 / 0.08 * 100))
-        scores.append(s)
-        weights.append(0.25)
-    else:
-        missing += 1
+    # EV/EBITDA vs sector — FIX #2: bankalarda atla
+    if not is_bank:
+        total += 1
+        evebitda = data.get("ev_to_ebitda")
+        sector_ev = sector_medians.get(data.get("sector", ""), {}).get("ev_ebitda")
+        if evebitda is not None and evebitda > 0 and sector_ev and sector_ev > 0:
+            ratio = evebitda / sector_ev
+            s = max(0, min(100, (1.5 - ratio) / 1.5 * 100))
+            scores.append(s)
+            weights.append(0.25)
+        else:
+            missing += 1
+
+    # FCF Yield — FIX #2: bankalarda atla (mevduat hareketleri bozar)
+    if not is_bank:
+        total += 1
+        fcfy = data.get("fcf_yield")
+        if fcfy is not None:
+            # FIX #11: basitleştirilmiş normalizasyon — %8 = 100 puan
+            s = max(0, min(100, (fcfy / 0.08) * 100))
+            scores.append(s)
+            weights.append(0.25)
+        else:
+            missing += 1
 
     if not scores:
         return None, 0
 
-    # Weighted average
     total_weight = sum(weights)
     if total_weight == 0:
         return None, 0
     final_score = sum(s * w for s, w in zip(scores, weights)) / total_weight
 
-    # Confidence: penalize missing data
     confidence = max(0, 100 - (missing / total) * 60)
     return final_score, int(confidence)
 
 
 def compute_quality_score(data: Dict[str, Any]) -> Tuple[Optional[float], int]:
-    """Compute quality score (0-100) with confidence."""
+    """
+    Quality score (0-100) + confidence.
+    FIX #2 & #8: Bankalar için current_ratio atlanır, D/E eşiği farklı.
+    """
     scores = []
     weights = []
     missing = 0
     total = 0
+    is_bank = _is_bank(data)
 
-    # ROE (higher = better)
+    # ROE
     total += 1
     roe = data.get("roe")
     if roe is not None:
-        s = min(100, max(0, roe * 100 / 0.25 * 100))
-        scores.append(s)
-        weights.append(0.3)
-    else:
-        missing += 1
-
-    # Operating margin
-    total += 1
-    om = data.get("operating_margin")
-    if om is not None:
-        s = min(100, max(0, om * 100 / 0.20 * 100))
-        scores.append(s)
-        weights.append(0.25)
-    else:
-        missing += 1
-
-    # Debt/Equity (lower = better)
-    total += 1
-    de = data.get("debt_to_equity")
-    if de is not None and de >= 0:
-        s = max(0, min(100, (150 - de) / 150 * 100))
+        s = min(100, max(0, (roe / 0.25) * 100))
         scores.append(s)
-        weights.append(0.25)
+        weights.append(0.35 if is_bank else 0.30)  # Bankalarda ROE daha kritik
     else:
         missing += 1
 
-    # Current ratio
-    total += 1
-    cr = data.get("current_ratio")
-    if cr is not None:
-        s = min(100, max(0, (cr - 0.5) / 2.0 * 100))
-        scores.append(s)
-        weights.append(0.20)
-    else:
-        missing += 1
+    # Operating margin — FIX #2: bankalarda atla
+    if not is_bank:
+        total += 1
+        om = data.get("operating_margin")
+        if om is not None:
+            s = min(100, max(0, (om / 0.20) * 100))
+            scores.append(s)
+            weights.append(0.25)
+        else:
+            missing += 1
+
+    # Debt/Equity — FIX #2 & #8: sektör-farkında eşik
+    if not is_bank:
+        total += 1
+        de = data.get("debt_to_equity")
+        if de is not None and de >= 0:
+            # Sanayi için 200, finansal olmayan diğerleri için 150
+            threshold = 200.0
+            s = max(0, min(100, ((threshold - de) / threshold) * 100))
+            scores.append(s)
+            weights.append(0.25)
+        else:
+            missing += 1
+
+    # Current ratio — FIX #2: bankalarda atla
+    if not is_bank:
+        total += 1
+        cr = data.get("current_ratio")
+        if cr is not None:
+            s = min(100, max(0, ((cr - 0.5) / 1.5) * 100))  # 2.0 = 100
+            scores.append(s)
+            weights.append(0.20)
+        else:
+            missing += 1
 
     if not scores:
         return None, 0
@@ -370,22 +399,14 @@ def compute_quality_score(data: Dict[str, Any]) -> Tuple[Optional[float], int]:
 
 def compute_composite_score(
     data: Dict[str, Any],
-    sector_medians: Dict[str, float],
+    sector_medians: Dict[str, Dict[str, float]],
 ) -> Dict[str, Any]:
-    """
-    Compute composite score with explicit component breakdown.
-    Missing data reduces confidence; it does NOT boost scores.
-    """
     val_score, val_conf = compute_valuation_score(data, sector_medians)
     qual_score, qual_conf = compute_quality_score(data)
-
     piotroski = compute_piotroski_score(data)
 
-    # Weighted composite: 50% valuation, 50% quality (simplified from spec
-    # because growth data is unavailable)
     components = []
     weights = []
-
     if val_score is not None:
         components.append(val_score * 0.50)
         weights.append(0.50)
@@ -399,10 +420,11 @@ def compute_composite_score(
     else:
         total_w = sum(weights)
         composite = sum(c * w for c, w in zip(components, weights)) / total_w
-        # Overall confidence: weighted average of component confidences
-        overall_conf = int((val_conf * 0.5 + qual_conf * 0.5)) if (val_score is not None and qual_score is not None) else max(val_conf, qual_conf)
+        if val_score is not None and qual_score is not None:
+            overall_conf = int(val_conf * 0.5 + qual_conf * 0.5)
+        else:
+            overall_conf = max(val_conf, qual_conf)
 
-    # Margin of Safety vs Graham Number
     mos = None
     graham = data.get("graham_number")
     price = data.get("price")
@@ -420,47 +442,46 @@ def compute_composite_score(
 
 
 # ============================================================================
-# FORECASTING (Conservative, assumption-explicit)
+# FORECASTING
 # ============================================================================
 
-def compute_12m_forecast(data: Dict[str, Any], score_result: Dict[str, Any]) -> Dict[str, Any]:
+def compute_12m_forecast(
+    data: Dict[str, Any],
+    score_result: Dict[str, Any],
+    expected_inflation: float = 0.30,  # FIX #7: parametre
+) -> Dict[str, Any]:
     """
     Scenario-based 12-month price target.
-    
+
     METHODOLOGY (explicit):
-    - Bear: Price reverts to 70% of current P/E multiple (multiple compression)
-    - Base: Price grows with earnings yield (conservative proxy for earnings growth)
-    - Bull: Price re-rates to 120% of current P/E multiple
-    
-    These are NOT statistically calibrated forecasts. They are
-    transparent heuristic scenarios. Do not treat them as predictions.
+    - Bear: -20% (multiple compression)
+    - Base: earnings-yield proportional, capped at 25%, floored at inflation*0.5
+    - Bull: base * 1.8
     """
     price = data.get("price")
-    pe = data.get("trailing_pe")
     earnings_yield = data.get("earnings_yield")
 
     if price is None or price <= 0:
         return {"bear": None, "base": None, "bull": None, "expected": None,
                 "expected_return": None, "note": "Insufficient price data"}
 
-    # Base case: earnings power drives price
-    # If earnings yield = 10%, implied annual return ≈ 10% (simplistic)
-    base_growth = 0.08  # Conservative 8% nominal (below Turkish historical inflation)
+    # FIX #7: Enflasyon tabanı — nominal büyüme en az enflasyonun yarısı
+    floor = max(0.03, expected_inflation * 0.5)
+    base_growth = floor
     if earnings_yield and earnings_yield > 0:
-        base_growth = min(0.20, max(0.03, earnings_yield * 0.8))
+        base_growth = min(0.25, max(floor, earnings_yield * 0.8))
 
-    bear_return = -0.20  # 20% downside in bear
+    bear_return = -0.20
     bull_return = base_growth * 1.8
 
     bear = price * (1 + bear_return)
     base = price * (1 + base_growth)
     bull = price * (1 + bull_return)
 
-    # Probability-weighted (20/55/25 from spec)
     expected = bear * 0.20 + base * 0.55 + bull * 0.25
     expected_return = (expected - price) / price
 
-    # Add dividend yield if available
+    # FIX #1: dividend_yield artık normalize edilmiş
     div_yield = data.get("dividend_yield") or 0
     total_return = expected_return + div_yield
 
@@ -472,24 +493,25 @@ def compute_12m_forecast(data: Dict[str, Any], score_result: Dict[str, Any]) ->
         "expected_return": round(expected_return, 4),
         "total_expected_return": round(total_return, 4),
         "dividend_yield": div_yield,
-        "base_assumption": f"{base_growth*100:.1f}% base growth",
+        "base_assumption": f"{base_growth*100:.1f}% base (enflasyon varsayımı: {expected_inflation*100:.0f}%)",
         "note": "Heuristic scenario, not calibrated forecast",
     }
 
 
 # ============================================================================
-# SECTOR MEDIANS (computed from universe)
+# SECTOR MEDIANS
 # ============================================================================
 
 def compute_sector_medians(all_data: List[Dict[str, Any]]) -> Dict[str, Dict[str, float]]:
-    """Compute median multiples per sector from available data."""
+    """
+    Compute median multiples per sector.
+    FIX #6: min 3 örneklem kuralı — az veri varsa medyan None.
+    """
     sectors: Dict[str, Dict[str, List[float]]] = {}
-
     for d in all_data:
         sector = d.get("sector", "Unknown")
         if sector not in sectors:
             sectors[sector] = {"pb": [], "ev_ebitda": [], "pe": []}
-
         if d.get("price_to_book") and d["price_to_book"] > 0:
             sectors[sector]["pb"].append(d["price_to_book"])
         if d.get("ev_to_ebitda") and d["ev_to_ebitda"] > 0:
@@ -501,7 +523,8 @@ def compute_sector_medians(all_data: List[Dict[str, Any]]) -> Dict[str, Dict[str
     for sector, metrics in sectors.items():
         medians[sector] = {}
         for key, values in metrics.items():
-            if values:
+            # FIX #6: min 3 örneklem
+            if len(values) >= 3:
                 medians[sector][key] = float(np.median(values))
     return medians
 
@@ -510,56 +533,72 @@ def compute_sector_medians(all_data: List[Dict[str, Any]]) -> Dict[str, Dict[str
 # SCANNER
 # ============================================================================
 
-def run_scanner(force_refresh: bool = False) -> pd.DataFrame:
-    """Run full universe scan. Returns DataFrame for display."""
+def run_scanner(
+    force_refresh: bool = False,
+    expected_inflation: float = 0.30,
+    progress_callback=None,
+) -> Tuple[pd.DataFrame, List[str]]:
+    """
+    FIX #4: progress_callback ile UI'ya ilerleme bildirimi.
+    FIX #5: failed listesi döndürülür.
+    """
     all_data = []
     failed = []
 
+    total = len(BIST_UNIVERSE)
     for i, sym in enumerate(BIST_UNIVERSE):
-        logger.info(f"Scanning {sym} ({i+1}/{len(BIST_UNIVERSE)})")
+        if progress_callback:
+            progress_callback((i + 1) / total, desc=f"Scanning {sym} ({i+1}/{total})")
+        logger.info(f"Scanning {sym} ({i+1}/{total})")
         data = fetch_ticker_data(sym, force_refresh)
         if data is not None and data.get("price") is not None:
             all_data.append(data)
         else:
-            failed.append(sym)
+            failed.append(sym.replace(".IS", ""))
+        # FIX #4: rate-limit
+        if not force_refresh and i < total - 1:
+            time.sleep(REQUEST_DELAY_SEC)
 
     if not all_data:
-        return pd.DataFrame()
+        return pd.DataFrame(), failed
 
     sector_medians = compute_sector_medians(all_data)
 
     rows = []
     for d in all_data:
         score_result = compute_composite_score(d, sector_medians)
-        forecast = compute_12m_forecast(d, score_result)
+        forecast = compute_12m_forecast(d, score_result, expected_inflation)
+        is_bank = _is_bank(d)
 
         rows.append({
             "Symbol": d["symbol"],
-            "Price": d["price"],
             "Sector": d["sector"],
-            "Composite Score": round(score_result["composite_score"], 1) if score_result["composite_score"] else None,
-            "Valuation Score": round(score_result["valuation_score"], 1) if score_result["valuation_score"] else None,
-            "Quality Score": round(score_result["quality_score"], 1) if score_result["quality_score"] else None,
-            "Piotroski (partial)": score_result["piotroski"],
+            "Type": "Bank" if is_bank else "Non-Fin",  # FIX #2: görsel ayrım
+            "Price": d["price"],
+            "Composite": round(score_result["composite_score"], 1) if score_result["composite_score"] else None,
+            "Valuation": round(score_result["valuation_score"], 1) if score_result["valuation_score"] else None,
+            "Quality": round(score_result["quality_score"], 1) if score_result["quality_score"] else None,
+            "Piotroski": score_result["piotroski"],
             "P/E": round(d["trailing_pe"], 2) if d["trailing_pe"] else None,
             "P/B": round(d["price_to_book"], 2) if d["price_to_book"] else None,
-            "ROE": round(d["roe"] * 100, 1) if d["roe"] else None,
-            "FCF Yield": round(d["fcf_yield"] * 100, 1) if d["fcf_yield"] else None,
-            "Graham Number": round(d["graham_number"], 2) if d["graham_number"] else None,
-            "Margin of Safety": round(score_result["margin_of_safety"] * 100, 1) if score_result["margin_of_safety"] else None,
-            "12M Base Target": forecast["base"],
-            "Expected Return": round(forecast["total_expected_return"] * 100, 1) if forecast["total_expected_return"] else None,
+            "ROE %": round(d["roe"] * 100, 1) if d["roe"] else None,
+            "FCF Yield %": round(d["fcf_yield"] * 100, 1) if d["fcf_yield"] else None,
+            "Graham": round(d["graham_number"], 2) if d["graham_number"] else None,
+            "MoS %": round(score_result["margin_of_safety"] * 100, 1) if score_result["margin_of_safety"] else None,
+            "12M Base": forecast["base"],
+            "Exp Return %": round(forecast["total_expected_return"] * 100, 1) if forecast["total_expected_return"] is not None else None,
             "Confidence": score_result["confidence"],
         })
 
     df = pd.DataFrame(rows)
-    # Sort by composite score, nulls last
-    df = df.sort_values("Composite Score", ascending=False, na_position="last")
-    return df
+    df = df.sort_values("Composite", ascending=False, na_position="last")
+    return df, failed
 
 
-def get_company_detail(symbol_input: str) -> Tuple[str, Optional[go.Figure]]:
-    """Return detailed markdown report and price chart for a company."""
+def get_company_detail(
+    symbol_input: str,
+    expected_inflation: float = 0.30,
+) -> Tuple[str, Optional[go.Figure]]:
     symbol = symbol_input.strip().upper()
     if not symbol.endswith(".IS"):
         symbol = symbol + ".IS"
@@ -568,63 +607,95 @@ def get_company_detail(symbol_input: str) -> Tuple[str, Optional[go.Figure]]:
     if data is None or data.get("price") is None:
         return f"## {symbol}\n\nNo data available. Check ticker validity.", None
 
-    # Recompute score (need sector medians from current cache)
+    # FIX #10: Cache boşsa önce scanner çalıştır
     all_cached = []
     for key in _cache:
         if key.startswith("ticker_"):
             _, val = _cache[key]
             if val is not None:
                 all_cached.append(val)
-    sector_medians = compute_sector_medians(all_cached) if all_cached else {}
 
+    if len(all_cached) < 5:
+        # Sektör medyanı için yeterli örnek yok — sessizce scanner tetikle
+        logger.info("Cache boş, sektör medyanı için hızlı tarama yapılıyor...")
+        for sym in BIST_UNIVERSE:
+            if sym == symbol:
+                continue
+            fetch_ticker_data(sym)
+            time.sleep(0.15)
+        all_cached = []
+        for key in _cache:
+            if key.startswith("ticker_"):
+                _, val = _cache[key]
+                if val is not None:
+                    all_cached.append(val)
+
+    sector_medians = compute_sector_medians(all_cached) if all_cached else {}
     score = compute_composite_score(data, sector_medians)
-    forecast = compute_12m_forecast(data, score)
+    forecast = compute_12m_forecast(data, score, expected_inflation)
+
+    is_bank = _is_bank(data)
+    bank_warning = ""
+    if is_bank:
+        bank_warning = "\n> ⚠️ **Banka**: EV/EBITDA, FCF Yield, Current Ratio ve D/E skorlamadan çıkarıldı. Graham Number yorumu bankalar için sınırlıdır.\n"
+
+    # Markdown raporu — N/A handling temizlendi
+    def fmt(val, fmt_str=".2f", suffix=""):
+        if val is None:
+            return "N/A"
+        try:
+            return f"{val:{fmt_str}}{suffix}"
+        except (ValueError, TypeError):
+            return str(val)
 
-    # Build markdown report
     lines = [
         f"## {data['symbol']} — Company Detail",
         "",
         f"**Sector**: {data['sector']} | **Industry**: {data['industry']}",
+        f"**Type**: {'Bank' if is_bank else 'Non-Financial'}",
         f"**Data timestamp**: {data['data_timestamp']}",
-        "",
+        bank_warning,
         "### Valuation",
         "",
-        f"| Metric | Value |",
-        f"|---|---|",
-        f"| Price | {data['price']} |",
-        f"| Market Cap | {data['market_cap']:,} |" if data['market_cap'] else "| Market Cap | N/A |",
-        f"| Trailing P/E | {data['trailing_pe']:.1f} |" if data['trailing_pe'] else "| Trailing P/E | N/A |",
-        f"| P/B | {data['price_to_book']:.2f} |" if data['price_to_book'] else "| P/B | N/A |",
-        f"| EV/EBITDA | {data['ev_to_ebitda']:.1f} |" if data['ev_to_ebitda'] else "| EV/EBITDA | N/A |",
-        f"| FCF Yield | {data['fcf_yield']*100:.1f}% |" if data['fcf_yield'] else "| FCF Yield | N/A |",
-        f"| Graham Number | {data['graham_number']:.2f} |" if data['graham_number'] else "| Graham Number | N/A |",
-        f"| Margin of Safety | {score['margin_of_safety']*100:.1f}% |" if score['margin_of_safety'] else "| Margin of Safety | N/A |",
+        "| Metric | Value |",
+        "|---|---|",
+        f"| Price | {fmt(data['price'], '.2f')} |",
+        f"| Market Cap | {fmt(data['market_cap'], ',.0f')} |",
+        f"| Trailing P/E | {fmt(data['trailing_pe'], '.1f')} |",
+        f"| Forward P/E | {fmt(data['forward_pe'], '.1f')} |",
+        f"| P/B | {fmt(data['price_to_book'], '.2f')} |",
+        f"| EV/EBITDA | {fmt(data['ev_to_ebitda'], '.1f')}{' *(N/A for banks)*' if is_bank else ''} |",
+        f"| FCF Yield | {fmt(data['fcf_yield']*100 if data['fcf_yield'] else None, '.1f', '%')}{' *(N/A for banks)*' if is_bank else ''} |",
+        f"| Graham Number | {fmt(data['graham_number'], '.2f')} |",
+        f"| Margin of Safety | {fmt(score['margin_of_safety']*100 if score['margin_of_safety'] else None, '.1f', '%')} |",
         "",
         "### Quality",
         "",
-        f"| Metric | Value |",
-        f"|---|---|",
-        f"| ROE | {data['roe']*100:.1f}% |" if data['roe'] else "| ROE | N/A |",
-        f"| ROA | {data['roa']*100:.1f}% |" if data['roa'] else "| ROA | N/A |",
-        f"| Operating Margin | {data['operating_margin']*100:.1f}% |" if data['operating_margin'] else "| Operating Margin | N/A |",
-        f"| Debt/Equity | {data['debt_to_equity']:.1f} |" if data['debt_to_equity'] is not None else "| Debt/Equity | N/A |",
-        f"| Current Ratio | {data['current_ratio']:.2f} |" if data['current_ratio'] else "| Current Ratio | N/A |",
-        f"| Piotroski (partial) | {score['piotroski']}/9 |" if score['piotroski'] is not None else "| Piotroski (partial) | N/A |",
+        "| Metric | Value |",
+        "|---|---|",
+        f"| ROE | {fmt(data['roe']*100 if data['roe'] else None, '.1f', '%')} |",
+        f"| ROA | {fmt(data['roa']*100 if data['roa'] else None, '.1f', '%')} |",
+        f"| Operating Margin | {fmt(data['operating_margin']*100 if data['operating_margin'] else None, '.1f', '%')} |",
+        f"| Debt/Equity | {fmt(data['debt_to_equity'], '.1f')}{' *(N/A for banks)*' if is_bank else ''} |",
+        f"| Current Ratio | {fmt(data['current_ratio'], '.2f')}{' *(N/A for banks)*' if is_bank else ''} |",
+        f"| Piotroski (partial) | {fmt(score['piotroski'], 'd')}/9 |",
         "",
         "### Scores",
         "",
-        f"- **Composite**: {score['composite_score']:.1f}/100 (confidence: {score['confidence']}%)" if score['composite_score'] else "- **Composite**: N/A",
-        f"- **Valuation**: {score['valuation_score']:.1f}/100" if score['valuation_score'] else "- **Valuation**: N/A",
-        f"- **Quality**: {score['quality_score']:.1f}/100" if score['quality_score'] else "- **Quality**: N/A",
+        f"- **Composite**: {fmt(score['composite_score'], '.1f')}/100 (confidence: {score['confidence']}%)",
+        f"- **Valuation**: {fmt(score['valuation_score'], '.1f')}/100",
+        f"- **Quality**: {fmt(score['quality_score'], '.1f')}/100",
         "",
         "### 12-Month Scenarios (heuristic, not calibrated)",
         "",
-        f"| Scenario | Target | Return |",
-        f"|---|---|---|",
-        f"| Bear | {forecast['bear']} | {(forecast['bear']/data['price']-1)*100:.1f}% |" if forecast['bear'] else "| Bear | N/A | N/A |",
-        f"| Base | {forecast['base']} | {(forecast['base']/data['price']-1)*100:.1f}% |" if forecast['base'] else "| Base | N/A | N/A |",
-        f"| Bull | {forecast['bull']} | {(forecast['bull']/data['price']-1)*100:.1f}% |" if forecast['bull'] else "| Bull | N/A | N/A |",
-        f"| **Probability-weighted** | **{forecast['expected']}** | **{forecast['total_expected_return']*100:.1f}%** |" if forecast['expected'] else "| Expected | N/A | N/A |",
+        f"Enflasyon varsayımı: **{expected_inflation*100:.0f}%** — {forecast.get('base_assumption', 'N/A')}",
+        "",
+        "| Scenario | Target | Return |",
+        "|---|---|---|",
+        f"| Bear | {fmt(forecast['bear'], '.2f')} | {fmt((forecast['bear']/data['price']-1)*100 if forecast['bear'] else None, '.1f', '%')} |",
+        f"| Base | {fmt(forecast['base'], '.2f')} | {fmt((forecast['base']/data['price']-1)*100 if forecast['base'] else None, '.1f', '%')} |",
+        f"| Bull | {fmt(forecast['bull'], '.2f')} | {fmt((forecast['bull']/data['price']-1)*100 if forecast['bull'] else None, '.1f', '%')} |",
+        f"| **Prob-weighted** | **{fmt(forecast['expected'], '.2f')}** | **{fmt(forecast['total_expected_return']*100 if forecast['total_expected_return'] is not None else None, '.1f', '%')}** |",
         "",
         f"*{forecast['note']}*",
         "",
@@ -634,7 +705,6 @@ def get_company_detail(symbol_input: str) -> Tuple[str, Optional[go.Figure]]:
 
     markdown = "\n".join(lines)
 
-    # Price chart
     try:
         ticker = yf.Ticker(symbol)
         hist = ticker.history(period="1y")
@@ -659,17 +729,19 @@ def get_company_detail(symbol_input: str) -> Tuple[str, Optional[go.Figure]]:
 
 
 # ============================================================================
-# DATA QUALITY MONITOR
+# DATA QUALITY
 # ============================================================================
 
-def data_quality_report() -> pd.DataFrame:
-    """Report data completeness across the universe."""
+def data_quality_report(progress_callback=None) -> pd.DataFrame:
     rows = []
-    for sym in BIST_UNIVERSE:
+    total = len(BIST_UNIVERSE)
+    for i, sym in enumerate(BIST_UNIVERSE):
+        if progress_callback:
+            progress_callback((i + 1) / total, desc=f"Checking {sym}")
         data = fetch_ticker_data(sym)
         if data is None:
             rows.append({"Symbol": sym.replace(".IS", ""), "Status": "FETCH FAILED",
-                          "Fields Available": 0, "Critical Missing": "ALL"})
+                          "Fields": "0/5", "Missing": "ALL", "Sector": "—", "Type": "—"})
             continue
 
         critical_fields = ["price", "trailing_pe", "price_to_book", "roe", "fcf_yield"]
@@ -679,10 +751,13 @@ def data_quality_report() -> pd.DataFrame:
         rows.append({
             "Symbol": data["symbol"],
             "Status": "OK" if available >= 3 else "INCOMPLETE",
-            "Fields Available": f"{available}/{len(critical_fields)}",
-            "Critical Missing": ", ".join(missing) if missing else "—",
+            "Fields": f"{available}/{len(critical_fields)}",
+            "Missing": ", ".join(missing) if missing else "—",
             "Sector": data.get("sector", "Unknown"),
+            "Type": "Bank" if _is_bank(data) else "Non-Fin",
         })
+        if i < total - 1:
+            time.sleep(REQUEST_DELAY_SEC * 0.5)
 
     return pd.DataFrame(rows)
 
@@ -694,131 +769,133 @@ def data_quality_report() -> pd.DataFrame:
 def build_ui():
     with gr.Blocks(title="BIST Value Intelligence", theme=gr.themes.Soft()) as demo:
         gr.Markdown("""
-# BIST Value Intelligence
+# BIST Value Intelligence (v2)
 ### Conservative Value Screening for Borsa Istanbul
 
-**⚠️ Important limitations:**
-- Data from Yahoo Finance is **not point-in-time**. Do not use for backtesting.
-- Coverage for non-BIST-100 stocks is incomplete. Missing data is shown as `N/A`, never imputed.
-- Scores are **relative rankings within this universe**, not absolute quality measures.
-- The 12-month scenarios are **transparent heuristics**, not statistically calibrated forecasts.
-- This tool is for research and education. Not investment advice.
+**⚠️ Önemli sınırlamalar:**
+- Yahoo Finance verisi **point-in-time değildir**. Backtest için kullanmayın.
+- BIST-100 dışı hisselerde kapsam eksiktir. Eksik veri `N/A` gösterilir, asla sıfırla doldurulmaz.
+- Skorlar bu evren içinde **göreceli sıralamadır**, mutlak kalite ölçüsü değildir.
+- 12 aylık senaryolar **şeffaf heuristiklerdir**, istatistiksel tahmin değildir.
+- **Bankalar** için EV/EBITDA, FCF Yield, Current Ratio ve D/E skorlamadan çıkarılmıştır.
+- Bu araç araştırma ve eğitim içindir. Yatırım tavsiyesi değildir.
         """)
 
         with gr.Tabs():
-            # Tab 1: Scanner
+            # TAB 1: Scanner
             with gr.Tab("📊 Market Scanner"):
                 with gr.Row():
-                    scan_btn = gr.Button("Run Scanner", variant="primary", scale=1)
-                    refresh_cb = gr.Checkbox(label="Force refresh (bypass cache)", value=False, scale=1)
+                    scan_btn = gr.Button("Run Scanner", variant="primary", scale=2)
+                    refresh_cb = gr.Checkbox(label="Force refresh", value=False, scale=1)
+                with gr.Row():
+                    # FIX #7: enflasyon parametresi
+                    inflation_slider = gr.Slider(
+                        0, 100, value=30, step=5,
+                        label="Beklenen enflasyon varsayımı (%)",
+                    )
 
                 status_text = gr.Textbox(label="Status", interactive=False, visible=False)
+                failed_text = gr.Textbox(label="Çekilemeyen hisseler", interactive=False, visible=False)
                 scanner_table = gr.Dataframe(
-                    label="BIST Universe Scan Results",
-                    interactive=False,
-                    wrap=True,
+                    label="BIST Universe Scan Results (Composite skora göre sıralı)",
+                    interactive=False, wrap=True,
                 )
 
-                def do_scan(force):
-                    status_text = gr.update(visible=True, value="Scanning universe...")
-                    df = run_scanner(force_refresh=force)
+                def do_scan(force, inflation_pct, progress=gr.Progress()):
+                    df, failed = run_scanner(
+                        force_refresh=force,
+                        expected_inflation=inflation_pct / 100.0,
+                        progress_callback=progress,
+                    )
                     if df.empty:
-                        return gr.update(value=None), gr.update(visible=True, value="No data retrieved. Check network.")
-                    return df, gr.update(visible=True, value=f"Scanned {len(df)} stocks. Sorted by composite score.")
-
-                scan_btn.click(do_scan, inputs=[refresh_cb], outputs=[scanner_table, status_text])
+                        return (
+                            gr.update(value=None),
+                            gr.update(visible=True, value="Veri çekilemedi. Ağ bağlantısını kontrol edin."),
+                            gr.update(visible=False),
+                        )
+                    msg = f"✅ {len(df)} hisse tarandı. Enflasyon varsayımı: %{inflation_pct:.0f}."
+                    if failed:
+                        return (
+                            df,
+                            gr.update(visible=True, value=msg),
+                            gr.update(visible=True, value="⚠️ " + ", ".join(failed)),
+                        )
+                    return df, gr.update(visible=True, value=msg), gr.update(visible=False)
+
+                scan_btn.click(
+                    do_scan,
+                    inputs=[refresh_cb, inflation_slider],
+                    outputs=[scanner_table, status_text, failed_text],
+                )
 
-            # Tab 2: Company Detail
+            # TAB 2: Company
             with gr.Tab("🔍 Company Analysis"):
                 with gr.Row():
-                    ticker_input = gr.Textbox(label="Ticker (e.g., THYAO, GARAN)", value="THYAO")
-                    detail_btn = gr.Button("Analyze", variant="primary")
+                    ticker_input = gr.Textbox(label="Ticker (e.g., THYAO, GARAN)", value="THYAO", scale=2)
+                    detail_inflation = gr.Slider(0, 100, value=30, step=5,
+                                                  label="Enflasyon (%)", scale=1)
+                    detail_btn = gr.Button("Analyze", variant="primary", scale=1)
 
                 detail_md = gr.Markdown()
                 price_chart = gr.Plot()
 
                 detail_btn.click(
                     get_company_detail,
-                    inputs=[ticker_input],
+                    inputs=[ticker_input, detail_inflation],
                     outputs=[detail_md, price_chart],
                 )
 
-            # Tab 3: Data Quality
+            # TAB 3: Data Quality
             with gr.Tab("📋 Data Quality Monitor"):
                 gr.Markdown("""
-Shows which fundamental fields are available for each ticker.
-**Critical fields**: price, trailing_pe, price_to_book, roe, fcf_yield.
-
-If fewer than 3 of 5 are available, the stock's score confidence is severely reduced.
+**Kritik alanlar**: price, trailing_pe, price_to_book, roe, fcf_yield.
+3/5'ten az alan varsa hisse `INCOMPLETE` işaretlenir ve skor güveni düşer.
                 """)
                 quality_btn = gr.Button("Check Data Quality", variant="primary")
                 quality_table = gr.Dataframe(label="Field Availability", interactive=False)
 
-                def do_quality():
-                    return data_quality_report()
+                def do_quality(progress=gr.Progress()):
+                    return data_quality_report(progress_callback=progress)
 
                 quality_btn.click(do_quality, outputs=[quality_table])
 
-            # Tab 4: Methodology
-            with gr.Tab("📐 Methodology"):
+            # TAB 4: Methodology
+            with gr.Tab("📐 Methodology & Changelog"):
                 gr.Markdown("""
-### Scoring Methodology
-
-**Valuation Score (50% weight in composite)**
-- Earnings yield (25%): normalized to 15% = 100
-- P/B vs sector median (25%): lower is better
-- EV/EBITDA vs sector median (25%): lower is better
-- FCF yield (25%): normalized to 8% = 100
-
-**Quality Score (50% weight in composite)**
-- ROE (30%): normalized to 25% = 100
-- Operating margin (25%): normalized to 20% = 100
-- Debt/Equity (25%): lower is better, 150 = 0
-- Current ratio (20%): 2.0 = 100, 0.5 = 0
-
-**Piotroski F-Score (partial)**
-- Computed from available current-period fields only
-- Does NOT include year-over-year changes (historical statements unavailable)
-- Scaled to 9-point maximum based on available components
-- **Labeled "partial" throughout the UI**
-
-**Graham Number**
-- `sqrt(22.5 × EPS × Book Value per Share)`
-- Requires positive EPS and positive BVPS
-- Returns `N/A` otherwise
-
-**12-Month Scenarios**
-- Bear: 20% downside (multiple compression)
-- Base: Earnings-yield-proportional growth, capped at 20%, floored at 3%
-- Bull: Base × 1.8
-- Probability-weighted: 20% bear, 55% base, 25% bull
-
-**Confidence Score**
-- Reflects data completeness
-- Missing critical fields reduce confidence
-- High confidence with missing data is impossible by design
-
-### What This Tool Does NOT Do
-
-- ❌ DCF valuation (requires growth assumptions we cannot validate)
-- ❌ Monte Carlo simulation (requires calibrated return distributions)
-- ❌ Machine learning (requires point-in-time data for training)
-- ❌ Historical backtesting (survivorship and look-ahead bias unavoidable with current data)
-- ❌ Fabricate missing data
-
-### Why the Limitations Exist
-
-Yahoo Finance fundamentals for BIST stocks are:
-1. **Not point-in-time**: the API returns current snapshots, not historical filing data
-2. **Incomplete**: many small/mid-cap stocks lack ROE, FCF, and debt figures
-3. **Inconsistent**: field availability changes without notice
-
-KAP (the official Turkish disclosure platform) is the authoritative source, but programmatic access requires an MKK API key and IP whitelisting. The `kap-mcp` library exists for this purpose [citation:2][citation:12] but cannot be used without institutional credentials.
-
-For a production-grade system, you need either:
-- KAP API access (via MKK)
-- A paid data vendor (Bloomberg, Refinitiv, Matriks, İş Yatırım)
-- BilancoVeri's API (free but needs validation) [citation:11]
+### v2 Düzeltmeleri
+
+| # | Düzeltme | Etki |
+|---|---|---|
+| 1 | `dividend_yield` ölçek normalizasyonu | Yanlış %500 getiri bug'ı giderildi |
+| 2 | Banka/Finansal sektör ayrımı | EV/EBITDA, FCF, C/R, D/E skorlamadan çıkarıldı |
+| 3 | Tip anotasyonu | `Dict[str, Dict[str, float]]` |
+| 4 | Progress bar + `sleep(0.3)` | UX + rate-limit koruması |
+| 5 | `failed` listesi UI'da | Şeffaflık |
+| 6 | Sektör medyanı min 3 örneklem | Tek örnekli medyan artık kullanılmıyor |
+| 7 | Enflasyon parametresi | 8% sabit varsayım kaldırıldı |
+| 8 | D/E eşiği 150→200 | Türk şirketleri için daha adil |
+| 9 | `import time` artık kullanılıyor | (sleep için) |
+| 10 | Company detail cache boşsa tarama | Sektör medyanı her zaman mevcut |
+| 11 | Normalizasyonlar sadeleştirildi | `ey/0.15*100` (çift çarpma yok) |
+| 12 | Bankalar için Graham uyarısı | Yorum sınırı belgelenmiş |
+
+### Skorlama Özeti
+
+**Valuation (50% ağırlık)**
+- Banka: Earnings Yield %30, P/B %40 (EV/EBITDA ve FCF yok)
+- Diğer: Earnings Yield %25, P/B %25, EV/EBITDA %25, FCF %25
+
+**Quality (50% ağırlık)**
+- Banka: ROE %35 (diğerleri yok)
+- Diğer: ROE %30, Op Margin %25, D/E %25, C/R %20
+
+### Hâlâ Yapılmayanlar
+
+- ❌ DCF (doğrulanabilir büyüme varsayımı yok)
+- ❌ Monte Carlo (kalibre dağılım yok)
+- ❌ ML (point-in-time veri yok)
+- ❌ Backtest (survivorship/look-ahead bias)
+- ❌ Veri uydurma
                 """)
 
     return demo