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

scraper2_hj3415/app/adapters/out/playwright/capabilities/text.py

@@ -0,0 +1,25 @@
+# scraper2_hj3415/app/adapters/out/playwright/capabilities/text.py
+from __future__ import annotations
+from ._base import _PlaywrightBase
+
+
+class PlaywrightText(_PlaywrightBase):
+    async def count(self, selector: str) -> int:
+        return await self._page.locator(selector).count()
+
+    async def text_content_first(self, selector: str) -> str:
+        return (await self._page.locator(selector).first.text_content()) or ""
+
+    async def all_texts(self, selector: str) -> list[str]:
+        loc = self._page.locator(selector)
+        return await loc.all_text_contents()
+
+    async def get_text_by_text(self, needle: str) -> str:
+        return (await self._page.get_by_text(needle).first.text_content()) or ""
+
+    async def inner_text(self, selector: str) -> str:
+        return await self._page.locator(selector).first.inner_text()
+
+    async def outer_html_nth(self, selector: str, index: int) -> str:
+        loc = self._page.locator(selector).nth(index)
+        return await loc.evaluate("el => el.outerHTML")

scraper2_hj3415/app/adapters/out/playwright/capabilities/wait.py

@@ -0,0 +1,96 @@
+# scraper2_hj3415/app/adapters/out/playwright/capabilities/wait.py
+from __future__ import annotations
+
+import asyncio
+import time
+from logging_hj3415 import logger
+from ._base import _PlaywrightBase
+
+class PlaywrightWait(_PlaywrightBase):
+    """
+    wait 관련은 _page만 필요하므로 _PlaywrightBase 상속 안 해도 되지만,
+    여기서는 self._page가 있다고 가정(PlaywrightBrowser가 베이스 제공).
+    """
+
+    async def sleep_ms(self, ms: int) -> None:
+        await asyncio.sleep(ms / 1000)
+
+    async def wait_attached(self, selector: str, *, timeout_ms: int = 10_000) -> None:
+        await self._page.locator(selector).first.wait_for(state="attached", timeout=timeout_ms)
+
+    async def wait_visible(self, selector: str, *, timeout_ms: int = 10_000) -> None:
+        await self._page.locator(selector).first.wait_for(state="visible", timeout=timeout_ms)
+
+    async def wait_table_nth_ready(
+        self,
+        table_selector: str,
+        *,
+        index: int,
+        min_rows: int = 1,
+        timeout_ms: int = 20_000,
+        poll_ms: int = 200,
+    ) -> None:
+        logger.debug("wait for table nth_ready")
+        table = self._page.locator(table_selector).nth(index)
+        await table.wait_for(state="attached", timeout=timeout_ms)
+
+        rows = table.locator("tbody tr")
+        deadline = time.monotonic() + timeout_ms / 1000
+
+        cnt = 0
+        while time.monotonic() < deadline:
+            try:
+                cnt = await rows.count()
+            except Exception:
+                cnt = 0
+
+            if cnt >= min_rows:
+                return
+
+            await asyncio.sleep(poll_ms / 1000)
+
+        logger.warning(f"table rows timeout: last_cnt={cnt}, need>={min_rows}")
+        raise TimeoutError(f"nth table not ready: index={index}, rows<{min_rows}")
+
+    async def wait_table_text_changed(
+        self,
+        table_selector: str,
+        *,
+        index: int,
+        prev_text: str | None,
+        min_rows: int = 1,
+        min_lines: int = 50,
+        timeout_sec: float = 12.0,
+        poll_sec: float = 0.2,
+    ) -> str:
+        # 0) row 기준 ready
+        await self.wait_table_nth_ready(
+            table_selector,
+            index=index,
+            min_rows=min_rows,
+            timeout_ms=int(timeout_sec * 1000),
+            poll_ms=int(poll_sec * 1000),
+        )
+
+        start = time.monotonic()
+        last_text = ""
+
+        while True:
+            loc = self._page.locator(table_selector).nth(index)
+            try:
+                text = await loc.inner_text()
+            except Exception:
+                text = ""
+
+            lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
+            is_valid = len(lines) >= min_lines
+
+            if is_valid:
+                last_text = text
+                if prev_text is None or text != prev_text:
+                    return text
+
+            if time.monotonic() - start >= timeout_sec:
+                return last_text
+
+            await asyncio.sleep(poll_sec)

