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

scraper2_hj3415/app/parsing/_normalize/text.py

@@ -0,0 +1,31 @@
+# scraper2_hj3415/app/parsing/_normalize/text.py
+from __future__ import annotations
+
+from typing import Any
+
+from common_hj3415.utils import clean_text
+
+
+def normalize_text(x: object | None) -> str:
+    """
+    임의의 값을 문자열로 정규화한다.
+    - None → ""
+    - 문자열 표현 규칙(clean_text) 적용
+    """
+    s = "" if x is None else str(x)
+    return clean_text(s)
+
+
+_NUM_EMPTY = {"", "-", "N/A", "NA", "null", "None"}
+
+
+def display_text(x: Any) -> str:
+    """
+    출력용 문자열로 정규화한다.
+    - '-', 'N/A' 등 의미 없는 값은 제거
+    """
+    s = normalize_text(x)
+    if not s or s in _NUM_EMPTY:
+        return ""
+    return s
+

scraper2_hj3415/app/parsing/_normalize/values.py

@@ -0,0 +1,70 @@
+# scraper2_hj3415/app/parsing/_normalize/values.py
+from __future__ import annotations
+import re
+from typing import Any
+from scraper2_hj3415.app.parsing._normalize.text import normalize_text
+
+
+def parse_numeric(
+    x: Any,
+    *,
+    strip_units: bool = False,
+    keep_text: bool = False,
+) -> int | float | str | None:
+    """
+    문자열을 숫자로 파싱 시도한다.
+
+    - strip_units=True:
+        '원', '%', '억' 등 단위를 제거한 뒤 숫자 파싱
+    - strip_units=False:
+        순수 숫자만 파싱
+    """
+    s = normalize_text(x)
+    if not s:
+        return None
+
+    t = s.replace(",", "")
+    if strip_units:
+        t = (
+            t.replace("원", "")
+             .replace("억원", "")
+             .replace("억", "")
+             .replace("%", "")
+             .strip()
+        )
+
+    # 정수
+    if re.fullmatch(r"-?\d+", t):
+        return int(t)
+
+    # 실수
+    if re.fullmatch(r"-?\d+(\.\d+)?", t):
+        return float(t)
+
+    return s if keep_text else None
+
+
+def to_number(x: Any) -> int | float | None:
+    """숫자만 허용 (실패 시 None)"""
+    return parse_numeric(x, strip_units=True, keep_text=False)
+
+def to_number_or_text(x: Any) -> float | str | None:
+    """숫자면 숫자, 아니면 텍스트"""
+    return parse_numeric(x, strip_units=True, keep_text=True)
+
+def to_num_or_text(x: Any) -> int | float | str | None:
+    """범용 셀 정규화"""
+    return parse_numeric(x, strip_units=False, keep_text=True)
+
+def to_int(x: Any) -> int | None:
+    v = parse_numeric(x, strip_units=True, keep_text=False)
+    if isinstance(v, (int, float)):
+        return int(v)
+    return None
+
+def to_float(x: Any) -> float | None:
+    v = parse_numeric(x, strip_units=True, keep_text=False)
+    if isinstance(v, (int, float)):
+        return float(v)
+    return None
+

scraper2_hj3415/app/parsing/_tables/html_table.py

