Harden valuation edge cases

4 files changed, 262 insertions, 58 deletions

diff --git a/components/valuation.py b/components/valuation.py
index a72d177..72c8001 100644
--- a/components/valuation.py
+++ b/components/valuation.py
@@ -146,35 +146,138 @@ def _render_ratios(ticker: str):
         st.info("Ratio data unavailable.")
         return
 
-    def r(key, fmt=fmt_ratio):
+    def _normalized_label(label: str) -> str:
+        return " ".join(str(label).replace("/", " ").replace("-", " ").split()).strip().lower()
+
+    def _display_value(key: str, fmt=fmt_ratio):
         val = ratios.get(key) if ratios else None
         return fmt(val) if val is not None else "—"
 
+    def _company_context() -> dict:
+        return info or {}
+
+    def _display_reasoned_metric(key: str, fmt=fmt_ratio) -> str:
+        val = ratios.get(key) if ratios else None
+        if val is not None:
+            return fmt(val)
+
+        ctx = _company_context()
+
+        if key == "peRatioTTM":
+            trailing_pe = ctx.get("trailingPE")
+            if trailing_pe is not None:
+                return fmt_ratio(trailing_pe)
+            if ratios and ratios.get("netProfitMarginTTM") is not None and ratios.get("netProfitMarginTTM") < 0:
+                return "N/M (neg. TTM earnings)"
+            trailing_eps = ctx.get("trailingEps")
+            if trailing_eps is not None:
+                try:
+                    if float(trailing_eps) <= 0:
+                        return "N/M (neg. TTM earnings)"
+                except (TypeError, ValueError):
+                    pass
+            return "—"
+
+        if key == "priceToBookRatioTTM":
+            book_value = ctx.get("bookValue")
+            if book_value is not None:
+                try:
+                    if float(book_value) <= 0:
+                        return "N/M (neg. equity)"
+                except (TypeError, ValueError):
+                    pass
+            return "—"
+
+        if key == "enterpriseValueMultipleTTM":
+            ebitda = ratios.get("ebitdaTTM") if ratios else None
+            if ebitda is not None:
+                try:
+                    if float(ebitda) <= 0:
+                        return "N/M (neg. EBITDA)"
+                except (TypeError, ValueError):
+                    pass
+            return "—"
+
+        if key == "dividendPayoutRatioTTM":
+            payout_ratio = ctx.get("payoutRatio")
+            if payout_ratio is not None:
+                try:
+                    if float(payout_ratio) <= 0:
+                        return "—"
+                except (TypeError, ValueError):
+                    pass
+            if ratios and ratios.get("netProfitMarginTTM") is not None and ratios.get("netProfitMarginTTM") < 0:
+                return "N/M (neg. earnings)"
+            return "—"
+
+        if key == "returnOnEquityTTM":
+            book_value = ctx.get("bookValue")
+            if book_value is not None:
+                try:
+                    if float(book_value) <= 0:
+                        return "N/M (neg. equity)"
+                except (TypeError, ValueError):
+                    pass
+            return "—"
+
+        if key == "debtToEquityRatioTTM":
+            book_value = ctx.get("bookValue")
+            if book_value is not None:
+                try:
+                    if float(book_value) <= 0:
+                        return "N/M (neg. equity)"
+                except (TypeError, ValueError):
+                    pass
+            return "—"
+
+        if key == "interestCoverageRatioTTM":
+            operating_margins = ctx.get("operatingMargins")
+            if operating_margins is not None:
+                try:
+                    if float(operating_margins) <= 0:
+                        return "N/M (neg. EBIT)"
+                except (TypeError, ValueError):
+                    pass
+            return "—"
+
+        return "—"
+
+    def _dedupe_metrics(metrics: list[tuple[str, str]]) -> list[tuple[str, str]]:
+        deduped: list[tuple[str, str]] = []
+        seen_labels: set[str] = set()
+        for label, val in metrics:
+            norm = _normalized_label(label)
+            if norm in seen_labels:
+                continue
+            seen_labels.add(norm)
+            deduped.append((label, val))
+        return deduped
+
     rows = [
-        ("Valuation", [
-            ("P/E (TTM)", r("peRatioTTM")),
-            ("Forward P/E", r("forwardPE")),
-            ("P/S (TTM)", r("priceToSalesRatioTTM")),
-            ("P/B", r("priceToBookRatioTTM")),
-            ("EV/EBITDA", r("enterpriseValueMultipleTTM")),
-            ("EV/Revenue", r("evToSalesTTM")),
-        ]),
-        ("Profitability", [
-            ("Gross Margin", r("grossProfitMarginTTM", fmt=fmt_pct)),
-            ("Operating Margin", r("operatingProfitMarginTTM", fmt=fmt_pct)),
-            ("Net Margin", r("netProfitMarginTTM", fmt=fmt_pct)),
-            ("ROE", r("returnOnEquityTTM", fmt=fmt_pct)),
-            ("ROA", r("returnOnAssetsTTM", fmt=fmt_pct)),
-            ("ROIC", r("returnOnInvestedCapitalTTM", fmt=fmt_pct)),
-        ]),
-        ("Leverage & Liquidity", [
-            ("Debt/Equity", r("debtToEquityRatioTTM")),
-            ("Current Ratio", r("currentRatioTTM")),
-            ("Quick Ratio", r("quickRatioTTM")),
-            ("Interest Coverage", r("interestCoverageRatioTTM")),
-            ("Dividend Yield", r("dividendYieldTTM", fmt=fmt_pct)),
-            ("Payout Ratio", r("dividendPayoutRatioTTM", fmt=fmt_pct)),
-        ]),
+        ("Valuation", _dedupe_metrics([
+            ("P/E (TTM)", _display_reasoned_metric("peRatioTTM")),
+            ("Forward P/E", _display_value("forwardPE")),
+            ("P/S (TTM)", _display_value("priceToSalesRatioTTM")),
+            ("P/B", _display_reasoned_metric("priceToBookRatioTTM")),
+            ("EV/EBITDA", _display_reasoned_metric("enterpriseValueMultipleTTM")),
+            ("EV/Revenue", _display_value("evToSalesTTM")),
+        ])),
+        ("Profitability", _dedupe_metrics([
+            ("Gross Margin", _display_value("grossProfitMarginTTM", fmt=fmt_pct)),
+            ("Operating Margin", _display_value("operatingProfitMarginTTM", fmt=fmt_pct)),
+            ("Net Margin", _display_value("netProfitMarginTTM", fmt=fmt_pct)),
+            ("ROE", _display_reasoned_metric("returnOnEquityTTM", fmt=fmt_pct)),
+            ("ROA", _display_value("returnOnAssetsTTM", fmt=fmt_pct)),
+            ("ROIC", _display_value("returnOnInvestedCapitalTTM", fmt=fmt_pct)),
+        ])),
+        ("Leverage & Liquidity", _dedupe_metrics([
+            ("Debt/Equity", _display_reasoned_metric("debtToEquityRatioTTM")),
+            ("Current Ratio", _display_value("currentRatioTTM")),
+            ("Quick Ratio", _display_value("quickRatioTTM")),
+            ("Interest Coverage", _display_reasoned_metric("interestCoverageRatioTTM")),
+            ("Dividend Yield", _display_value("dividendYieldTTM", fmt=fmt_pct)),
+            ("Payout Ratio", _display_reasoned_metric("dividendPayoutRatioTTM", fmt=fmt_pct)),
+        ])),
     ]
 
     for section_name, metrics in rows:
@@ -463,14 +566,30 @@ def _render_comps(ticker: str):
     available = [c for c in ["symbol", "peRatioTTM", "priceToSalesRatioTTM", "priceToBookRatioTTM", "enterpriseValueMultipleTTM", "netProfitMarginTTM", "returnOnEquityTTM", "debtToEquityRatioTTM"] if c in df.columns]
     df = df[available].rename(columns=display_cols)
 
-    pct_cols = {"Net Margin", "ROE"}
+    def _format_comp_value(column: str, value):
+        if value is None:
+            return "—"
+        try:
+            v = float(value)
+        except (TypeError, ValueError):
+            return "—"
+
+        if column == "P/E":
+            return fmt_ratio(v) if v > 0 else "N/M (neg. earnings)"
+        if column == "P/B":
+            return fmt_ratio(v) if v > 0 else "N/M (neg. equity)"
+        if column == "EV/EBITDA":
+            return fmt_ratio(v) if v > 0 else "N/M (neg. EBITDA)"
+        if column == "D/E":
+            return fmt_ratio(v) if v >= 0 else "N/M (neg. equity)"
+        if column in {"Net Margin", "ROE"}:
+            return fmt_pct(v)
+        return fmt_ratio(v) if v > 0 else "—"
+
     for col in df.columns:
         if col == "Ticker":
             continue