scraper2_hj3415/app/adapters/out/sinks/memory_sink.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 from typing import Iterable
 
 from contracts_hj3415.nfs.nfs_dto import NfsDTO
-from contracts_hj3415.nfs.types import Endpoints
+from contracts_hj3415.nfs.types import Endpoint
 
 from scraper2_hj3415.app.adapters.out.sinks.store import InMemoryStore
 
@@ -13,13 +13,13 @@ class MemorySink:
     def __init__(self, store: InMemoryStore[NfsDTO]):
         self._store = store
 
-    async def write(self, dto: NfsDTO, *, endpoint: Endpoints) -> None:
+    async def write(self, dto: NfsDTO, *, endpoint: Endpoint) -> None:
         await self._store.put(endpoint, dto.code, dto)
 
     async def write_many(
         self,
         dtos: Iterable[NfsDTO],
         *,
-        endpoint: Endpoints,
+        endpoint: Endpoint,
     ) -> None:
         await self._store.put_many(endpoint, ((d.code, d) for d in dtos))

scraper2_hj3415/app/adapters/out/sinks/mongo_sink.py

@@ -7,13 +7,13 @@ from typing import Iterable
 from pymongo.asynchronous.database import AsyncDatabase
 
 from contracts_hj3415.nfs.nfs_dto import NfsDTO
-from contracts_hj3415.nfs.types import Endpoints
+from contracts_hj3415.nfs.types import Endpoint
 
 from db2_hj3415.nfs.repo import (
-    upsert_latest_payload,
-    upsert_latest_payload_many,
-    insert_snapshot_payload,
-    insert_snapshots_payload_many,
+    upsert_latest,
+    upsert_latest_many,
+    insert_snapshot,
+    insert_snapshots_many,
 )
 
 
@@ -21,17 +21,17 @@ class MongoSink:
     def __init__(self, db: AsyncDatabase):
         self._db = db
 
-    async def write(self, dto: NfsDTO, *, endpoint: Endpoints) -> None:
+    async def write(self, dto: NfsDTO, *, endpoint: Endpoint) -> None:
         code = str(dto.code).strip()
         if not code:
             return
 
         payload = dict(dto.payload)  # Mapping 방어
 
