scraper2-hj3415 2.4.1__py3-none-any.whl → 2.7.0__py3-none-any.whl

scraper2_hj3415/app/parsing/c101/earning_surprise.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+from scraper2_hj3415.app.ports.browser.browser_port import BrowserPort
+from common_hj3415.utils import clean_text
+
+_EARNING_SURPRISE_TABLE = "#earning_list"
+
+def _strip_bullets_commas(s: str) -> str:
+    """
+    "●  120,064.0" / "101,922.8" 같은 텍스트에서 숫자 파싱을 방해하는 것 제거.
+    """
+    s = clean_text(s)
+    s = s.replace(",", "")
+    s = s.replace("●", "")
+    s = s.replace("○", "")
+    s = s.replace("▲", "")
+    s = s.replace("▼", "")
+    return clean_text(s)
+
+
+def _to_number_like(x: Any) -> Any:
+    """
+    숫자면 float/int로, 아니면 문자열 그대로.
+    """
+    if x is None:
+        return None
+    if isinstance(x, (int, float)):
+        return x
+    s = _strip_bullets_commas(str(x))
+    if not s:
+        return None
+
+    # 숫자 패턴이면 숫자로
+    #  - "65.00" "209.17" "-123.4"
+    if re.fullmatch(r"[-+]?\d+(\.\d+)?", s):
+        # 정수면 int 유지하고 싶으면 여기서 분기 가능
+        try:
+            f = float(s)
+            # "65.0" 같이 소수점 .0이면 int로 바꿀지 정책 선택
+            return f
+        except Exception:
+            return s
+
+    return s
+
+
+def _norm_item_label(item: str) -> str:
+    """
+    item(th 텍스트) 정규화:
+    - "전분기대비보기 전년동기대비" -> "전년동기대비"
+    - "Surprise" 등은 그대로
+    """
+    t = clean_text(item)
+
+    # 버튼 텍스트가 섞이는 케이스: "전분기대비보기 전년동기대비"
+    if ("전분기대비" in t) and ("전년동기대비" in t):
+        return "전년동기대비"
+    if "전분기대비" in t:
+        return "전분기대비"
+    if "전년동기대비" in t:
+        return "전년동기대비"
+    if "컨센서스" in t:
+        return "컨센서스"
+    if "잠정치" in t:
+        return "잠정치"
+    if "Surprise" in t or "SURPRISE" in t or "surprise" in t:
+        return "Surprise"
+
+    return t
+
+
+async def _row_cells_texts(
+    browser: BrowserPort,
+    *,
+    row_sel: str,
+) -> list[str]:
+    """
+    tbody의 특정 tr에서 th/td 텍스트를 왼쪽부터 순서대로 모두 가져온다.
+    """
+    # th,td 전체 개수
+    n = await browser.count_in_nth(
+        _EARNING_SURPRISE_TABLE,
+        scope_index=0,
+        inner_selector=f"{row_sel} th, {row_sel} td",
+    )
+
+    out: list[str] = []
+    for j in range(n):
+        txt = await browser.inner_text_in_nth(
+            _EARNING_SURPRISE_TABLE,
+            scope_index=0,
+            inner_selector=f"{row_sel} th, {row_sel} td",
+            inner_index=j,
+        )
+        out.append(clean_text(txt))
+    return out
+
+
+async def parse_c101_earnings_surprise_table(
+    browser: BrowserPort,
+    *,
+    debug_rows: bool = False,
+) -> dict[str, Any]:
+    """
+    earning_list HTML 구조(제공된 원본)에 맞춘 안정 파서.
+
+    반환:
+      {
+        "periods": [...],
+        "metrics": { section: { item: {period: value} } },
+        "meta": {...},
+        ...(debug_rows면 "rows": raw_cells_rows)
+      }
+    """
+    await browser.wait_attached(_EARNING_SURPRISE_TABLE)
+
+    row_cnt = await browser.count_in_nth(
+        _EARNING_SURPRISE_TABLE,
+        scope_index=0,
+        inner_selector="tbody tr",
+    )
+    if not row_cnt:
+        out = {"periods": [], "metrics": {}, "meta": {}}
+        if debug_rows:
+            out["rows"] = []
+        return out
+
+    raw_cells_rows: list[list[str]] = []
+
+    periods: list[str] = []
+    period_count = 0
+
+    metrics: dict[str, dict[str, dict[str, Any]]] = {}
+    meta: dict[str, dict[str, Any]] = {}
+
+    current_section: str | None = None
+
+    for i in range(1, row_cnt + 1):  # nth-child 1-based
+        row_sel = f"tbody tr:nth-child({i})"
+        cells = await _row_cells_texts(browser, row_sel=row_sel)
+        raw_cells_rows.append(cells)
+
+        if not cells:
+            continue
+
+        joined = " ".join([c for c in cells if c])
+
+        # 1) periods 추출: "재무연월" 헤더 row
+        # HTML: <th colspan="2">재무연월</th> + <th>2025/09</th> + <th>2025/12</th>
+        if ("재무연월" in joined) and not periods:
+            # cells 예: ["재무연월", "2025/09", "2025/12"] 또는 table 구조에 따라 3~4개
+            # 여기서는 "YYYY/NN" 패턴만 뽑는 게 가장 안전함
+            periods = [c for c in cells if re.fullmatch(r"\d{4}/\d{2}", c)]
+            period_count = len(periods)
+            continue
+
+        # periods 없으면 본문 해석 불가
+        if not periods:
+            continue
+
+        # 2) meta row: "잠정치발표(예정)일/회계기준"
+        if "잠정치발표(예정)일/회계기준" in joined:
+            # 보통 cells: ["잠정치발표(예정)일/회계기준", "2025/10/14(연결)", "2026/01/08(연결)"]
+            vals = [c for c in cells if c and "잠정치발표" not in c]
+            vals = vals[-period_count:] if period_count else vals
+            meta["잠정치발표(예정)일/회계기준"] = {
+                periods[idx]: vals[idx] if idx < len(vals) else None
+                for idx in range(period_count)
+            }
+            continue
+
+        # 3) 본문 row 정규화: 항상 [section, item, v1, v2, ...] 로 맞추기
+        # HTML 케이스:
+        #  - 섹션 시작 행(영업이익/당기순이익): cells = ["영업이익", "컨센서스", v1, v2]
+        #  - rowspan 내부 다음 행:             cells = ["잠정치", v1, v2]  (section 없음 → 왼쪽 패딩 필요)
+        #  - ext0 행(전분기대비):              cells = ["", "전분기대비", v1, v2]  (첫 칸 빈 th)
+        #
+        # period_count가 2라면, 정상형은 길이 2 + period_count = 4
+        want_len = 2 + period_count
+
+        norm = cells[:]
+        if len(norm) == want_len - 1:
+            # section th가 빠진 케이스: ["잠정치", v1, v2] -> ["", "잠정치", v1, v2]
+            norm = [""] + norm
+        elif len(norm) < want_len:
+            # 애매한 경우: 오른쪽을 None으로 채움
+            norm = ([""] * (want_len - len(norm))) + norm
+            norm = norm[-want_len:]
+
+        section_cell = clean_text(norm[0])
+        item_cell = clean_text(norm[1])
+        value_cells = norm[2 : 2 + period_count]
+
+        # section 갱신
+        if section_cell:
+            current_section = section_cell
+            metrics.setdefault(current_section, {})
+        if not current_section:
+            # 섹션이 한 번도 잡히지 않은 상태면 skip
+            continue
+
+        item = _norm_item_label(item_cell)
+        if not item:
+            continue
+
+        # 값 매핑
+        bucket = metrics[current_section].setdefault(item, {})
+        for idx, p in enumerate(periods):
+            raw_v = value_cells[idx] if idx < len(value_cells) else None
+            bucket[p] = _to_number_like(raw_v)
+
+    out: dict[str, Any] = {"periods": periods, "metrics": metrics, "meta": meta}
+    if debug_rows:
+        out["rows"] = raw_cells_rows
+    return out

