ecos-reader 0.2.0__tar.gz → 0.2.1__tar.gz

{ecos_reader-0.2.0 → ecos_reader-0.2.1}/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] - 2026-05-29
+
+> 0.3.0 은 시그니처 breaking 재설계(epic #3)를 위해 예약돼 있어, 본 하위호환
+> 기능 추가는 patch(0.2.1) 로 릴리스합니다.
+
+### Added
+- `get_base_rate` 에 `frequency` 파라미터 추가 (`"M"` 기본 / `"D"`). ECOS 통계표
+  `722Y001` 은 일별 원천이라 `frequency="D"` 로 변경일 단위(sparse) 시계열을
+  조회할 수 있습니다. `"D"` 지정 시 날짜 형식은 `YYYYMMDD`, 기본 조회기간도
+  일별 포맷으로 산출합니다. 기본값 `"M"` 으로 기존 동작은 그대로 유지(하위호환).
+
+### Notes
+- M2 평잔·계절조정(`161Y005`/`BBHS00`) 시계열은 기존
+  `get_m2_variants(variant="평잔_계절조정")` 로 이미 제공됩니다 (별도 추가 없음).
+
 ## [0.2.0] - 2026-05-29
 
 v0.1.6 라이브 e2e 검증에서 드러난 follow-up(#2 Reliability epic)을 정리한 릴리스.

{ecos_reader-0.2.0 → ecos_reader-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ecos-reader
-Version: 0.2.0
+Version: 0.2.1
 Summary: 한국은행 ECOS Open API Python 클라이언트
 Project-URL: Homepage, https://github.com/choo121600/ecos-reader
 Project-URL: Documentation, https://choo121600.github.io/ecos-reader/

{ecos_reader-0.2.0 → ecos_reader-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ecos-reader"
-version = "0.2.0"
+version = "0.2.1"
 description = "한국은행 ECOS Open API Python 클라이언트"
 readme = "README.md"
 license = "MIT"

{ecos_reader-0.2.0 → ecos_reader-0.2.1}/src/ecos/__init__.py

@@ -20,7 +20,7 @@ Examples
 
 from __future__ import annotations
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 __author__ = "yeonguk"
 
 # Config API
@@ -38,6 +38,8 @@ from .exceptions import (
     EcosError,
     EcosNetworkError,
     EcosRateLimitError,
+    EcosServerError,
+    EcosValidationError,
 )
 
 # Indicator APIs
@@ -111,6 +113,8 @@ __all__ = [
     "EcosConfigError",
     "EcosNetworkError",
     "EcosRateLimitError",
+    "EcosServerError",
+    "EcosValidationError",
     # Warnings
     "EcosPartialCoverageWarning",
     # 재정 지표

{ecos_reader-0.2.0 → ecos_reader-0.2.1}/src/ecos/cache.py

@@ -8,7 +8,9 @@ from __future__ import annotations
 
 import hashlib
 import json
+import threading
 import time
+from collections import OrderedDict
 from dataclasses import dataclass
 from typing import Any
 
@@ -53,8 +55,11 @@ class Cache:
     def __init__(self, ttl: int = 3600, maxsize: int = 100):
         self.ttl = ttl
         self.maxsize = maxsize
-        self._cache: dict[str, CacheEntry] = {}
-        self._access_order: list[str] = []
+        # OrderedDict가 LRU 순서를 직접 보유하므로 O(1) move_to_end/popitem 사용.
+        # 별도 _access_order 리스트(O(n) remove)와의 비일관성을 제거한다.
+        self._cache: OrderedDict[str, CacheEntry] = OrderedDict()
+        # 재진입 가능 락: get()이 만료 시 invalidate()를 호출하므로 RLock 필요.
+        self._lock = threading.RLock()
         self._enabled: bool = True
 
     @property
@@ -103,26 +108,26 @@ class Cache:
         if not self._enabled:
             return None
 
-        entry = self._cache.get(key)
-        if entry is None:
-            record_cache_miss()
-            log_cache_operation("get", key, hit=False)
-            return None
+        with self._lock:
+            entry = self._cache.get(key)
+            if entry is None:
+                record_cache_miss()
+                log_cache_operation("get", key, hit=False)
+                return None
 
-        if entry.is_expired():
-            self.invalidate(key)
-            record_cache_miss()
-            log_cache_operation("get", key, hit=False)
-            return None
+            if entry.is_expired():
+                # 만료 항목 능동 제거 (maxsize 미만이어도 메모리 점유 방지)
+                self._cache.pop(key, None)
+                record_cache_miss()
+                log_cache_operation("get", key, hit=False)
+                return None
 
-        # LRU: 접근된 항목을 최신으로 이동
-        if key in self._access_order:
-            self._access_order.remove(key)
-        self._access_order.append(key)
+            # LRU: 접근된 항목을 최신으로 이동 (O(1))
+            self._cache.move_to_end(key)
 
-        record_cache_hit()
-        log_cache_operation("get", key, hit=True)
-        return entry.value
+            record_cache_hit()
+            log_cache_operation("get", key, hit=True)
+            return entry.value
 
     def set(self, key: str, value: Any) -> None:
         """
@@ -138,19 +143,19 @@ class Cache:
         if not self._enabled:
             return
 
-        # 최대 크기 초과 시 가장 오래된 항목 제거
-        while len(self._cache) >= self.maxsize and self._access_order:
-            oldest_key = self._access_order.pop(0)
-            self._cache.pop(oldest_key, None)
-
-        self._cache[key] = CacheEntry(value=value, created_at=time.time(), ttl=self.ttl)
-
-        if key in self._access_order:
-            self._access_order.remove(key)
-        self._access_order.append(key)
+        with self._lock:
+            if key in self._cache:
+                # 기존 키 갱신: 값 교체 후 최신으로 이동, 퇴출 불필요
+                self._cache[key] = CacheEntry(value=value, created_at=time.time(), ttl=self.ttl)
+                self._cache.move_to_end(key)
+            else:
+                # 최대 크기 초과 시 가장 오래된 항목(맨 앞) 제거 (O(1))
+                while self._cache and len(self._cache) >= self.maxsize:
+                    self._cache.popitem(last=False)
+                self._cache[key] = CacheEntry(value=value, created_at=time.time(), ttl=self.ttl)
 
-        record_cache_set()
-        log_cache_operation("set", key)
+            record_cache_set()
+            log_cache_operation("set", key)
 
     def invalidate(self, key: str) -> None:
         """
@@ -161,24 +166,26 @@ class Cache:
         key : str
             무효화할 캐시 키
         """
-        self._cache.pop(key, None)
-        if key in self._access_order:
-            self._access_order.remove(key)
+        with self._lock:
+            self._cache.pop(key, None)
 
     def clear(self) -> None:
         """모든 캐시를 삭제합니다."""
-        self._cache.clear()
-        self._access_order.clear()
-        record_cache_clear()
-        log_cache_operation("clear", "")
+        with self._lock:
+            self._cache.clear()
+            record_cache_clear()
+            log_cache_operation("clear", "")
 
     def __len__(self) -> int:
         """캐시된 항목 수"""
-        return len(self._cache)
+        with self._lock:
+            return len(self._cache)
 
     def __contains__(self, key: str) -> bool:
-        """캐시 키 존재 여부"""
-        return key in self._cache and not self._cache[key].is_expired()
+        """캐시 키 존재 여부 (만료 항목은 미포함으로 간주)"""
+        with self._lock:
+            entry = self._cache.get(key)
+            return entry is not None and not entry.is_expired()
 
 
 # 전역 캐시 인스턴스

{ecos_reader-0.2.0 → ecos_reader-0.2.1}/src/ecos/client.py

@@ -12,13 +12,15 @@ from typing import Any, cast
 from urllib.parse import quote
 
 import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util import Retry
 
 from .cache import Cache, get_cache
 from .config import Settings, get_api_key
 from .exceptions import (
+    ECOS_ERROR_CODES,
     RETRYABLE_ERROR_CODES,
     EcosAPIError,
-    EcosConfigError,
     EcosNetworkError,
     EcosRateLimitError,
 )
@@ -68,9 +70,40 @@ class EcosClient:
         self.timeout = timeout
         self.max_retries = max_retries
         self.use_cache = use_cache
-        self.session = requests.Session()
+        self.session = self._build_session()
         self._cache: Cache | None = get_cache() if use_cache else None
 
+    def _build_session(self) -> requests.Session:
+        """재시도 정책과 커넥션 풀이 구성된 Session을 생성합니다.
+
+        전송 계층(urllib3.Retry)에서 처리하는 것:
+        - 5xx/429/408 및 연결/읽기 오류 재시도 (``status_forcelist``)
+        - 4xx(408/429 제외)는 ``status_forcelist`` 밖이므로 재시도하지 않음
+        - 429/503의 ``Retry-After`` 헤더 존중 (``respect_retry_after_header``)
+
+        ECOS 비즈니스 에러(HTTP 200 + ``RESULT.CODE``)는 이 계층에서 보이지
+        않으므로 ``_make_request``의 애플리케이션 루프에서 별도로 재시도한다.
+        """
+        session = requests.Session()
+        retry = Retry(
+            total=self.max_retries,
+            backoff_factor=Settings.RETRY_BACKOFF_FACTOR,
+            status_forcelist=Settings.RETRY_STATUS_FORCELIST,
+            allowed_methods=frozenset({"GET"}),
+            respect_retry_after_header=True,
+            # 재시도 소진 후에도 마지막 응답을 그대로 반환받아 raise_for_status로
+            # 일관되게 변환한다 (urllib3가 MaxRetryError를 던지지 않도록).
+            raise_on_status=False,
+        )
+        adapter = HTTPAdapter(
+            max_retries=retry,
+            pool_connections=Settings.POOL_CONNECTIONS,
+            pool_maxsize=Settings.POOL_MAXSIZE,
+        )
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        return session
+
     def _get_api_key(self) -> str:
         """
         요청 시점의 API Key를 반환합니다.
@@ -155,6 +188,9 @@ class EcosClient:
         EcosRateLimitError
             Rate Limit 초과 시
         """
+        # 전송 계층(urllib3.Retry)이 5xx/429/408·연결/읽기 오류를 이미 재시도한다.
+        # 이 루프는 HTTP 200으로 내려오는 ECOS 비즈니스 에러(ERROR-500/600/602 등
+        # RETRYABLE_ERROR_CODES)만 추가로 재시도한다.
         last_exception: Exception | None = None
 
         for attempt in range(self.max_retries):
@@ -170,38 +206,35 @@ class EcosClient:
                 logger.debug(f"API 응답 성공: {len(data)} 바이트 수신")
                 return data
 
-            except requests.exceptions.Timeout:
-                last_exception = EcosNetworkError(f"요청 타임아웃 ({self.timeout}초)")
-                if attempt < self.max_retries - 1:
-                    log_retry_attempt(attempt + 1, self.max_retries, last_exception)
+            except requests.exceptions.Timeout as e:
+                # 읽기 타임아웃: urllib3 재시도까지 소진된 상태이므로 즉시 변환
+                raise EcosNetworkError(f"요청 타임아웃 ({self.timeout}초)") from e
 
             except requests.exceptions.ConnectionError as e:
-                # urllib3가 에러 메시지에 raw URL(api_key 포함)을 끼워넣는 경우가 있어 마스킹
-                last_exception = EcosNetworkError(f"네트워크 연결 오류: {mask_api_key(str(e))}")
-                if attempt < self.max_retries - 1:
-                    log_retry_attempt(attempt + 1, self.max_retries, last_exception)
+                # 연결 오류: urllib3 재시도 소진 후 도달. raw URL(api_key)이 섞일 수
+                # 있어 마스킹.
+                raise EcosNetworkError(f"네트워크 연결 오류: {mask_api_key(str(e))}") from e
 
             except requests.exceptions.HTTPError as e:
-                # requests의 HTTPError는 "... for url: <full URL with key>" 형식이므로 마스킹 필수
-                last_exception = EcosNetworkError(f"HTTP 오류: {mask_api_key(str(e))}")
-                if attempt < self.max_retries - 1:
-                    log_retry_attempt(attempt + 1, self.max_retries, last_exception)
+                # 4xx(408/429 제외)는 status_forcelist 밖이라 재시도 없이 즉시 도달하고,
+                # 5xx/429는 어댑터가 재시도를 소진한 최종 응답이다. 어느 쪽이든 즉시 raise.
+                # requests HTTPError str()에 full URL(key 포함)이 들어가므로 마스킹 필수.
+                raise EcosNetworkError(f"HTTP 오류: {mask_api_key(str(e))}") from e
 
             except (EcosAPIError, EcosRateLimitError) as e:
-                # 재시도 가능한 에러인지 확인
+                # 비즈니스 에러: 재시도 대상이 아니면 즉시 raise
                 error_key = f"ERROR-{e.code}" if hasattr(e, "code") else ""
-                if error_key in RETRYABLE_ERROR_CODES:
-                    last_exception = e
-                    if attempt < self.max_retries - 1:
-                        log_retry_attempt(attempt + 1, self.max_retries, last_exception)
-                else:
+                if error_key not in RETRYABLE_ERROR_CODES:
                     raise
 
-            # 재시도 전 대기 (exponential backoff)
-            if attempt < self.max_retries - 1:
-                wait_time = Settings.RETRY_BACKOFF_FACTOR * (2**attempt)
-                logger.debug(f"재시도 전 대기: {wait_time:.2f}초")
-                time.sleep(wait_time)
+                last_exception = e
+                if attempt < self.max_retries - 1:
+                    log_retry_attempt(attempt + 1, self.max_retries, e)
+                    # 비즈니스 에러는 HTTP 200이라 Retry-After 헤더가 없으므로
+                    # exponential backoff 적용
+                    wait_time = Settings.RETRY_BACKOFF_FACTOR * (2**attempt)
+                    logger.debug(f"재시도 전 대기: {wait_time:.2f}초")
+                    time.sleep(wait_time)
 
         # 모든 재시도 실패
         if last_exception:
@@ -232,20 +265,30 @@ class EcosClient:
         if code == "INFO-200":
             return
 
-        # 정보 코드 100: 인증키 오류
-        if code == "INFO-100":
-            log_error_response(code, message, url)
-            raise EcosConfigError(message)
-
-        # 에러 코드
-        if code.startswith("ERROR"):
-            error_num = code.split("-")[-1] if "-" in code else code.replace("ERROR", "")
-            log_error_response(code, message, url)
-
-            if error_num == "602":
-                raise EcosRateLimitError(message)
+        # 카탈로그(ECOS_ERROR_CODES) 단일 조회로 코드별 예외 결정
+        mapping = ECOS_ERROR_CODES.get(code)
+        if mapping is None:
+            # 카탈로그 미등록 코드: ERROR 접두는 일반 API 에러로, 그 외는 정상 처리
+            if code.startswith("ERROR"):
+                log_error_response(code, message, url)
+                raise EcosAPIError(self._error_num(code), message)
+            return
 
-            raise EcosAPIError(error_num, message)
+        exc_class, default_message, _retryable = mapping
+        log_error_response(code, message, url)
+        msg = message or default_message
+
+        # EcosAPIError 계열은 (code, message) 시그니처, 그 외(Config/RateLimit)는 (message)
+        if issubclass(exc_class, EcosAPIError):
+            raise exc_class(self._error_num(code), msg)
+        raise exc_class(msg)
+
+    @staticmethod
+    def _error_num(code: str) -> str:
+        """``ERROR-100`` → ``100``처럼 코드에서 숫자 부분을 추출합니다."""
+        if "-" in code:
+            return code.split("-", 1)[-1]
+        return code.replace("ERROR", "")
 
     def _cached_request(
         self,

{ecos_reader-0.2.0 → ecos_reader-0.2.1}/src/ecos/config.py

@@ -139,6 +139,12 @@ class Settings:
     DEFAULT_TIMEOUT: int = 30  # 초
     MAX_RETRIES: int = 3
     RETRY_BACKOFF_FACTOR: float = 1.0
+    # 재시도 대상 HTTP 상태 코드. 4xx 중에서는 408(timeout)/429(rate limit)만 포함하고
+    # 나머지 4xx(클라이언트 오류)는 재시도하지 않는다.
+    RETRY_STATUS_FORCELIST: tuple[int, ...] = (408, 429, 500, 502, 503, 504)
+    # 커넥션 풀 크기 (대량 동시 요청 시 기본값 10 병목 완화)
+    POOL_CONNECTIONS: int = 10
+    POOL_MAXSIZE: int = 20
 
     # 캐시 설정
     CACHE_TTL: int = 3600  # 1시간

ecos_reader-0.2.1/src/ecos/exceptions.py

@@ -0,0 +1,102 @@
+"""
+ecos-reader 예외 클래스 정의
+
+ECOS API 에러 및 라이브러리 예외를 처리합니다.
+"""
+
+from __future__ import annotations
+
+
+class EcosError(Exception):
+    """ecos-reader 기본 예외"""
+
+    pass
+
+
+class EcosAPIError(EcosError):
+    """ECOS API 호출 에러
+
+    Attributes
+    ----------
+    code : str
+        ECOS API 에러 코드
+    message : str
+        에러 메시지
+    """
+
+    def __init__(self, code: str, message: str):
+        self.code = code
+        self.message = message
+        super().__init__(f"[{code}] {message}")
+
+
+class EcosConfigError(EcosError):
+    """설정 관련 에러 (API Key 등)"""
+
+    pass
+
+
+class EcosNetworkError(EcosError):
+    """네트워크 연결 에러"""
+
+    pass
+
+
+class EcosValidationError(EcosAPIError):
+    """클라이언트 책임 요청 오류 (4xx 성격)
+
+    필수값 누락·형식/타입 오류 등 요청 자체가 잘못된 경우. 동일 요청을
+    재시도해도 동일하게 실패하므로 재시도 대상이 아닙니다.
+    """
+
+    pass
+
+
+class EcosServerError(EcosAPIError):
+    """ECOS 서버측 오류 (5xx 성격)
+
+    서버 오류·DB Connection·SQL 오류 등. 일시적 오류(서버/DB)는 재시도
+    대상일 수 있습니다 (`ECOS_ERROR_CODES`의 retryable 플래그 참조).
+    """
+
+    pass
+
+
+class EcosRateLimitError(EcosError):
+    """Rate Limit 초과"""
+
+    def __init__(self, message: str, code: str = "602"):
+        self.code = code
+        self.message = message
+        super().__init__(f"[{code}] {message}")
+
+
+# ECOS 에러 코드 단일 진실원천 (Single Source of Truth)
+#
+# 키는 ECOS API가 실제로 반환하는 하이픈 형식("ERROR-602")으로 통일한다.
+# 값은 (예외 클래스, 기본 메시지, 재시도 가능 여부) 3-튜플이다.
+# 클라이언트는 이 매핑을 조회해 코드별 예외를 일관되게 발생시키고,
+# RETRYABLE_ERROR_CODES도 여기서 파생한다.
+ECOS_ERROR_CODES: dict[str, tuple[type[EcosError], str, bool]] = {
+    # 정보 코드
+    "INFO-100": (EcosConfigError, "인증키가 유효하지 않습니다.", False),
+    "INFO-200": (EcosAPIError, "해당하는 데이터가 없습니다.", False),  # 빈 결과로 처리
+    # 클라이언트 책임(요청 검증) 에러 — 재시도해도 동일 실패
+    "ERROR-100": (EcosValidationError, "필수 값이 누락되어 있습니다.", False),
+    "ERROR-101": (EcosValidationError, "주기와 다른 형식의 날짜 형식입니다.", False),
+    "ERROR-200": (EcosValidationError, "파일타입 값이 누락 혹은 유효하지 않습니다.", False),
+    "ERROR-300": (EcosValidationError, "조회건수 값이 누락되어 있습니다.", False),
+    "ERROR-301": (EcosValidationError, "조회건수 값의 타입이 유효하지 않습니다.", False),
+    "ERROR-400": (EcosAPIError, "검색범위가 적정범위를 초과하여 TIMEOUT이 발생하였습니다.", False),
+    # 서버측 에러 — 서버/DB는 일시적일 수 있어 재시도, SQL 오류는 비재시도
+    "ERROR-500": (EcosServerError, "서버 오류입니다.", True),
+    "ERROR-600": (EcosServerError, "DB Connection 오류입니다.", True),
+    "ERROR-601": (EcosServerError, "SQL 오류입니다.", False),
+    # Rate limit
+    "ERROR-602": (EcosRateLimitError, "과도한 OpenAPI 호출로 이용이 제한되었습니다.", True),
+}
+
+# 재시도 가능한 에러 코드 — ECOS_ERROR_CODES의 retryable 플래그에서 파생
+RETRYABLE_ERROR_CODES: frozenset[str] = frozenset(
+    code for code, (_exc, _msg, retryable) in ECOS_ERROR_CODES.items() if retryable
+)

ecos_reader-0.2.1/src/ecos/indicators/_dates.py

@@ -0,0 +1,64 @@
+"""
+indicators 공용 날짜 헬퍼.
+
+기본 조회 기간(시작/종료)을 빈도별로 계산하는 단일 진실원천 모듈입니다.
+모든 함수는 ECOS API가 요구하는 문자열 형식을 반환합니다:
+
+- ``default_daily``      → ``YYYYMMDD``
+- ``default_monthly``    → ``YYYYMM``
+- ``default_quarterly``  → ``YYYYQN``
+- ``default_annual``     → ``YYYY``
+
+각 함수는 ``today`` 인자로 기준일을 주입할 수 있어 테스트에서 결정적으로
+동작합니다 (기본값은 ``datetime.now()``).
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+
+
+def _reference(today: datetime | None) -> datetime:
+    """기준일을 반환합니다. ``None``이면 현재 시각."""
+    return today if today is not None else datetime.now()
+
+
+def default_daily(days_back: int = 365, *, today: datetime | None = None) -> tuple[str, str]:
+    """일별 기본 조회 기간을 ``YYYYMMDD`` 형식으로 반환합니다.
+
+    ``timedelta`` 기반이므로 윤년 2/29 경계에서도
+    ``ValueError: day is out of range`` 없이 안전합니다.
+    """
+    end = _reference(today)
+    start = end - timedelta(days=days_back)
+    return start.strftime("%Y%m%d"), end.strftime("%Y%m%d")
+
+
+def default_monthly(months_back: int = 12, *, today: datetime | None = None) -> tuple[str, str]:
+    """월별 기본 조회 기간을 ``YYYYMM`` 형식으로 반환합니다."""
+    end = _reference(today)
+
+    total_months = end.year * 12 + end.month
+    start_total_months = total_months - months_back
+
+    start_year = (start_total_months - 1) // 12
+    start_month = (start_total_months - 1) % 12 + 1
+
+    return f"{start_year}{start_month:02d}", f"{end.year}{end.month:02d}"
+
+
+def default_quarterly(years_back: int = 5, *, today: datetime | None = None) -> tuple[str, str]:
+    """분기별 기본 조회 기간을 ``YYYYQN`` 형식으로 반환합니다.
+
+    시작은 ``years_back`` 년 전의 1분기, 종료는 기준일이 속한 분기입니다.
+    """
+    end = _reference(today)
+    start_year = end.year - years_back
+    current_quarter = (end.month - 1) // 3 + 1
+    return f"{start_year}Q1", f"{end.year}Q{current_quarter}"
+
+
+def default_annual(years_back: int = 10, *, today: datetime | None = None) -> tuple[str, str]:
+    """연간 기본 조회 기간을 ``YYYY`` 형식으로 반환합니다."""
+    end = _reference(today)
+    return str(end.year - years_back), str(end.year)

{ecos_reader-0.2.0 → ecos_reader-0.2.1}/src/ecos/indicators/bond.py

@@ -6,7 +6,6 @@
 
 from __future__ import annotations
 
-from datetime import datetime
 from typing import Literal
 
 import pandas as pd
@@ -18,27 +17,10 @@ from ..constants import (
     STAT_BOND_YIELD_TYPE,
 )
 from ..parser import normalize_stat_result, parse_response
+from ._dates import default_monthly
 from ._deprecations import warn_partial_coverage as _warn_partial_coverage
 
 
-def _get_default_dates(months_back: int = 24) -> tuple[str, str]:
-    """기본 조회 기간을 반환합니다 (기본 2년)."""
-    end_date = datetime.now()
-
-    # 총 개월 수 계산
-    total_months = end_date.year * 12 + end_date.month
-    start_total_months = total_months - months_back
-
-    # 연도와 월 계산
-    start_year = (start_total_months - 1) // 12
-    start_month = (start_total_months - 1) % 12 + 1
-
-    start_str = f"{start_year}{start_month:02d}"
-    end_str = f"{end_date.year}{end_date.month:02d}"
-
-    return start_str, end_str
-
-
 def get_bond_yield(
     bond_type: Literal["종류별", "시장별"] = "종류별",
     start_date: str | None = None,
@@ -106,7 +88,7 @@ def get_bond_yield(
 
     # 기본 날짜 설정
     if start_date is None or end_date is None:
-        default_start, default_end = _get_default_dates(24)
+        default_start, default_end = default_monthly(24)
         start_date = start_date or default_start
         end_date = end_date or default_end
 

{ecos_reader-0.2.0 → ecos_reader-0.2.1}/src/ecos/indicators/fiscal.py

@@ -6,8 +6,6 @@
 
 from __future__ import annotations
 
-from datetime import datetime
-
 import pandas as pd
 
 from ..client import get_client
@@ -17,24 +15,7 @@ from ..constants import (
     STAT_FISCAL_BALANCE,
 )
 from ..parser import normalize_stat_result, parse_response
-
-
-def _get_default_dates(months_back: int = 24) -> tuple[str, str]:
-    """기본 조회 기간을 반환합니다 (기본 2년)."""
-    end_date = datetime.now()
-
-    # 총 개월 수 계산
-    total_months = end_date.year * 12 + end_date.month
-    start_total_months = total_months - months_back
-
-    # 연도와 월 계산
-    start_year = (start_total_months - 1) // 12
-    start_month = (start_total_months - 1) % 12 + 1
-
-    start_str = f"{start_year}{start_month:02d}"
-    end_str = f"{end_date.year}{end_date.month:02d}"
-
-    return start_str, end_str
+from ._dates import default_monthly
 
 
 def get_fiscal_balance(
@@ -84,7 +65,7 @@ def get_fiscal_balance(
     """
     # 기본 날짜 설정
     if start_date is None or end_date is None:
-        default_start, default_end = _get_default_dates(24)
+        default_start, default_end = default_monthly(24)
         start_date = start_date or default_start
         end_date = end_date or default_end