@@ -0,0 +1,88 @@
+from typing import Any, Sequence
+
+from io import StringIO
+import pandas as pd
+
+from logging_hj3415 import logger
+from scraper2_hj3415.app.parsing._normalize.table import normalize_metrics_df
+from common_hj3415.utils import clean_text
+
+
+def _flatten_col(col: Any) -> str:
+    """
+    pandas MultiIndex 컬럼(tuple)을 사람이 쓰기 좋은 단일 key로 변환한다.
+    - ('재무년월','재무년월') 같은 중복은 하나로 축약
+    - 단위 문자열 제거
+    - '주재 무제표' 같은 깨진 라벨 보정
+    """
+    if isinstance(col, tuple):
+        parts = [clean_text(p) for p in col if clean_text(p)]
+        if not parts:
+            s = ""
+        elif len(parts) == 2 and parts[0] == parts[1]:
+            s = parts[0]
+        else:
+            s = "_".join(parts)
+    else:
+        s = clean_text(col)
+
+    s = (
+        s.replace("(억원, %)", "")
+        .replace("(원)", "")
+        .replace("(배)", "")
+        .replace("(%)", "")
+        .strip()
+    )
+    s = s.replace("주재 무제표", "주재무제표")
+    return clean_text(s)
+
+
+def try_html_table_to_df(
+    html: str, *, flatten_cols: bool = False, header: int | Sequence[int] = 0
+) -> pd.DataFrame | None:
+    try:
+        dfs = pd.read_html(StringIO(html), header=header)
+    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
+
+    if flatten_cols:
+        df = df.copy()
+        df.columns = [_flatten_col(c) for c in df.columns]
+    return df
+
+
+def df_to_c1034_metric_list(df: pd.DataFrame) -> list[dict[str, Any]]:
+    """
+    C103 테이블 DataFrame -> 정규화된 records(list[dict])
+    - 항목이 비면 제거
+    - 항목_raw(정규화 전 원래 라벨) 보존
+    """
+    if df is None or df.empty:
+        return []
+
+    df = df.copy()
+
+    # 정규화 전에 원래 항목 라벨 보존
+    if "항목" in df.columns:
+        df["항목_raw"] = (
+            df["항목"]
+            .where(df["항목"].notna(), None)
+            .map(lambda x: str(x) if x is not None else None)
+        )
+
+    df = normalize_metrics_df(df)
+
+    records: list[dict[str, Any]] = []
+    for r in df.to_dict(orient="records"):
+        item = r.get("항목")
+        if not item:
+            continue
+        records.append(r)
+    return records
+

scraper2_hj3415/app/parsing/c101/_sise_normalizer.py

