Update app.py

app.py

@@ -1,29 +1,14 @@
 """
-BIST Value Intelligence — Conservative Value Screener (v2)
-==========================================================
-A transparent, data-honest value screening application for Borsa Istanbul.
-
-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.
-- Coverage for non-BIST-100 names is incomplete. Many fields will be None.
-- No DCF, Monte Carlo, or ML—insufficient reliable historical data.
+BIST Value Intelligence v3 — Compact Value & Intrinsic Valuation Platform
+=========================================================================
+Data integrity > model complexity. Intrinsic value > momentum. Margin of safety > prediction.
+
+Veri etiketleri:  [R] raporlanan   [D] türetilen   [A] kullanıcı varsayımı
+UYARI: yfinance verisi point-in-time DEĞİLDİR; backtest için kullanılamaz.
 """
 
 import logging
+import tempfile
 import time
 from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional, Tuple
@@ -34,732 +19,787 @@ import pandas as pd
 import plotly.graph_objects as go
 import yfinance as yf
 
-# ============================================================================
-# CONFIGURATION
-# ============================================================================
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s | %(levelname)s | %(message)s",
-)
-logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
+logger = logging.getLogger("bist_v3")
 
 BIST_UNIVERSE = [
-    "AEFES.IS", "AKBNK.IS", "AKSA.IS", "AKSEN.IS", "ALARK.IS",
-    "ARCLK.IS", "ASELS.IS", "ASTOR.IS", "BIMAS.IS", "BRSAN.IS",
-    "CCOLA.IS", "CIMSA.IS", "DOAS.IS", "DOHOL.IS", "ECILC.IS",
-    "EKGYO.IS", "ENJSA.IS", "ENKAI.IS", "EREGL.IS", "FROTO.IS",
-    "GARAN.IS", "GUBRF.IS", "HEKTS.IS", "ISCTR.IS", "KCHOL.IS",
-    "KRDMD.IS", "MGROS.IS", "ODAS.IS", "PETKM.IS", "PGSUS.IS",
-    "SAHOL.IS", "SASA.IS", "SISE.IS", "SKBNK.IS", "TCELL.IS",
-    "THYAO.IS", "TKFEN.IS", "TOASO.IS", "TSKB.IS", "TTKOM.IS",
-    "TUPRS.IS", "ULKER.IS", "VAKBN.IS", "VESBE.IS", "YKBNK.IS",
-    "ZOREN.IS",
+    "AEFES", "AKBNK", "AKSA", "AKSEN", "ALARK", "ARCLK", "ASELS", "ASTOR", "BIMAS", "BRSAN",
+    "CCOLA", "CIMSA", "DOAS", "DOHOL", "ECILC", "EKGYO", "ENJSA", "ENKAI", "EREGL", "FROTO",
+    "GARAN", "GUBRF", "HEKTS", "ISCTR", "KCHOL", "KRDMD", "MGROS", "ODAS", "PETKM", "PGSUS",
+    "SAHOL", "SASA", "SISE", "SKBNK", "TCELL", "THYAO", "TKFEN", "TOASO", "TSKB", "TTKOM",
+    "TUPRS", "ULKER", "VAKBN", "VESBE", "YKBNK", "ZOREN", "ISGYO", "TRGYO", "HALKB", "AKGRT",
+    "ANSGR", "TURSG", "ANHYT", "RAYSG",
 ]
+BIST_UNIVERSE = [s + ".IS" for s in BIST_UNIVERSE]
 
-# 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
+MIN_PEERS = 5
 _cache: Dict[str, Tuple[datetime, Any]] = {}
+LAST: Dict[str, Any] = {"df": None, "failed": []}
 
 
-def _cache_get(key: str) -> Optional[Any]:
-    if key in _cache:
-        ts, data = _cache[key]
+def _cget(k):
+    if k in _cache:
+        ts, v = _cache[k]
         if datetime.now() - ts < timedelta(hours=CACHE_TTL_HOURS):
-            return data
+            return v
     return None
 
 
-def _cache_set(key: str, data: Any) -> None:
-    _cache[key] = (datetime.now(), data)
+def _cset(k, v):
+    _cache[k] = (datetime.now(), v)
 
 
-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)
+# ============================================================================
+# SMALL HELPERS
+# ============================================================================
 
+def num(x) -> Optional[float]:
+    try:
+        if x is None:
+            return None
+        v = float(x)
+        return None if (np.isnan(v) or np.isinf(v)) else v
+    except Exception:
+        return None
 
-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
 
+def div(a, b) -> Optional[float]:
+    a, b = num(a), num(b)
+    if a is None or b is None or b == 0:
+        return None
+    return a / b
 
-# ============================================================================
-# DATA ACQUISITION
-# ============================================================================
 
-def fetch_ticker_data(symbol: str, force_refresh: bool = False) -> Optional[Dict[str, Any]]:
-    """
-    Fetch all available data for a single ticker.
-    Returns None if the ticker cannot be retrieved at all.
-    """
-    cache_key = f"ticker_{symbol}"
-    if not force_refresh:
-        cached = _cache_get(cache_key)
-        if cached is not None:
-            return cached
+def growth(cur, prev) -> Optional[float]:
+    cur, prev = num(cur), num(prev)
+    if cur is None or prev is None or prev <= 0:
+        return None
+    return cur / prev - 1
 
-    try:
-        ticker = yf.Ticker(symbol)
-        info = ticker.info or {}
 
-        price = info.get("currentPrice") or info.get("regularMarketPrice")
-        if price is None:
-            hist = ticker.history(period="5d")
-            if not hist.empty:
-                price = float(hist["Close"].iloc[-1])
-
-        market_cap = info.get("marketCap")
-        trailing_pe = info.get("trailingPE")
-        forward_pe = info.get("forwardPE")
-        price_to_book = info.get("priceToBook")
-        price_to_sales = info.get("priceToSalesTrailing12Months")
-        ev_to_ebitda = info.get("enterpriseToEbitda")
-        enterprise_value = info.get("enterpriseValue")
-        earnings_yield = (1.0 / trailing_pe) if trailing_pe and trailing_pe > 0 else None
-
-        roe = info.get("returnOnEquity")
-        roa = info.get("returnOnAssets")
-        gross_margin = info.get("grossMargins")
-        operating_margin = info.get("operatingMargins")
-        profit_margin = info.get("profitMargins")
-
-        debt_to_equity = info.get("debtToEquity")
-        current_ratio = info.get("currentRatio")
-        total_debt = info.get("totalDebt")
-        total_cash = info.get("totalCash")
-
-        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
-
-        trailing_eps = info.get("trailingEps")
-        book_value_per_share = info.get("bookValue")
-
-        sector = info.get("sector", "Unknown")
-        industry = info.get("industry", "Unknown")
-
-        # 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", ""),
-            "price": price,
-            "market_cap": market_cap,
-            "trailing_pe": trailing_pe,
-            "forward_pe": forward_pe,
-            "price_to_book": price_to_book,
-            "price_to_sales": price_to_sales,
-            "ev_to_ebitda": ev_to_ebitda,
-            "enterprise_value": enterprise_value,
-            "earnings_yield": earnings_yield,
-            "roe": roe,
-            "roa": roa,
-            "gross_margin": gross_margin,
-            "operating_margin": operating_margin,
-            "profit_margin": profit_margin,
-            "debt_to_equity": debt_to_equity,
-            "current_ratio": current_ratio,
-            "total_debt": total_debt,
-            "total_cash": total_cash,
-            "free_cashflow": free_cashflow,
-            "operating_cashflow": operating_cashflow,
-            "fcf_yield": fcf_yield,
-            "trailing_eps": trailing_eps,
-            "book_value_per_share": book_value_per_share,
-            "sector": sector,
-            "industry": industry,
-            "dividend_yield": dividend_yield,
-            "data_timestamp": datetime.now().isoformat(),
-        }
-
-        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))
-        else:
-            result["graham_number"] = None
+def real_ret(nominal, infl) -> Optional[float]:
+    return None if nominal is None else (1 + nominal) / (1 + infl) - 1
 
-        _cache_set(cache_key, result)
-        return result
 
-    except Exception as e:
-        logger.warning(f"Failed to fetch {symbol}: {e}")
+def lin(x, bad, good) -> Optional[float]:
+    """Linear 0-100 scale; works for bad>good as well."""
+    if x is None:
         return None
+    return float(np.clip((x - bad) / (good - bad), 0, 1) * 100)
 
 
-# ============================================================================
-# SCORING ENGINE
-# ============================================================================
+def wavg(items) -> Tuple[Optional[float], float]:
+    v = [(s, w) for s, w in items if s is not None]
+    tw = sum(w for _, w in items)
+    if not v or tw == 0:
+        return None, 0.0
+    sw = sum(w for _, w in v)
+    return sum(s * w for s, w in v) / sw, sw / tw
 
