ohmydata 0.2.1__tar.gz → 0.2.2__tar.gz

{ohmydata-0.2.1 → ohmydata-0.2.2}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.2.2 — 2026-09-06
+
+- Enhanced `yfinance` fundamentals pipeline with institutional Forward P/E calibration and GAAP distortion detection:
+  - **Institutional FY1 Forward P/E Calibration**:
+    - Calibrated `forward_pe` anchored to current fiscal year (`0y`) sell-side consensus instead of out-year (+1y).
+    - Preserved raw provider-native values as `raw_forward_pe` and `raw_forward_eps` alongside `forward_pe_source` (`"FY1_CONSENSUS"` or `"RAW_FALLBACK"`).
+    - Implemented defensive price derivation and currency/share-class unit mismatch protection for ADRs (ratio guard between 0.25 and 3.0) to safely fall back to raw values.
+  - **GAAP vs. Non-GAAP Distortion Detection**:
+    - Integrated Non-GAAP core operating consensus from `info.get("epsCurrentYear")` (`eps_current_year`).
+    - Added algorithmic relative deviation calculation (`gaap_diff_pct = |eps_0y - eps_current_year| / min`) and distortion flagging (`has_gaap_distortion` when `gaap_diff_pct > 0.25`).
+    - Protects algorithmic screeners and downstream valuation pipelines from spin-off, M&A, and accounting windfall false-value traps (e.g. `GEV`).
+
 ## 0.2.1 — 2026-09-04
 
 - Upgraded official `yfinance` provider lock from `1.5.1` to `1.7.0` (`ohmydata[yfinance]`):

