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

scraper2_hj3415/app/usecases/ingest/ingest_c104.py

@@ -0,0 +1,182 @@
+# scraper2_hj3415/app/usecases/ingest/ingest_c104.py
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Iterable, Optional, cast
+
+from scraper2_hj3415.app.services.fetch.fetch_c104 import FetchC104
+from scraper2_hj3415.app.ports.sinks.nfs_sink_port import NfsSinkPort
+from common_hj3415.utils.time import utcnow
+
+from scraper2_hj3415.app.domain.endpoint import EndpointKind
+from scraper2_hj3415.app.domain.constants import get_block_keys
+from scraper2_hj3415.app.domain.doc import NfsDoc
+from scraper2_hj3415.app.domain.blocks import MetricsBlock
+
+from contracts_hj3415.nfs.types import Endpoint
+
+from contracts_hj3415.nfs.c104_dto import (
+    C104DTO,
+    C104Payload,
+    C104Blocks,
+    C104Labels,
+    C104ValuesMap,
+)
+
+from logging_hj3415 import logger
+
+
+endpoint_kind = EndpointKind.C104
+endpoint: Endpoint = cast(Endpoint, endpoint_kind.value)
+
+
+def _metricsblock_to_c104_metric_map(block: MetricsBlock) -> dict[str, C104ValuesMap]:
+    """
+    MetricsBlock(domain) -> dict[MetricKey, dict[CodeKey, Num]]
+    - domain MetricSeries.values 가 이미 {code: num} 형태라면 그대로 dict로 고정시킴.
+    """
+    out: dict[str, C104ValuesMap] = {}
+    for mk, series in block.metrics.items():
+        out[mk] = dict(series.values)  # Mapping -> dict
+    return out
+
+
+def c104_doc_to_dto(*, doc: NfsDoc, asof: datetime) -> C104DTO:
+    """
+    NfsDoc(domain, endpoint=c104) -> C104DTO(contracts envelope)
+
+    C104Payload 구조:
+      {
+        "blocks": {"수익성y": {metric: {code: num}}, "성장성y": {...}},
+        "labels": {"수익성y": {metric: raw_label}, "성장성y": {...}}
+      }
+
+    정책:
+      - blocks/labels는 항상 y/q 키를 가진다. (없으면 빈 dict)
+      - doc.labels는 없을 수도 있으니 dict()로 안전 변환
+    """
+    # 1) 기본 골격은 항상 채운다 (규약 안정성)
+    blocks: C104Blocks = {
+        "수익성y": {},
+        "성장성y": {},
+        "안정성y": {},
+        "활동성y": {},
+        "가치분석y": {},
+        "수익성q": {},
+        "성장성q": {},
+        "안정성q": {},
+        "활동성q": {},
+        "가치분석q": {},
+    }
+    labels: C104Labels = {
+        "수익성y": {},
+        "성장성y": {},
+        "안정성y": {},
+        "활동성y": {},
+        "가치분석y": {},
+        "수익성q": {},
+        "성장성q": {},
+        "안정성q": {},
+        "활동성q": {},
+        "가치분석q": {},
+    }
+
+    # 2) 도메인 블록키 순서/목록 기준으로 채움
+    for bk in get_block_keys(endpoint_kind):
+        bd = doc.blocks.get(bk)
+        if bd is None:
+            continue
+
+        if not isinstance(bd, MetricsBlock):
+            raise TypeError(
+                f"c104 expects MetricsBlock, got {type(bd).__name__} | block_key={bk!r}"
+            )
+
+        metric_map = _metricsblock_to_c104_metric_map(bd)
+        label_map = dict(doc.labels.get(bk, {}))  # 없으면 {}
+
+        match bk:
+            case "수익성y":
+                blocks["수익성y"] = metric_map
+                labels["수익성y"] = label_map
+            case "성장성y":
+                blocks["성장성y"] = metric_map
+                labels["성장성y"] = label_map
+            case "안정성y":
+                blocks["안정성y"] = metric_map
+                labels["안정성y"] = label_map
+            case "활동성y":
+                blocks["활동성y"] = metric_map
+                labels["활동성y"] = label_map
+            case "가치분석y":
+                blocks["가치분석y"] = metric_map
+                labels["가치분석y"] = label_map
+            case "수익성q":
+                blocks["수익성q"] = metric_map
+                labels["수익성q"] = label_map
+            case "성장성q":
+                blocks["성장성q"] = metric_map
+                labels["성장성q"] = label_map
+            case "안정성q":
+                blocks["안정성q"] = metric_map
+                labels["안정성q"] = label_map
+            case "활동성q":
+                blocks["활동성q"] = metric_map
+                labels["활동성q"] = label_map
+            case "가치분석q":
+                blocks["가치분석q"] = metric_map
+                labels["가치분석q"] = label_map
+            case _:
+                raise ValueError(f"invalid C104 block key: {bk!r}")
+
+    payload: C104Payload = cast(C104Payload, {"blocks": blocks, "labels": labels})
+
+    # ⚠️ TypedDict는 런타임 검증이 아니라 타입체커용이므로,
+    # C104Payload(**payload) 같은 생성은 불가능(=TypedDict는 호출 불가)
+    return C104DTO(
+        code=doc.code,
+        asof=asof,
+        endpoint=endpoint,
+        payload=payload,  # 그대로 dict 주입
+    )
+
+
+class IngestC104:
+    def __init__(self, fetch: FetchC104, sink: NfsSinkPort[C104DTO]):
+        self.fetch = fetch
+        self.sink = sink
+
+    async def execute(
+        self,
+        code: str,
+        *,
+        sleep_sec: float = 2.0,
+        asof: datetime | None = None,
+    ) -> C104DTO:
+        asof = asof or utcnow()
+
+        doc = await self.fetch.execute(code, sleep_sec=sleep_sec)
+        logger.debug(f"doc:\n{doc}")
+        if doc is None:
+            raise RuntimeError(f"c106 fetch returned None: code={code}")
+
+        dto = c104_doc_to_dto(doc=doc, asof=asof)
+        logger.debug(f"dto:\n{dto}")
+
+        await self.sink.write(dto, endpoint=endpoint)
+        return dto
+
+    async def execute_many(
+        self,
+        codes: Iterable[str],
+        *,
+        sleep_sec: float = 2.0,
+        asof: Optional[datetime] = None,
+    ) -> list[C104DTO]:
+        batch_asof = asof or utcnow()
+
+        docs = await self.fetch.execute_many(codes, sleep_sec=sleep_sec)
+        dtos = [c104_doc_to_dto(doc=d, asof=batch_asof) for d in docs]
+        logger.debug(f"dtos:\n{dtos}")
+        await self.sink.write_many(dtos, endpoint=endpoint)
+        return dtos