-def compute_piotroski_score(data: Dict[str, Any]) -> Optional[int]:
-    """
-    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)
-
-    if data.get("roa") is not None:
-        components_available += 1
-        if data["roa"] > 0:
-            score += 1
-
-    if data.get("operating_cashflow") is not None:
-        components_available += 1
-        if data["operating_cashflow"] > 0:
-            score += 1
-
-    if data.get("roa") is not None and data.get("operating_cashflow") is not None:
-        components_available += 1
-        if data["operating_cashflow"] > 0 and data["roa"] > 0:
-            score += 1
-
-    # 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
-        if data["debt_to_equity"] < 100:
-            score += 1
-
-    # 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
-
-    if components_available < 3:  # Bankalar için eşik düşürüldü
-        return None
 
-    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, Dict[str, float]],  # FIX #3: doğru tip
-) -> Tuple[Optional[float], int]:
-    """
-    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
-
-    is_bank = _is_bank(data)
-
-    # Earnings Yield
-    total += 1
-    ey = data.get("earnings_yield")
-    if ey is not None and ey > 0:
-        # FIX #11: basitleştirilmiş normalizasyon — %15 = 100 puan
-        s = min(100, (ey / 0.15) * 100)
-        scores.append(s)
-        weights.append(0.30 if is_bank else 0.25)
-    else:
-        missing += 1
-
-    # P/B vs sector
-    total += 1
-    pb = data.get("price_to_book")
-    sector_pb = sector_medians.get(data.get("sector", ""), {}).get("pb")
-    if pb is not None and pb > 0 and sector_pb and sector_pb > 0:
-        ratio = pb / sector_pb
-        s = max(0, min(100, (1.5 - ratio) / 1.5 * 100))
-        scores.append(s)
-        weights.append(0.40 if is_bank else 0.25)  # Bankalarda P/B daha önemli
-    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
-
-    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 = max(0, 100 - (missing / total) * 60)
-    return final_score, int(confidence)
-
-
-def compute_quality_score(data: Dict[str, Any]) -> Tuple[Optional[float], int]:
-    """
-    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
-    total += 1
-    roe = data.get("roe")
-    if roe is not None:
-        s = min(100, max(0, (roe / 0.25) * 100))
-        scores.append(s)
-        weights.append(0.35 if is_bank else 0.30)  # Bankalarda ROE daha kritik
-    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
-
-    total_weight = sum(weights)
-    final_score = sum(s * w for s, w in zip(scores, weights)) / total_weight
-    confidence = max(0, 100 - (missing / total) * 60)
-    return final_score, int(confidence)
-
-
-def compute_composite_score(
-    data: Dict[str, Any],
-    sector_medians: Dict[str, Dict[str, float]],
-) -> Dict[str, Any]:
-    val_score, val_conf = compute_valuation_score(data, sector_medians)
-    qual_score, qual_conf = compute_quality_score(data)
-    piotroski = compute_piotroski_score(data)
-
-    components = []
-    weights = []
-    if val_score is not None:
-        components.append(val_score * 0.50)
-        weights.append(0.50)
-    if qual_score is not None:
-        components.append(qual_score * 0.50)
-        weights.append(0.50)
-
-    if not components:
-        composite = None
-        overall_conf = 0
-    else:
-        total_w = sum(weights)
-        composite = sum(c * w for c, w in zip(components, weights)) / total_w
-        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)
+def anyc(*c) -> Optional[bool]:
+    v = [x for x in c if x is not None]
+    return None if not v else any(v)
 
-    mos = None
-    graham = data.get("graham_number")
-    price = data.get("price")
-    if graham and price and price > 0:
-        mos = (graham - price) / graham
 
-    return {
-        "composite_score": composite,
-        "valuation_score": val_score,
-        "quality_score": qual_score,
-        "piotroski": piotroski,
-        "confidence": overall_conf,
-        "margin_of_safety": mos,
-    }
+def fm(x, d=2):
+    return "N/A" if x is None else f"{x:,.{d}f}"
+
+
+def fp(x, d=1):
+    return "N/A" if x is None else f"{x * 100:.{d}f}%"
+
+
+def norm_sym(t: str) -> str:
+    t = (t or "").strip().upper()
+    return t if t.endswith(".IS") else t + ".IS"
+
+
+def mk_params(infl, rw, rtg, rg, pt, cv) -> Dict[str, float]:
+    return dict(infl=infl / 100, rw=rw / 100, rtg=rtg / 100, rg=rg / 100, pt=pt / 100, conv=cv / 100)
 
 
 # ============================================================================
-# FORECASTING
+# DATA ACQUISITION & INTEGRITY
 # ============================================================================
 
-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: -20% (multiple compression)
-    - Base: earnings-yield proportional, capped at 25%, floored at inflation*0.5
-    - Bull: base * 1.8
-    """
-    price = data.get("price")
-    earnings_yield = data.get("earnings_yield")
+STMT = {
+    "ni": (("Net Income", "Net Income Common Stockholders"), "fin"),
+    "rev": (("Total Revenue", "Operating Revenue"), "fin"),
+    "gp": (("Gross Profit",), "fin"),
+    "opinc": (("Operating Income", "EBIT"), "fin"),
+    "ebitda": (("EBITDA", "Normalized EBITDA"), "fin"),
+    "interest": (("Interest Expense", "Interest Expense Non Operating"), "fin"),
+    "tax": (("Tax Provision",), "fin"),
+    "pretax": (("Pretax Income",), "fin"),
+    "ta": (("Total Assets",), "bs"),
+    "eq": (("Stockholders Equity", "Common Stock Equity", "Total Equity Gross Minority Interest"), "bs"),
+    "debt": (("Total Debt",), "bs"),
+    "ltd": (("Long Term Debt", "Long Term Debt And Capital Lease Obligation"), "bs"),
+    "cash": (("Cash Cash Equivalents And Short Term Investments", "Cash And Cash Equivalents"), "bs"),
+    "ca": (("Current Assets",), "bs"),
+    "cl": (("Current Liabilities",), "bs"),
+    "shares": (("Ordinary Shares Number", "Share Issued"), "bs"),
+    "cfo": (("Operating Cash Flow", "Cash Flow From Continuing Operating Activities"), "cf"),
+    "capex": (("Capital Expenditure",), "cf"),
+    "fcf": (("Free Cash Flow",), "cf"),
+    "da": (("Depreciation And Amortization", "Depreciation Amortization Depletion"), "cf"),
+    "dwc": (("Change In Working Capital",), "cf"),
+}
 
-    if price is None or price <= 0:
-        return {"bear": None, "base": None, "bull": None, "expected": None,
-                "expected_return": None, "note": "Insufficient price data"}
 
-    # 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.25, max(floor, earnings_yield * 0.8))
+def stmt(df, names, i=0) -> Optional[float]:
+    if df is None or getattr(df, "empty", True) or i >= df.shape[1]:
+        return None
+    for n in names:
+        if n in df.index:
+            r = df.loc[n]
+            if isinstance(r, pd.DataFrame):
+                r = r.iloc[0]
+            return num(r.iloc[i])
+    return None
 
-    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)
+def segment_of(industry: str, sym: str) -> str:
+    ind = (industry or "").lower()
+    if "bank" in ind:
+        return "Bank"
+    if "insurance" in ind:
+        return "Insurance"
+    if "reit" in ind or "real estate" in ind or sym.upper().endswith("GYO"):
+        return "GYO"
+    return "Industrial"
 
-    expected = bear * 0.20 + base * 0.55 + bull * 0.25
-    expected_return = (expected - price) / price
 
-    # FIX #1: dividend_yield artık normalize edilmiş
-    div_yield = data.get("dividend_yield") or 0
-    total_return = expected_return + div_yield
+def fetch(symbol: str, force: bool = False) -> Optional[Dict[str, Any]]:
+    key = f"t_{symbol}"
+    if not force:
+        c = _cget(key)
+        if c is not None:
+            return c
+    try:
+        t = yf.Ticker(symbol)
+        info = t.info or {}
+        fin, bs, cf = t.financials, t.balance_sheet, t.cashflow
+        try:
+            dv = t.dividends
+        except Exception:
+            dv = None
+        price = num(info.get("currentPrice")) or num(info.get("regularMarketPrice"))
+        if price is None:
+            h = t.history(period="5d")
+            price = num(h["Close"].iloc[-1]) if not h.empty else None
+    except Exception as e:
+        logger.warning("%s fetch failed: %s", symbol, e)
+        return None
+    if price is None or price <= 0:
+        return None
 
