547 lines
23 KiB
Python
547 lines
23 KiB
Python
"""
|
|
kis_trader/database/db_manager.py — 통합 DB 관리자
|
|
==================================================
|
|
기존 ``database.TradeDB``(MariaDB 2,000줄)를 **그대로 재사용**하고,
|
|
본 모듈에서는 주문(order_id=ODNO) 단위 추적을 위한 ``orders`` 테이블을
|
|
추가·관리한다.
|
|
|
|
핵심 설계:
|
|
1. ODNO(한투 주문번호)를 PK 로 사용 → DB 레벨에서 중복 주문 차단.
|
|
2. UNIQUE(strategy_id, code, order_date, side) 인덱스 → 같은 전략이
|
|
같은 날 같은 종목·같은 방향으로 중복 주문 시도 시 서버단 차단.
|
|
3. 전략별 filter → 꼬리잡기봇과 스캘핑봇의 "남의 집 물건 팔기" 방지.
|
|
|
|
본 모듈은 TradeDB 를 수정하지 않고 래핑한다 (원본 코드 존중 규칙).
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import datetime
|
|
import logging
|
|
from typing import Dict, List, Optional
|
|
|
|
from database import TradeDB # 프로젝트 루트 모듈
|
|
|
|
logger = logging.getLogger("kis_trader.db")
|
|
|
|
# 싱글톤: 프로세스 내 TradeDBExt 재사용 (연결 낭비 방지)
|
|
_SINGLETON: Optional["TradeDBExt"] = None
|
|
|
|
|
|
def get_db() -> "TradeDBExt":
|
|
global _SINGLETON
|
|
if _SINGLETON is None:
|
|
_SINGLETON = TradeDBExt()
|
|
return _SINGLETON
|
|
|
|
|
|
class TradeDBExt:
|
|
"""
|
|
기존 TradeDB 를 합성(Composition)한 래퍼. ``self.raw`` 로 원본 객체 접근.
|
|
``orders`` 테이블 생성/마이그레이션을 책임지고, 주문 이력을 기록/조회하는
|
|
메서드를 추가로 제공한다.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.raw = TradeDB()
|
|
self.conn = self.raw.conn
|
|
self._ensure_orders_table()
|
|
|
|
# ------------------------------------------------------------------
|
|
# 테이블 마이그레이션: orders
|
|
# ------------------------------------------------------------------
|
|
def _ensure_orders_table(self) -> None:
|
|
"""
|
|
orders 테이블:
|
|
ord_no : 한투 주문번호(ODNO). PK — 서버단 중복 차단.
|
|
strategy_id : SCALP_RSI_REVERSAL, SHORT_ANT_SHAKING 등
|
|
code/name : 종목코드/명
|
|
side : BUY / SELL
|
|
qty : 주문 수량
|
|
price : 주문 시 참고가 (시장가=0 일 수 있음)
|
|
filled_qty : 실제 체결 수량
|
|
filled_avg_price : 평균 체결가
|
|
status : SUBMITTED / FILLED / PARTIAL / REJECTED / CANCELLED
|
|
msg_cd/msg1 : 한투 응답 메시지(실패 원인 추적)
|
|
submitted_at : 주문 접수 시각
|
|
filled_at : 체결 확인 시각
|
|
|
|
UNIQUE(strategy_id, code, ord_date, side):
|
|
같은 전략·같은 종목·같은 날짜·같은 방향 중복 주문 시도를 서버단 차단.
|
|
(정정/취소는 별도 ODNO 로 인입되므로 구분됨)
|
|
"""
|
|
try:
|
|
self.conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS orders (
|
|
ord_no VARCHAR(30) NOT NULL PRIMARY KEY,
|
|
strategy_id VARCHAR(40) NOT NULL,
|
|
code VARCHAR(20) NOT NULL,
|
|
name VARCHAR(100) NOT NULL DEFAULT '',
|
|
side VARCHAR(8) NOT NULL,
|
|
qty INT NOT NULL,
|
|
price DOUBLE DEFAULT 0,
|
|
filled_qty INT NOT NULL DEFAULT 0,
|
|
filled_avg_price DOUBLE DEFAULT 0,
|
|
status VARCHAR(16) NOT NULL DEFAULT 'SUBMITTED',
|
|
msg_cd VARCHAR(20) DEFAULT NULL,
|
|
msg1 VARCHAR(300) DEFAULT NULL,
|
|
ord_date VARCHAR(10) NOT NULL,
|
|
submitted_at VARCHAR(30) NOT NULL,
|
|
filled_at VARCHAR(30) DEFAULT NULL,
|
|
raw_json MEDIUMTEXT DEFAULT NULL,
|
|
INDEX idx_strategy_date (strategy_id, ord_date),
|
|
INDEX idx_code_date (code, ord_date),
|
|
UNIQUE KEY uq_strategy_code_side_date (strategy_id, code, side, ord_date)
|
|
) CHARACTER SET utf8mb4
|
|
""")
|
|
logger.info("📊 orders 테이블 확인/생성 완료")
|
|
except Exception as e:
|
|
logger.warning("orders 테이블 생성 실패(무시·폴백): %s", e)
|
|
|
|
# ------------------------------------------------------------------
|
|
# orders CRUD
|
|
# ------------------------------------------------------------------
|
|
def insert_order(
|
|
self,
|
|
*,
|
|
ord_no: str,
|
|
strategy_id: str,
|
|
code: str,
|
|
name: str,
|
|
side: str,
|
|
qty: int,
|
|
price: float = 0.0,
|
|
status: str = "SUBMITTED",
|
|
msg_cd: Optional[str] = None,
|
|
msg1: Optional[str] = None,
|
|
raw_json: Optional[str] = None,
|
|
) -> bool:
|
|
"""
|
|
주문 기록 INSERT. PK(ord_no) 중복이면 False 반환 (서버단 차단).
|
|
side: 'BUY' | 'SELL'
|
|
"""
|
|
side = (side or "").upper()
|
|
assert side in ("BUY", "SELL"), f"side must be BUY|SELL, got {side}"
|
|
now = datetime.datetime.now()
|
|
try:
|
|
with self.conn:
|
|
self.conn.execute(
|
|
"""
|
|
INSERT INTO orders (
|
|
ord_no, strategy_id, code, name, side, qty, price,
|
|
status, msg_cd, msg1, ord_date, submitted_at, raw_json
|
|
) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
|
""",
|
|
(
|
|
ord_no, strategy_id, code, name, side, qty, price,
|
|
status, msg_cd, msg1,
|
|
now.strftime("%Y-%m-%d"),
|
|
now.strftime("%Y-%m-%d %H:%M:%S"),
|
|
raw_json,
|
|
),
|
|
)
|
|
return True
|
|
except Exception as e:
|
|
# 중복 PK(1062) / 유니크 인덱스 위반은 정상적 차단으로 간주
|
|
msg = str(e)
|
|
if "1062" in msg or "Duplicate entry" in msg:
|
|
logger.warning(
|
|
"⚠️ [주문중복차단] strategy=%s code=%s side=%s ord_no=%s (이미 DB 존재)",
|
|
strategy_id, code, side, ord_no,
|
|
)
|
|
return False
|
|
logger.error("insert_order 실패 (ord_no=%s): %s", ord_no, e)
|
|
return False
|
|
|
|
def update_order_fill(
|
|
self,
|
|
*,
|
|
ord_no: str,
|
|
filled_qty: int,
|
|
filled_avg_price: float,
|
|
status: str = "FILLED",
|
|
) -> bool:
|
|
"""주문 체결 확인 후 체결가/체결수량/상태 갱신."""
|
|
now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
try:
|
|
with self.conn:
|
|
self.conn.execute(
|
|
"""
|
|
UPDATE orders
|
|
SET filled_qty=%s, filled_avg_price=%s, status=%s, filled_at=%s
|
|
WHERE ord_no=%s
|
|
""",
|
|
(filled_qty, filled_avg_price, status, now, ord_no),
|
|
)
|
|
return True
|
|
except Exception as e:
|
|
logger.error("update_order_fill 실패 (%s): %s", ord_no, e)
|
|
return False
|
|
|
|
def mark_order_rejected(
|
|
self, *, ord_no: str, msg_cd: str = "", msg1: str = ""
|
|
) -> None:
|
|
"""주문 실패/거부 시 상태 REJECTED 처리."""
|
|
try:
|
|
with self.conn:
|
|
self.conn.execute(
|
|
"""
|
|
UPDATE orders SET status='REJECTED', msg_cd=%s, msg1=%s
|
|
WHERE ord_no=%s
|
|
""",
|
|
(msg_cd, msg1, ord_no),
|
|
)
|
|
except Exception as e:
|
|
logger.debug("mark_order_rejected 실패 (%s): %s", ord_no, e)
|
|
|
|
def get_order_by_odno(self, ord_no: str) -> Optional[Dict]:
|
|
try:
|
|
row = self.conn.execute(
|
|
"SELECT * FROM orders WHERE ord_no=%s", (ord_no,)
|
|
).fetchone()
|
|
return dict(row) if row else None
|
|
except Exception as e:
|
|
logger.error("get_order_by_odno 실패: %s", e)
|
|
return None
|
|
|
|
def get_orders_today(
|
|
self, strategy_id: Optional[str] = None
|
|
) -> List[Dict]:
|
|
today = datetime.datetime.now().strftime("%Y-%m-%d")
|
|
try:
|
|
if strategy_id:
|
|
rows = self.conn.execute(
|
|
"""
|
|
SELECT * FROM orders
|
|
WHERE ord_date=%s AND strategy_id=%s
|
|
ORDER BY submitted_at DESC
|
|
""",
|
|
(today, strategy_id),
|
|
).fetchall()
|
|
else:
|
|
rows = self.conn.execute(
|
|
"""
|
|
SELECT * FROM orders
|
|
WHERE ord_date=%s
|
|
ORDER BY submitted_at DESC
|
|
""",
|
|
(today,),
|
|
).fetchall()
|
|
return [dict(r) for r in rows]
|
|
except Exception as e:
|
|
logger.error("get_orders_today 실패: %s", e)
|
|
return []
|
|
|
|
# ------------------------------------------------------------------
|
|
# 조건검색 유니버스 스냅샷 (백테스트용 이력)
|
|
# ------------------------------------------------------------------
|
|
# 설계 원칙:
|
|
# - 5분 슬롯 스냅샷은 정보 손실이 크다(그 사이 들락날락한 종목 유실).
|
|
# - 따라서 **변동(ENTER/EXIT) 발생 tick 마다 풀 스냅샷**을 저장한다.
|
|
# - 변동 없는 tick 은 저장하지 않는다 (공간 절약).
|
|
# - 각 스냅샷은 같은 ``event_time`` 을 공유하는 N 행으로 표현.
|
|
# - 백테스트 시 특정 시점 유니버스 = 그 시점 이전 최근 event_time.
|
|
_HISTORY_MIGRATED = False
|
|
|
|
def _ensure_history_columns(self) -> None:
|
|
"""
|
|
target_candidates_history 에 필요한 확장 컬럼을 자동 추가:
|
|
* strategy_id — 전략 구분 (기존 키움 스캐너 행은 NULL)
|
|
* event_time — 스냅샷 시각 (초 단위 'YYYY-MM-DD HH:MM:SS')
|
|
"""
|
|
if TradeDBExt._HISTORY_MIGRATED:
|
|
return
|
|
try:
|
|
cols = self.conn.get_columns("target_candidates_history")
|
|
if "strategy_id" not in cols:
|
|
self.conn.execute(
|
|
"ALTER TABLE target_candidates_history "
|
|
"ADD COLUMN strategy_id VARCHAR(30) DEFAULT NULL"
|
|
)
|
|
logger.info("📌 target_candidates_history.strategy_id 컬럼 추가")
|
|
if "event_time" not in cols:
|
|
self.conn.execute(
|
|
"ALTER TABLE target_candidates_history "
|
|
"ADD COLUMN event_time VARCHAR(19) DEFAULT NULL"
|
|
)
|
|
logger.info("📌 target_candidates_history.event_time 컬럼 추가")
|
|
# 인덱스 — 백테스트 조회 속도 확보
|
|
for idx_name, idx_def in (
|
|
("idx_strategy_event",
|
|
"(strategy_id, event_time)"),
|
|
):
|
|
try:
|
|
self.conn.execute(
|
|
f"CREATE INDEX {idx_name} "
|
|
f"ON target_candidates_history {idx_def}"
|
|
)
|
|
except Exception as e:
|
|
# 이미 존재 / 버전 미지원 → 무시
|
|
if "1061" not in str(e) and "Duplicate" not in str(e):
|
|
logger.debug("idx %s 생성 실패: %s", idx_name, e)
|
|
except Exception as e:
|
|
logger.debug("history 컬럼 마이그레이션: %s", e)
|
|
TradeDBExt._HISTORY_MIGRATED = True
|
|
|
|
def insert_condition_universe_snapshot(
|
|
self,
|
|
*,
|
|
strategy_id: str,
|
|
event_time: str,
|
|
items: List[Dict],
|
|
slot_key: Optional[str] = None,
|
|
) -> int:
|
|
"""
|
|
조건검색 변동(ENTER/EXIT) 발생 tick 마다 호출되는 **풀 스냅샷** 저장.
|
|
같은 ``event_time`` 으로 들어온 N 행 = 그 시점의 유니버스 전체.
|
|
|
|
Args:
|
|
strategy_id : 'SCALP' | 'SHORT' | 'BREAKOUT' ...
|
|
event_time : 'YYYY-MM-DD HH:MM:SS' (초 단위). 백테스트 기준 시각.
|
|
items : [{"code": "...", "name": "..."}, ...] — 현재 유니버스 전체
|
|
slot_key : (선택) 기존 5분 슬롯 키. 과거 대시보드/쿼리 호환용.
|
|
|
|
Returns: 실제 INSERT 된 행수
|
|
"""
|
|
if not items or not event_time:
|
|
return 0
|
|
self._ensure_history_columns()
|
|
|
|
# slot_key 기본값 — 기존 스키마 NOT NULL 이므로 최소한 값 채움
|
|
if not slot_key:
|
|
# event_time 'YYYY-MM-DD HH:MM:SS' → 'YYYYMMDDHHMM' (5분 단위 반올림 X, 그대로)
|
|
try:
|
|
dp = event_time.replace("-", "").replace(":", "").replace(" ", "")
|
|
slot_key = dp[:12] # YYYYMMDDHHMM
|
|
except Exception:
|
|
slot_key = event_time[:12]
|
|
|
|
inserted = 0
|
|
try:
|
|
with self.conn:
|
|
# 동일 (전략, event_time) 키로 재호출되면 이전 것 지우고 재기록
|
|
# (사실상 중복 호출 방지용 — ConditionSearchManager 가 tick 단위 유니크)
|
|
self.conn.execute(
|
|
"DELETE FROM target_candidates_history "
|
|
"WHERE strategy_id=%s AND event_time=%s",
|
|
(strategy_id, event_time),
|
|
)
|
|
for it in items:
|
|
code = (it.get("code") or "").strip()
|
|
if not code:
|
|
continue
|
|
name = (it.get("name") or code)[:100]
|
|
try:
|
|
self.conn.execute(
|
|
"""
|
|
INSERT INTO target_candidates_history
|
|
(slot_key, scan_time, code, name, score, price,
|
|
market, sector, theme, strategy_id, event_time)
|
|
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
|
""",
|
|
(slot_key, event_time, code, name, 0.0, 0.0,
|
|
"Q", "", "", strategy_id, event_time),
|
|
)
|
|
inserted += 1
|
|
except Exception as e:
|
|
logger.debug("history insert 실패(%s/%s): %s",
|
|
strategy_id, code, e)
|
|
except Exception as e:
|
|
logger.warning("history 스냅샷 저장 실패: %s", e)
|
|
return inserted
|
|
|
|
# 범용 별칭 — 유니버스 소스가 condition 이든 ranking 이든 같은 테이블을 공유
|
|
# (함수명 혼동 줄이기 위한 alias. 기존 호출부는 그대로 동작)
|
|
def insert_universe_snapshot(
|
|
self,
|
|
*,
|
|
strategy_id: str,
|
|
event_time: str,
|
|
items: List[Dict],
|
|
slot_key: Optional[str] = None,
|
|
) -> int:
|
|
return self.insert_condition_universe_snapshot(
|
|
strategy_id=strategy_id, event_time=event_time,
|
|
items=items, slot_key=slot_key,
|
|
)
|
|
|
|
# ------------------------------------------------------------------
|
|
# 백테스트 헬퍼: 특정 시점의 유니버스 복원
|
|
# ------------------------------------------------------------------
|
|
def get_universe_at(
|
|
self, *, strategy_id: str, at_time: str
|
|
) -> List[Dict]:
|
|
"""
|
|
``at_time`` ('YYYY-MM-DD HH:MM:SS') 시점에 봇이 보던 유니버스를 복원.
|
|
= 그 시각 이전의 가장 최근 event_time 스냅샷.
|
|
"""
|
|
self._ensure_history_columns()
|
|
try:
|
|
row = self.conn.execute(
|
|
"""
|
|
SELECT MAX(event_time) AS et
|
|
FROM target_candidates_history
|
|
WHERE strategy_id=%s AND event_time <= %s
|
|
""",
|
|
(strategy_id, at_time),
|
|
).fetchone()
|
|
et = (row or {}).get("et") if row else None
|
|
if not et:
|
|
return []
|
|
rows = self.conn.execute(
|
|
"""
|
|
SELECT code, name FROM target_candidates_history
|
|
WHERE strategy_id=%s AND event_time=%s
|
|
ORDER BY code
|
|
""",
|
|
(strategy_id, et),
|
|
).fetchall()
|
|
return [{"code": r["code"], "name": r["name"]} for r in rows]
|
|
except Exception as e:
|
|
logger.error("get_universe_at 실패: %s", e)
|
|
return []
|
|
|
|
def iter_universe_events(
|
|
self,
|
|
*,
|
|
strategy_id: str,
|
|
start_time: str,
|
|
end_time: str,
|
|
) -> List[Dict]:
|
|
"""
|
|
``[start_time, end_time]`` 구간의 모든 스냅샷 이벤트를 시간순 반환.
|
|
각 이벤트 = {"event_time": ..., "codes": [...]}.
|
|
백테스트 루프에서 시점별 유니버스를 순회할 때 사용.
|
|
"""
|
|
self._ensure_history_columns()
|
|
try:
|
|
rows = self.conn.execute(
|
|
"""
|
|
SELECT event_time, code, name
|
|
FROM target_candidates_history
|
|
WHERE strategy_id=%s
|
|
AND event_time BETWEEN %s AND %s
|
|
ORDER BY event_time, code
|
|
""",
|
|
(strategy_id, start_time, end_time),
|
|
).fetchall()
|
|
grouped: Dict[str, List[Dict]] = {}
|
|
for r in rows:
|
|
et = r["event_time"]
|
|
grouped.setdefault(et, []).append(
|
|
{"code": r["code"], "name": r["name"]}
|
|
)
|
|
return [
|
|
{"event_time": et, "items": items}
|
|
for et, items in sorted(grouped.items())
|
|
]
|
|
except Exception as e:
|
|
logger.error("iter_universe_events 실패: %s", e)
|
|
return []
|
|
|
|
def get_universe_by_candle_time(
|
|
self,
|
|
*,
|
|
strategy_id: str,
|
|
start_ymd: str,
|
|
end_ymd: str,
|
|
) -> Dict[str, List[str]]:
|
|
"""
|
|
백테스트 편의용 — 1분봉 캔들 시각(YYYYMMDDHHMM)을 키로 하는 유니버스 dict.
|
|
|
|
실매매는 10초 주기로 REST 를 돌려 변동 tick 마다 초단위 ``event_time``
|
|
(YYYY-MM-DD HH:MM:SS) 으로 ``target_candidates_history`` 에 적재한다.
|
|
반면 백테스트 엔진은 1분봉 단위로 돌아가므로, 각 캔들에 대해
|
|
**그 캔들의 종가 형성 시각 (HH:MM:59) 이전의 가장 최근 스냅샷** 을
|
|
선택해 "그 시점에 봇이 보던 유니버스" 를 재현한다.
|
|
|
|
Args:
|
|
strategy_id: 'SCALP' | 'SHORT' | 'BREAKOUT'
|
|
start_ymd: 시작일 YYYYMMDD
|
|
end_ymd: 종료일 YYYYMMDD
|
|
|
|
Returns:
|
|
``{candle_time(YYYYMMDDHHMM): [code, ...]}`` —
|
|
해당 1분 캔들 종료 시점에 유효했던 유니버스 코드 리스트.
|
|
스냅샷이 하나도 없으면 빈 dict.
|
|
"""
|
|
self._ensure_history_columns()
|
|
|
|
# 조회 범위: 전일 마지막 스냅샷도 포함하기 위해 시작일 00:00:00 이전 1건은
|
|
# 엔진 쪽에서 "이전에 유효했던 유니버스" 로 물려받는 게 자연스럽다.
|
|
# 단순화를 위해 start_ymd 00:00:00 ~ end_ymd 23:59:59 범위로 쿼리.
|
|
start_time = (
|
|
f"{start_ymd[:4]}-{start_ymd[4:6]}-{start_ymd[6:8]} 00:00:00"
|
|
)
|
|
end_time = (
|
|
f"{end_ymd[:4]}-{end_ymd[4:6]}-{end_ymd[6:8]} 23:59:59"
|
|
)
|
|
|
|
events = self.iter_universe_events(
|
|
strategy_id=strategy_id,
|
|
start_time=start_time,
|
|
end_time=end_time,
|
|
)
|
|
if not events:
|
|
return {}
|
|
|
|
# 각 스냅샷의 event_time 을 'YYYYMMDDHHMMSS' (14자리 정수비교용) 으로 정규화.
|
|
# event_time 문자열은 이미 시간순 정렬됨 (iter_universe_events).
|
|
normalized: List[tuple] = []
|
|
for ev in events:
|
|
et = str(ev.get("event_time") or "")
|
|
if len(et) < 19:
|
|
continue
|
|
et_key = (
|
|
et[0:4] + et[5:7] + et[8:10]
|
|
+ et[11:13] + et[14:16] + et[17:19]
|
|
) # YYYYMMDDHHMMSS
|
|
codes = [it["code"] for it in ev.get("items", []) if it.get("code")]
|
|
normalized.append((et_key, codes))
|
|
|
|
if not normalized:
|
|
return {}
|
|
|
|
out: Dict[str, List[str]] = {}
|
|
# candle_time 은 분단위 (YYYYMMDDHHMM). 각 캔들의 "종가 형성 시점" 은
|
|
# 그 분의 59초로 본다 → candle_end_key = candle_time + "59".
|
|
# 스냅샷 포인터를 전진하며 O(N+M) 으로 매칭.
|
|
ev_idx = 0
|
|
n_ev = len(normalized)
|
|
active_codes: List[str] = []
|
|
|
|
# 첫 이벤트 시각을 분단위로 내림 → 그 이전 캔들은 유니버스 없음
|
|
first_ev_key = normalized[0][0]
|
|
|
|
# 날짜별 장중 시간대 (09:00~15:30) 1분 단위로 캔들 시각 생성.
|
|
# DB 에 없는 시각도 dict 에 key 가 생기면 메모리 낭비이므로, 엔진이 실제
|
|
# 요청하는 캔들 시각에 대해서만 값을 반환하도록 **lazy** 하게 넘기고 싶지만,
|
|
# 엔진 쪽은 dict lookup 만 하므로 여기서 미리 만들어 주는 편이 단순.
|
|
from datetime import datetime, timedelta
|
|
d0 = datetime.strptime(start_ymd, "%Y%m%d").date()
|
|
d1 = datetime.strptime(end_ymd, "%Y%m%d").date()
|
|
day = d0
|
|
while day <= d1:
|
|
# 장중 대략 범위: 08:00 ~ 16:00 (pre/post 여유)
|
|
t = datetime.combine(day, datetime.min.time()).replace(hour=8)
|
|
t_end = datetime.combine(day, datetime.min.time()).replace(hour=16)
|
|
while t <= t_end:
|
|
candle_time = t.strftime("%Y%m%d%H%M")
|
|
candle_end_key = candle_time + "59" # YYYYMMDDHHMMSS
|
|
# 그 이전 또는 같은 시각의 가장 최근 event_time 까지 포인터 전진
|
|
while ev_idx < n_ev and normalized[ev_idx][0] <= candle_end_key:
|
|
active_codes = normalized[ev_idx][1]
|
|
ev_idx += 1
|
|
if active_codes and candle_end_key >= first_ev_key:
|
|
out[candle_time] = active_codes
|
|
t += timedelta(minutes=1)
|
|
day += timedelta(days=1)
|
|
|
|
return out
|
|
|
|
# ------------------------------------------------------------------
|
|
# TradeDB 위임 (원본 API 그대로 사용)
|
|
# ------------------------------------------------------------------
|
|
def __getattr__(self, name):
|
|
"""TradeDBExt 에 없는 속성/메서드는 self.raw 에 위임."""
|
|
return getattr(self.raw, name)
|