scraper2_hj3415/app/usecases/ingest/ingest_c106.py

@@ -0,0 +1,136 @@
+# scraper2_hj3415/app/usecases/ingest/ingest_c106.py
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Iterable, Optional, cast
+
+from scraper2_hj3415.app.services.fetch.fetch_c106 import FetchC106
+from scraper2_hj3415.app.ports.sinks.nfs_sink_port import NfsSinkPort
+from common_hj3415.utils.time import utcnow
+
+from scraper2_hj3415.app.domain.endpoint import EndpointKind
+from scraper2_hj3415.app.domain.constants import get_block_keys
+from scraper2_hj3415.app.domain.doc import NfsDoc
+from scraper2_hj3415.app.domain.blocks import MetricsBlock
+
+from contracts_hj3415.nfs.types import Endpoint
+
+from contracts_hj3415.nfs.c106_dto import (
+    C106DTO,
+    C106Payload,
+    C106Blocks,
+    C106Labels,
+    C106ValuesMap,
+)
+
+from logging_hj3415 import logger
+
+
+endpoint_kind = EndpointKind.C106
+endpoint: Endpoint = cast(Endpoint, endpoint_kind.value)
+
+
+def _metricsblock_to_c106_metric_map(block: MetricsBlock) -> dict[str, C106ValuesMap]:
+    """
+    MetricsBlock(domain) -> dict[MetricKey, dict[CodeKey, Num]]
+    - domain MetricSeries.values 가 이미 {code: num} 형태라면 그대로 dict로 고정시킴.
+    """
+    out: dict[str, C106ValuesMap] = {}
+    for mk, series in block.metrics.items():
+        out[mk] = dict(series.values)  # Mapping -> dict
+    return out
+
+
+def c106_doc_to_dto(*, doc: NfsDoc, asof: datetime) -> C106DTO:
+    """
+    NfsDoc(domain, endpoint=c106) -> C106DTO(contracts envelope)
+
+    C106Payload 구조:
+      {
+        "blocks": {"y": {metric: {code: num}}, "q": {...}},
+        "labels": {"y": {metric: raw_label}, "q": {...}}
+      }
+
+    정책:
+      - blocks/labels는 항상 y/q 키를 가진다. (없으면 빈 dict)
+      - doc.labels는 없을 수도 있으니 dict()로 안전 변환
+    """
+    # 1) 기본 골격은 항상 채운다 (규약 안정성)
+    blocks: C106Blocks = {"y": {}, "q": {}}
+    labels: C106Labels = {"y": {}, "q": {}}
+
+    # 2) 도메인 블록키 순서/목록 기준으로 채움
+    for bk in get_block_keys(endpoint_kind):
+        bd = doc.blocks.get(bk)
+        if bd is None:
+            continue
+
+        if not isinstance(bd, MetricsBlock):
+            raise TypeError(
+                f"c106 expects MetricsBlock, got {type(bd).__name__} | block_key={bk!r}"
+            )
+
+        metric_map = _metricsblock_to_c106_metric_map(bd)
+        label_map = dict(doc.labels.get(bk, {}))  # 없으면 {}
+
+        match bk:
+            case "y":
+                blocks["y"] = metric_map
+                labels["y"] = label_map
+            case "q":
+                blocks["q"] = metric_map
+                labels["q"] = label_map
+            case _:
+                raise ValueError(f"invalid c106 block key: {bk!r}")
+
+    payload: C106Payload = cast(C106Payload, {"blocks": blocks, "labels": labels})
+
+    # ⚠️ TypedDict는 런타임 검증이 아니라 타입체커용이므로,
+    # C106Payload(**payload) 같은 생성은 불가능(=TypedDict는 호출 불가)
+    return C106DTO(
+        code=doc.code,
+        asof=asof,
+        endpoint=endpoint,
+        payload=payload,  # 그대로 dict 주입
+    )
+
+
+class IngestC106:
+    def __init__(self, fetch: FetchC106, sink: NfsSinkPort[C106DTO]):
+        self.fetch = fetch
+        self.sink = sink
+
+    async def execute(
+        self,
+        code: str,
+        *,
+        sleep_sec: float = 2.0,
+        asof: datetime | None = None,
+    ) -> C106DTO:
+        asof = asof or utcnow()
+
+        doc = await self.fetch.execute(code, sleep_sec=sleep_sec)
+        logger.debug(f"doc:\n{doc}")
+        if doc is None:
+            raise RuntimeError(f"c106 fetch returned None: code={code}")
+
+        dto = c106_doc_to_dto(doc=doc, asof=asof)
+        logger.debug(f"dto:\n{dto}")
+
+        await self.sink.write(dto, endpoint=endpoint)
+        return dto
+
+    async def execute_many(
+        self,
+        codes: Iterable[str],
+        *,
+        sleep_sec: float = 2.0,
+        asof: Optional[datetime] = None,
+    ) -> list[C106DTO]:
+        batch_asof = asof or utcnow()
+
+        docs = await self.fetch.execute_many(codes, sleep_sec=sleep_sec)
+        dtos = [c106_doc_to_dto(doc=d, asof=batch_asof) for d in docs]
+        logger.debug(f"dtos:\n{dtos}")
+        await self.sink.write_many(dtos, endpoint=endpoint)
+        return dtos

