pyqqq 0.12.167__tar.gz → 0.12.169__tar.gz

{pyqqq-0.12.167 → pyqqq-0.12.169}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyqqq
-Version: 0.12.167
+Version: 0.12.169
 Summary: Package for quantitative strategy development on the PyQQQ platform
 License: MIT
 Author: PyQQQ team

{pyqqq-0.12.167 → pyqqq-0.12.169}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyqqq"
-version = "0.12.167"
+version = "0.12.169"
 description = "Package for quantitative strategy development on the PyQQQ platform"
 authors = ["PyQQQ team <pyqqq.cs@gmail.com>"]
 readme = "README.md"

{pyqqq-0.12.167 → pyqqq-0.12.169}/pyqqq/backtest/broker.py

@@ -1,5 +1,6 @@
 import datetime as dtm
 import os
+import fcntl
 from abc import ABC, abstractmethod
 from dataclasses import asdict
 from decimal import Decimal
@@ -291,7 +292,7 @@ class TradingBroker(BaseBroker):
 
     def create_order(self, asset_code: str, side: OrderSide, quantity: int, order_type: OrderType = OrderType.MARKET, price: int | Decimal = 0, exchange: OrderExchange = OrderExchange.KRX) -> str:
         self.logger.debug(f"create_order: {asset_code} {side} {quantity} {order_type} {price} {exchange}")
-        return self.trading_api.create_order(asset_code, side, quantity, order_type, price, exchange)
+        return self.trading_api.create_order(asset_code, side, quantity, order_type, price, exchange=exchange)
 
     def update_order(self, org_order_no: str, order_type: OrderType, price: int | Decimal, quantity: int = 0, exchange: OrderExchange = OrderExchange.KRX):
         if isinstance(self.trading_api, KISSimpleOverseasStock):
@@ -305,7 +306,7 @@ class TradingBroker(BaseBroker):
                 raise ValueError(f"order not found: {org_order_no}")
         else:
             self.logger.debug(f"update_order: {org_order_no} {order_type} {price} {quantity}")
-            return self.trading_api.update_order(org_order_no, order_type, price, quantity, exchange)
+            return self.trading_api.update_order(org_order_no, order_type, price, quantity, exchange=exchange)
 
     def cancel_order(self, order_no: str, quantity: int = 0):
         if isinstance(self.trading_api, KISSimpleOverseasStock):
@@ -383,6 +384,7 @@ class MockBroker(BaseBroker):
         time_unit="minutes",
         current_data_handling: Literal["include", "virtual", "exclude"] = "virtual",
         local_cache_path: str = LOCAL_CACHE_PATH,
+        market_nxt_on: bool = False,
     ):
         """MockBroker 클래스의 초기화 메서드입니다.
 
@@ -398,11 +400,14 @@ class MockBroker(BaseBroker):
                 - "virtual": 직전(1분전)까지의 데이터 + 현재(분)의 시가로 통일한 가상 데이터 반환 (기본값)
                 - "exclude": 직전(1분전)까지의 데이터만 반환
             local_cache_path (str, optional): 데이터 로컬 캐시 경로. Defaults to "./data".
+            market_nxt_on (bool, optional): 넥스트레이드 시장 활성화 여부. Defaults to False.
         """
         self.logger = get_logger("MockBroker", clock)
         self.clock = clock
         self.clock.on_time_change = self.on_time_change
         self.market = market
+        self.market_nxt_on = market_nxt_on
+        self.logger.info(f"init market_nxt_on={self.market_nxt_on}")
 
         self.next_order_no = 1000
         self.cash = 1_000_000_000
@@ -470,8 +475,12 @@ class MockBroker(BaseBroker):
         def typed_result(value) -> Decimal:
             return Decimal(value).quantize(Decimal("0.0000")) if self.market == "us_stock" else Decimal(int(value))
 