scraper2_hj3415/app/parsing/c101/fundamentals.py

@@ -0,0 +1,95 @@
+# scraper2_hj3415/app/parsing/c101/fundamentals.py
+from __future__ import annotations
+
+import re
+from typing import Any
+from scraper2_hj3415.app.ports.browser.browser_port import BrowserPort
+from common_hj3415.utils import clean_text
+from scraper2_hj3415.app.parsing._normalize.text import normalize_text
+from scraper2_hj3415.app.parsing._normalize.values import to_number_or_text
+
+_FUNDAMENTALS_TABLE = "div.fund.fl_le table.gHead03"
+
+
+def _normalize_period_key(s: str) -> str:
+    """
+    예)
+      "2024/12(A)" -> "2024/12"
+      "2025/12(E)" -> "2025/12"
+      "2025/12"    -> "2025/12"
+    """
+    s = s.strip()
+    # 뒤쪽 괄호 주석 제거: (A) (E) (P) 등
+    s = re.sub(r"\([^)]*\)$", "", s).strip()
+    return s
+
+EXCLUDED_METRICS = {"회계기준"}
+
+async def parse_c101_fundamentals_table(
+    browser: BrowserPort,
+) -> dict[str, dict[str, Any]]:
+    """
+    '펀더멘털 주요지표(실적/컨센서스)' 테이블을
+    metric_key -> {period_key -> value} 형태로 반환한다.
+
+    반환 예)
+      {
+        "PBR": {"2024/12": 13.62, "2025/12": None},
+        "회계기준": {"2024/12": "연결", "2025/12": "연결"},
+        ...
+      }
+    """
+    await browser.wait_attached(_FUNDAMENTALS_TABLE)
+
+    rows = await browser.table_records(_FUNDAMENTALS_TABLE, header=0)
+    if not rows:
+        return {}
+
+    cleaned_rows: list[dict[str, Any]] = []
+    for r in rows:
+        rr: dict[str, Any] = {}
+        for k, v in r.items():
+            kk = clean_text(k)
+            if not kk:
+                continue
+            rr[kk] = normalize_text(v) if kk == "주요지표" else to_number_or_text(v)
+
+        if rr.get("주요지표"):
+            cleaned_rows.append(rr)
+
+    if not cleaned_rows:
+        return {}
+
+    # columns: 순서 보존 합치기
+    seen: set[str] = set()
+    columns: list[str] = []
+    for rr in cleaned_rows:
+        for kk in rr.keys():
+            if kk not in seen:
+                seen.add(kk)
+                columns.append(kk)
+
+    metric_col = "주요지표" if "주요지표" in columns else columns[0]
+    raw_value_cols = [c for c in columns if c != metric_col]
+
+    # period_cols 정규화(괄호 제거)
+    # ⚠️ "2024/12(A)" / "2025/12" 같은 원본 컬럼명을 유지해야 rr.get(...)이 되므로
+    #    (원본컬럼, 정규화컬럼) 페어로 들고 간다.
+    col_pairs: list[tuple[str, str]] = [(c, _normalize_period_key(c)) for c in raw_value_cols]
+
+    metrics: dict[str, dict[str, Any]] = {}
+
+    for rr in cleaned_rows:
+        name = rr.get(metric_col)
+        if not name:
+            continue
+
+        metric_key = str(name).strip()
+        if metric_key in EXCLUDED_METRICS:
+            continue  # ⬅️ 여기서 제외
+
+        bucket = metrics.setdefault(metric_key, {})
+        for raw_c, norm_c in col_pairs:
+            bucket[norm_c] = rr.get(raw_c)
+
+    return metrics