scraper2_hj3415/app/usecases/ingest/ingest_c108.py

@@ -0,0 +1,122 @@
+# scraper2_hj3415/app/usecases/ingest/ingest_c108.py
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Iterable, Optional, cast
+
+from scraper2_hj3415.app.services.fetch.fetch_c108 import FetchC108
+from scraper2_hj3415.app.ports.sinks.nfs_sink_port import NfsSinkPort
+from common_hj3415.utils.time import utcnow
+
+from scraper2_hj3415.app.domain.endpoint import EndpointKind
+from scraper2_hj3415.app.domain.constants import get_block_keys
+from scraper2_hj3415.app.domain.doc import NfsDoc
+from scraper2_hj3415.app.domain.blocks import RecordsBlock
+
+from contracts_hj3415.nfs.types import Endpoint
+
+from contracts_hj3415.nfs.c108_dto import C108DTO, C108Payload, C108Blocks
+
+from logging_hj3415 import logger
+
+endpoint_kind = EndpointKind.C108
+endpoint: Endpoint = cast(Endpoint, endpoint_kind.value)
+
+
+def _to_list_of_dict(rows: object) -> list[dict]:
+    """
+    RecordsBlock.rows(Sequence[Mapping]) -> list[dict]
+    - sink/serialization 안전하게 dict로 강제
+    """
+    if not rows:
+        return []
+    out: list[dict] = []
+    if isinstance(rows, list):
+        for r in rows:
+            if isinstance(r, dict):
+                out.append(r)
+            else:
+                out.append(dict(r))  # Mapping이면 dict() 가능
+        return out
+
+    # Sequence[Mapping] 일반 케이스
+    try:
+        for r in rows:  # type: ignore[assignment]
+            out.append(dict(r))  # Mapping 가정
+    except Exception:
+        return []
+    return out
+
+
+def c108_doc_to_dto(*, doc: NfsDoc, asof: datetime) -> C108DTO:
+    """
+    NfsDoc(domain) -> C108DTO(contracts envelope)
+
+    규칙:
+      - labels는 항상 존재(빈 dict라도)
+      - c108은 labels를 비우는 것이 정상
+      - payload.blocks['리포트'] = list[dict]
+    """
+    if doc.endpoint_kind != EndpointKind.C108:
+        raise ValueError(f"c108_doc_to_dto expects C108 doc, got: {doc.endpoint_kind}")
+
+    # contracts payload 구조에 맞게: blocks/labels를 항상 구성
+    blocks: C108Blocks = {"리포트": []}
+
+    # block_keys를 따르되, 실질적으로는 '리포트' 하나만 있어도 충분
+    for bk in get_block_keys(EndpointKind.C108):
+        if bk != "리포트":
+            continue
+
+        block = doc.blocks.get(bk)
+        if isinstance(block, RecordsBlock):
+            blocks["리포트"] = _to_list_of_dict(block.rows)
+        else:
+            # 혹시 구조가 섞였으면 최대한 안전하게 빈 값
+            blocks["리포트"] = []
+
+    payload: C108Payload = {"blocks": blocks}
+
+    return C108DTO(
+        code=doc.code,
+        asof=asof,
+        endpoint=endpoint,
+        payload=payload,
+    )
+
+
+class IngestC108:
+    def __init__(self, fetch: FetchC108, sink: NfsSinkPort[C108DTO]):
+        self.fetch = fetch
+        self.sink = sink
+
+    async def execute(
+        self, code: str, *, sleep_sec: float = 2.0, asof: datetime | None = None
+    ) -> C108DTO:
+        asof = asof or utcnow()
+
+        doc = await self.fetch.execute(code, sleep_sec=sleep_sec)
+        logger.debug(f"doc:\n{doc}")
+        if doc is None:
+            raise RuntimeError(f"c108 fetch returned None: code={code}")
+
+        dto = c108_doc_to_dto(doc=doc, asof=asof)
+        logger.debug(f"dto:\n{dto}")
+
+        await self.sink.write(dto, endpoint=endpoint)
+        return dto
+
+    async def execute_many(
+        self,
+        codes: Iterable[str],
+        *,
+        sleep_sec: float = 2.0,
+        asof: Optional[datetime] = None,
+    ) -> list[C108DTO]:
+        batch_asof = asof or utcnow()
+
+        docs = await self.fetch.execute_many(codes, sleep_sec=sleep_sec)
+        dtos = [c108_doc_to_dto(doc=d, asof=batch_asof) for d in docs]
+        logger.debug(f"dtos:\n{dtos}")
+        await self.sink.write_many(dtos, endpoint=endpoint)
+        return dtos