-        schedule = get_market_schedule(today, exchange=self._get_exchange_code())
-        if now.time() < schedule.open_time:
+        market_schedule = get_market_schedule(today, exchange=self._get_exchange_code())
+        open_time = market_schedule.open_time
+        if self.market_nxt_on:
+            open_time = dtm.time(8, 0, 0)
+
+        if now.time() < open_time:
             last_trading_day = get_last_trading_day(today, exchange=self._get_exchange_code())
             df = self.get_daily_price(code, last_trading_day, last_trading_day)  # 전일 종가는 일봉, 분봉 구분이 필요 없다.
             return typed_result(df["close"].iloc[-1])
@@ -496,7 +505,8 @@ class MockBroker(BaseBroker):
 
     def get_minute_price(self, code: str) -> pd.DataFrame:
         """
-        self.clock 기준 오늘 정규장 시작부터 현재 시각 (이전) 까지의 분봉 데이터를 조회합니다.
+        self.clock 기준 당일의 정규장 시작부터 현재 시각 (이전) 까지의 분봉 데이터를 조회합니다.  
+        단, market_nxt_on 이면, NXT 가능 종목의 경우 프리마켓, 정규마켓, 애프터마켓의 분봉을 모두 조회합니다.
 
         Args:
             code (str): 종목 코드
@@ -509,13 +519,21 @@ class MockBroker(BaseBroker):
         if df.empty:
             return df
 
-        # 정규장 정보로만 거르기
+        # 정규장 정보로만 거르기 ==================================
         market_schedule = get_market_schedule(today, "NYSE" if self.market == "us_stock" else "KRX")
         open_time = dtm.datetime.combine(today, market_schedule.open_time)
         close_time = dtm.datetime.combine(today, market_schedule.close_time)
+
+        # TODO: us_stock 에 대해서는 따로 적용해야 함.
+        is_nxt = df.index[0] == dtm.datetime.combine(today, dtm.time(8, 0, 0))
+        if self.market_nxt_on and is_nxt:
+            open_time = dtm.datetime.combine(today, dtm.time(8, 0, 0))
+            close_time = dtm.datetime.combine(today, dtm.time(20, 0, 0))
+
         if df.index.tz is not None:
             df.index = df.index.tz_localize(None)
         df = df[(df.index >= open_time) & (df.index <= close_time)]
+        # ========================================================
 
         # 미래 정보 없애기
         now = pd.Timestamp(self.clock.now())
@@ -558,34 +576,71 @@ class MockBroker(BaseBroker):
 
     @lru_cache(maxsize=40)
     def _get_minute_price_with_cache(self, date, code) -> pd.DataFrame:
-        file_path = f"{self.local_cache_path}/minutes/{date}/{code}.csv" if self.local_cache_path else None
+        """
+        market_nxt_on 이면, NXT 프리마켓, 정규마켓, 애프터마켓의 분봉이 모두 반환된다.
+        """
+        folder_name = "nxt_minutes" if self.market_nxt_on else "minutes"
+        file_path = f"{self.local_cache_path}/{folder_name}/{date}/{code}.csv" if self.local_cache_path else None
         if file_path and os.path.exists(file_path):
-            df = pd.read_csv(file_path)
-            df["time"] = pd.to_datetime(df["time"])
-            df.set_index("time", inplace=True)
-            return df
+            try:
+                with open(file_path, 'r') as f:
+                    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+                    try:
+                        df = pd.read_csv(f)
+                        df['time'] = pd.to_datetime(df['time'])
+                        df.set_index('time', inplace=True)
+                    finally:
+                        fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+            except Exception as e:
+                self.logger.exception(e)
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+                df = self._fetch_minute_price(date, code)
+        else:
+            df = self._fetch_minute_price(date, code)
+
+        return df
 
+    def _fetch_minute_price(self, date, code) -> pd.DataFrame:
+        folder_name = "nxt_minutes" if self.market_nxt_on else "minutes"
+        file_path = f"{self.local_cache_path}/{folder_name}/{date}/{code}.csv" if self.local_cache_path else None
+
+        if self.market == "us_stock":
+            dfs = get_us_minute_data(date, [code])
         else:
-            if self.market == "us_stock":
-                dfs = get_us_minute_data(date, [code])
+            if self.market_nxt_on:
+                dfs = get_kr_minute_data(date, [code], dtm.timedelta(minutes=1), source="kis", adjusted=True, exchange=DataExchange.NXT)
+                if dfs[code].empty:  # NXT 에 해당 종목이 없는 경우 KRX 의 결과값을 반환한다. 하지만 로컬 캐시 폴더는 NXT 기준으로 저장한다.
+                    dfs = get_kr_minute_data(date, [code], dtm.timedelta(minutes=1), source="kis", adjusted=True, exchange=DataExchange.KRX)
             else:
-                dfs = get_kr_minute_data(date, [code], dtm.timedelta(minutes=1), source="kis", adjusted=True)
+                dfs = get_kr_minute_data(date, [code], dtm.timedelta(minutes=1), source="kis", adjusted=True, exchange=DataExchange.KRX)
 
-            df = dfs[code]
-            if df.empty:
-                return df
+        df = dfs[code]
+        if df.empty:
+            return df
 
-            if self.local_cache_path:
-                if not os.path.exists(f"{self.local_cache_path}/minutes/{date}"):
-                    os.makedirs(f"{self.local_cache_path}/minutes/{date}")
+        if self.local_cache_path:
+            if not os.path.exists(f"{self.local_cache_path}/{folder_name}/{date}"):
+                os.makedirs(f"{self.local_cache_path}/{folder_name}/{date}")
 
-                df.reset_index(inplace=True)
-                df.to_csv(file_path, index=False)
-                df.set_index("time", inplace=True)
+            df.reset_index(inplace=True)
+            with open(file_path, 'w') as f:
+                fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+                try:
+                    df.to_csv(f, index=False)
+                except Exception as e:
+                    self.logger.exception(e)
+                finally:
+                    fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+            df.set_index("time", inplace=True)
 
-            return df
+        return df
 
     def get_daily_price(self, code: str, from_date: Optional[dtm.date] = None, end_date: Optional[dtm.date] = None):
+        """
+        지정된 기간 동안의 정규장 시작부터 현재 시각 (이전) 까지의 일봉 데이터를 조회합니다.  
+        단, market_nxt_on 이면, NXT 가능 종목의 경우 프리마켓, 정규마켓, 애프터마켓의 일봉을 모두 조회합니다.
+        """
         today = self.clock.today()
 
         def _exclude_today(df: pd.DataFrame) -> pd.DataFrame:
@@ -604,7 +659,12 @@ class MockBroker(BaseBroker):
         if self.market == "us_stock":
             dfs = get_us_daily_data([code], from_date, end_date, adjusted=True, ascending=True)
         else:
-            dfs = get_kr_daily_data([code], from_date, end_date, adjusted=True, ascending=True)
+            if self.market_nxt_on:
+                dfs = get_kr_daily_data([code], from_date, end_date, adjusted=True, ascending=True, exchange=DataExchange.NXT)
+                if code not in dfs or dfs[code].empty:
+                    dfs = get_kr_daily_data([code], from_date, end_date, adjusted=True, ascending=True, exchange=DataExchange.KRX)
+            else:
+                dfs = get_kr_daily_data([code], from_date, end_date, adjusted=True, ascending=True, exchange=DataExchange.KRX)
 
         df = dfs[code]
 
@@ -612,16 +672,22 @@ class MockBroker(BaseBroker):
             # 마지막 데이터가 오늘인 경우 장중 여부와 설정에따라 구분되어 처리될 필요가 있다.
             now = self.clock.now()
             schedule = get_market_schedule(today, exchange=self._get_exchange_code())
+            open_time = schedule.open_time
+            close_time = schedule.close_time
+            if self.market_nxt_on:
+                open_time = dtm.time(8, 0, 0)
+                close_time = dtm.time(20, 0, 0)
+
             if schedule.full_day_closed:
                 pass  # end_date 가 폐장일이면 해당 날짜의 데이터는 이미 없음
             else:
                 if self.current_data_handling == "include":
                     pass
                 elif self.current_data_handling == "virtual":
-                    if now.time() < schedule.open_time:
+                    if now.time() < open_time:
                         # 장 오픈 전은 전일 데이터 까지만 반환
                         df = _exclude_today(df)
-                    elif now.time() <= schedule.close_time:
+                    elif now.time() <= close_time:
                         # 장중에는 분봉을 적절히 활용
                         minute_df = self.get_minute_price(code)
                         if minute_df.empty:
@@ -665,9 +731,8 @@ class MockBroker(BaseBroker):
         return positions
 
     def create_order(self, asset_code: str, side: OrderSide, quantity: int, order_type: OrderType = OrderType.MARKET, price: int = 0, exchange: OrderExchange = OrderExchange.KRX) -> str:
-        # TODO: exchange에 따라 다른 봉을 보는 처리가 추가로 되어야 함
         price = self.get_price(asset_code) if order_type == OrderType.MARKET else price
-        self.logger.info(f"CREATE ORDER: {self._get_asset_name(asset_code)} side:{side} price:{price} quantity:{quantity} order_type:{order_type}")
+        self.logger.info(f"CREATE ORDER: {self._get_asset_name(asset_code)} side:{side} price:{price} quantity:{quantity} order_type:{order_type} exchange:{exchange.value}")
         order_no = str(self.next_order_no)
         self.next_order_no += 1
 
@@ -775,14 +840,27 @@ class MockBroker(BaseBroker):
         close_time = dtm.datetime.combine(today, market_schedule.close_time)
         preclose_auction_start_time = close_time - dtm.timedelta(minutes=10)
 
+        nxt_pre_open_time = dtm.datetime.combine(today, dtm.time(8, 0, 0))
+        nxt_pre_close_time = dtm.datetime.combine(today, dtm.time(8, 50, 0))
+        nxt_main_open_time = dtm.datetime.combine(today, dtm.time(9, 0, 30))
+        nxt_main_close_time = dtm.datetime.combine(today, dtm.time(15, 20, 0))
+        nxt_after_open_time = dtm.datetime.combine(today, dtm.time(15, 40, 0))
+        nxt_after_close_time = dtm.datetime.combine(today, dtm.time(20, 0, 0))
+
         just_closed = current_time.replace(second=0, microsecond=0) == close_time.replace(second=0, microsecond=0)
         if preclose_auction_start_time - dtm.timedelta(minutes=1) <= current_time <= preclose_auction_start_time + dtm.timedelta(minutes=1):
             # 로그 출력 수 조정
             self.logger.debug(f"just_closed: {just_closed} {self.pending_orders}")
 
         if market_schedule.full_day_closed or current_time < open_time or (current_time > close_time and not just_closed):
-            self.logger.warning(f"on_time_change: {before_time} ~ {current_time} market is closed")
-            return
+            if self.market_nxt_on and not market_schedule.full_day_closed:
+                # market_nxt_on 인 경우 메인 마켓은 KRX 그대로 사용하고 프리마켓과 애프터마켓만 추가한다.
+                if current_time < nxt_pre_open_time or nxt_pre_close_time <= current_time < open_time or close_time < current_time < nxt_after_open_time or nxt_after_close_time <= current_time:
+                    self.logger.warning(f"on_time_change(nxt_on): {before_time} ~ {current_time} market is closed")
+                    return
+            else:
+                self.logger.warning(f"on_time_change: {before_time} ~ {current_time} market is closed")
+                return
 
         for order in list(self.pending_orders):
             if self.time_unit == "minutes":
@@ -794,7 +872,6 @@ class MockBroker(BaseBroker):
                     # 강제로 1분 차이를 만들어 줌
                     before_time = current_time - dtm.timedelta(seconds=60)
 
-                # TODO: exchange에 따라 다른 봉을 보는 처리가 추가로 되어야 함
                 df = self.get_minute_price(order.asset_code)
                 if df.empty:
                     self.logger.warning(f"ORDER CANCELED: {order.asset_code} minute data is empty")

{pyqqq-0.12.167 → pyqqq-0.12.169}/pyqqq/brokerage/kis/domestic_stock.py

@@ -2646,6 +2646,16 @@ class KISDomesticStock:
                 - ocr_no: OCR번호
                 - crfd_item_yn: 크라우드펀딩종목여부
                 - elec_scty_yn: 전자증권여부
+                - issu_istt_cd: 발행기관코드
+                - etf_chas_erng_rt_dbnb: ETF추적수익율배수
+                - etf_etn_ivst_heed_item_yn: ETF/ETN투자유의종목여부
+                - stln_int_rt_dvsn_cd: 대주이자율구분코드
+                - frnr_psnl_lmt_rt: 외국인개인한도비율
+                - lstg_rqsr_issu_istt_cd: 상장신청인발행기관코드
+                - lstg_rqsr_item_cd: 상장신청인종목코드
+                - trst_istt_issu_istt_cd: 신탁기관발행기관코드
+                - cptt_trad_tr_psbl_yn: NXT 거래종목여부
+                - nxt_tr_stop_yn: NXT 거래정지여부
 
         Raise:
             ValueError: API 에러 발생시

{pyqqq-0.12.167 → pyqqq-0.12.169}/pyqqq/brokerage/kis/simple.py

@@ -278,10 +278,10 @@ class KISSimpleDomesticStock:
 
         Args:
             asset_code(str): 종목코드
-            data_exchange(DataExchange): 데이터 거래소
+            data_exchange(DataExchange): 데이터 거래소 (cf. NXT의 경우 해당되지 않는 종목은 Empty DataFrame이 아니고 모든 값이 0인 DataFrame이 반환됩니다.)
 
         Returns:
-            pd.DataFrame: 분봉 데이터
+            pd.DataFrame: 분봉 데이터 (시간의 역순)
         """
 
         request_datetime = dtm.datetime.now()