-        if col in pct_cols:
-            df[col] = df[col].apply(lambda v: fmt_pct(v) if v is not None else "—")
-        else:
-            df[col] = df[col].apply(lambda v: fmt_ratio(v) if v is not None else "—")
+        df[col] = df[col].apply(lambda v, c=col: _format_comp_value(c, v))
 
     def highlight_subject(row):
         if row["Ticker"] == ticker.upper():
@@ -737,19 +856,30 @@ def _render_historical_ratios(ticker: str):
             primary, alt, fmt = _HIST_RATIO_OPTIONS[label]
             display_cols[label] = (primary, alt, fmt)
 
+        def _format_hist_value(label: str, value, fmt: str | None) -> str:
+            if value is None:
+                return "—"
+            try:
+                v = float(value)
+            except (TypeError, ValueError):
+                return "—"
+
+            if fmt == "pct":
+                return f"{v * 100:.2f}%"
+            if label == "P/E":
+                return f"{v:.2f}x" if v > 0 else "N/M (neg. earnings)"
+            if label == "EV/EBITDA":
+                return f"{v:.2f}x" if v > 0 else "N/M (neg. EBITDA)"
+            if label in {"P/B", "Debt/Equity"}:
+                return f"{v:.2f}x" if v > 0 else "N/M (neg. equity)"
+            return f"{v:.2f}x" if v > 0 else "—"
+
         table_rows = []
         for row in merged_rows:
             r: dict = {"Year": str(row.get("date", ""))[:4]}
             for label, (primary, alt, fmt) in display_cols.items():
                 val = row.get(primary) or (row.get(alt) if alt else None)
-                if val is not None:
-                    try:
-                        v = float(val)
-                        r[label] = f"{v * 100:.2f}%" if fmt == "pct" else f"{v:.2f}x"
-                    except (TypeError, ValueError):
-                        r[label] = "—"
-                else:
-                    r[label] = "—"
+                r[label] = _format_hist_value(label, val, fmt)
             table_rows.append(r)
 
         if table_rows:
diff --git a/services/data_service.py b/services/data_service.py
index 412ca94..c278a2f 100644
--- a/services/data_service.py
+++ b/services/data_service.py
@@ -298,10 +298,14 @@ def compute_ttm_ratios(ticker: str) -> dict:
                 ratios["netProfitMarginTTM"] = net_income / revenue
 
         if equity and equity > 0 and net_income is not None:
-            ratios["returnOnEquityTTM"] = net_income / equity
+            roe = net_income / equity
+            if abs(roe) < 10:
+                ratios["returnOnEquityTTM"] = roe
 
         if total_assets and total_assets > 0 and net_income is not None:
-            ratios["returnOnAssetsTTM"] = net_income / total_assets
+            roa = net_income / total_assets
+            if abs(roa) < 10:
+                ratios["returnOnAssetsTTM"] = roa
 
         # ROIC = NOPAT / Invested Capital
         if ebit is not None and pretax_income and pretax_income != 0:
@@ -309,27 +313,39 @@ def compute_ttm_ratios(ticker: str) -> dict:
             nopat = ebit * (1 - effective_tax_rate)
             invested_capital = (equity or 0) + (total_debt or 0) - cash
             if invested_capital > 0:
-                ratios["returnOnInvestedCapitalTTM"] = nopat / invested_capital
+                roic = nopat / invested_capital
+                if abs(roic) < 10:
+                    ratios["returnOnInvestedCapitalTTM"] = roic
 
         # ── Valuation multiples ───────────────────────────────────────────────
         if market_cap and market_cap > 0:
             if net_income and net_income > 0:
                 ratios["peRatioTTM"] = market_cap / net_income
             if revenue and revenue > 0:
-                ratios["priceToSalesRatioTTM"] = market_cap / revenue
+                ps = market_cap / revenue
+                if 0 < ps < 100:
+                    ratios["priceToSalesRatioTTM"] = ps
             if equity and equity > 0:
-                ratios["priceToBookRatioTTM"] = market_cap / equity
+                pb = market_cap / equity
+                if 0 < pb < 100:
+                    ratios["priceToBookRatioTTM"] = pb
 
         if market_cap and market_cap > 0:
             ev = market_cap + (total_debt or 0.0) - cash
             if revenue and revenue > 0:
-                ratios["evToSalesTTM"] = ev / revenue
-            if ebitda and ebitda > 0:
-                ratios["enterpriseValueMultipleTTM"] = ev / ebitda
+                ev_sales = ev / revenue
+                if 0 < ev_sales < 100:
+                    ratios["evToSalesTTM"] = ev_sales
+            if ebitda and ebitda > 1e6:
+                ev_ebitda = ev / ebitda
+                if 0 < ev_ebitda < 500:
+                    ratios["enterpriseValueMultipleTTM"] = ev_ebitda
 
         # ── Leverage & Liquidity ──────────────────────────────────────────────
         if equity and equity > 0 and total_debt is not None:
-            ratios["debtToEquityRatioTTM"] = total_debt / equity
+            de = total_debt / equity
+            if 0 <= de < 100:
+                ratios["debtToEquityRatioTTM"] = de
 
         if current_liabilities and current_liabilities > 0 and current_assets is not None:
             ratios["currentRatioTTM"] = current_assets / current_liabilities
@@ -338,8 +354,10 @@ def compute_ttm_ratios(ticker: str) -> dict:
 
         if ebit is not None and interest_expense:
             ie = abs(interest_expense)
-            if ie > 0:
-                ratios["interestCoverageRatioTTM"] = ebit / ie
+            if ie > 0 and ebit > 0:
+                coverage = ebit / ie
+                if 0 < coverage < 1000:
+                    ratios["interestCoverageRatioTTM"] = coverage
 
         # ── Dividends (from cash flow statement) ─────────────────────────────
         dividends_paid = None
@@ -351,9 +369,13 @@ def compute_ttm_ratios(ticker: str) -> dict:
 
         if dividends_paid and dividends_paid > 0:
             if market_cap and market_cap > 0:
-                ratios["dividendYieldTTM"] = dividends_paid / market_cap
+                div_yield = dividends_paid / market_cap
+                if 0 <= div_yield < 1:
+                    ratios["dividendYieldTTM"] = div_yield
             if net_income and net_income > 0:
-                ratios["dividendPayoutRatioTTM"] = dividends_paid / net_income
+                payout = dividends_paid / net_income
+                if 0 <= payout < 10:
+                    ratios["dividendPayoutRatioTTM"] = payout
 
         # Expose raw EBITDA so callers (e.g. DCF EV/EBITDA section) use the
         # same TTM figure as the Key Ratios tab — single canonical source.
@@ -498,12 +520,18 @@ def get_historical_ratios_yfinance(ticker: str) -> list[dict]:
 
                 if equity and equity > 0:
                     if net_income is not None:
-                        row["returnOnEquity"] = net_income / equity
+                        roe = net_income / equity
+                        if abs(roe) < 10:
+                            row["returnOnEquity"] = roe
                     if total_debt is not None:
-                        row["debtEquityRatio"] = total_debt / equity
+                        de = total_debt / equity
+                        if 0 <= de < 100:
+                            row["debtEquityRatio"] = de
 
                 if total_assets and total_assets > 0 and net_income is not None:
-                    row["returnOnAssets"] = net_income / total_assets
+                    roa = net_income / total_assets
+                    if abs(roa) < 10:
+                        row["returnOnAssets"] = roa
 
             # Price-based ratios — average closing price in ±45-day window around year-end
             if shares and not hist.empty:
@@ -525,9 +553,13 @@ def get_historical_ratios_yfinance(ticker: str) -> list[dict]:
                         if net_income and net_income > 0:
                             row["peRatio"] = market_cap / net_income
                         if equity and equity > 0:
-                            row["priceToBookRatio"] = market_cap / equity
+                            pb = market_cap / equity
+                            if 0 < pb < 100:
+                                row["priceToBookRatio"] = pb
                         if total_rev and total_rev > 0:
-                            row["priceToSalesRatio"] = market_cap / total_rev
+                            ps = market_cap / total_rev
+                            if 0 < ps < 100:
+                                row["priceToSalesRatio"] = ps
 
                         # EV/EBITDA — approximate. Skip if EBITDA is too small to be meaningful,
                         # which otherwise creates absurd multiples for some software names.
diff --git a/services/fmp_service.py b/services/fmp_service.py
index 1e5ea42..82a9c4c 100644
--- a/services/fmp_service.py
+++ b/services/fmp_service.py
@@ -33,6 +33,11 @@ def get_key_ratios(ticker: str) -> dict:
 
     All ratios are self-computed via compute_ttm_ratios() — no FMP calls.
     Forward P/E and dividend fallbacks come from yfinance's info dict.
+
+    For edge cases, trailing P/E prefers the vendor-supplied value from the
+    info dict when the self-computed statement-based figure is missing or
+    materially inconsistent. This avoids obviously bad P/E outputs on tickers
+    with restatements, near-zero earnings, or statement mapping quirks.
     """
     ticker = ticker.upper()
     merged = {"symbol": ticker}
@@ -44,13 +49,43 @@ def get_key_ratios(ticker: str) -> dict:
     # Forward P/E requires analyst estimates — can't compute from statements
     info = get_company_info(ticker)
     if info:
+        trailing_pe_info = info.get("trailingPE")
+        trailing_pe_computed = merged.get("peRatioTTM")
+
+        if trailing_pe_info is not None:
+            try:
+                vendor_pe = float(trailing_pe_info)
+            except (TypeError, ValueError):
+                vendor_pe = None
+
+            try:
+                computed_pe = float(trailing_pe_computed) if trailing_pe_computed is not None else None
+            except (TypeError, ValueError):
+                computed_pe = None
+
+            if vendor_pe is not None and vendor_pe > 0:
+                if computed_pe is None or computed_pe <= 0:
+                    merged["peRatioTTM"] = vendor_pe
+                else:
+                    # If the two values are wildly different, trust the vendor
+                    # trailing P/E. This prevents edge-case display bugs where a
+                    # malformed TTM net income makes P/E look duplicated/wrong.
+                    ratio_gap = max(vendor_pe, computed_pe) / max(min(vendor_pe, computed_pe), 1e-9)
+                    if ratio_gap > 2.0:
+                        merged["peRatioTTM"] = vendor_pe
+
         if info.get("forwardPE") is not None:
             merged["forwardPE"] = info["forwardPE"]
         # Fallback: dividends from info dict when cash-flow data is missing
         if merged.get("dividendYieldTTM") is None and info.get("dividendYield") is not None:
             merged["dividendYieldTTM"] = info["dividendYield"]
-        if merged.get("dividendPayoutRatioTTM") is None and info.get("payoutRatio") is not None:
-            merged["dividendPayoutRatioTTM"] = info["payoutRatio"]
+        payout_ratio_info = info.get("payoutRatio")
+        if (
+            merged.get("dividendPayoutRatioTTM") is None
+            and payout_ratio_info is not None
+            and float(payout_ratio_info) > 0
+        ):
+            merged["dividendPayoutRatioTTM"] = payout_ratio_info
 
     return merged if len(merged) > 1 else {}
 
diff --git a/services/valuation_service.py b/services/valuation_service.py
index 6db4053..8559842 100644
--- a/services/valuation_service.py
+++ b/services/valuation_service.py
@@ -79,6 +79,13 @@ def run_dcf(
         growth_rate = historical_growth if historical_growth is not None else 0.05
 
     base_fcf = float(historical[-1])
+    if base_fcf <= 0:
+        return {
+            "error": (
+                "DCF is not meaningful with zero or negative base free cash flow. "
+                "Use comps, EV/EBITDA, or adjust the model only after underwriting a credible FCF turnaround."
+            )
+        }
 
     projected_fcfs = []
     for year in range(1, projection_years + 1):