-        await upsert_latest_payload(
+        await upsert_latest(
             self._db, endpoint=endpoint, code=code, payload=payload, asof=dto.asof
         )
-        await insert_snapshot_payload(
+        await insert_snapshot(
             self._db, endpoint=endpoint, code=code, payload=payload, asof=dto.asof
         )
 
@@ -39,7 +39,7 @@ class MongoSink:
         self,
         dtos: Iterable[NfsDTO],
         *,
-        endpoint: Endpoints,
+        endpoint: Endpoint,
     ) -> None:
         items: dict[str, dict] = {}
         ts: datetime | None = None
@@ -55,9 +55,9 @@ class MongoSink:
         if not items:
             return
 
-        await upsert_latest_payload_many(
+        await upsert_latest_many(
             self._db, endpoint=endpoint, items=items, asof=ts
         )
-        await insert_snapshots_payload_many(
+        await insert_snapshots_many(
             self._db, endpoint=endpoint, items=items, asof=ts
         )

scraper2_hj3415/app/adapters/site/wisereport_playwright.py

@@ -1,15 +1,19 @@
 # scraper2_hj3415/app/adapters/site/wisereport_playwright.py
 from __future__ import annotations
 
+import re
 from scraper2_hj3415.app.ports.browser.browser_port import BrowserPort
+from scraper2_hj3415.app.ports.site.wisereport_port import WiseReportPort
 from logging_hj3415 import logger
 
+_Q_SIGNAL_RE = re.compile(r"/(03|06|09)\b")
 
-class WiseReportPlaywright:
+
+class WiseReportPlaywright(WiseReportPort):
     def __init__(self, browser: BrowserPort):
         self.browser = browser
 
-    async def ensure_yearly_consensus_open_in_table_nth(
+    async def _ensure_yearly_consensus_open_in_table_nth(
         self,
         *,
         table_selector: str,  # 예: TABLE_XPATH ("xpath=//div[@id='wrapper']//div//table")
@@ -150,19 +154,226 @@ class WiseReportPlaywright:
         logger.warning("ensure_yearly_consensus_open_in_table_nth: exceeded max_rounds")
         return False
 
-    async def click_steps(
+    async def _click_steps(
         self,
         steps: list[tuple[str, str]],
         *,
         jitter_sec: float = 0.6,
     ) -> None:
-        """
-        현재 페이지에서 탭/라디오/검색 버튼 클릭만 수행.
-        """
         for _name, selector in steps:
             await self.browser.wait_attached(selector)
+            await self.browser.scroll_into_view(selector)
+
             logger.info(f"click step: {_name}")
-            await self.browser.click(selector)
-            # 서버/클라이언트 부담 줄이기: 작은 지터
-            wait = int((0.5 + (jitter_sec * 0.5))*1000)
+
+            ok = await self.browser.try_click(selector, timeout_ms=1500, force=False)
+            try:
+                if ok:
+                    await self.browser.click(selector, timeout_ms=4000, force=False)
+                else:
+                    await self.browser.click(selector, timeout_ms=4000, force=True)
+            except Exception:
+                await self.browser.click(selector, timeout_ms=4000, force=True)
+
+            wait = int((0.5 + (jitter_sec * 0.5)) * 1000)
             await self.browser.sleep_ms(wait)
+
+    async def _is_quarter_view_by_header(
+        self, *, table_selector: str, table_index: int
+    ) -> tuple[bool, list[str]]:
+        """
+        분기 화면 판정:
+          - 헤더에 YYYY/03 or YYYY/06 or YYYY/09 가 하나라도 있으면 분기 화면으로 확정
+          - YYYY/12만 있는 경우는 (분기 전환 실패 가능성이 높으니) 분기 화면으로 보지 않음
+        """
+        periods = await self.browser.table_header_periods_mm_nth(
+            table_selector, index=table_index
+        )
+        is_q = any(_Q_SIGNAL_RE.search(p) for p in periods)
+        return is_q, periods
+
+    async def set_view_c103(
+        self,
+        *,
+        key: str,
+        steps: list[tuple[str, str]],
+        table_selector: str,
+        table_index: int,
+        max_attempts: int = 5,
+        stabilize_timeout_sec: float = 10.0,
+    ) -> None:
+        """
+        c103 화면을 원하는 상태(key)에 맞게 '확정'한다.
+        - key.endswith("q") => 분기 화면이어야 함
+        - key.endswith("y") => 연간 화면이어야 함  (즉 분기 시그널이 없어야 함)
+
+        클릭 -> 안정화(wait_table_text_changed) -> 헤더 판정 -> 실패 시 복구/재시도.
+        """
+        want_q = key.endswith("q")
+        last_periods: list[str] = []
+        last_is_q: bool | None = None
+
+        for attempt in range(1, max_attempts + 1):
+            logger.info(f"set_view_c103: key={key} attempt={attempt} want_q={want_q}")
+
+            # 1) 클릭 (가벼운 지터 포함)
+            await self._click_steps(steps, jitter_sec=0.6)
+
+            # 2) 토글 펼치기 (네 함수 그대로 사용)
+            try:
+                await self._ensure_yearly_consensus_open_in_table_nth(
+                    table_selector=table_selector,
+                    table_index=table_index,
+                )
+            except Exception as e:
+                logger.debug(f"ensure open failed (ignored): {type(e).__name__}: {e}")
+
+            # 3) 렌더 안정화: '변경'은 보장 못하지만, 로딩 흔들림을 줄여줌
+            try:
+                _ = await self.browser.wait_table_text_changed(
+                    table_selector,
+                    index=table_index,
+                    prev_text=None,
+                    min_rows=5,
+                    min_lines=30,
+                    timeout_sec=stabilize_timeout_sec,
+                )
+            except Exception as e:
+                logger.debug(
+                    f"stabilize wait failed (ignored): {type(e).__name__}: {e}"
+                )
+
+            # 4) 헤더로 상태 확정
+            is_q, periods = await self._is_quarter_view_by_header(
+                table_selector=table_selector,
+                table_index=table_index,
+            )
+            last_is_q, last_periods = is_q, periods
+
+            logger.info(
+                f"set_view_c103: key={key} header periods(head)={periods[:8]} is_q={is_q}"
+            )
+
+            if want_q == is_q:
+                return  # ✅ 성공 확정
+
+            # 5) 실패 시 복구 전략
+            # attempt가 올라갈수록 강하게: 스크롤/force click은 click_steps 쪽을 강화하는 게 좋지만
+            # 여기서는 reload로 리셋을 걸어준다.
+            if attempt in (2, 4):
+                logger.warning(f"set_view_c103 mismatch -> reload | key={key}")
+                await self.browser.reload(timeout_ms=12_000)
+            await self.browser.sleep_ms(250)
+
+        raise RuntimeError(
+            f"set_view_c103 failed: key={key} want_q={want_q} last_is_q={last_is_q} "
+            f"last_periods={last_periods[:12]}"
+        )
+
+    async def set_view_c104(
+        self,
+        *,
+        key: str,
+        steps: list[tuple[str, str]],
+        table_selector: str,
+        table_index: int,
+        prev_text_by_idx: dict[int, str | None],
+        max_attempts: int = 5,
+        stabilize_timeout_sec: float = 10.0,
+        min_rows: int = 5,
+        min_lines: int = 30,
+        open_consensus: bool = True,
+    ) -> None:
+        """
+        c104 화면을 원하는 상태(key)에 맞게 '확정'한다.
+
+        - key.endswith("q") => 분기 화면이어야 함 (헤더에 03/06/09 존재)
+        - key.endswith("y") => 연간 화면이어야 함 (헤더에 03/06/09 없어야 함, 12는 보통 존재)
+
+        절차:
+        1) 클릭 steps
+        2) (옵션) 연간컨센서스 펼치기
+        3) wait_table_text_changed (idx별 prev_text 추적)
+        4) header periods로 q/y 판정
+        5) mismatch면 reload/재시도
+        """
+        want_q = key.endswith("q")
+
+        # idx별 prev_text 초기값 방어
+        if table_index not in prev_text_by_idx:
+            prev_text_by_idx[table_index] = None
+
+        last_periods: list[str] = []
+        last_is_q: bool | None = None
+
+        for attempt in range(1, max_attempts + 1):
+            logger.info(
+                f"set_view_c104: key={key} idx={table_index} attempt={attempt} want_q={want_q}"
+            )
+
+            # 1) 클릭(행동)
+            await self._click_steps(steps, jitter_sec=0.6)
+
+            # 2) 컨센서스 펼치기(옵션)
+            if open_consensus:
+                try:
+                    await self._ensure_yearly_consensus_open_in_table_nth(
+                        table_selector=table_selector,
+                        table_index=table_index,
+                        wait_timeout_sec=stabilize_timeout_sec,
+                    )
+                except Exception as e:
+                    logger.debug(
+                        f"ensure open failed (ignored): {type(e).__name__}: {e}"
+                    )
+
+            # 3) 안정화(변경/유효 텍스트 대기) - idx별로 prev 추적
+            try:
+                prev_text_by_idx[
+                    table_index
+                ] = await self.browser.wait_table_text_changed(
+                    table_selector,
+                    index=table_index,
+                    prev_text=prev_text_by_idx[table_index],
+                    min_rows=min_rows,
+                    min_lines=min_lines,
+                    timeout_sec=stabilize_timeout_sec,
+                )
+            except Exception as e:
+                logger.debug(
+                    f"stabilize wait failed (ignored): {type(e).__name__}: {e}"
+                )
+
+            # 4) 헤더로 상태 확정
+            is_q, periods = await self._is_quarter_view_by_header(
+                table_selector=table_selector,
+                table_index=table_index,
+            )
+            last_is_q, last_periods = is_q, periods
+
+            logger.info(
+                f"set_view_c104: key={key} idx={table_index} periods(head)={periods[:8]} is_q={is_q}"
+            )
+
+            # periods 자체가 비면 "불확정"으로 보고 재시도하는 게 안전
+            if not periods:
+                logger.warning(
+                    f"set_view_c104: header periods empty -> retry | key={key} idx={table_index}"
+                )
+            else:
+                if want_q == is_q:
+                    return  # ✅ 성공 확정
+
+            # 5) 실패 복구 전략
+            if attempt in (2, 4):
+                logger.warning(
+                    f"set_view_c104 mismatch/uncertain -> reload | key={key}"
+                )
+                await self.browser.reload(timeout_ms=12_000)
+
+            await self.browser.sleep_ms(250)
+
+        raise RuntimeError(
+            f"set_view_c104 failed: key={key} idx={table_index} want_q={want_q} "
+            f"last_is_q={last_is_q} last_periods={last_periods[:8]}"
+        )

scraper2_hj3415/app/domain/constants.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from typing import Mapping
 
-from contracts_hj3415.nfs.types import BlockKeys
+from contracts_hj3415.nfs.types import BlockKey
 from contracts_hj3415.nfs.constants import C101_BLOCK_KEYS, C103_BLOCK_KEYS, C104_BLOCK_KEYS, C106_BLOCK_KEYS, C108_BLOCK_KEYS
 from scraper2_hj3415.app.domain.endpoint import EndpointKind
 
@@ -25,7 +25,7 @@ def get_block_keys(endpoint: EndpointKind) -> tuple[str, ...]:
     return BLOCK_KEYS_BY_ENDPOINT.get(endpoint, ())
 
 
-def is_known_block(endpoint: EndpointKind, key: BlockKeys) -> bool:
+def is_known_block(endpoint: EndpointKind, key: BlockKey) -> bool:
     """
     블록 키가 해당 endpoint의 공식 목록에 포함되는지 여부.
     (검증/필터링/동적 payload merge 등에 사용)

scraper2_hj3415/app/parsing/_tables/html_table.py

@@ -5,6 +5,7 @@ import pandas as pd
 
 from logging_hj3415 import logger
 from scraper2_hj3415.app.parsing._normalize.table import normalize_metrics_df
+from scraper2_hj3415.app.parsing._normalize.label import sanitize_label
 from common_hj3415.utils import clean_text
 
 
@@ -68,12 +69,12 @@ def df_to_c1034_metric_list(df: pd.DataFrame) -> list[dict[str, Any]]:
 
     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)
+            .map(lambda x: sanitize_label(x) if x is not None else None)
         )
 
     df = normalize_metrics_df(df)

scraper2_hj3415/app/parsing/c103_parser.py

@@ -3,7 +3,10 @@ from __future__ import annotations
 from typing import Any
 
 from scraper2_hj3415.app.ports.browser.browser_port import BrowserPort
-from scraper2_hj3415.app.parsing._tables.html_table import try_html_table_to_df, df_to_c1034_metric_list
+from scraper2_hj3415.app.parsing._tables.html_table import (
+    try_html_table_to_df,
+    df_to_c1034_metric_list,
+)
 
 TABLE_XPATH = "xpath=//div[@id='wrapper']//div//table"
 TABLE_INDEX = 2

scraper2_hj3415/app/parsing/c104_parser.py

@@ -4,7 +4,10 @@ from __future__ import annotations
 from typing import Any
 
 from scraper2_hj3415.app.ports.browser.browser_port import BrowserPort
-from scraper2_hj3415.app.parsing._tables.html_table import try_html_table_to_df, df_to_c1034_metric_list
+from scraper2_hj3415.app.parsing._tables.html_table import (
+    try_html_table_to_df,
+    df_to_c1034_metric_list,
+)
 
 TABLE_XPATH = 'xpath=//table[@class="gHead01 all-width data-list"]'
 

scraper2_hj3415/app/ports/browser/browser_port.py

@@ -1,115 +1,32 @@
 # scraper2_hj3415/app/ports/browser/browser_port.py
 from __future__ import annotations
 
-from typing import Protocol, Any
+from typing import Protocol
 
+from .capabilities import (
+    BrowserInteractionPort,
+    BrowserNavigationPort,
+    BrowserScopePort,
+    BrowserTablePort,
+    BrowserTextPort,
+    BrowserWaitPort,
+)
 
-class BrowserPort(Protocol):
-    async def wait_table_nth_ready(
-            self,
-            table_selector: str,
-            *,
-            index: int,
-            min_rows: int = 1,
-            timeout_ms: int = 20_000,
-            poll_ms: int = 200,
-    ) -> None: ...
-    async def title(self) -> str: ...
-    async def current_url(self) -> str: ...
-    async def goto_and_wait_for_stable(self, url: str, timeout_ms: int = 10_000) -> None: ...
-    async def reload(self, *, timeout_ms: int = 10_000) -> None: ...
-    async def sleep_ms(self, ms: int) -> None: ...
-    async def wait_attached(
-        self, selector: str, *, timeout_ms: int = 10_000
-    ) -> None: ...
-    async def wait_visible(
-        self, selector: str, *, timeout_ms: int = 10_000
-    ) -> None: ...
-    async def click(
-        self,
-        selector: str,
-        *,
-        index: int = 0,
-        timeout_ms: int = 4_000,
-        force: bool = False,
-    ) -> None: ...
-    async def try_click(
-        self,
-        selector: str,
-        *,
-        index: int = 0,
-        timeout_ms: int = 1_500,
-        force: bool = False,
-    ) -> bool: ...
-    async def count(self, selector: str) -> int: ...
-    async def scroll_into_view(self, selector: str, *, index: int = 0) -> None: ...
-    async def text_content_first(self, selector: str) -> str: ...
-    async def all_texts(self, selector: str) -> list[str]: ...
-    async def get_text_by_text(self, needle: str) -> str: ...
-    async def inner_text(self, selector: str) -> str: ...
-    async def outer_html_nth(self, selector: str, index: int) -> str: ...
-    async def wait_table_text_changed(
-            self,
-            table_selector: str,
-            *,
-            index: int,
-            prev_text: str | None,
-            min_rows: int = 1,
-            min_lines: int = 50,
-            timeout_sec: float = 12.0,
-            poll_sec: float = 0.2,
-    ) -> str: ...
-    async def is_attached(self, selector: str, *, index: int = 0) -> bool: ...
-    async def computed_style(
-        self, selector: str, *, index: int = 0, prop: str
-    ) -> str: ...
-    async def count_in_nth(
-        self,
-        scope_selector: str,
-        *,
-        scope_index: int,
-        inner_selector: str,
-    ) -> int: ...
-    async def eval_in_nth_first(
-        self,
-        scope_selector: str,
-        *,
-        scope_index: int,
-        inner_selector: str,
-        expression: str,
-    ) -> Any: ...
-    async def inner_text_in_nth(
-        self,
-        scope_selector: str,
-        *,
-        scope_index: int,
-        inner_selector: str,
-        inner_index: int = 0,
-        timeout_ms: int = 10_000,
-    ) -> str:
-        """
-        scope_selector의 nth(scope_index) 요소 안에서
-        inner_selector의 nth(inner_index) 요소의 innerText를 반환.
-        (렌더링 기준 텍스트: 줄바꿈/스타일 영향 반영)
-        """
-        ...
 
-    async def text_content_in_nth(
-        self,
-        scope_selector: str,
-        *,
-        scope_index: int,
-        inner_selector: str,
-        inner_index: int = 0,
-        timeout_ms: int = 10_000,
-    ) -> str:
-        """
-        scope_selector의 nth(scope_index) 요소 안에서
-        inner_selector의 nth(inner_index) 요소의 textContent를 반환.
-        (DOM 기준 텍스트: 숨김 텍스트도 포함될 수 있음)
-        """
-        ...
+class BrowserPort(
+    BrowserNavigationPort,
+    BrowserWaitPort,
+    BrowserInteractionPort,
+    BrowserTextPort,
+    BrowserScopePort,
+    BrowserTablePort,
+    Protocol,
+):
+    """
+    프로젝트에서 사용하는 최종 BrowserPort.
 
-    async def table_records(
-        self, table_selector: str, *, header: int | list[int] | None = 0
-    ) -> list[dict[str, Any]]: ...
+    - 내부는 capability 단위로 분리되어 있으며,
+      필요하면 파서/유스케이스가 BrowserPort 대신
+      특정 capability 포트만 의존하도록 바꿀 수 있다.
+    """
+    ...