@@ -321,9 +321,9 @@ class KISSimpleDomesticStock:
 
             open_time = schedule.open_time
 
-            # FIXME: 넥스트레이드 시장은 1시간 전 데이터를 조회해야 함
+            # FIXME: 넥스트레이드 시장 (수능일 같은 경우 넥스트레이드는 시간 변동 없이 8시 그대로 오픈한다는 얘기가 있어서 확인 필요)
             if data_exchange == DataExchange.NXT:
-                open_time = (dtm.datetime.combine(request_datetime.date(), schedule.open_time) - dtm.timedelta(hours=1)).time()
+                open_time = dtm.time(8, 0, 0)
 
             if request_time.time() < open_time:
                 break

{pyqqq-0.12.167 → pyqqq-0.12.169}/pyqqq/brokerage/tracker.py

@@ -8,6 +8,7 @@ from pyqqq.utils.api_client import raise_for_status, send_request
 from pyqqq.utils.array import find
 from pyqqq.utils.logger import get_logger
 from pyqqq.utils.market_schedule import get_market_schedule, get_last_trading_day
+from pyqqq.utils.singleton import singleton
 from typing import Dict, Optional, List
 import asyncio
 import os
@@ -15,6 +16,111 @@ import pyqqq.config as c
 import datetime as dtm
 
 