@@ -0,0 +1,103 @@
+# scraper2/app/parsing/_sise_normalize.py
+from __future__ import annotations
+
+import re
+from typing import Mapping
+
+# 공통 구분자: 값/키 둘 다 여기로 쪼갬
+_DEFAULT_SEP = "/"
+
+_UNIT_REPLACEMENTS = {
+    "Weeks": "주",
+    "Week": "주",
+    # 필요해지면 여기에 추가
+    # "Days": "일",
+    # "Months": "개월",
+}
+
+
+def _clean_token(s: str) -> str:
+    # 괄호/공백 제거 + 중복 공백 정리
+    s = s.strip()
+    s = s.replace("(", " ").replace(")", " ")
+    s = re.sub(r"\s+", " ", s).strip()
+    return s
+
+
+def _compact_key(s: str) -> str:
+    s = _clean_token(s)
+    s = _replace_units(s)      # ✅ 여기서 Weeks → 주
+    return s.replace(" ", "")
+
+def _split_slash(s: str) -> list[str]:
+    return [p.strip() for p in s.split(_DEFAULT_SEP)]
+
+def _replace_units(s: str) -> str:
+    for src, dst in _UNIT_REPLACEMENTS.items():
+        s = s.replace(src, dst)
+    return s
+
+
+def _maybe_expand_pair_key_value(key: str, value: str) -> dict[str, str] | None:
+    ks = _split_slash(key)
+    vs = _split_slash(value)
+    if len(ks) <= 1 or len(ks) != len(vs):
+        return None
+
+    out: dict[str, str] = {}
+
+    # 1) 특수 케이스: "수익률 (1M/3M/6M/1Y)"
+    first = _clean_token(ks[0])
+    m = re.match(r"^(?P<prefix>.+?)\s+(?P<token>[0-9A-Za-z]+)$", first)
+    if m:
+        prefix = m.group("prefix").strip()
+        token0 = m.group("token").strip()
+        tokens = [token0] + [_clean_token(x) for x in ks[1:]]
+        for tok, v in zip(tokens, vs):
+            out[_compact_key(f"{prefix}{tok}")] = v
+        return out
+
+    # 2) 일반 케이스 + "prefix 전파" (52Weeks 최고/최저 같은 패턴)
+    # 첫 토큰이 "52Weeks 최고"처럼 "prefix + label"이면,
+    # 이후 토큰이 "최저"처럼 prefix가 생략된 경우 prefix를 붙여준다.
+    first_tok = _clean_token(ks[0])
+    m2 = re.match(r"^(?P<prefix>[0-9A-Za-z]+)\s+(?P<label>.+)$", first_tok)
+    if m2:
+        prefix = m2.group("prefix").strip()
+        label0 = m2.group("label").strip()
+        labels = [label0] + [_clean_token(x) for x in ks[1:]]
+        for lab, v in zip(labels, vs):
+            out[_compact_key(f"{prefix}{lab}")] = v
+        return out
+
+    # 3) 완전 일반: 그대로 매칭
+    for k, v in zip(ks, vs):
+        out[_compact_key(k)] = v
+    return out
+
+
+def normalize_sise_kv_map(src: Mapping[str, str]) -> dict[str, str]:
+    """
+    c101 시세 블록(dict[str,str])을 "정규화된 키 dict"로 변환.
+
+    정규화 규칙:
+    - key/value에 "/"가 있고 길이가 맞으면 분해해 여러 항목으로 확장
+      예) "거래량/거래대금" -> "거래량", "거래대금"
+      예) "52Weeks 최고/최저" -> "52Weeks최고", "52Weeks최저"
+      예) "수익률 (1M/3M/6M/1Y)" -> "수익률1M", "수익률3M", ...
+    - 나머지는 key의 공백 제거 정도만 적용해서 유지
+    """
+    out: dict[str, str] = {}
+
+    for k, v in src.items():
+        k = k.strip()
+        v = v.strip()
+
+        expanded = _maybe_expand_pair_key_value(k, v)
+        if expanded:
+            out.update(expanded)
+            continue
+
+        out[_compact_key(k)] = v
+
+    return out

scraper2_hj3415/app/parsing/c101/company_overview.py

@@ -0,0 +1,47 @@
+# scraper2_hj3415/app/parsing/c101/company_overview.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
+
+# 정규표현식
+_DATE_RE = re.compile(r"(\d{4}\.\d{2}\.\d{2})")  # YYYY.MM.DD
+
+async def parse_c101_company_overview(browser: BrowserPort) -> dict[str, Any]:
+    """
+    '기업개요' 섹션에서
+    - 기준일자([기준:YYYY.MM.DD])
+    - 개요 문장들(li.dot_cmp)
+    을 추출한다.
+    """
+    out: dict[str, Any] = {}
+
+    기준_sel = "div.header-table p"
+    개요_ul_sel = "div.cmp_comment ul.dot_cmp"
+    개요_li_sel = "div.cmp_comment ul.dot_cmp > li.dot_cmp"
+
+    # 1) 기준일자
+    await browser.wait_attached(기준_sel)
+    raw = clean_text(await browser.text_content_first(기준_sel))
+
+    m = _DATE_RE.search(raw)
+    out["기준일자"] = m.group(1) if m else raw
+
+    # 2) 개요 문장들
+    await browser.wait_attached(개요_ul_sel)
+    li_texts = await browser.all_texts(개요_li_sel)
+
+    lines: list[str] = []
+    for t in li_texts:
+        ct = clean_text(t)
+        if ct:
+            lines.append(ct)
+
+    # out["개요_리스트"] = lines # 일단 필요 없음
+    out["개요"] = "".join(
+        lines
+    )  # 정책: 저장용이면 join("") 유지, 표시용이면 "\n".join 고려
+
+    return out

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