scraper2_hj3415/app/parsing/c101/major_shareholders.py

@@ -0,0 +1,57 @@
+# scraper2_hj3415/app/parsing/c101/major_shareholders.py
+from __future__ import annotations
+
+from typing import Any
+from scraper2_hj3415.app.ports.browser.browser_port import BrowserPort
+from scraper2_hj3415.app.parsing._normalize.text import normalize_text
+from scraper2_hj3415.app.parsing._normalize.label import normalize_key_label
+from scraper2_hj3415.app.parsing._normalize.values import to_int, to_float
+
+def _pick_value_by_norm_key(row: dict[str, Any], candidates: list[str]) -> Any:
+    # row의 키들을 정규화 맵으로 만든 뒤 후보를 정규화해서 조회
+    norm_map: dict[str, str] = {
+        normalize_key_label(k): k for k in row.keys()
+    }
+    for cand in candidates:
+        rk = norm_map.get(normalize_key_label(cand))
+        if rk is None:
+            continue
+        v = row.get(rk)
+        # "키만 있고 값이 비어있는" 경우 다음 후보 탐색
+        if v is None:
+            continue
+        if isinstance(v, str) and not v.strip():
+            continue
+        return v
+    return None
+
+
+async def parse_c101_major_shareholders(browser: BrowserPort) -> list[dict[str, Any]]:
+    table_sel = "#cTB13"
+    await browser.wait_attached(table_sel)
+
+    records = await browser.table_records(table_sel, header=0)
+
+    if not records:
+        return []
+
+    out: list[dict[str, Any]] = []
+    for r in records:
+        name = normalize_text(_pick_value_by_norm_key(r, ["주요주주", "주요주주명"]))
+        if not name:
+            continue
+
+        shares_raw = _pick_value_by_norm_key(
+            r, ["보유주식수(보통)", "보유주식수", "보유주식수(보통주)"]
+        )
+        ratio_raw = _pick_value_by_norm_key(r, ["보유지분(%)", "보유지분", "보유지분%"])
+
+        out.append(
+            {
+                "주요주주": name,
+                "보유주식수": to_int(shares_raw),  # 파싱 실패 시 None 가능
+                "보유지분": to_float(ratio_raw),  # "0.91%"도 처리되게 파서 보장 필요
+            }
+        )
+
+    return out