+@singleton
+class TrackerSocket:
+    """
+    거래 내역 추적을 위한 WebSocket 소켓 클래스입니다.
+
+    Args:
+        simple_api (EBestSimpleDomesticStock | KISSimpleDomesticStock): 간편 거래 API 객체
+    """
+
+    def __init__(self, simple_api: EBestSimpleDomesticStock | KISSimpleDomesticStock):
+        self.simple_api = simple_api
+        self.task: asyncio.Task = None
+        self.stop_event = asyncio.Event()
+        self.logger = get_logger(__name__ + ".TrackerSocket")
+        self.trading_tracker_counter = 1
+        self.event_callbacks: Dict[callable] = {}
+
+    async def start(self):
+        """
+        TradingSocket에서 거래내역 추적을 시작합니다.
+        """
+        if self.task is not None and not self.task.done():
+            self.logger.info("TrackerSocket already started!")
+            return
+
+        self.task = asyncio.create_task(self._listen_order_event())
+        self.logger.info("TrackerSocket started!")
+
+    async def _listen_order_event(self):
+        """
+        주문 이벤트를 수신하고 처리하는 비동기 메서드입니다.
+        """
+        self.logger.info("Listening for order events...")
+        try:
+            async for event in self.simple_api.listen_order_event(self.stop_event):
+                self._relay_order_event(event)
+        except asyncio.CancelledError:
+            self.logger.info("Order event listening cancelled.")
+        except Exception as e:
+            self.logger.exception(f"Error while listening to order events: {e}")
+
+    def _relay_order_event(self, event: OrderEvent):
+        """
+        주문 이벤트를 등록된 콜백 함수로 전달합니다.
+
+        Args:
+            event (OrderEvent): 주문 이벤트 객체
+        """
+        self.logger.debug(f"Relay order event: {event}")
+
+        for callback in self.event_callbacks.values():
+            try:
+                callback(event)
+            except Exception as e:
+                self.logger.exception(f"Error in callback {callback}: {e}")
+
+    def add_tracker(self, callback: callable):
+        """
+        TradingTracker를 추가합니다.
+
+        Args:
+            callback (callable): 거래 내역 추적 이벤트를 처리할 콜백 함수
+        """
+        ret = self.trading_tracker_counter
+        self.event_callbacks[self.trading_tracker_counter] = callback
+        self.trading_tracker_counter += 1
+
+        self.logger.info(f"Tracker added: {ret}")
+        return ret
+
+    async def remove_tracker(self, tracker_number: int):
+        """
+        TradingTracker를 제거합니다.
+        Args:
+            tracker_number (int): 제거할 트래커 번호
+        """
+        if tracker_number in self.event_callbacks:
+            del self.event_callbacks[tracker_number]
+            self.logger.info(f"Tracker removed: {tracker_number}")
+        else:
+            self.logger.warning(f"Tracker {tracker_number} not found!")
+
+        if len(self.event_callbacks) == 0:
+            self.logger.info("No more trackers, stopping TrackerSocket.")
+            await self.stop()
+
+    async def stop(self):
+        """
+        거래 내역 추적을 중지합니다.
+        """
+        if self.task is None or self.task.done():
+            self.logger.info("TrackerSocket already stopped!")
+            return
+
+        self.stop_event.set()
+        self.task.cancel()
+        try:
+            await self.task
+        except asyncio.CancelledError:
+            pass
+        self.logger.info("TrackerSocket stopped!")
+
+        self.task = asyncio.create_task(self._monitor_schedule())
+
+
 class TradingTracker:
     """
     거래 내역 추적을 위한 클래스입니다
@@ -69,7 +175,6 @@ class TradingTracker:
         """ 백그라운드로 실행되는 거래 이벤트 모니터링 Task """
 
         self.simple_api = simple_api
-        self.stop_event = asyncio.Event()
         self.account_no = None
         self.fee_rate = fee_rate  # 증권사 수수료율
         self.tax_rate = Decimal("0.0018")  # KOSPI, KOSDAQ 매도시 거래세율 0.18%
@@ -77,6 +182,8 @@ class TradingTracker:
         self.ticker_date: dtm.datetime = None  # 종목 정보 갱신 시간
         self.save_trading_history = False  # 거래 내역 저장 여부
         self.last_t_day_tickers: Dict[str, Dict] = {}
+        self.tracker_socket = TrackerSocket(simple_api)
+        self.tracker_number = None
 
         self.started = False
         self.callback_id = 0
@@ -94,7 +201,7 @@ class TradingTracker:
         elif isinstance(self.simple_api, KISSimpleDomesticStock):
             self.account_no = self.simple_api.account_no + self.simple_api.account_product_code
 
-        self.logger.info(f"Trading tarcker started! Account No: {self.account_no} / save history: {self.save_trading_history}")
+        self.logger.info(f"Trading tracker started! Account No: {self.account_no} / save history: {self.save_trading_history}")
 
         self._fetch_tickers()
         self._sync_positions_and_pending_orders()
@@ -104,8 +211,10 @@ class TradingTracker:
             for o in self.pending_orders:
                 self.logger.info(f"- {o.order_no}({o.org_order_no})\t{o.side}\t{o.asset_code}\t{o.filled_quantity}/{o.quantity}\t{o.is_pending}")
 
+        self.tracker_number = self.tracker_socket.add_tracker(self._handle_order_event)
+
         self.tasks = [
-            asyncio.create_task(self._monitor_trading()),
+            asyncio.create_task(self.tracker_socket.start()),
             asyncio.create_task(self._monitor_schedule()),
         ]
         self.started = True
@@ -142,25 +251,15 @@ class TradingTracker:
         """
         거래 내역 추적을 중지합니다
         """
-        self.stop_event.set()
         for t in self.tasks:
             t.cancel()
-
         await asyncio.gather(*self.tasks)
+        await self.tracker_socket.remove_tracker(self.tracker_number)
         self.started = False
 
-    async def _monitor_trading(self):
-        try:
-            async for event in self.simple_api.listen_order_event(self.stop_event):
-                self._handle_order_event(event)
-        except asyncio.CancelledError:
-            return
-        except Exception as e:
-            self.logger.exception(f"Error on handling order event: {e}")
-
     async def _monitor_schedule(self):
         """거래 시간대별 작업을 위한 스케줄을 모니터링합니다"""
-        while not self.stop_event.is_set():
+        while not self.tracker_socket.stop_event.is_set():
             market_schedule = get_market_schedule(dtm.date.today())
 
             if not market_schedule.full_day_closed:

{pyqqq-0.12.167 → pyqqq-0.12.169}/pyqqq/data/daily.py

@@ -177,6 +177,9 @@ def get_ohlcv_by_codes_for_period(
         cols = data["cols"]
         dataset = data["rows"]
 
+        if not dataset:
+            continue
+
         for code in dataset.keys():
             rows = dataset[code]
             for row in rows:

{pyqqq-0.12.167 → pyqqq-0.12.169}/pyqqq/data/minutes.py

@@ -149,11 +149,11 @@ def get_all_day_data(
         source (str, optional): 데이터를 검색할 API. 'ebest' 또는 'kis'를 지정할 수 있습니다. 기본값은 'ebest'입니다.
         adjusted (bool): 수정주가 여부. 기본값은 True.
         ascending (bool): 오름차순 여부. 기본값은 True.
-        exchange (Union[str, DataExchange]): 거래소. 기본값은 KRX.
+        exchange (Union[str, DataExchange]): 거래소. 기본값은 KRX. (cf. NXT의 경우 해당되지 않는 종목은 Empty DataFrame이 반환됩니다.)
 
     Returns:
         dict[str, pd.DataFrame]: 주식 코드를 키로 하고, 해당 주식의 일일 OHLCV 데이터가 포함된 pandas DataFrame을 값으로 하는 딕셔너리.
-        각 DataFrame에는 변환된 'time' 열이 포함되어 있으며, 이는 조회된 데이터의 시간을 나타냅니다. 'time' 열은 DataFrame의 인덱스로 설정됩니다.
+        각 DataFrame에는 변환된 'time' 열이 포함되어 있으며, 이는 조회된 데이터의 시간을 나타냅니다. 'time' 열은 DataFrame의 인덱스로 설정되고 오름차순으로 정렬됩니다.
 
         DataFrame의 열은 다음과 같습니다:
 

{pyqqq-0.12.167 → pyqqq-0.12.169}/pyqqq/data/realtime.py

@@ -95,6 +95,7 @@ def get_all_last_orderbooks():
 
     return result
 
+
 @singleton
 class TickEventListener:
     """