{ohmydata-0.2.1 → ohmydata-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ohmydata
-Version: 0.2.1
+Version: 0.2.2
 Summary: Financial and alternative market data ingestion SDK.
 Author: OMD contributors
 Requires-Python: <3.13,>=3.11
@@ -26,6 +26,8 @@ Description-Content-Type: text/markdown
 
 # Oh My Data (OMD)
 
+[English](README.md) | [中文说明](README_zh.md)
+
 `ohmydata` is an offline-first market-data ingestion SDK and CLI. Provider endpoint
 adapters accept already initialized official-compatible clients; credentials
 are never loaded by this library.
@@ -40,8 +42,9 @@ uv run python -c "import ohmydata; print(ohmydata.__version__)"
 ```
 
 The core has no runtime dependencies. Install `ohmydata[tushare]` for the
-Pandas-backed Tushare adapter, `ohmydata[sec-cli]` for the SEC N-PORT batch CLI,
-or `ohmydata[sec-financials]` for company 10-K/10-Q financial statements and Parquet
+Pandas-backed Tushare adapter, `ohmydata[yfinance]` for US/global market data and
+fundamentals, `ohmydata[sec-cli]` for the SEC N-PORT batch CLI, or
+`ohmydata[sec-financials]` for company 10-K/10-Q financial statements and Parquet
 dataset writer. Provider tests use fake clients and never call a network.
 
 ## Core Architecture (offline & immutable)
@@ -503,6 +506,65 @@ preserve native line item labels and concepts (`concept`, `label`, `value_native
 beside standardized XBRL categories (`standard_concept`) for cross-company
 quantitative comparisons.
 
+### yfinance (US & Global Market Data, Fundamentals, and Zero-Drift Audit)
+
+Install `ohmydata[yfinance]` to access normalized market data, valuation ratios,
+and financial statements with strict version pinning (`yfinance==1.7.0`):
+
+```python
+from ohmydata.providers.yfinance import (
+    YFinanceAdjustmentMode,
+    YFinanceBatchPolicy,
+    YFinanceClient,
+    YFinanceDailyBarsRequest,
+    YFinanceFundamentalsRequest,
+    YFinanceRepairPolicy,
+)
+
+client = YFinanceClient()
+
+# 1. Fetch normalized daily bars (OHLCV) with repair isolation
+bars_req = YFinanceDailyBarsRequest(
+    symbols=("SPY", "QQQ", "^VIX"),
+    start_date="2024-01-01",
+    end_date_exclusive="2024-02-01",
+    adjustment_mode=YFinanceAdjustmentMode.RAW_WITH_ADJ_CLOSE,
+    batch_policy=YFinanceBatchPolicy.STRICT,
+    repair_policy=YFinanceRepairPolicy.PER_SYMBOL,
+)
+bars_result = client.fetch_daily_bars(bars_req)
+df = bars_result.dataframe
+
+# 2. Fetch fundamentals with institutional FY1 Forward P/E calibration
+fund_req = YFinanceFundamentalsRequest(
+    symbols=("NVDA", "GEV"),
+    include_financials=True,
+    include_valuation=True,
+    include_estimates=True,
+)
+fund_result = client.fetch_fundamentals(fund_req)
+
+nvda = fund_result.records["NVDA"]
+# Forward P/E is calibrated to current year consensus (FY1 0y.avg) rather than out-year (+1y)
+print("NVDA Calibrated FPE:", nvda.valuation.forward_pe, nvda.valuation.forward_pe_source)
+print("NVDA Raw Yahoo FPE:", nvda.valuation.raw_forward_pe)
+
+gev = fund_result.records["GEV"]
+# GAAP vs Non-GAAP accounting distortion detection (flags one-off windfalls > 25%)
+if gev.estimates.has_gaap_distortion:
+    print(f"GEV GAAP distortion flagged! Gap: {gev.estimates.gaap_diff_pct * 100:.1f}%")
+```
+
+#### Zero-Drift Audit CLI (`omd audit-drift`)
+
+Audit 10+ years of historical data against the 13-ETF `r10a0` benchmark universe before
+any provider upgrade:
+
+```bash
+# Strict unadjusted market bar zero-drift gate (must be bit-exact 0.0 error)
+uv run omd audit-drift --universe r10a0 --baseline-dir <old_version_dir> --target-dir <new_version_dir> --raw-only
+```
+
 ## Dataframe Adapters (Polars & Pandas)
 
 The optional `ohmydata[polars]` extra provides explicit, eager representation

{ohmydata-0.2.1 → ohmydata-0.2.2}/README.md

@@ -1,5 +1,7 @@
 # Oh My Data (OMD)
 
+[English](README.md) | [中文说明](README_zh.md)
+
 `ohmydata` is an offline-first market-data ingestion SDK and CLI. Provider endpoint
 adapters accept already initialized official-compatible clients; credentials
 are never loaded by this library.
@@ -14,8 +16,9 @@ uv run python -c "import ohmydata; print(ohmydata.__version__)"
 ```
 
 The core has no runtime dependencies. Install `ohmydata[tushare]` for the
-Pandas-backed Tushare adapter, `ohmydata[sec-cli]` for the SEC N-PORT batch CLI,
-or `ohmydata[sec-financials]` for company 10-K/10-Q financial statements and Parquet
+Pandas-backed Tushare adapter, `ohmydata[yfinance]` for US/global market data and
+fundamentals, `ohmydata[sec-cli]` for the SEC N-PORT batch CLI, or
+`ohmydata[sec-financials]` for company 10-K/10-Q financial statements and Parquet
 dataset writer. Provider tests use fake clients and never call a network.
 
 ## Core Architecture (offline & immutable)
@@ -477,6 +480,65 @@ preserve native line item labels and concepts (`concept`, `label`, `value_native
 beside standardized XBRL categories (`standard_concept`) for cross-company
 quantitative comparisons.
 
+### yfinance (US & Global Market Data, Fundamentals, and Zero-Drift Audit)
+
+Install `ohmydata[yfinance]` to access normalized market data, valuation ratios,
+and financial statements with strict version pinning (`yfinance==1.7.0`):
+
+```python
+from ohmydata.providers.yfinance import (
+    YFinanceAdjustmentMode,
+    YFinanceBatchPolicy,
+    YFinanceClient,
+    YFinanceDailyBarsRequest,
+    YFinanceFundamentalsRequest,
+    YFinanceRepairPolicy,
+)
+
+client = YFinanceClient()
+
+# 1. Fetch normalized daily bars (OHLCV) with repair isolation
+bars_req = YFinanceDailyBarsRequest(
+    symbols=("SPY", "QQQ", "^VIX"),
+    start_date="2024-01-01",
+    end_date_exclusive="2024-02-01",
+    adjustment_mode=YFinanceAdjustmentMode.RAW_WITH_ADJ_CLOSE,
+    batch_policy=YFinanceBatchPolicy.STRICT,
+    repair_policy=YFinanceRepairPolicy.PER_SYMBOL,
+)
+bars_result = client.fetch_daily_bars(bars_req)
+df = bars_result.dataframe
+
+# 2. Fetch fundamentals with institutional FY1 Forward P/E calibration
+fund_req = YFinanceFundamentalsRequest(
+    symbols=("NVDA", "GEV"),
+    include_financials=True,
+    include_valuation=True,
+    include_estimates=True,
+)
+fund_result = client.fetch_fundamentals(fund_req)
+
+nvda = fund_result.records["NVDA"]
+# Forward P/E is calibrated to current year consensus (FY1 0y.avg) rather than out-year (+1y)
+print("NVDA Calibrated FPE:", nvda.valuation.forward_pe, nvda.valuation.forward_pe_source)
+print("NVDA Raw Yahoo FPE:", nvda.valuation.raw_forward_pe)
+
+gev = fund_result.records["GEV"]
+# GAAP vs Non-GAAP accounting distortion detection (flags one-off windfalls > 25%)
+if gev.estimates.has_gaap_distortion:
+    print(f"GEV GAAP distortion flagged! Gap: {gev.estimates.gaap_diff_pct * 100:.1f}%")
+```
+
+#### Zero-Drift Audit CLI (`omd audit-drift`)
+
+Audit 10+ years of historical data against the 13-ETF `r10a0` benchmark universe before
+any provider upgrade:
+
+```bash
+# Strict unadjusted market bar zero-drift gate (must be bit-exact 0.0 error)
+uv run omd audit-drift --universe r10a0 --baseline-dir <old_version_dir> --target-dir <new_version_dir> --raw-only
+```
+
 ## Dataframe Adapters (Polars & Pandas)
 
 The optional `ohmydata[polars]` extra provides explicit, eager representation

{ohmydata-0.2.1 → ohmydata-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ohmydata"
-version = "0.2.1"
+version = "0.2.2"
 description = "Financial and alternative market data ingestion SDK."
 readme = "README.md"
 requires-python = ">=3.11,<3.13"

{ohmydata-0.2.1 → ohmydata-0.2.2}/src/ohmydata/__init__.py

@@ -1,5 +1,5 @@
 """Provisional offline-only Oh My Data package scaffold."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 __all__ = ["__version__"]

ohmydata-0.2.2/src/ohmydata/providers/yfinance/_fundamentals_parsers.py

@@ -0,0 +1,199 @@
+"""Internal helper functions for parsing financial statements, valuation, and analyst estimates."""
+
+from __future__ import annotations
+
+import datetime
+from typing import Any
+
+import pandas as pd
+
+
+def _safe_float(val: Any) -> float | None:
+    """Convert arbitrary numeric value to float or None."""
+    try:
+        if val is None or pd.isna(val):
+            return None
+        f = float(val)
+        return f if pd.notna(f) else None
+    except (ValueError, TypeError):
+        return None
+
+
+def extract_quarterly_pair(series: pd.Series | None) -> tuple[float | None, float | None]:
+    """Return (latest_quarter, same_quarter_last_year) from a quarterly series."""
+    if series is None or series.empty:
+        return (None, None)
+    cleaned = pd.to_numeric(series, errors="coerce").dropna()
+    if len(cleaned) < 5:
+        # If at least 1 quarter exists, return latest, but prev_year is None
+        latest = _safe_float(cleaned.iloc[0]) if len(cleaned) >= 1 else None
+        return (latest, None)
+    return (_safe_float(cleaned.iloc[0]), _safe_float(cleaned.iloc[4]))
+
+
+def extract_metric_pair(
+    stmt: pd.DataFrame | None, candidate_keys: list[str]
+) -> tuple[float | None, float | None]:
+    """Search for metric rows across aliases and extract (latest, prev_year)."""
+    if stmt is None or stmt.empty:
+        return (None, None)
+    # Search index names ignoring case and whitespace
+    norm_index = {str(idx).strip().lower(): idx for idx in stmt.index}
+    for candidate in candidate_keys:
+        cand_key = candidate.strip().lower()
+        if cand_key in norm_index:
+            row_key = norm_index[cand_key]
+            return extract_quarterly_pair(stmt.loc[row_key])
+    return (None, None)
+
+
+def extract_report_date(
+    info: dict[str, Any] | None, income_stmt: pd.DataFrame | None
+) -> datetime.date | None:
+    """Extract report date from mostRecentQuarter or statement columns, rejecting epoch 0."""
+    info = info or {}
+    candidates: list[datetime.date] = []
+
+    mrq = info.get("mostRecentQuarter")
+    if mrq is not None:
+        try:
+            if isinstance(mrq, (int, float)) and mrq > 0:
+                dt = datetime.datetime.fromtimestamp(mrq, tz=datetime.UTC).date()
+                candidates.append(dt)
+            elif isinstance(mrq, str):
+                dt = pd.to_datetime(mrq).date()
+                candidates.append(dt)
+        except (ValueError, TypeError, OSError):
+            pass
+
+    if income_stmt is not None and not income_stmt.empty:
+        for col in income_stmt.columns:
+            try:
+                dt = pd.to_datetime(col).date()
+                candidates.append(dt)
+                break
+            except (ValueError, TypeError, OSError):
+                pass
+
+    for dt in candidates:
+        # Must be after 1990-01-01 and not epoch 1970-01-01
+        if dt.year >= 1990:
+            return dt
+
+    return None
+
+
+def extract_estimates_horizons(
+    df_est: pd.DataFrame | None,
+) -> tuple[float | None, float | None, float | None, float | None]:
+    """Extract (current_q, next_q, current_y, next_y) from estimate DataFrame."""
+    if df_est is None or df_est.empty:
+        return (None, None, None, None)
+
+    # Clean index
+    df_clean = df_est.copy()
+    df_clean.index = [str(idx).strip().lower() for idx in df_clean.index]
+
+    # Find avg / mean column
+    target_col = None
+    for col in df_clean.columns:
+        c_low = str(col).lower()
+        if "avg" in c_low or "mean" in c_low:
+            target_col = col
+            break
+    if target_col is None and len(df_clean.columns) > 0:
+        target_col = df_clean.columns[0]
+
+    if target_col is None:
+        return (None, None, None, None)
+
+    series = pd.to_numeric(df_clean[target_col], errors="coerce")
+
+    def _get_val(keys: list[str]) -> float | None:
+        for k in keys:
+            if k in series.index:
+                val = series.loc[k]
+                return _safe_float(val)
+        return None
+
+    cq = _get_val(["0q", "current quarter", "currentq"])
+    nq = _get_val(["+1q", "next quarter", "nextq", "1q"])
+    cy = _get_val(["0y", "current year", "currenty"])
+    ny = _get_val(["+1y", "next year", "nexty", "1y"])
+    return (cq, nq, cy, ny)
+
+
+def derive_implied_price(
+    raw_forward_pe: float | None,
+    raw_forward_eps: float | None,
+    trailing_pe: float | None,
+    deps_latest: float | None,
+    market_cap: float | None,
+    shares_outstanding: float | None,
+) -> float | None:
+    """Derive implied market price defensively across priority cascade."""
+    if (
+        raw_forward_pe is not None
+        and raw_forward_eps is not None
+        and raw_forward_pe > 0
+        and raw_forward_eps > 0
+    ):
+        return raw_forward_pe * raw_forward_eps
+    if trailing_pe is not None and deps_latest is not None and trailing_pe > 0 and deps_latest > 0:
+        return trailing_pe * deps_latest
+    if market_cap is not None and shares_outstanding is not None and shares_outstanding > 0:
+        return market_cap / shares_outstanding
+    return None
+
+
+def calibrate_forward_pe(
+    implied_price: float | None,
+    raw_forward_pe: float | None,
+    raw_forward_eps: float | None,
+    eps_0y: float | None,
+) -> tuple[float | None, float | None, str | None]:
+    """Calibrate institutional FY1 Forward P/E against sell-side consensus with ADR protection.
+
+    Returns:
+        tuple of (calibrated_forward_pe, calibrated_forward_eps, forward_pe_source)
+    """
+    calibrated_fpe = raw_forward_pe
+    calibrated_feps = raw_forward_eps
+    fpe_source = "RAW_FALLBACK" if raw_forward_pe is not None else None
+
+    if implied_price is not None and eps_0y is not None and eps_0y > 0:
+        is_mismatched = False
+        if raw_forward_eps is not None and raw_forward_eps > 0:
+            ratio = eps_0y / raw_forward_eps
+            if ratio > 3.0 or ratio < 0.25:
+                is_mismatched = True
+
+        if not is_mismatched:
+            calibrated_fpe = round(implied_price / eps_0y, 4)
+            calibrated_feps = round(eps_0y, 4)
+            fpe_source = "FY1_CONSENSUS"
+
+    return (calibrated_fpe, calibrated_feps, fpe_source)
+
+
+def detect_gaap_distortion(
+    eps_0y: float | None,
+    eps_current_year: float | None,
+) -> tuple[float | None, bool]:
+    """Detect relative GAAP vs Non-GAAP consensus divergence (e.g. spin-offs, M&A windfalls).
+
+    Returns:
+        tuple of (gaap_diff_pct, has_gaap_distortion)
+    """
+    gaap_diff_pct = None
+    has_gaap_distortion = False
+
+    if eps_0y is not None and eps_current_year is not None and eps_0y > 0 and eps_current_year > 0:
+        denom = min(eps_0y, eps_current_year)
+        if denom > 0:
+            gap = abs(eps_0y - eps_current_year) / denom
+            gaap_diff_pct = round(gap, 4)
+            if gap > 0.25:
+                has_gaap_distortion = True
+
+    return (gaap_diff_pct, has_gaap_distortion)

{ohmydata-0.2.1 → ohmydata-0.2.2}/src/ohmydata/providers/yfinance/fundamentals.py

@@ -12,6 +12,16 @@ import pandas as pd
 from ohmydata.core.policy import RetryPolicy
 from ohmydata.core.provenance import FetchProvenance
 
+from ._fundamentals_parsers import (
+    _safe_float,
+    calibrate_forward_pe,
+    derive_implied_price,
+    detect_gaap_distortion,
+    extract_estimates_horizons,
+    extract_metric_pair,
+    extract_quarterly_pair,
+    extract_report_date,
+)
 from .endpoints import validate_yfinance_symbol
 
 NON_EQUITY_QUOTE_TYPES = frozenset(
@@ -19,90 +29,18 @@ NON_EQUITY_QUOTE_TYPES = frozenset(
 )
 
 
-def _safe_float(val: Any) -> float | None:
-    """Convert arbitrary numeric value to float or None."""
-    try:
-        if val is None or pd.isna(val):
-            return None
-        f = float(val)
-        return f if pd.notna(f) else None
-    except (ValueError, TypeError):
-        return None
-
-
-def extract_quarterly_pair(series: pd.Series | None) -> tuple[float | None, float | None]:
-    """Return (latest_quarter, same_quarter_last_year) from a quarterly series."""
-    if series is None or series.empty:
-        return (None, None)
-    cleaned = pd.to_numeric(series, errors="coerce").dropna()
-    if len(cleaned) < 5:
-        # If at least 1 quarter exists, return latest, but prev_year is None
-        latest = _safe_float(cleaned.iloc[0]) if len(cleaned) >= 1 else None
-        return (latest, None)
-    return (_safe_float(cleaned.iloc[0]), _safe_float(cleaned.iloc[4]))
-
-
-def extract_metric_pair(
-    stmt: pd.DataFrame | None, candidate_keys: list[str]
-) -> tuple[float | None, float | None]:
-    """Search for metric rows across aliases and extract (latest, prev_year)."""
-    if stmt is None or stmt.empty:
-        return (None, None)
-    # Search index names ignoring case and whitespace
-    norm_index = {str(idx).strip().lower(): idx for idx in stmt.index}
-    for candidate in candidate_keys:
-        cand_key = candidate.strip().lower()
-        if cand_key in norm_index:
-            row_key = norm_index[cand_key]
-            return extract_quarterly_pair(stmt.loc[row_key])
-    return (None, None)
-
-
-def extract_report_date(
-    info: dict[str, Any] | None, income_stmt: pd.DataFrame | None
-) -> datetime.date | None:
-    """Extract report date from mostRecentQuarter or statement columns, rejecting epoch 0."""
-    info = info or {}
-    candidates: list[datetime.date] = []
-
-    mrq = info.get("mostRecentQuarter")
-    if mrq is not None:
-        try:
-            if isinstance(mrq, (int, float)) and mrq > 0:
-                dt = datetime.datetime.fromtimestamp(mrq, tz=datetime.UTC).date()
-                candidates.append(dt)
-            elif isinstance(mrq, str):
-                dt = pd.to_datetime(mrq).date()
-                candidates.append(dt)
-        except (ValueError, TypeError, OSError):
-            pass
-
-    if income_stmt is not None and not income_stmt.empty:
-        for col in income_stmt.columns:
-            try:
-                dt = pd.to_datetime(col).date()
-                candidates.append(dt)
-                break
-            except (ValueError, TypeError, OSError):
-                pass
-
-    for dt in candidates:
-        # Must be after 1990-01-01 and not epoch 1970-01-01
-        if dt.year >= 1990:
-            return dt
-
-    return None
-
-
 @dataclass(frozen=True)
 class YFinanceValuationSnapshot:
     """Snapshot of valuation ratios and market size."""
 
     trailing_pe: float | None = None
-    forward_pe: float | None = None
+    forward_pe: float | None = None  # Calibrated FY1 institutional Forward P/E
+    raw_forward_pe: float | None = None  # Provider-native raw value from info.get("forwardPE")
+    forward_pe_source: str | None = None  # "FY1_CONSENSUS" | "RAW_FALLBACK" | None
     peg_ratio: float | None = None
     price_to_sales: float | None = None
-    forward_eps: float | None = None
+    forward_eps: float | None = None  # Calibrated FY1 forward EPS (or raw if uncalibrated)
+    raw_forward_eps: float | None = None  # Provider-native raw value from info.get("forwardEps")
     market_cap: float | None = None
     enterprise_value: float | None = None
     shares_outstanding: float | None = None
@@ -147,7 +85,7 @@ class YFinanceQuarterlyFinancials:
 
 @dataclass(frozen=True)
 class YFinanceAnalystEstimates:
-    """Analyst consensus estimates across 4 horizons."""
+    """Analyst consensus estimates across horizons and Non-GAAP cross-validation."""
 
     revenue_est_current_q: float | None = None
     revenue_est_next_q: float | None = None
@@ -155,8 +93,13 @@ class YFinanceAnalystEstimates:
     revenue_est_next_y: float | None = None
     eps_est_current_q: float | None = None
     eps_est_next_q: float | None = None
-    eps_est_current_y: float | None = None
-    eps_est_next_y: float | None = None
+    eps_est_current_y: float | None = None  # Sell-side consensus 0y.avg (often GAAP in Yahoo)
+    eps_est_next_y: float | None = None  # Sell-side consensus +1y.avg
+    eps_current_year: float | None = (
+        None  # Core operating consensus from info.get("epsCurrentYear") (Non-GAAP)
+    )
+    gaap_diff_pct: float | None = None  # Relative deviation: |eps_0y - eps_current_y| / min
+    has_gaap_distortion: bool = False  # True when gaap_diff_pct > 0.25
 
 
 @dataclass(frozen=True)
@@ -236,46 +179,6 @@ class YFinanceFundamentalsResult:
         return pd.DataFrame(self.to_records())
 
 
-def extract_estimates_horizons(
-    df_est: pd.DataFrame | None,
-) -> tuple[float | None, float | None, float | None, float | None]:
-    """Extract (current_q, next_q, current_y, next_y) from estimate DataFrame."""
-    if df_est is None or df_est.empty:
-        return (None, None, None, None)
-
-    # Clean index
-    df_clean = df_est.copy()
-    df_clean.index = [str(idx).strip().lower() for idx in df_clean.index]
-
-    # Find avg / mean column
-    target_col = None
-    for col in df_clean.columns:
-        c_low = str(col).lower()
-        if "avg" in c_low or "mean" in c_low:
-            target_col = col
-            break
-    if target_col is None and len(df_clean.columns) > 0:
-        target_col = df_clean.columns[0]
-
-    if target_col is None:
-        return (None, None, None, None)
-
-    series = pd.to_numeric(df_clean[target_col], errors="coerce")
-
-    def _get_val(keys: list[str]) -> float | None:
-        for k in keys:
-            if k in series.index:
-                val = series.loc[k]
-                return _safe_float(val)
-        return None
-
-    cq = _get_val(["0q", "current quarter", "currentq"])
-    nq = _get_val(["+1q", "next quarter", "nextq", "1q"])
-    cy = _get_val(["0y", "current year", "currenty"])
-    ny = _get_val(["+1y", "next year", "nexty", "1y"])
-    return (cq, nq, cy, ny)
-
-
 def parse_symbol_fundamentals(
     symbol: str,
     info: dict[str, Any] | None,
@@ -312,17 +215,10 @@ def parse_symbol_fundamentals(
         str(info.get("currency") or info.get("financialCurrency") or "").strip().upper() or None
     )
 
-    valuation = YFinanceValuationSnapshot(
-        trailing_pe=_safe_float(info.get("trailingPE")),
-        forward_pe=_safe_float(info.get("forwardPE")),
-        peg_ratio=_safe_float(info.get("pegRatio")),
-        price_to_sales=_safe_float(info.get("priceToSalesTrailing12Months")),
-        forward_eps=_safe_float(info.get("forwardEps")),
-        market_cap=market_cap,
-        enterprise_value=_safe_float(info.get("enterpriseValue")),
-        shares_outstanding=shares_outstanding,
-        currency=currency,
-    )
+    trailing_pe = _safe_float(info.get("trailingPE"))
+    raw_forward_pe = _safe_float(info.get("forwardPE"))
+    raw_forward_eps = _safe_float(info.get("forwardEps"))
+    eps_current_year = _safe_float(info.get("epsCurrentYear"))
 
     # Extract statements YoY pairs
     rev_latest, rev_prev = extract_metric_pair(
@@ -349,19 +245,16 @@ def parse_symbol_fundamentals(
         ],
     )
     fcf_latest, fcf_prev = extract_metric_pair(cashflow_stmt, ["Free Cash Flow"])
-    capex_latest, capex_prev = extract_metric_pair(
-        cashflow_stmt, ["Capital Expenditure", "Capital Expenditures"]
-    )
+    capex_latest, capex_prev = extract_metric_pair(cashflow_stmt, ["Capital Expenditure"])
 
     debt_latest, debt_prev = extract_metric_pair(balance_stmt, ["Total Debt"])
     cash_latest, cash_prev = extract_metric_pair(
         balance_stmt,
-        ["Cash And Cash Equivalents", "Cash Cash Equivalents And Short Term Investments", "Cash"],
+        ["Cash And Cash Equivalents", "Cash Cash Equivalents And Short Term Investments"],
     )
     net_debt_latest, net_debt_prev = extract_metric_pair(balance_stmt, ["Net Debt"])
     equity_latest, equity_prev = extract_metric_pair(
-        balance_stmt,
-        ["Stockholders Equity", "Total Stockholder Equity", "Common Stock Equity"],
+        balance_stmt, ["Stockholders Equity", "Total Equity Gross Minority Interest"]
     )
 
     financials = YFinanceQuarterlyFinancials(
@@ -400,6 +293,46 @@ def parse_symbol_fundamentals(
     # Extract estimates
     rcq, rnq, rcy, rny = extract_estimates_horizons(rev_estimate_df)
     ecq, enq, ecy, eny = extract_estimates_horizons(eps_estimate_df)
+    eps_0y = ecy
+
+    # Derive implied price defensively
+    implied_price = derive_implied_price(
+        raw_forward_pe=raw_forward_pe,
+        raw_forward_eps=raw_forward_eps,
+        trailing_pe=trailing_pe,
+        deps_latest=deps_latest,
+        market_cap=market_cap,
+        shares_outstanding=shares_outstanding,
+    )
+
+    # Calibrate FY1 Forward P/E
+    calibrated_fpe, calibrated_feps, fpe_source = calibrate_forward_pe(
+        implied_price=implied_price,
+        raw_forward_pe=raw_forward_pe,
+        raw_forward_eps=raw_forward_eps,
+        eps_0y=eps_0y,
+    )
+
+    # GAAP vs. Non-GAAP Distortion Detection
+    gaap_diff_pct, has_gaap_distortion = detect_gaap_distortion(
+        eps_0y=eps_0y,
+        eps_current_year=eps_current_year,
+    )
+
+    valuation = YFinanceValuationSnapshot(
+        trailing_pe=trailing_pe,
+        forward_pe=calibrated_fpe,
+        raw_forward_pe=raw_forward_pe,
+        forward_pe_source=fpe_source,
+        peg_ratio=_safe_float(info.get("pegRatio")),
+        price_to_sales=_safe_float(info.get("priceToSalesTrailing12Months")),
+        forward_eps=calibrated_feps,
+        raw_forward_eps=raw_forward_eps,
+        market_cap=market_cap,
+        enterprise_value=_safe_float(info.get("enterpriseValue")),
+        shares_outstanding=shares_outstanding,
+        currency=currency,
+    )
 
     estimates = YFinanceAnalystEstimates(
         revenue_est_current_q=rcq,
@@ -410,6 +343,9 @@ def parse_symbol_fundamentals(
         eps_est_next_q=enq,
         eps_est_current_y=ecy,
         eps_est_next_y=eny,
+        eps_current_year=eps_current_year,
+        gaap_diff_pct=gaap_diff_pct,
+        has_gaap_distortion=has_gaap_distortion,
     )
 
     report_dt = extract_report_date(info, income_stmt)
@@ -420,9 +356,27 @@ def parse_symbol_fundamentals(
         quote_type=quote_type,
         is_excluded=is_excluded,
         exclusion_reason=exclusion_reason,
-        revenue_growth_hint=_safe_float(info.get("revenueGrowth")),
-        eps_growth_hint=_safe_float(info.get("earningsGrowth")),
         valuation=valuation,
         financials=financials,
         estimates=estimates,
     )
+
+
+__all__ = [
+    "NON_EQUITY_QUOTE_TYPES",
+    "YFinanceAnalystEstimates",
+    "YFinanceFundamentalsRequest",
+    "YFinanceFundamentalsResult",
+    "YFinanceQuarterlyFinancials",
+    "YFinanceSymbolFundamentals",
+    "YFinanceValuationSnapshot",
+    "_safe_float",
+    "calibrate_forward_pe",
+    "derive_implied_price",
+    "detect_gaap_distortion",
+    "extract_estimates_horizons",
+    "extract_metric_pair",
+    "extract_quarterly_pair",
+    "extract_report_date",
+    "parse_symbol_fundamentals",
+]

{ohmydata-0.2.1 → ohmydata-0.2.2}/uv.lock

@@ -491,7 +491,7 @@ wheels = [
 
 [[package]]
 name = "ohmydata"
-version = "0.2.1"
+version = "0.2.2"
 source = { editable = "." }
 
 [package.optional-dependencies]