scraper2/main.py → scraper2_hj3415/cli.py

@@ -1,21 +1,32 @@
-# scraper2/main.py
+# scraper2_hj3415/cli.py
 from __future__ import annotations
 
 import asyncio
-from typing import Any, Literal, cast
+from typing import Any, cast, get_args
 
+
+import time
 import typer
 from datetime import datetime, timezone
 
-from scraper2.app.composition import build_usecases
-from scraper2.app.ports.ingest_port import IngestPort
+from db2_hj3415.nfs.repo import ensure_indexes
+from db2_hj3415.settings import get_settings
+from db2_hj3415.universe.repo import list_universe_codes
+
+from scraper2_hj3415.app.composition import build_usecases
+from scraper2_hj3415.app.ports.ingest.nfs_ingest_port import NfsIngestPort
+from scraper2_hj3415.app.domain.types import Sink
 
-from logging_hj3415 import setup_logging
+from contracts_hj3415.nfs.types import Endpoint
+from contracts_hj3415.universe.types import UniverseName
+
+from logging_hj3415 import setup_logging, current_log_level, reset_logging, to_pretty_json
 
 setup_logging()
+# 운영시에는 아래 항목 주석처리하고 환경변수로 제어할것
+reset_logging("DEBUG")
+print(f"Current log level - {current_log_level()}")
 