scraper2_hj3415/app/parsing/c101/sise.py

@@ -0,0 +1,47 @@
+# scraper2_hj3415/app/parsing/c101/sise.py
+from __future__ import annotations
+
+from scraper2_hj3415.app.ports.browser.browser_port import BrowserPort
+from common_hj3415.utils import clean_text
+from ._sise_normalizer import normalize_sise_kv_map
+
+_SISE_TABLE = "#cTB11"
+
+async def parse_c101_sise_table(browser: BrowserPort) -> dict[str, str]:
+    """
+    #cTB11 시세정보 테이블을 th(항목명) -> td(값) dict로 추출한다.
+    - 화면에 보이는 텍스트 기준(innerText)
+    """
+    await browser.wait_attached(_SISE_TABLE)
+
+    row_cnt = await browser.count_in_nth(
+        _SISE_TABLE,
+        scope_index=0,
+        inner_selector="tbody tr",
+    )
+
+    out: dict[str, str] = {}
+
+    for i in range(1, row_cnt + 1):  # nth-child는 1-based
+        row_sel = f"tbody tr:nth-child({i})"
+
+        key = await browser.inner_text_in_nth(
+            _SISE_TABLE,
+            scope_index=0,
+            inner_selector=f"{row_sel} th",
+            inner_index=0,
+        )
+        val = await browser.inner_text_in_nth(
+            _SISE_TABLE,
+            scope_index=0,
+            inner_selector=f"{row_sel} td",
+            inner_index=0,
+        )
+
+        k = clean_text(key)
+        v = clean_text(val)
+        if k:
+            out[k] = v
+    raw = out
+    return normalize_sise_kv_map(raw)
+

scraper2_hj3415/app/parsing/c101/summary_cmp.py