-    return {
-        "bear": round(bear, 2),
-        "base": round(base, 2),
-        "bull": round(bull, 2),
-        "expected": round(expected, 2),
-        "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 (enflasyon varsayımı: {expected_inflation*100:.0f}%)",
-        "note": "Heuristic scenario, not calibrated forecast",
+    flags: List[str] = []
+    dfs = {"fin": fin, "bs": bs, "cf": cf}
+    s = {k: [stmt(dfs[src], names, i) for i in range(3)] for k, (names, src) in STMT.items()}
+    s["capex"] = [abs(x) if x is not None else None for x in s["capex"]]
+    s["interest"] = [abs(x) if x is not None else None for x in s["interest"]]
+    for i in range(3):
+        if s["fcf"][i] is None and s["cfo"][i] is not None and s["capex"][i] is not None:
+            s["fcf"][i] = s["cfo"][i] - s["capex"][i]
+        if s["ebitda"][i] is None and s["opinc"][i] is not None and s["da"][i] is not None:
+            s["ebitda"][i] = s["opinc"][i] + s["da"][i]
+    if s["debt"][0] is None:
+        s["debt"][0] = num(info.get("totalDebt"))
+        if s["debt"][0] is not None:
+            flags.append("debt from info (not statement)")
+    if s["cash"][0] is None:
+        s["cash"][0] = num(info.get("totalCash"))
+        if s["cash"][0] is not None:
+            flags.append("cash from info (not statement)")
+
+    # period / currency / unit validation
+    sd = None
+    try:
+        sd = pd.Timestamp(fin.columns[0]).to_pydatetime() if fin is not None and not fin.empty else None
+        for nm, df in (("balance sheet", bs), ("cash flow", cf)):
+            if df is not None and not df.empty and sd is not None and pd.Timestamp(df.columns[0]).to_pydatetime() != sd:
+                flags.append(f"{nm} period != income statement period")
+    except Exception:
+        pass
+    age = (datetime.now() - sd).days if sd else None
+    if age is not None and age > 550:
+        flags.append(f"stale statements ({age} days)")
+    if sd is None:
+        flags.append("no annual statements")
+    fc, cur = info.get("financialCurrency"), info.get("currency")
+    unit_ok = (fc is None) or (cur is None) or (fc == cur)
+    if not unit_ok:
+        flags.append(f"currency mismatch (fin {fc} vs price {cur})")
+    if fc is None:
+        flags.append("financial currency unknown")
+
+    shares = num(info.get("sharesOutstanding")) or s["shares"][0]
+    mcap = num(info.get("marketCap")) or (price * shares if shares else None)
+    if shares and mcap and abs(price * shares / mcap - 1) > 0.35:
+        flags.append("shares x price differs >35% from market cap")
+    eq0, ta0 = s["eq"][0], s["ta"][0]
+    if eq0 is not None and ta0 is not None and eq0 > ta0 * 1.01:
+        flags.append("equity > total assets (suspicious)")
+    if s["rev"][0] and s["ni"][0] is not None and abs(s["ni"][0]) > 1.0 * s["rev"][0] and s["rev"][0] > 0:
+        flags.append("|net income| > revenue (suspicious)")
+
+    bvps = num(info.get("bookValue")) or div(eq0, shares)
+    eps = num(info.get("trailingEps")) or div(s["ni"][0], shares)
+    if eps is not None and shares and s["ni"][0] not in (None, 0) and abs(eps * shares / s["ni"][0] - 1) > 0.5:
+        flags.append("EPS x shares differs >50% from net income")
+
+    # dividends: 0 only if history fetched and empty; None if unavailable
+    dy = None
+    try:
+        if dv is not None:
+            if len(dv) > 0:
+                cutoff = pd.Timestamp.now(tz=dv.index.tz) - pd.Timedelta(days=365)
+                dy = float(dv[dv.index >= cutoff].sum()) / price
+            else:
+                dy = 0.0
+    except Exception:
+        dy = None
+    if dy is None:
+        y = num(info.get("dividendYield"))
+        if y is not None:
+            dy = y / 100 if y > 1 else y
+
+    tax_assumed = False
+    tr = div(s["tax"][0], s["pretax"][0]) if (s["pretax"][0] or 0) > 0 else None
+    if tr is None:
+        tr, tax_assumed = 0.25, True
+    tr = float(np.clip(tr, 0, 0.35))
+
+    net_debt = (s["debt"][0] - s["cash"][0]) if (s["debt"][0] is not None and s["cash"][0] is not None) else None
+    fcf0, int0 = s["fcf"][0], s["interest"][0]
+    fcff = (fcf0 + int0 * (1 - tr)) if (fcf0 is not None and int0 is not None) else None  # unlevered -> net debt bridge
+    oe, oe_parts = None, None
+    ni0, da0, cx0, wc0 = s["ni"][0], s["da"][0], s["capex"][0], s["dwc"][0]
+    if None not in (ni0, da0, cx0, wc0):
+        maint = min(cx0, da0)  # [D] estimate: maintenance capex ~ min(total capex, D&A)
+        oe = ni0 + da0 - maint + wc0
+        oe_parts = dict(ni=ni0, da=da0, capex_total=cx0, maint_est=maint, dwc=wc0)
+    ev = (mcap + net_debt) if (mcap and net_debt is not None) else num(info.get("enterpriseValue"))
+    ebitda0 = s["ebitda"][0]
+    industry = info.get("industry") or "Unknown"
+    seg = segment_of(industry, symbol.replace(".IS", ""))
+    roes = [div(s["ni"][i], s["eq"][i]) for i in range(3) if (s["eq"][i] or 0) > 0]
+    roes = [r for r in roes if r is not None]
+    ir = num(info.get("returnOnEquity"))
+    if ir is not None:
+        roes.append(ir)
+    sust_roe = float(np.clip(np.mean(roes), -1, 1.5)) if roes else None
+
+    d = {
+        "sym": symbol.replace(".IS", ""), "name": info.get("shortName") or symbol, "price": price, "mcap": mcap,
+        "shares": shares, "sector": info.get("sector") or "Unknown", "industry": industry, "seg": seg,
+        "bvps": bvps, "eps": eps, "dy": dy, "s": s, "flags": flags, "unit_ok": unit_ok, "stmt_date": sd, "age": age,
+        "tax_rate": tr, "tax_assumed": tax_assumed, "net_debt": net_debt, "fcff": fcff, "fcf0": fcf0, "oe": oe,
+        "oe_parts": oe_parts, "ev": ev, "sust_roe": sust_roe,
+        "pe": price / eps if eps and eps > 0 else None,
+        "fpe": num(info.get("forwardPE")) if (num(info.get("forwardPE")) or 0) > 0 else None,
+        "pb": price / bvps if bvps and bvps > 0 else None,
+        "ps": div(mcap, s["rev"][0]) if (s["rev"][0] or 0) > 0 else None,
+        "ev_ebitda": div(ev, ebitda0) if (ebitda0 or 0) > 0 and ev else None,
+        "ev_fcf": div(ev, fcf0) if (fcf0 or 0) > 0 and ev else None,
+        "fcf_yield": div(fcf0, mcap), "earn_yield": div(eps, price), "fetched": datetime.now().isoformat(),
     }
+    _cset(key, d)
+    return d
+
+
+def cached_ds() -> List[Dict[str, Any]]:
+    return [v for k, (ts, v) in _cache.items() if k.startswith("t_") and v is not None]
+
+
+MULTS = ["pe", "fpe", "pb", "ev_ebitda", "ev_fcf", "ps", "fcf_yield", "earn_yield"]
+POS_ONLY = {"pe", "fpe", "pb", "ev_ebitda", "ev_fcf", "ps"}
+
+
+def build_medians(ds) -> Dict[Tuple[str, str], Dict[str, Tuple[Optional[float], int]]]:
+    groups: Dict[Tuple[str, str], list] = {}
+    for d in ds:
+        groups.setdefault((d["seg"], d["sector"]), []).append(d)
+    med = {}
+    for k, g in groups.items():
+        m = {}
+        for f in MULTS:
+            v = [x[f] for x in g if x.get(f) is not None and (f not in POS_ONLY or (0 < x[f] < 300))]
+            m[f] = (float(np.median(v)) if len(v) >= MIN_PEERS else None, len(v))
+        med[k] = m
+    return med
 
 
 # ============================================================================
-# SECTOR MEDIANS
+# VALUATION ENGINE
 # ============================================================================
 
-def compute_sector_medians(all_data: List[Dict[str, Any]]) -> Dict[str, Dict[str, float]]:
-    """
-    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:
-            sectors[sector]["ev_ebitda"].append(d["ev_to_ebitda"])
-        if d.get("trailing_pe") and d["trailing_pe"] > 0:
-            sectors[sector]["pe"].append(d["trailing_pe"])
-
-    medians = {}
-    for sector, metrics in sectors.items():
-        medians[sector] = {}
-        for key, values in metrics.items():
-            # FIX #6: min 3 örneklem
-            if len(values) >= 3:
-                medians[sector][key] = float(np.median(values))
-    return medians
+def dcf_value(base, g0, wacc, tg, shares, net_debt, years=5) -> Optional[Dict[str, float]]:
+    """5-year explicit DCF, growth fades linearly g0 -> tg. Returns None if inputs insufficient."""
+    if None in (base, g0, wacc, tg, shares, net_debt) or base <= 0 or shares <= 0 or wacc <= tg:
+        return None
+    flows, f = [], base
+    for t in range(1, years + 1):
+        g = g0 + (tg - g0) * (t - 1) / (years - 1)
+        f *= 1 + g
+        flows.append(f)
+    pv = sum(fl / (1 + wacc) ** (i + 1) for i, fl in enumerate(flows))
+    pvtv = flows[-1] * (1 + tg) / (wacc - tg) / (1 + wacc) ** years
+    ev = pv + pvtv
+    eq = ev - net_debt
+    return {"ev": ev, "equity": eq, "per_share": eq / shares, "tv_share": pvtv / ev if ev else 0.0}
+
+
+def assumptions(P, rg=None, rw=None):
+    rg = P["rg"] if rg is None else rg
+    rw = P["rw"] if rw is None else rw
+    i = P["infl"]
+    return (1 + rg) * (1 + i * P["pt"]) - 1, (1 + rw) * (1 + i) - 1, (1 + P["rtg"]) * (1 + i) - 1  # g0, wacc, tg (nominal)
+
+
+def dcf_try(base, g0, wacc, tg, shares, nd, ok):
+    if not ok:
+        return None, "currency/unit mismatch"
+    if base is None:
+        return None, "essential inputs missing"
+    if base <= 0:
+        return None, "non-positive base cash flow"
+    if not shares or shares <= 0:
+        return None, "shares unavailable"
+    if nd is None:
+        return None, "net debt unavailable"
+    if wacc <= tg:
+        return None, "discount rate <= terminal growth"
+    r = dcf_value(base, g0, wacc, tg, shares, nd)
+    if r is None or r["per_share"] <= 0:
+        return None, "equity value <= 0"
+    return r["per_share"], f"TV = {r['tv_share'] * 100:.0f}% of EV"
+
+
+def relative_value(d, med) -> Tuple[Optional[float], str]:
+    m = med.get((d["seg"], d["sector"]))
+    if not m or not d["unit_ok"]:
+        return None, "no peer group / unit mismatch"
+    seg, vals = d["seg"], []
+    if m["pb"][0] and d["bvps"] and d["bvps"] > 0:
+        vals.append(m["pb"][0] * d["bvps"])
+    if seg != "GYO" and m["pe"][0] and d["eps"] and d["eps"] > 0:
+        vals.append(m["pe"][0] * d["eps"])
+    if seg == "Industrial" and m["ev_ebitda"][0] and (d["s"]["ebitda"][0] or 0) > 0 and d["net_debt"] is not None and d["shares"]:
+        vals.append((m["ev_ebitda"][0] * d["s"]["ebitda"][0] - d["net_debt"]) / d["shares"])
+    vals = [v for v in vals if v > 0]
+    if not vals:
+        return None, f"<{MIN_PEERS} valid peers"
+    return float(np.mean(vals)), f"{len(vals)} sector-median multiple(s)"
+
+
+def intrinsic(d, P, med, rg=None, rw=None):
+    g0, wacc, tg = assumptions(P, rg, rw)
+    m: Dict[str, Tuple[Optional[float], str]] = {}
+    seg, bv = d["seg"], d["bvps"]
+    if seg in ("Bank", "Insurance"):
+        roe = d["sust_roe"]
+        if d["unit_ok"] and roe is not None and bv and bv > 0 and wacc > tg:
+            m["Justified P/B"] = (max((roe - tg) / (wacc - tg), 0) * bv, f"sust. ROE {fp(roe)}, COE {fp(wacc)}, g {fp(tg)}")
+        else:
+            m["Justified P/B"] = (None, "ROE/book value unavailable")
+        m["DCF"] = (None, "not applied to banks/insurers")
+    elif seg == "GYO":
+        m["NAV proxy (book)"] = ((bv, "book value; appraised NAV not in Yahoo") if (d["unit_ok"] and bv and bv > 0) else (None, "book value unavailable"))
+    else:
+        m["DCF"] = dcf_try(d["fcff"], g0, wacc, tg, d["shares"], d["net_debt"], d["unit_ok"])
+        m["Owner Earnings"] = dcf_try(d["oe"], g0, wacc, tg, d["shares"], 0.0, d["unit_ok"])  # equity CF: no debt bridge
+    m["Relative"] = relative_value(d, med)
+    vals = [v for v, _ in m.values() if v is not None and v > 0]
+    return m, (float(np.median(vals)) if vals else None)
+
+
+def reverse_dcf(d, P):
+    if d["seg"] in ("Bank", "Insurance"):
+        return None, "FCF-based reverse DCF not applicable to banks/insurers"
+    base, shares, nd = d["fcff"], d["shares"], d["net_debt"]
+    if not d["unit_ok"] or base is None or base <= 0 or not shares or nd is None:
+        return None, "essential inputs missing or FCFF <= 0"
+    _, wacc0, tg = assumptions(P)
+
+    def solve(wacc):
+        if wacc <= tg:
+            return None
+        f = lambda g: dcf_value(base, g, wacc, tg, shares, nd)["per_share"]
+        lo, hi = -0.9, 3.0
+        if not (f(lo) <= d["price"] <= f(hi)):
+            return None
+        for _ in range(80):
+            mid = (lo + hi) / 2
+            lo, hi = (mid, hi) if f(mid) < d["price"] else (lo, mid)
+        return (lo + hi) / 2
+
+    rows = []
+    for dw in (-0.03, 0.0, 0.03):
+        rw = P["rw"] + dw
+        w = (1 + rw) * (1 + P["infl"]) - 1
+        g = solve(w)
+        rows.append({"Real discount rate": fp(rw), "Nominal WACC": fp(w), "Implied FCF growth (nominal, yr1)": fp(g),
+                     "Implied (real)": fp(real_ret(g, P["infl"]))})
+    return rows, "ok"
+
+
+def scenarios(d, P, med, probs):
+    SC = [("Bear", -0.04, 0.03, 0.85), ("Base", 0.0, 0.0, 1.0), ("Bull", 0.04, -0.02, 1.10)]
+    out, ok = [], True
+    for (nm, dg, dw, mult), p in zip(SC, probs):
+        _, iv = intrinsic(d, P, med, rg=P["rg"] + dg, rw=max(P["rw"] + dw, 0.0))
+        tgt = None if iv is None else (d["price"] + P["conv"] * (iv - d["price"])) * mult
+        ok &= tgt is not None
+        out.append({"Scenario": nm, "Real growth": fp(P["rg"] + dg), "Real disc. rate": fp(max(P["rw"] + dw, 0)),
+                    "Multiple factor": mult, "Intrinsic": iv, "Target": tgt, "Prob": p})
+    if not ok:
+        return out, None
+    pw = sum(o["Prob"] * o["Target"] for o in out)
+    nom = pw / d["price"] - 1
+    dy = d["dy"] or 0.0
+    tot = nom + dy
+    return out, dict(pw=pw, nominal=nom, total=tot, real=real_ret(tot, P["infl"]), real_price=real_ret(nom, P["infl"]),
+                     dy_known=d["dy"] is not None)
+
+
+def validate_probs(bear, base):
+    bull = 100 - bear - base
+    if bear < 0 or base < 0 or bull < -1e-9:
+        return None
+    return (bear / 100, base / 100, bull / 100)
 
 
 # ============================================================================
-# SCANNER
+# QUALITY, PIOTROSKI, RISK
 # ============================================================================
 
-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):
-        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.replace(".IS", ""))
-        # FIX #4: rate-limit
-        if not force_refresh and i < total - 1:
-            time.sleep(REQUEST_DELAY_SEC)
+def cv(series):
+    v = [x for x in series if x is not None]
+    if len(v) < 3 or np.mean(v) <= 0:
+        return None
+    return float(np.std(v) / np.mean(v))
+
+
+def quality(d):
+    s, q = d["s"], {}
+    ni0, eq0, ta0, rev0 = s["ni"][0], s["eq"][0], s["ta"][0], s["rev"][0]
+    q["roe"] = div(ni0, eq0) if (eq0 or 0) > 0 else None
+    q["roa"] = div(ni0, ta0)
+    ic = None
+    if None not in (eq0, s["debt"][0], s["cash"][0]):
+        ic = eq0 + s["debt"][0] - s["cash"][0]
+    q["roic"] = div(s["opinc"][0] * (1 - d["tax_rate"]), ic) if (s["opinc"][0] is not None and ic and ic > 0) else None
+    q["gm"] = div(s["gp"][0], rev0)
+    q["opm"] = div(s["opinc"][0], rev0)
+    q["npm"] = div(ni0, rev0)
+    q["de"] = div(s["debt"][0], eq0) * 100 if (eq0 or 0) > 0 and s["debt"][0] is not None else None
+    e0 = s["ebitda"][0]
+    q["nd_ebitda"] = div(d["net_debt"], e0) if (e0 or 0) > 0 and d["net_debt"] is not None else None
+    q["cr"] = div(s["ca"][0], s["cl"][0])
+    q["icov"] = div(s["opinc"][0], s["interest"][0]) if (s["interest"][0] or 0) > 0 else None
+    q["fcf_conv"] = div(s["fcf"][0], ni0) if (ni0 or 0) > 0 else None
+    q["fcf_cv"] = cv(s["fcf"])
+    q["ni_cv"] = cv(s["ni"])
+    q["rev_g"] = growth(rev0, s["rev"][1])
+    q["ni_g"] = growth(ni0, s["ni"][1])
+    q["eq_ta"] = div(eq0, ta0)
+    return q
+
+
+def piotroski(d):
+    s = d["s"]
+
+    def cmp(a, b, op):
+        return None if a is None or b is None else op(a, b)
+
+    roa = [div(s["ni"][i], s["ta"][i]) for i in (0, 1)]
+    cr = [div(s["ca"][i], s["cl"][i]) for i in (0, 1)]
+    lev = [div(s["ltd"][i] if s["ltd"][i] is not None else s["debt"][i], s["ta"][i]) for i in (0, 1)]
+    gm = [div(s["gp"][i], s["rev"][i]) for i in (0, 1)]
+    at = [div(s["rev"][i], s["ta"][i]) for i in (0, 1)]
+    comps = [
+        ("1 Net income > 0", cmp(s["ni"][0], 0, lambda a, b: a > b)),
+        ("2 CFO > 0", cmp(s["cfo"][0], 0, lambda a, b: a > b)),
+        ("3 ROA improved", cmp(roa[0], roa[1], lambda a, b: a > b)),
+        ("4 CFO > net income", cmp(s["cfo"][0], s["ni"][0], lambda a, b: a > b)),
+        ("5 Leverage decreased", cmp(lev[0], lev[1], lambda a, b: a < b)),
+        ("6 Current ratio improved", cmp(cr[0], cr[1], lambda a, b: a > b)),
+        ("7 No share dilution", cmp(s["shares"][0], s["shares"][1], lambda a, b: a <= b * 1.005)),
+        ("8 Gross margin improved", cmp(gm[0], gm[1], lambda a, b: a > b)),
+        ("9 Asset turnover improved", cmp(at[0], at[1], lambda a, b: a > b)),
+    ]
+    n = sum(1 for _, v in comps if v is not None)
+    return sum(1 for _, v in comps if v), n, comps
+
+
+def risk_engine(d, q, cov):
+    s, bank = d["s"], d["seg"] in ("Bank", "Insurance")
+    ni0, ni1 = s["ni"][0], s["ni"][1]
+    fl = []
+
+    def add(name, w, cond, detail):
+        fl.append((name, w, None if cond is None else ("TRIGGERED" if cond else "OK"), detail))
+
+    add("Financial distress", 12, anyc(None if s["eq"][0] is None else s["eq"][0] <= 0,
+                                       None if q["icov"] is None else q["icov"] < 1.5,
+                                       None if (ni0 is None or s["cfo"][0] is None) else (ni0 < 0 and s["cfo"][0] < 0)),
+        "equity<=0, interest cover<1.5, or NI<0 & CFO<0")
+    lev = anyc(None if q["eq_ta"] is None else q["eq_ta"] < 0.06) if bank else anyc(
+        None if q["nd_ebitda"] is None else q["nd_ebitda"] > 4, None if q["de"] is None else q["de"] > 200)
+    add("Leverage", 12, lev, "bank: equity/assets<6%; else ND/EBITDA>4 or D/E>200%")
+    add("Liquidity", 10, None if bank else (None if q["cr"] is None else q["cr"] < 1), "current ratio < 1")
+    add("Negative FCF", 10, None if bank else (None if s["fcf"][0] is None else s["fcf"][0] < 0), "FCF < 0")
+    ed = None
+    if ni0 is not None and ni1 is not None:
+        ed = ni0 < 0 or (ni1 > 0 and ni0 < 0.8 * ni1)
+    add("Earnings deterioration", 10, ed, "NI < 0 or down >20% y/y")
+    md = None
+    if not bank and q["opm"] is not None and s["opinc"][1] is not None and (s["rev"][1] or 0) > 0:
+        md = q["opm"] < s["opinc"][1] / s["rev"][1] - 0.02
+    add("Margin deterioration", 8, md, "operating margin down >2 pts")
+    dv = None if bank or ni0 is None or s["cfo"][0] is None or ni0 <= 0 else s["cfo"][0] < 0.5 * ni0
+    add("CFO vs NI divergence", 10, dv, "CFO < 50% of positive NI")
+    dil = cmp_g = growth(s["shares"][0], s["shares"][1])
+    add("Dilution", 8, None if dil is None else dil > 0.03, "share count +3% y/y")
+    ev = anyc(None if d["pe"] is None and d["eps"] is None else (d["eps"] is not None and d["eps"] <= 0) or (d["pe"] is not None and d["pe"] > 40),
+              None if d["pb"] is None else d["pb"] > 6)
+    add("Extreme valuation", 10, ev, "P/E>40, loss-making, or P/B>6")
+    add("Data reliability", 10, cov < 0.7 or bool(d["flags"]), f"coverage<70% or integrity flags ({len(d['flags'])})")
+    ev_w = sum(w for _, w, st, _ in fl if st is not None)
+    score = None if ev_w == 0 else 100 * sum(w for _, w, st, _ in fl if st == "TRIGGERED") / ev_w
+    return score, fl
 
-    if not all_data:
-        return pd.DataFrame(), failed
 
-    sector_medians = compute_sector_medians(all_data)
+# ============================================================================
+# SCORING & ANALYSIS
+# ============================================================================
 
-    rows = []
-    for d in all_data:
-        score_result = compute_composite_score(d, sector_medians)
-        forecast = compute_12m_forecast(d, score_result, expected_inflation)
-        is_bank = _is_bank(d)
-
-        rows.append({
-            "Symbol": d["symbol"],
-            "Sector": d["sector"],
-            "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": 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"],
-        })
+WEIGHTS = {"Industrial": (.35, .30, .20, .15), "Bank": (.40, .35, .10, .15),
+           "Insurance": (.40, .30, .15, .15), "GYO": (.45, .20, .20, .15)}
+
+
+def coverage(d):
+    s, seg = d["s"], d["seg"]
+    f = [d["price"], d["mcap"], d["shares"], d["pb"], d["pe"], s["ni"][0], s["eq"][0], s["ta"][0], d["bvps"]]
+    if seg not in ("Bank", "Insurance"):
+        f += [s["rev"][0], s["cfo"][0], s["debt"][0], s["cash"][0], d["fcff"], s["ebitda"][0], d["oe"]]
+    return sum(x is not None for x in f) / len(f)
+
+
+def analyze(d, P, med, probs=(0.25, 0.5, 0.25)):
+    A: Dict[str, Any] = {"d": d}
+    infl, seg = P["infl"], d["seg"]
+    q = quality(d)
+    A["q"] = q
+    A["methods"], A["iv"] = intrinsic(d, P, med)
+    A["mos"] = (A["iv"] - d["price"]) / A["iv"] if A["iv"] else None
+    rv, A["rel_note"] = relative_value(d, med)
+    A["rel_mos"] = (rv - d["price"]) / rv if rv else None
+    A["pio"] = piotroski(d)
+    A["cov"] = coverage(d)
+    A["risk"], A["flags"] = risk_engine(d, q, A["cov"])
+    bank = seg in ("Bank", "Insurance")
+    rroe, rroic = real_ret(q["roe"], infl), real_ret(q["roic"], infl)
+    rrev, rni = real_ret(q["rev_g"], infl), real_ret(q["ni_g"], infl)
+    pe_s = (0.0 if d["eps"] <= 0 else lin(d["pe"], 25, 4)) if d["eps"] is not None else None
+    pb_s = lin(d["pb"], 4, 0.5) if d["pb"] else (0.0 if d["bvps"] is not None and d["bvps"] <= 0 else None)
+    vi = [(lin(A["mos"], -0.3, 0.5), 4), (lin(A["rel_mos"], -0.3, 0.5), 2)]
+    if bank:
+        vi += [(pe_s, 2), (pb_s, 3), (lin(d["dy"], 0, 0.08), 1)]
+    elif seg == "GYO":
+        vi += [(lin(d["pb"], 1.5, 0.4), 3), (pe_s, 1)]
+    else:
+        vi += [(pe_s, 1), (pb_s, 1), (lin(d["ev_ebitda"], 15, 3), 1), (lin(d["fcf_yield"], -0.02, 0.12), 1),
+               (lin(d["earn_yield"], 0, 0.25), 1)]
+    if bank:
+        qi = [(lin(rroe, -0.1, 0.2), 4), (lin(q["roa"], 0, 0.03), 2), (lin(q["ni_cv"], 2, 0.3), 2),
+              (lin(d["dy"], 0, 0.08), 1), (lin(rni, -0.2, 0.3), 1)]
+    else:
+        qi = [(lin(rroe, -0.1, 0.2), 3), (lin(rroic, -0.05, 0.15), 3), (lin(q["opm"], 0.02, 0.25), 2),
+              (lin(q["fcf_conv"], 0, 1.2), 2), (lin(q["fcf_cv"], 2, 0.3), 1), (lin(rrev, -0.1, 0.2), 1), (lin(rni, -0.2, 0.3), 1)]
+    sc, n, _ = A["pio"]
+    e0 = d["s"]["ebitda"][0]
+    if bank:
+        si = [(lin(q["eq_ta"], 0.04, 0.12), 4), (lin(q["roa"], 0, 0.02), 1)]
+    else:
+        nde = 0.0 if (e0 is not None and e0 <= 0 and (d["net_debt"] or 0) > 0) else lin(q["nd_ebitda"], 5, 0)
+        if q["nd_ebitda"] is None and d["net_debt"] is not None and d["net_debt"] <= 0 and (e0 or 0) > 0:
+            nde = 100.0  # net cash
+        si = [(nde, 3), (lin(q["cr"], 0.8, 2.0), 2), (lin(q["icov"], 1, 8), 2), (lin(q["de"], 250, 30), 2),
+              (lin(sc / n, 0.3, 0.8) if n >= 5 else None, 2)]
+    A["val"], A["val_cov"] = wavg(vi)
+    A["qual"], A["qual_cov"] = wavg(qi)
+    A["str"], A["str_cov"] = wavg(si)
+    w = WEIGHTS[seg]
+    comps = [A["val"], A["qual"], A["str"], None if A["risk"] is None else 100 - A["risk"]]
+    if A["val"] is None or A["qual"] is None:
+        A["composite"] = None
+    else:
+        av = [(c, wt) for c, wt in zip(comps, w) if c is not None]
+        A["composite"] = sum(c * wt for c, wt in av) / sum(wt for _, wt in av) * min(1.0, A["cov"] / 0.7)
+    sev = (not d["unit_ok"]) or any("stale" in f or "period" in f for f in d["flags"])
+    lvl = 2 if A["cov"] >= 0.85 else 1 if A["cov"] >= 0.65 else 0
+    lvl = max(lvl - (1 if sev else 0), 0)
+    A["conf"] = ["Low", "Medium", "High"][lvl]
+    pr = validate_probs(probs[0] * 100, probs[1] * 100) or (0.25, 0.5, 0.25)
+    A["scen"], A["exp"] = scenarios(d, P, med, pr)
+    return A
 
-    df = pd.DataFrame(rows)
-    df = df.sort_values("Composite", ascending=False, na_position="last")
-    return df, failed
 
+# ============================================================================
+# OUTPUT BUILDERS
+# ============================================================================
 
-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"
-
-    data = fetch_ticker_data(symbol)
-    if data is None or data.get("price") is None:
-        return f"## {symbol}\n\nNo data available. Check ticker validity.", None
-
-    # 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)
-
-    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, 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)
-
-    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",
-        "",
-        "| 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",
-        "",
-        "| 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**: {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"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']}*",
-        "",
-        "---",
-        "*Data source: Yahoo Finance via yfinance. Fundamentals are not point-in-time.*",
-    ]
+def get_A(ticker, P, probs=(0.25, 0.5, 0.25)):
+    sym = norm_sym(ticker)
+    d = fetch(sym)
+    if d is None:
+        return None, f"⚠️ {sym} verisi çekilemedi."
+    return analyze(d, P, build_medians(cached_ds()), probs), None
 
-    markdown = "\n".join(lines)
 
+def price_fig(sym, extra=None):
     try:
-        ticker = yf.Ticker(symbol)
-        hist = ticker.history(period="1y")
-        if not hist.empty:
-            fig = go.Figure()
-            fig.add_trace(go.Scatter(
-                x=hist.index, y=hist["Close"],
-                mode="lines", name="Close",
-                line=dict(color="#1f77b4", width=2),
-            ))
-            fig.update_layout(
-                title=f"{symbol} — 1 Year Price",
-                xaxis_title="Date", yaxis_title="Price (TRY)",
-                template="plotly_white", height=400,
-            )
-        else:
-            fig = None
+        h = yf.Ticker(norm_sym(sym)).history(period="1y")
+        if h.empty:
+            return None
+        f = go.Figure(go.Scatter(x=h.index, y=h["Close"], mode="lines", name="Close"))
+        for nm, v in (extra or {}).items():
+            if v:
+                f.add_hline(y=v, line_dash="dot", annotation_text=nm)
+        f.update_layout(title=f"{sym} — 1Y", template="plotly_white", height=380, margin=dict(l=10, r=10, t=40, b=10))
+        return f
     except Exception:
-        fig = None
+        return None
 
-    return markdown, fig
+
+def scan_row(A):
+    d, q = A["d"], A["q"]
+    sc, n, _ = A["pio"]
+    e = A["exp"]
+    return {
+        "Ticker": d["sym"], "Segment": d["seg"], "Sector": d["sector"], "Price": round(d["price"], 2),
+        "Composite": None if A["composite"] is None else round(A["composite"], 1),
+        "Intrinsic": None if A["iv"] is None else round(A["iv"], 2),
+        "MoS %": None if A["mos"] is None else round(A["mos"] * 100, 1),
+        "P/E": None if d["pe"] is None else round(d["pe"], 1), "P/B": None if d["pb"] is None else round(d["pb"], 2),
+        "ROE %": None if q["roe"] is None else round(q["roe"] * 100, 1),
+        "ROIC %": None if q["roic"] is None else round(q["roic"] * 100, 1),
+        "FCF Yield %": None if d["fcf_yield"] is None else round(d["fcf_yield"] * 100, 1),
+        "Piotroski": f"{sc}/{n} (cov {n}/9)" if n else "N/A",
+        "Risk": None if A["risk"] is None else round(A["risk"], 0),
+        "Exp Return % (nom, incl div)": None if not e else round(e["total"] * 100, 1),
+        "Real Exp Return %": None if not e or e["real"] is None else round(e["real"] * 100, 1),
+        "Coverage %": round(A["cov"] * 100), "Confidence": A["conf"],
+    }
+
+
+def run_scan(force, extra, P, progress):
+    syms = BIST_UNIVERSE + [norm_sym(x) for x in (extra or "").split(",") if x.strip()]
+    syms = list(dict.fromkeys(syms))
+    ds, failed = [], []
+    for i, s in enumerate(syms):
+        progress((i + 1) / len(syms), desc=f"Fetching {s}")
+        was_cached = (not force) and _cget(f"t_{s}") is not None
+        d = fetch(s, force)
+        (ds.append(d) if d else failed.append(s))
+        if not was_cached:
+            time.sleep(REQUEST_DELAY_SEC)
+    med = build_medians(ds)
+    rows = [scan_row(analyze(d, P, med)) for d in ds]
+    df = pd.DataFrame(rows)
+    LAST["df"], LAST["failed"] = df, failed
+    return df, failed
+
+
+def apply_filters(seg, minc, minm, sortby, desc):
+    df = LAST["df"]
+    if df is None or df.empty:
+        return None, None
+    x = df.copy()
+    if seg != "All":
+        x = x[x["Segment"] == seg]
+    x = x[x["Composite"].fillna(-1) >= minc]
+    if minm > -100:
+        x = x[x["MoS %"].fillna(-1e9) >= minm]
+    x = x.sort_values(sortby, ascending=not desc, na_position="last")
+    f = tempfile.NamedTemporaryFile(delete=False, suffix=".csv", prefix="bist_v3_")
+    x.to_csv(f.name, index=False)
+    return x, f.name
+
+
+def md_report(A, P):
+    d = A["d"]
+    L = [f"## {d['sym']} — {d['name']}",
+         f"**{d['seg']}** · {d['sector']} / {d['industry']} · Fiyat **{fm(d['price'])} TRY** · Mali tablo: "
+         f"{d['stmt_date'].date() if d['stmt_date'] else 'N/A'}",
+         f"**Composite {fm(A['composite'], 0)}** | Valuation {fm(A['val'], 0)} | Quality {fm(A['qual'], 0)} | "
+         f"Strength {fm(A['str'], 0)} | Risk {fm(A['risk'], 0)} (düşük=iyi) | Coverage {fp(A['cov'], 0)} | "
+         f"Confidence **{A['conf']}**",
+         f"**Intrinsic value [D]:** {fm(A['iv'])} TRY · Margin of Safety {fp(A['mos'])}"]
+    L.append("\n| Yöntem | Değer/hisse | Not |\n|---|---|---|")
+    for k, (v, n) in A["methods"].items():
+        L.append(f"| {k} | {fm(v)} | {n} |")
+    if d["flags"]:
+        L.append("\n**⚠️ Veri bayrakları:** " + "; ".join(d["flags"]))
+    L.append("\n*Intrinsic = mevcut yöntemlerin medyanı. Skorlar evren içi göreceli, açıklanabilir heuristiklerdir.*")
+    return "\n".join(L)
+
+
+def radar_fig(A):
+    cats = ["Valuation", "Quality", "Strength", "Safety (100-Risk)"]
+    v = [A["val"], A["qual"], A["str"], None if A["risk"] is None else 100 - A["risk"]]
+    v = [x or 0 for x in v]
+    f = go.Figure(go.Scatterpolar(r=v + v[:1], theta=cats + cats[:1], fill="toself"))
+    f.update_layout(polar=dict(radialaxis=dict(range=[0, 100])), height=340, margin=dict(l=30, r=30, t=30, b=20))
+    return f
 
 
 # ============================================================================
-# DATA QUALITY
+# SELF TEST (synthetic)
 # ============================================================================
 
-def data_quality_report(progress_callback=None) -> pd.DataFrame:
-    rows = []
-    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": "0/5", "Missing": "ALL", "Sector": "—", "Type": "—"})
-            continue
-
-        critical_fields = ["price", "trailing_pe", "price_to_book", "roe", "fcf_yield"]
-        available = sum(1 for f in critical_fields if data.get(f) is not None)
-        missing = [f for f in critical_fields if data.get(f) is None]
-
-        rows.append({
-            "Symbol": data["symbol"],
-            "Status": "OK" if available >= 3 else "INCOMPLETE",
-            "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)
+def self_test() -> str:
+    res = []
+
+    def chk(name, cond):
+        res.append(("✅ " if cond else "❌ ") + name)
+
+    r = dcf_value(100, 0, 0.10, 0, 10, 200)
+    chk("DCF: g=0,tg=0 → EV=1000", r is not None and abs(r["ev"] - 1000) < 1e-6)
+    chk("EV→Equity: 1000-200=800, 80/share", r is not None and abs(r["equity"] - 800) < 1e-6 and abs(r["per_share"] - 80) < 1e-6)
+    chk("DCF refuses wacc<=tg", dcf_value(100, 0.1, 0.05, 0.05, 10, 0) is None)
+    chk("DCF refuses FCF<=0", dcf_value(-5, 0.1, 0.2, 0.05, 10, 0) is None)
+    chk("DCF refuses missing input", dcf_value(100, 0.1, 0.2, 0.05, None, 0) is None)
+    chk("Real return 50% nom / 25% infl = 20%", abs(real_ret(0.5, 0.25) - 0.2) < 1e-12)
+    chk("div by zero → None", div(1, 0) is None and div(None, 2) is None)
+    P = dict(infl=0.30, rw=0.10, rtg=0.01, rg=0.03, pt=0.5, conv=0.5)
+    g0, w, tg = assumptions(P)
+    chk("WACC > terminal growth (defaults)", w > tg)
+    chk("Probabilities 25/50 → 25/50/25 sum=1", validate_probs(25, 50) is not None and abs(sum(validate_probs(25, 50)) - 1) < 1e-9)
+    chk("Probabilities 70/50 rejected", validate_probs(70, 50) is None)
+    # reverse DCF consistency
+    d = {"fcff": 100.0, "shares": 10.0, "net_debt": 200.0, "price": 80.0, "unit_ok": True, "seg": "Industrial"}
+    P2 = dict(infl=0.0, rw=0.10, rtg=0.0, rg=0.0, pt=0.0, conv=0.5)
+    rows, _ = reverse_dcf(d, P2)
+    chk("Reverse DCF: price 80 → implied g≈0", rows is not None and rows[1]["Implied FCF growth (nominal, yr1)"] == "0.0%")
+    # Piotroski incompleteness
+    empty = {"s": {k: [None, None, None] for k in STMT}}
+    sc, n, _ = piotroski(empty)
+    chk("Piotroski all-missing → 0 available (not 9/9)", n == 0 and sc == 0)
+    # peer rule
+    ds = [{"seg": "Industrial", "sector": "X", "pe": 10.0 + i, **{m: None for m in MULTS if m != "pe"}} for i in range(4)]
+    chk("Sector median needs >=5 peers", build_medians(ds)[("Industrial", "X")]["pe"][0] is None)
+    ds += [{"seg": "Industrial", "sector": "X", "pe": 20.0, **{m: None for m in MULTS if m != "pe"}}]
+    chk("Sector median with 5 peers computed", build_medians(ds)[("Industrial", "X")]["pe"][0] == 12.0 or build_medians(ds)[("Industrial", "X")]["pe"][0] is not None)
+    chk("Segment classification", segment_of("Banks - Regional", "GARAN") == "Bank" and segment_of("Real Estate", "EKGYO") == "GYO"
+        and segment_of("Insurance - Life", "ANHYT") == "Insurance" and segment_of("Steel", "EREGL") == "Industrial")
+    return "\n".join(res)
 
 
 # ============================================================================
@@ -767,144 +807,328 @@ def data_quality_report(progress_callback=None) -> pd.DataFrame:
 # ============================================================================
 
 def build_ui():
-    with gr.Blocks(title="BIST Value Intelligence", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-# BIST Value Intelligence (v2)
-### Conservative Value Screening for Borsa Istanbul
-
-**⚠️ Ö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.Blocks(title="BIST Value Intelligence v3", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# BIST Value Intelligence v3\n**⚠️ yfinance verisi point-in-time değildir; backtest için kullanılamaz. "
+                    "Eksik veri `N/A` gösterilir, asla sıfırla doldurulmaz. 12 aylık senaryolar heuristiktir, istatistiksel tahmin değildir. "
+                    "Yatırım tavsiyesi değildir.**")
+        with gr.Accordion("⚙️ Varsayımlar [A] (tüm sekmeler için)", open=False):
+            with gr.Row():
+                s_infl = gr.Slider(0, 100, 30, step=1, label="Enflasyon (%)")
+                s_rw = gr.Slider(1, 30, 10, step=0.5, label="Reel iskonto oranı (%)")
+                s_rtg = gr.Slider(0, 5, 1, step=0.25, label="Reel terminal büyüme (%)")
+            with gr.Row():
+                s_rg = gr.Slider(-10, 20, 3, step=0.5, label="Baz reel büyüme (%)")
+                s_pt = gr.Slider(0, 100, 50, step=5, label="Enflasyonun nominal büyümeye geçişi (%)")
+                s_cv = gr.Slider(0, 100, 50, step=5, label="12 ay içinde değer-fiyat farkının kapanma oranı (%)")
+        PI = [s_infl, s_rw, s_rtg, s_rg, s_pt, s_cv]
 
         with gr.Tabs():
-            # TAB 1: Scanner
             with gr.Tab("📊 Market Scanner"):
                 with gr.Row():
                     scan_btn = gr.Button("Run Scanner", variant="primary", scale=2)
-                    refresh_cb = gr.Checkbox(label="Force refresh", value=False, scale=1)
+                    force = gr.Checkbox(label="Force refresh", value=False)
+                extra = gr.Textbox(label="Ek tickerlar (virgülle, örn: TRGYO,KONTR)", value="")
+                with gr.Row():
+                    f_seg = gr.Dropdown(["All", "Industrial", "Bank", "Insurance", "GYO"], value="All", label="Segment")
+                    f_c = gr.Slider(0, 100, 0, step=5, label="Min composite")
+                    f_m = gr.Slider(-100, 100, -100, step=5, label="Min MoS % (-100 = kapalı)")
                 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 (Composite skora göre sıralı)",
-                    interactive=False, wrap=True,
-                )
-
-                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,
-                    )
+                    f_sort = gr.Dropdown(["Composite", "MoS %", "P/E", "P/B", "ROE %", "ROIC %", "FCF Yield %", "Risk",
+                                          "Exp Return % (nom, incl div)", "Real Exp Return %", "Coverage %"],
+                                         value="Composite", label="Sırala")
+                    f_desc = gr.Checkbox(label="Azalan", value=True)
+                    f_btn = gr.Button("Filtreyi uygula")
+                status = gr.Markdown()
+                table = gr.Dataframe(interactive=False, wrap=True)
+                csv = gr.File(label="CSV indir")
+                FI = [f_seg, f_c, f_m, f_sort, f_desc]
+
+                def do_scan(frc, ext, *a, progress=gr.Progress()):
+                    P = mk_params(*a[:6])
+                    seg, c, m, so, de = a[6:]
+                    df, failed = run_scan(frc, ext, P, progress)
                     if df.empty:
-                        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}."
+                        return None, None, "⚠️ Veri çekilemedi."
+                    x, path = apply_filters(seg, c, m, so, de)
+                    msg = f"✅ {len(df)} hisse tarandı · coverage ort. %{df['Coverage %'].mean():.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
+                        msg += f" · ⚠️ Çekilemeyen ({len(failed)}): " + ", ".join(failed)
+                    return x, path, msg
+
+                def do_filter(*a):
+                    x, path = apply_filters(*a)
+                    return x, path
+
+                scan_btn.click(do_scan, [force, extra] + PI + FI, [table, csv, status])
+                f_btn.click(do_filter, FI, [table, csv])
+
             with gr.Tab("🔍 Company Analysis"):
                 with gr.Row():
-                    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)
+                    t1 = gr.Textbox(value="THYAO", label="Ticker", scale=2)
+                    b1 = gr.Button("Analyze", variant="primary")
+                md1 = gr.Markdown()
+                with gr.Row():
+                    p1 = gr.Plot()
+                    r1 = gr.Plot()
 
-                detail_md = gr.Markdown()
-                price_chart = gr.Plot()
+                def company(t, *a):
+                    P = mk_params(*a)
+                    A, err = get_A(t, P)
+                    if err:
+                        return err, None, None
+                    return md_report(A, P), price_fig(A["d"]["sym"], {"Intrinsic": A["iv"]}), radar_fig(A)
 
-                detail_btn.click(
-                    get_company_detail,
-                    inputs=[ticker_input, detail_inflation],
-                    outputs=[detail_md, price_chart],
-                )
+                b1.click(company, [t1] + PI, [md1, p1, r1])
 
-            # TAB 3: Data Quality
-            with gr.Tab("📋 Data Quality Monitor"):
-                gr.Markdown("""
-**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(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 & Changelog"):
-                gr.Markdown("""
-### 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
-                """)
+            with gr.Tab("🧮 Intrinsic Value Calculator"):
+                with gr.Row():
+                    t2 = gr.Textbox(value="EREGL", label="Ticker", scale=2)
+                    b2 = gr.Button("Calculate", variant="primary")
+                md2 = gr.Markdown()
+                p2 = gr.Plot()
+
+                def calc(t, *a):
+                    P = mk_params(*a)
+                    A, err = get_A(t, P)
+                    if err:
+                        return err, None
+                    d = A["d"]
+                    g0, w, tg = assumptions(P)
+                    L = [f"### {d['sym']} — {d['seg']}",
+                         f"**Varsayımlar [A]:** yıl-1 nominal büyüme {fp(g0)} (reel {fp(P['rg'])}, enflasyon geçişi %{P['pt'] * 100:.0f}) · "
+                         f"nominal iskonto {fp(w)} · nominal terminal {fp(tg)}",
+                         f"**Girdiler [R/D]:** FCFF {fm(d['fcff'], 0)} (FCF + faiz×(1−vergi{' varsayım' if d['tax_assumed'] else ''})) · "
+                         f"net borç {fm(d['net_debt'], 0)} · hisse {fm(d['shares'], 0)} · vergi {fp(d['tax_rate'], 0)}"]
+                    if d["oe_parts"]:
+                        o = d["oe_parts"]
+                        L.append(f"**Owner Earnings [D]:** NI {fm(o['ni'], 0)} + D&A {fm(o['da'], 0)} − bakım capex (tahmin=min(capex, D&A)) "
+                                 f"{fm(o['maint_est'], 0)} + ΔİS sermayesi {fm(o['dwc'], 0)} = **{fm(d['oe'], 0)}** (toplam capex {fm(o['capex_total'], 0)})")
+                    L.append("\n| Yöntem | Değer | Not |\n|---|---|---|")
+                    for k, (v, n) in A["methods"].items():
+                        L.append(f"| {k} | {fm(v)} | {n} |")
+                    L.append(f"\n**Intrinsic (medyan): {fm(A['iv'])}** · Fiyat {fm(d['price'])} · MoS {fp(A['mos'])}")
+                    names = [k for k, (v, _) in A["methods"].items() if v]
+                    vals = [A["methods"][k][0] for k in names]
+                    f = go.Figure(go.Bar(x=["Price"] + names + ["Intrinsic"], y=[d["price"]] + vals + [A["iv"] or 0]))
+                    f.update_layout(template="plotly_white", height=340, margin=dict(l=10, r=10, t=20, b=10))
+                    return "\n".join(L), f
+
+                b2.click(calc, [t2] + PI, [md2, p2])
+
+            with gr.Tab("↩️ Reverse DCF"):
+                with gr.Row():
+                    t3 = gr.Textbox(value="TOASO", label="Ticker", scale=2)
+                    b3 = gr.Button("Solve", variant="primary")
+                md3 = gr.Markdown()
+                tb3 = gr.Dataframe(interactive=False)
+
+                def rev(t, *a):
+                    P = mk_params(*a)
+                    A, err = get_A(t, P)
+                    if err:
+                        return err, None
+                    d = A["d"]
+                    rows, note = reverse_dcf(d, P)
+                    if rows is None:
+                        return f"**{d['sym']}**: ⚠️ {note}", None
+                    g0, _, _ = assumptions(P)
+                    h = d["s"]["fcf"]
+                    hist = f"{fp((h[0] / h[2]) ** 0.5 - 1)}" if (h[0] or 0) > 0 and (h[2] or 0) > 0 else "N/A"
+                    md = (f"**{d['sym']}** fiyat {fm(d['price'])} → piyasanın fiyatladığı FCF büyümesi (5 yıl, terminale doğru sönümlenir).\n\n"
+                          f"Mevcut varsayım yıl-1 büyüme: {fp(g0)} · Tarihsel FCF CAGR (2y, nominal): {hist}\n\n"
+                          "Not: Zorunlu bir 'doğru' yoktur; implied büyüme makul görünmüyorsa piyasa beklentisi ya aşırı iyimser ya da kötümserdir.")
+                    return md, pd.DataFrame(rows)
+
+                b3.click(rev, [t3] + PI, [md3, tb3])
+
+            with gr.Tab("💎 Financial Quality"):
+                with gr.Row():
+                    t4 = gr.Textbox(value="BIMAS", label="Ticker", scale=2)
+                    b4 = gr.Button("Show", variant="primary")
+                md4 = gr.Markdown()
+                tb4 = gr.Dataframe(interactive=False)
+                tb4b = gr.Dataframe(interactive=False)
+
+                def qual(t, *a):
+                    P = mk_params(*a)
+                    A, err = get_A(t, P)
+                    if err:
+                        return err, None, None
+                    q, d = A["q"], A["d"]
+                    pc = lambda x: fp(x)
+                    rows = [("ROE [D]", pc(q["roe"])), ("ROE (reel) [D]", pc(real_ret(q["roe"], P["infl"]))), ("ROA [D]", pc(q["roa"])),
+                            ("ROIC [D]", pc(q["roic"])), ("Gross margin [D]", pc(q["gm"])), ("Operating margin [D]", pc(q["opm"])),
+                            ("Net margin [D]", pc(q["npm"])), ("Debt/Equity % [D]", fm(q["de"], 0)), ("Net debt/EBITDA [D]", fm(q["nd_ebitda"])),
+                            ("Current ratio [D]", fm(q["cr"])), ("Interest coverage [D]", fm(q["icov"])), ("FCF/NI [D]", fm(q["fcf_conv"])),
+                            ("FCF variation (CV) [D]", fm(q["fcf_cv"])), ("Revenue growth nominal [D]", pc(q["rev_g"])),
+                            ("Revenue growth real [D]", pc(real_ret(q["rev_g"], P["infl"]))), ("Earnings growth nominal [D]", pc(q["ni_g"])),
+                            ("Earnings growth real [D]", pc(real_ret(q["ni_g"], P["infl"]))), ("Equity/Assets [D]", pc(q["eq_ta"]))]
+                    sc, n, comps = A["pio"]
+                    cp = [(c, "N/A" if v is None else ("1" if v else "0")) for c, v in comps]
+                    md = (f"**{d['sym']}** — Piotroski: **{sc}/{n}** (hesaplanabilen {n}/9)" +
+                          ("" if n == 9 else " ⚠️ eksik bileşen var; skor tam değildir.") +
+                          (" Bankalar için Piotroski sınırlı anlam taşır." if d["seg"] in ("Bank", "Insurance") else ""))
+                    return md, pd.DataFrame(rows, columns=["Metric", "Value"]), pd.DataFrame(cp, columns=["Piotroski component", "Result"])
+
+                b4.click(qual, [t4] + PI, [md4, tb4, tb4b])
+
+            with gr.Tab("🛡️ Risk Analysis"):
+                with gr.Row():
+                    t5 = gr.Textbox(value="PGSUS", label="Ticker", scale=2)
+                    b5 = gr.Button("Assess", variant="primary")
+                md5 = gr.Markdown()
+                tb5 = gr.Dataframe(interactive=False)
+
+                def risk_tab(t, *a):
+                    P = mk_params(*a)
+                    A, err = get_A(t, P)
+                    if err:
+                        return err, None
+                    rows = [{"Flag": n, "Weight": w, "Status": s or "N/A", "Rule": dt} for n, w, s, dt in A["flags"]]
+                    return (f"**{A['d']['sym']}** Risk skoru: **{fm(A['risk'], 0)}/100** (yalnızca değerlendirilebilen bayraklar üzerinden; "
+                            f"düşük = iyi). Coverage {fp(A['cov'], 0)}."), pd.DataFrame(rows)
+
+                b5.click(risk_tab, [t5] + PI, [md5, tb5])
+
+            with gr.Tab("🏭 Sector Comparison"):
+                with gr.Row():
+                    t6 = gr.Textbox(value="EREGL", label="Ticker (opsiyonel)", scale=2)
+                    b6 = gr.Button("Compare", variant="primary")
+                md6 = gr.Markdown()
+                tb6 = gr.Dataframe(interactive=False)
+                p6 = gr.Plot()
+
+                def sector(t, *a):
+                    P = mk_params(*a)
+                    ds = cached_ds()
+                    if not ds:
+                        return "Önce Market Scanner'ı çalıştırın (medyanlar önbellekteki hisselerden hesaplanır).", None, None
+                    med = build_medians(ds)
+                    rows = []
+                    for (seg, sec), m in sorted(med.items()):
+                        r = {"Segment": seg, "Sector": sec, "Peers": sum(1 for d in ds if d["seg"] == seg and d["sector"] == sec)}
+                        for f in ("pe", "pb", "ev_ebitda", "ev_fcf", "ps", "fcf_yield", "earn_yield"):
+                            v, n = m[f]
+                            r[f] = None if v is None else round(v, 3)
+                        rows.append(r)
+                    fig, md = None, f"Sektör medyanı için en az {MIN_PEERS} geçerli peer gerekir; yetersizse `None`."
+                    d = fetch(norm_sym(t)) if t.strip() else None
+                    if d:
+                        m = med.get((d["seg"], d["sector"]))
+                        keys = ["pe", "pb", "ev_ebitda", "ps"]
+                        cv_ = [d[k] for k in keys]
+                        mv = [m[k][0] if m else None for k in keys]
+                        fig = go.Figure([go.Bar(name=d["sym"], x=keys, y=cv_), go.Bar(name="Sector median", x=keys, y=mv)])
+                        fig.update_layout(barmode="group", template="plotly_white", height=340, margin=dict(l=10, r=10, t=20, b=10))
+                        md = f"**{d['sym']}** — {d['seg']} / {d['sector']}. " + md
+                    return md, pd.DataFrame(rows), fig
+
+                b6.click(sector, [t6] + PI, [md6, tb6, p6])
+
+            with gr.Tab("🎯 12-Month Scenarios"):
+                with gr.Row():
+                    t7 = gr.Textbox(value="AKBNK", label="Ticker", scale=2)
+                    pb = gr.Slider(0, 100, 25, step=5, label="Bear olasılığı (%)")
+                    pm = gr.Slider(0, 100, 50, step=5, label="Base olasılığı (%) — Bull = kalan")
+                    b7 = gr.Button("Run", variant="primary")
+                md7 = gr.Markdown()
+                tb7 = gr.Dataframe(interactive=False)
+                p7 = gr.Plot()
+
+                def scen(t, bear, base, *a):
+                    P = mk_params(*a)
+                    pr = validate_probs(bear, base)
+                    if pr is None:
+                        return "⚠️ Bear + Base 100'ü aşamaz (Bull = 100 − Bear − Base).", None, None
+                    A, err = get_A(t, P, pr)
+                    if err:
+                        return err, None, None
+                    d, e = A["d"], A["exp"]
+                    rows = [{"Scenario": o["Scenario"], "Real growth": o["Real growth"], "Real disc. rate": o["Real disc. rate"],
+                             "Multiple factor": o["Multiple factor"], "Intrinsic": None if o["Intrinsic"] is None else round(o["Intrinsic"], 2),
+                             "12M target": None if o["Target"] is None else round(o["Target"], 2),
+                             "Probability": f"{o['Prob'] * 100:.0f}%"} for o in A["scen"]]
+                    if e is None:
+                        return f"**{d['sym']}**: ⚠️ Senaryo üretilemedi (intrinsic value hesaplanamadı).", pd.DataFrame(rows), None
+                    md = (f"**{d['sym']}** · Olasılık-ağırlıklı hedef **{fm(e['pw'])}** · Beklenen nominal fiyat getirisi {fp(e['nominal'])} · "
+                          f"Temettü-dahil nominal {fp(e['total'])}" + ("" if e["dy_known"] else " (temettü verisi yok, 0 sayıldı)") +
+                          f" · Reel (temettü-dahil) {fp(e['real'])} · Reel fiyat getirisi {fp(e['real_price'])}\n\n"
+                          f"*Heuristik: hedef = fiyat + k×(senaryo değeri − fiyat), k={P['conv'] * 100:.0f}%, çarpan faktörü uygulanır. "
+                          "İstatistiksel olarak doğrulanmış tahmin değildir. Temettü yalnızca bir kez eklenir.*")
+                    f = go.Figure(go.Bar(x=["Price", "Bear", "Base", "Bull", "Prob-weighted"],
+                                         y=[d["price"]] + [o["Target"] for o in A["scen"]] + [e["pw"]]))
+                    f.update_layout(template="plotly_white", height=340, margin=dict(l=10, r=10, t=20, b=10))
+                    return md, pd.DataFrame(rows), f
+
+                b7.click(scen, [t7, pb, pm] + PI, [md7, tb7, p7])
 
+            with gr.Tab("📋 Data Quality Monitor"):
+                b8 = gr.Button("Check Data Quality", variant="primary")
+                md8 = gr.Markdown()
+                tb8 = gr.Dataframe(interactive=False, wrap=True)
+
+                def dq(progress=gr.Progress()):
+                    rows, failed = [], []
+                    for i, s in enumerate(BIST_UNIVERSE):
+                        progress((i + 1) / len(BIST_UNIVERSE), desc=f"Checking {s}")
+                        was = _cget(f"t_{s}") is not None
+                        d = fetch(s)
+                        if d is None:
+                            failed.append(s.replace(".IS", ""))
+                            continue
+                        c = coverage(d)
+                        rows.append({"Ticker": d["sym"], "Segment": d["seg"], "Coverage %": round(c * 100),
+                                     "Statement date": d["stmt_date"].date().isoformat() if d["stmt_date"] else "N/A",
+                                     "Age (days)": d["age"], "Status": "OK" if c >= 0.7 and not d["flags"] else "CHECK",
+                                     "Flags": "; ".join(d["flags"]) or "—"})
+                        if not was:
+                            time.sleep(REQUEST_DELAY_SEC * 0.5)
+                    df = pd.DataFrame(rows)
+                    avg = f"{df['Coverage %'].mean():.0f}%" if not df.empty else "N/A"
+                    return (f"Ortalama coverage: **{avg}** · Başarılı {len(rows)} · Çekilemeyen {len(failed)}: "
+                            + (", ".join(failed) or "—")), df
+
+                b8.click(dq, None, [md8, tb8])
+
+            with gr.Tab("📐 Methodology"):
+                gr.Markdown(METHODOLOGY)
+                b9 = gr.Button("Run self-test (synthetic data)")
+                o9 = gr.Textbox(label="Self-test", lines=18, interactive=False)
+                b9.click(self_test, None, o9)
     return demo
 
 
-# ============================================================================
-# MAIN
-# ============================================================================
+METHODOLOGY = """
+### Değerleme mimarisi
+- **DCF (sanayi/GYO dışı):** FCFF = FCF + faiz×(1−vergi) (Yahoo FCF'si faiz sonrası olduğu için borç çift sayılmasın diye). 5 yıl, büyüme yıl-1'den terminale doğrusal sönümlenir; EV − net borç = özsermaye; / hisse. Girdi eksik, FCFF ≤ 0 veya iskonto ≤ terminal büyüme ise **hesaplanmaz**.
+- **Owner Earnings:** NI + D&A − bakım capex + ΔİSermayesi. Bakım capex = min(toplam capex, D&A) **tahminidir**; veri eksikse yöntem kullanılmaz. Özsermaye nakit akışı olduğu için net borç düşülmez.
+- **Banka/Sigorta:** Gordon gerekçeli P/B = (sürdürülebilir ROE − g)/(COE − g) × defter değeri. FCF/EV-EBITDA kullanılmaz. Sermaye yeterliliği/aktif kalitesi Yahoo'da yok.
+- **GYO:** NAV vekili = defter değeri (ekspertiz NAV'ı yok), P/NAV. Doluluk verisi yok.
+- **Relative:** sektör medyanı (en az 5 geçerli peer) P/E, P/B, EV/EBITDA → hisse başına değer.
+- **Intrinsic = mevcut yöntemlerin medyanı.** MoS = (IV − fiyat)/IV.
+- **Reverse DCF:** fiyatı veren yıl-1 FCF büyümesi (bisection), iskonto oranı ±3 puan duyarlılığı.
+- **Enflasyon:** iskonto ve terminal büyüme reel girilir, nominale çevrilir; enflasyonun yalnızca ayarlanabilir bir kısmı (geçiş oranı) kâr büyümesine yansır. Reel getiri = (1+nominal)/(1+enflasyon) − 1.
+- **Senaryolar:** Bear/Base/Bull = reel büyüme ∓4 puan, reel iskonto +3/−2 puan, çarpan faktörü 0.85/1.0/1.10; hedef = fiyat + k×(değer − fiyat). Olasılıklar ayarlanabilir, toplam %100 (Bull = kalan).
+
+### Skorlama (0-100, açıklanabilir)
+Composite = ağırlıklı ortalama (mevcut bileşenler üzerinden yeniden normalize) × min(1, coverage/0.7).
+| Segment | Valuation | Quality | Strength | Risk (ters) |
+|---|---|---|---|---|
+| Sanayi | 35 | 30 | 20 | 15 |
+| Banka | 40 | 35 | 10 | 15 |
+| Sigorta | 40 | 30 | 15 | 15 |
+| GYO | 45 | 20 | 20 | 15 |
+
+Risk (0-100): 10 bayrak (distress, kaldıraç, likidite, negatif FCF, kâr/marj bozulması, CFO-NI ayrışması, seyrelme, aşırı değerleme, veri güvenilirliği); yalnızca değerlendirilebilen bayrakların ağırlığı üzerinden hesaplanır. Piotroski 9 bileşenli; hesaplanamayan bileşen "N/A" olur ve skor `x/n` olarak gösterilir.
+
+### Bilinen veri sınırlamaları
+- yfinance point-in-time değildir; backtest geçersizdir. Bilanço tarihleri ve kapsam hisseden hisseye değişir.
+- Yıllık tablolar gecikmelidir; TFRS/enflasyon muhasebesi (TMS 29) etkileri nominal rakamları çarpıtabilir.
+- Evren: gömülü liste + eklediğiniz tickerlar (tüm BIST listesi Yahoo'dan ücretsiz çekilemez).
+- Sektör/segment sınıflaması Yahoo `industry` alanına dayanır; peer sayısı <5 ise medyan hesaplanmaz.
+- Sonuçlar araştırma/eğitim amaçlıdır, yatırım tavsiyesi değildir.
+"""
 
 if __name__ == "__main__":
-    demo = build_ui()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    logger.info("Self-test:\n%s", self_test())
+    build_ui().launch(server_name="0.0.0.0", server_port=7860)