-Endpoint = Literal["c101", "c103", "c104", "c106", "c108", "all"]
-Sink = Literal["memory", "mongo"]
 
 app = typer.Typer(no_args_is_help=True)
 
@@ -30,54 +41,19 @@ app.add_typer(mi_app, name="mi")
 # small helpers
 # -------------------------
 
-def _endpoint_list(ep: Endpoint) -> list[str]:
-    return ["c101", "c103", "c104", "c106", "c108"] if ep == "all" else [ep]
+def _endpoint_list(endpoint: str) -> list[str]:
+    if endpoint == "all":
+        return list(get_args(Endpoint))  # -> ["c101", "c103", "c104", "c106", "c108"]
+    return [endpoint]
 
 async def _mongo_bootstrap(db) -> None:
-    from db2.nfs import ensure_indexes
-    from db2.settings import get_settings
-
     s = get_settings()
     await ensure_indexes(db, snapshot_ttl_days=s.SNAPSHOT_TTL_DAYS)
 
-
-async def _load_codes_from_universe(db, *, universe: str) -> list[str]:
-    """
-    db2.universe에 저장된 universe_latest에서 codes 로드.
-    (네 db2 API 명에 맞춰 조정하면 됨)
-    """
-    from db2.universe import get_universe_latest  # 네가 가진 API
-
-    doc = await get_universe_latest(db, universe=universe)
-    if not doc:
-        return []
-
-    # doc 형태가 {"items":[{code,name,...}, ...]} 혹은 {"payload":{"items":[...]}} 일 수 있어서 방어
-    data = doc
-    if isinstance(data, dict) and "payload" in data and isinstance(data["payload"], dict):
-        data = data["payload"]
-    if isinstance(data, dict) and "items" in data:
-        data = data["items"]
-
-    if not isinstance(data, list):
-        return []
-
-    codes: list[str] = []
-    for row in data:
-        if not isinstance(row, dict):
-            continue
-        code = str(row.get("code") or "").strip()
-        if code:
-            codes.append(code)
-    return codes
-
-
-import time
-
 async def _run_ingest_with_progress(
     *,
     ucs: Any,
-    endpoint: Endpoint,
+    endpoint: str,
     codes: list[str],
     sleep_sec: float,
     show: bool,
@@ -99,7 +75,7 @@ async def _run_ingest_with_progress(
             yield xs[i:i + n]
 
     async def _run_one_endpoint(ep: str) -> None:
-        ingest_uc = cast(IngestPort, getattr(ucs.ingest, ep))
+        ingest_uc = cast(NfsIngestPort, getattr(ucs.ingest, ep))
 
         ok = 0
         fail = 0
@@ -128,18 +104,6 @@ async def _run_ingest_with_progress(
     elapsed = time.perf_counter() - t0   # ✅ 종료 시각
     typer.echo(f"\n⏱ elapsed time: {_format_elapsed(elapsed)}")
 
-def _dto_to_pretty(obj: Any) -> str:
-    # pydantic v2 우선
-    if hasattr(obj, "model_dump_json"):
-        return obj.model_dump_json(indent=2, by_alias=False)
-    if hasattr(obj, "model_dump"):
-        import json
-        return json.dumps(obj.model_dump(), ensure_ascii=False, indent=2)
-    # dict fallback
-    if isinstance(obj, dict):
-        import json
-        return json.dumps(obj, ensure_ascii=False, indent=2, default=str)
-    return str(obj)
 
 def _format_elapsed(sec: float) -> str:
     if sec < 60:
@@ -189,11 +153,11 @@ def _parse_asof(asof: str | None) -> datetime:
 
 @nfs_app.command("one")
 def nfs_one(
-    endpoint: Endpoint = typer.Argument(..., help="c101|c103|c104|c106|c108|all"),
     code: str = typer.Argument(..., help="종목코드 (예: 005930)"),
+    endpoint: str = typer.Argument(..., help="c101|c103|c104|c106|c108|all"),
     sleep_sec: float = typer.Option(2.0, "--sleep"),
     sink: Sink = typer.Option("memory", "--sink"),
-    show: bool = typer.Option(True, "--show/--no-show", help="결과 DTO 출력"),
+    show: bool = typer.Option(False, "--show/--no-show", help="결과 DTO 출력"),
     asof: str | None = typer.Option(None, "--asof", help="배치 기준시각(ISO8601, UTC 권장). 예: 2026-01-09T05:00:00Z"),
 ):
     code = code.strip()
@@ -201,7 +165,7 @@ def nfs_one(
         raise typer.BadParameter("code는 비어있을 수 없습니다.")
 
     async def _run():
-        ucs = build_usecases(sink_kind=sink)
+        ucs = build_usecases(sink=sink)
 
         if sink == "mongo":
             if ucs.db is None:
@@ -211,17 +175,23 @@ def nfs_one(
         try:
             run_asof = _parse_asof(asof)
             for ep in _endpoint_list(endpoint):
-                ingest_uc = cast(IngestPort, getattr(ucs.ingest, ep))
+                ingest_uc = cast(NfsIngestPort, getattr(ucs.ingest, ep))
                 results = await ingest_uc.execute_many([code], sleep_sec=sleep_sec, asof=run_asof)
                 dto = results[0] if results else None
 
                 typer.echo(f"\n=== ONE DONE: {ep} {code} ===")
-                if not show:
+                is_memory_sink = sink == "memory"
+                should_show = show or is_memory_sink
+
+                if not should_show:
                     continue
+
                 if dto is None:
                     typer.echo("(no result)")
                 else:
-                    typer.echo(_dto_to_pretty(dto))
+                    if is_memory_sink:
+                        typer.echo("memory result:")
+                    typer.echo(to_pretty_json(dto))
         finally:
             await ucs.aclose()
 
@@ -230,7 +200,7 @@ def nfs_one(
 
 @nfs_app.command("all")
 def nfs_all(
-    endpoint: Endpoint = typer.Argument(..., help="c101|c103|c104|c106|c108|all"),
+    endpoint: str = typer.Argument(..., help="c101|c103|c104|c106|c108|all"),
     universe: str = typer.Option("krx300", "--universe"),
     limit: int = typer.Option(0, "--limit", help="0=전체"),
     sleep_sec: float = typer.Option(2.0, "--sleep"),
@@ -241,15 +211,18 @@ def nfs_all(
     asof: str | None = typer.Option(None, "--asof", help="배치 기준시각(ISO8601). 예: 2026-01-09T05:00:00Z"),
 ):
     async def _run():
-        ucs = build_usecases(sink_kind=sink)
+        ucs = build_usecases(sink=sink)
         if ucs.db is None:
             raise RuntimeError("all 모드는 DB가 필요합니다. mongo sink로 ucs.db를 노출하세요.")
         await _mongo_bootstrap(ucs.db)
 
-        codes = await _load_codes_from_universe(ucs.db, universe=universe)
-        if not codes:
-            raise RuntimeError(f"universe='{universe}' codes가 비었습니다. 먼저 krx sync로 universe를 채우세요.")
+        try:
+            u = UniverseName(universe)
+        except ValueError:
+            raise typer.BadParameter(f"unknown universe: {universe}")
+        codes = await list_universe_codes(ucs.db, universe=u)
 
+        codes = sorted(codes)
         if limit and limit > 0:
             codes = codes[:limit]
 
@@ -281,4 +254,4 @@ def mi():
 
 
 if __name__ == "__main__":
-    app()
+    app()

{scraper2_hj3415-2.4.1.dist-info → scraper2_hj3415-2.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scraper2-hj3415
-Version: 2.4.1
+Version: 2.7.0
 Summary: Naver WiseReport scraper
 Keywords: example,demo
 Author-email: Hyungjin Kim <hj3415@gmail.com>
@@ -17,6 +17,8 @@ Requires-Dist: lxml>=6.0.2
 Requires-Dist: typer>=0.21.0
 Requires-Dist: db2-hj3415
 Requires-Dist: contracts-hj3415
+Requires-Dist: common-hj3415
+Requires-Dist: logging-hj3415
 
 # scraper2