@@ -0,0 +1,87 @@
+# scraper2_hj3415/app/parsing/c101/summary_cmp.py
+from __future__ import annotations
+
+from typing import Any
+from scraper2_hj3415.app.ports.browser.browser_port import BrowserPort
+from common_hj3415.utils import clean_text
+from scraper2_hj3415.app.parsing._normalize.values import to_number
+
+
+async def parse_c101_summary_cmp_table(browser: BrowserPort) -> dict[str, Any]:
+    """
+    <table class="cmp-table"> (회사 요약 테이블)에서 종목 기본 + EPS/BPS/PER... 등을 추출한다.
+
+    반환 예:
+    {
+      "종목명": "삼성전자",
+      "코드": "005930",
+      "영문명": "SamsungElec",
+      "시장": "KOSPI : 코스피 전기·전자",
+      "WICS": "WICS : 반도체와반도체장비",
+      "EPS": 4816,
+      "BPS": 60632,
+      "PER": 31.58,
+      "업종PER": 21.93,
+      "PBR": 2.51,
+      "현금배당수익률": 0.95,
+      "결산": "12월 결산",
+    }
+    """
+    out: dict[str, Any] = {}
+
+    # 테이블 존재 확인
+    await browser.wait_attached("table.cmp-table")
+
+    # --- 1) td0101: 종목명/코드/영문/시장/WICS ---
+    out["종목명"] = clean_text(
+        await browser.text_content_first("table.cmp-table td.td0101 span.name")
+    )
+    out["코드"] = clean_text(
+        await browser.text_content_first("table.cmp-table td.td0101 b.num")
+    )
+
+    # td0101의 dt 텍스트들을 읽어 분류
+    dt0101 = await browser.all_texts("table.cmp-table td.td0101 dl > dt")
+    for t in dt0101[1:] if dt0101 else []:
+        t = clean_text(t)
+        if not t:
+            continue
+        if t.startswith("KOSPI") or t.startswith("KOSDAQ"):
+            out["시장"] = t
+        elif t.startswith("WICS"):
+            out["WICS"] = t
+        else:
+            if "영문명" not in out:
+                out["영문명"] = t
+
+    # --- 2) td0301: EPS/BPS/PER/업종PER/PBR/현금배당수익률/결산 ---
+    base_dl = "table.cmp-table td.td0301 dl"
+    dt_sel = f"{base_dl} > dt"
+
+    dt_texts = await browser.all_texts(dt_sel)  # dt 전체 텍스트(숫자 포함)
+    if not dt_texts:
+        return out
+
+    # dt는 DOM 상에서 1..N 순서
+    for i, raw_dt in enumerate(dt_texts, start=1):
+        dt_text = clean_text(raw_dt)
+        if not dt_text:
+            continue
+
+        num_sel = f"{base_dl} > dt:nth-child({i}) b.num"
+
+        # 숫자 없는 라인: 예) "12월 결산"
+        if not await browser.is_attached(num_sel):
+            if "결산" in dt_text:
+                out["결산"] = dt_text
+            continue
+
+        num_text = clean_text(await browser.text_content_first(num_sel))
+        if not num_text:
+            continue
+
+        label = clean_text(dt_text.replace(num_text, "")).replace(":", "")
+        if label:
+            out[label] = to_number(num_text)
+
+    return out

scraper2_hj3415/app/parsing/c101/yearly_consensus.py

@@ -0,0 +1,197 @@
+# scraper2_hj3415/app/parsing/c101/yearly_consensus.py
+from __future__ import annotations
+
+from io import StringIO
+import re
+from typing import Any
+
+import pandas as pd
+
+from scraper2_hj3415.app.ports.browser.browser_port import BrowserPort
+from scraper2_hj3415.app.parsing._normalize.values import to_float
+from scraper2_hj3415.app.parsing._normalize.text import normalize_text
+from common_hj3415.utils import clean_text
+from logging_hj3415 import logger
+
+_YEARLY_CONSENSUS_TABLE = "#cTB25"
+
+
+# -----------------------------
+# column / period normalize
+# -----------------------------
+_COL_UNIT_RE = re.compile(r"\([^)]*\)")  # (억원, %), (원), (배) ... 제거용
+_PERIOD_RE = re.compile(r"^\s*(\d{4})\s*\(?([A-Za-z])?\)?\s*$")  # 2022(A), 2025(E)
+
+
+def _flatten_col(col: Any) -> str:
+    """
+    pd.read_html(header=[0,1])로 생긴 MultiIndex 컬럼을 '매출액_금액' 같은 단일 키로 만든다.
+    - ('매출액(억원, %)', '금액') -> '매출액_금액'
+    - ('매출액(억원, %)', 'YoY') -> '매출액_YoY'
+    - 단위 괄호 제거
+    """
+    if isinstance(col, tuple):
+        parts = [clean_text(str(p)) for p in col if clean_text(str(p))]
+        if len(parts) == 2 and parts[0] == parts[1]:
+            s = parts[0]
+        else:
+            s = "_".join(parts) if parts else ""
+    else:
+        s = clean_text(str(col))
+
+    # 단위 괄호 제거
+    s = _COL_UNIT_RE.sub("", s)
+    s = clean_text(s)
+
+    # 컬럼 표기 깨짐 보정
+    s = s.replace("주재 무제표", "주재무제표")
+
+    # 공백 제거(키 안정화)
+    s = s.replace(" ", "")
+    return s
+
+
+def _normalize_period(
+    s: Any,
+    *,
+    keep_suffix: bool = False,
+) -> str | None:
+    """
+    기간 문자열을 표준 period key로 정규화한다.
+
+    - "2022(A)", "2026(E)", "2022" 등을 처리
+    - 기본 정책: 연간 = YYYY/12
+    """
+    t = normalize_text(s)
+    if not t:
+        return None
+
+    # 헤더 방어
+    if t == "재무년월":
+        return None
+
+    # 이미 표준 포맷이면 그대로
+    if re.fullmatch(r"\d{4}/\d{2}", t):
+        return t
+
+    m = _PERIOD_RE.match(t)
+    if not m:
+        return None
+
+    year, suffix = m.groups()  # suffix: "A" | "E" | None
+
+    if keep_suffix and suffix:
+        return f"{year}{suffix}"
+
+    return f"{year}/{12}"
+
+
+def _normalize_metric_key(col_key: str) -> str:
+    """
+    최종 metric key를 사람이 쓰기 좋은 형태로 정리.
+    """
+    k = col_key
+
+    # 매출액은 '금액'/'YoY'가 분리되어 있으니 명시적으로 이름을 고정
+    if k.startswith("매출액_금액"):
+        return "매출액"
+    if k.startswith("매출액_YoY"):
+        return "매출액YoY"
+
+    # 나머지는 그대로(단위/공백은 _flatten_col에서 제거됨)
+    # 예: "영업이익", "당기순이익", "EPS", "PER", "PBR", "ROE", "EV/EBITDA", "순부채비율"
+    return k
+
+
+def _html_to_df(html: str) -> pd.DataFrame | None:
+    """
+    yearly consensus 테이블은 2줄 헤더이므로 header=[0,1]로 읽고 flatten한다.
+    """
+    try:
+        dfs = pd.read_html(StringIO(html), header=[0, 1])
+    except Exception as e:
+        logger.exception("pd.read_html failed: {}", e)
+        return None
+    if not dfs:
+        return None
+    df = dfs[0]
+    if df is None or df.empty:
+        return None
+
+    df = df.copy()
+    df.columns = [_flatten_col(c) for c in df.columns]
+    return df
+
+
+def _df_to_metric_map(df: pd.DataFrame) -> dict[str, dict[str, Any]]:
+    """
+    DataFrame(row: period, col: metric) -> {metric: {period: value}} 로 pivot
+    """
+    if df is None or df.empty:
+        return {}
+
+    # NaN -> None
+    df = df.where(pd.notnull(df), None)
+
+    # '재무년월' 컬럼 찾기(안정)
+    # 보통 "재무년월"로 flatten 되지만, 혹시 깨지는 경우 대비
+    period_col = None
+    for c in df.columns:
+        if "재무년월" == c or c.endswith("재무년월") or "재무년월" in c:
+            period_col = c
+            break
+    if not period_col:
+        logger.warning("[cTB25] period column not found")
+        return {}
+
+    out: dict[str, dict[str, Any]] = {}
+
+    for _, row in df.iterrows():
+        period = _normalize_period(row.get(period_col), keep_suffix=True)
+        if not period:
+            continue
+
+        for col, raw_val in row.items():
+            if col == period_col:
+                continue
+            # 주재무제표는 metric-map에서 제외(원하면 따로 meta로 빼도 됨)
+            if "주재무제표" in str(col):
+                continue
+
+            metric = _normalize_metric_key(str(col))
+
+            num = to_float(raw_val)
+            val: Any = num if num is not None else (normalize_text(raw_val) or None)
+
+            out.setdefault(metric, {})[period] = val
+
+    return out
+
+
+async def parse_c101_yearly_consensus_table(
+    browser: BrowserPort,
+) -> dict[str, dict[str, Any]]:
+    """
+    #cTB25 (3년 실적 + 2년 추정) 테이블을
+    {metric: {period: value}} 형태로 반환한다.
+    """
+    await browser.wait_attached(_YEARLY_CONSENSUS_TABLE)
+    await browser.wait_table_nth_ready(
+        _YEARLY_CONSENSUS_TABLE,
+        index=0,
+        min_rows=5,
+        timeout_ms=30_000,
+        poll_ms=200,
+    )
+
+    html = await browser.outer_html_nth(_YEARLY_CONSENSUS_TABLE, 0)
+    if not html or "<table" not in html:
+        logger.warning("[cTB25] outerHTML invalid or empty")
+        return {}
+
+    df = _html_to_df(html)
+    if df is None:
+        logger.warning("[cTB25] df is empty/invalid")
+        return {}
+
+    return _df_to_metric_map(df)