ksxt 1.0.4__py3-none-any.whl → 1.0.5__py3-none-any.whl

ksxt/parser/bithumb.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from operator import attrgetter
 from typing import Dict, List, Optional
 
@@ -46,8 +46,22 @@ class BithumbParser(BaseParser):
             warning_code=False if safer.safe_string(market, "market_warning") == "NONE" else True,
         )
 
-    def parse_historical_data(self, response: dict, symbol: str, base_market: str = "KRW") -> HistoricalDataInfo:
+    def parse_historical_data(
+        self,
+        response: List[Dict],
+        symbol: str,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        base_market: str = "KRW",
+    ) -> HistoricalDataInfo:
         ohlcv = [self._parse_ohlcva(_, base_market) for _ in response]
+
+        # Filter by start and end datetime
+        if start:
+            ohlcv = [data for data in ohlcv if data.datetime >= start]
+        if end:
+            ohlcv = [data for data in ohlcv if data.datetime <= end]
+
         sorted_ohlcv = sorter.sort_by(ohlcv, key="datetime")
 
         security_name = symbol
@@ -256,8 +270,21 @@ class BithumbParser(BaseParser):
             market_ask_fee=safer.safe_number(response, "maker_ask_fee"),
         )
 
-    def parse_open_order_history(self, response: dict, base_market: str = "KRW") -> OpenedOrderHistory:
+    def parse_open_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> OpenedOrderHistory:
         orders = [self._parse_open_order_info(order, base_market) for order in response]
+
+        # Filter by start and end datetime
+        if start:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return OpenedOrderHistory(history=orders)
 
     def _parse_open_order_info(self, order: dict, base_market: str = "KRW") -> OpenedOrderInfo:
@@ -268,13 +295,27 @@ class BithumbParser(BaseParser):
             price=safer.safe_number(order, "price"),
             qty=safer.safe_number(order, "volume"),
             amount=safer.safe_number(order, "price") * safer.safe_number(order, "volume"),
+            tax=0,
             fee=safer.safe_number(order, "reserved_fee"),
             created_at=datetime.fromisoformat(safer.safe_string(order, "created_at")),
             order_type=safer.safe_string(order, "ord_type"),
         )
 
-    def parse_closed_order_history(self, response: dict, base_market: str = "KRW") -> ClosedOrderHistory:
+    def parse_closed_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> ClosedOrderHistory:
         orders = [self._parse_closed_order_info(order, base_market) for order in response]
+
+        # Filter by start and end datetime
+        if start:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return ClosedOrderHistory(history=orders)
 
     def _parse_closed_order_info(self, order: dict, base_market: str = "KRW") -> ClosedOrderInfo:
@@ -285,6 +326,7 @@ class BithumbParser(BaseParser):
             price=safer.safe_number(order, "price"),
             qty=safer.safe_number(order, "volume"),
             amount=safer.safe_number(order, "price") * safer.safe_number(order, "volume"),
+            tax=0,
             fee=safer.safe_number(order, "reserved_fee"),
             created_at=datetime.fromisoformat(safer.safe_string(order, "created_at")),
             order_type=safer.safe_string(order, "ord_type"),
@@ -296,12 +338,46 @@ class BithumbParser(BaseParser):
     def parse_create_order(self, response: dict, base_market: str = "KRW") -> CreateOrderResponse:
         return CreateOrderResponse(order_datetime=datetime.now(), order_id=safer.safe_string(response, "uuid"))
 
-    def parse_withdrawal_history(self, response: List[Dict], base_market: str = "KRW") -> WithdrawalHistory:
+    def parse_withdrawal_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> WithdrawalHistory:
         parsed_items = [self._parse_transaction_history_item(item, base_market) for item in response]
+
+        # Filter by start and end datetime
+        if start:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return WithdrawalHistory(history=parsed_items)
 
-    def parse_deposit_history(self, response: List[Dict], base_market: str = "KRW") -> DepositHistory:
+    def parse_deposit_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> DepositHistory:
         parsed_items = [self._parse_transaction_history_item(item, base_market) for item in response]
+
+        # Filter by start and end datetime
+        if start:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return DepositHistory(history=parsed_items)
 
     def _parse_transaction_history_item(self, item: Dict, base_market: str = "KRW") -> TransactionInfo:
@@ -309,6 +385,7 @@ class BithumbParser(BaseParser):
             uuid=safer.safe_string(item, "uuid"),
             type=safer.safe_string(item, "type"),
             amount=safer.safe_number(item, "amount"),
+            tax=0,
             fee=safer.safe_number(item, "fee"),
             currency=safer.safe_string(item, "currency"),
             created_at=datetime.fromisoformat(safer.safe_string(item, "created_at")),

ksxt/parser/koreainvest.py

@@ -52,9 +52,23 @@ class KoreaInvestParser(BaseParser):
             warning_code=safer.safe_boolean(market, " market_warning"),
         )
 
-    def parse_historical_data(self, response: Dict, symbol: str, base_market: str = "KRW") -> HistoricalDataInfo:
+    def parse_historical_data(
+        self,
+        response: List[Dict],
+        symbol: str,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        base_market: str = "KRW",
+    ) -> HistoricalDataInfo:
         safe_response = safer.safe_value(response, "output2")
         ohlcv = [self._parse_ohlcva(_, base_market) for _ in safe_response]
+
+        # Filter by start and end datetime
+        if start:
+            ohlcv = [data for data in ohlcv if data.datetime >= start]
+        if end:
+            ohlcv = [data for data in ohlcv if data.datetime <= end]
+
         sorted_ohlcv = sorter.sort_by(ohlcv, key="datetime")
 
         security_name = symbol
@@ -77,9 +91,23 @@ class KoreaInvestParser(BaseParser):
             acml_amount=safer.safe_number(ohlcva, "acml_tr_pbmn"),
         )
 
-    def parse_historical_index_data(self, response: Dict, symbol: str, base_market: str = "KRW") -> HistoricalDataInfo:
+    def parse_historical_index_data(
+        self,
+        response: Dict,
+        symbol: str,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        base_market: str = "KRW",
+    ) -> HistoricalDataInfo:
         safe_response = safer.safe_value(response, "output2")
         ohlcv = [self._parse_index_ohlcva(_, base_market) for _ in safe_response]
+
+        # Filter by start and end datetime
+        if start:
+            ohlcv = [data for data in ohlcv if data.datetime >= start]
+        if end:
+            ohlcv = [data for data in ohlcv if data.datetime <= end]
+
         sorted_ohlcv = sorter.sort_by(ohlcv, key="datetime")
 
         security_name = symbol
@@ -242,10 +270,19 @@ class KoreaInvestParser(BaseParser):
             market_ask_fee=0.0140527 + trading_fee,
         )
 
-    def parse_closed_order_history(self, response: Dict, base_market: str = "KRW") -> ClosedOrderHistory:
+    def parse_closed_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> ClosedOrderHistory:
         safe_response = safer.safe_value(response, "output1")
-        history = [self._parse_closed_order_info(_, base_market) for _ in safe_response]
-        return ClosedOrderHistory(history=history)
+        orders = [self._parse_closed_order_info(_, base_market) for _ in safe_response]
+
+        # Filter by start and end datetime
+        if start:
+            orders = [order for order in orders if order.created_at >= start]
+        if end:
+            orders = [order for order in orders if order.created_at <= end]
+
+        return ClosedOrderHistory(history=orders)
 
     def _parse_closed_order_info(self, order: Dict, base_market: str = "KRW") -> ClosedOrderInfo:
         if safer.safe_string(order, "sll_buy_dvsn_cd") == "01":
@@ -260,16 +297,26 @@ class KoreaInvestParser(BaseParser):
             price=safer.safe_number(order, "avg_prvs"),
             qty=safer.safe_number(order, "tot_ccld_qty"),
             amount=safer.safe_number(order, "tot_ccld_amt"),
+            tax=0,
             # 단일 주문 이력에는 수수료 관련 정보가 없고, 조회한 전체 목록에 대해 수수료 정보만 존재한다.
             fee=0,
             created_at=datetime.fromisoformat(safer.safe_string(order, "ord_dt")),
             order_type=safer.safe_string(order, "avg_prvs"),
         )
 
-    def parse_open_order_history(self, response: Dict, base_market: str = "KRW") -> OpenedOrderHistory:
+    def parse_open_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> OpenedOrderHistory:
         safe_response = safer.safe_value(response, "output1")
-        history = [self._parse_open_order_info(_, base_market) for _ in safe_response]
-        return OpenedOrderHistory(history=history)
+        orders = [self._parse_open_order_info(_, base_market) for _ in safe_response]
+
+        # Filter by start and end datetime
+        if start:
+            orders = [order for order in orders if order.created_at >= start]
+        if end:
+            orders = [order for order in orders if order.created_at <= end]
+
+        return OpenedOrderHistory(history=orders)
 
     def _parse_open_order_info(self, order: Dict, base_market: str = "KRW") -> OpenedOrderInfo:
         if safer.safe_string(order, "sll_buy_dvsn_cd") == "01":
@@ -284,6 +331,7 @@ class KoreaInvestParser(BaseParser):
             price=safer.safe_number(order, "avg_prvs"),
             qty=safer.safe_number(order, "tot_ccld_qty"),
             amount=safer.safe_number(order, "tot_ccld_amt"),
+            tax=0,
             # 단일 주문 이력에는 수수료 관련 정보가 없고, 조회한 전체 목록에 대해 수수료 정보만 존재한다.
             fee=0,
             created_at=datetime.fromisoformat(safer.safe_string(order, "ord_dt")),

ksxt/parser/parser.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Dict, List, Optional
 import inspect
 
@@ -30,7 +31,14 @@ class BaseParser:
     def _parse_market(self, market: Dict) -> SecurityData:
         self._raise_not_implemented_error()
 
-    def parse_historical_data(self, response: dict, symbol: str, base_market: str = "KRW") -> HistoricalDataInfo:
+    def parse_historical_data(
+        self,
+        response: List[Dict],
+        symbol: str,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        base_market: str = "KRW",
+    ) -> HistoricalDataInfo:
         self._raise_not_implemented_error()
 
     def _parse_ohlcva(self, ohlcva: dict, base_market: str = "KRW") -> OHLCVData:
@@ -79,13 +87,17 @@ class BaseParser:
     def parse_trade_fee(self, response: dict, base_market: str = "KRW") -> TradeFeeInfo:
         self._raise_not_implemented_error()
 
-    def parse_open_order_history(self, response: dict, base_market: str = "KRW") -> OpenedOrderHistory:
+    def parse_open_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> OpenedOrderHistory:
         self._raise_not_implemented_error()
 
     def _parse_open_order_info(self, order: dict, base_market: str = "KRW") -> OpenedOrderInfo:
         self._raise_not_implemented_error()
 
-    def parse_closed_order_history(self, response: dict, base_market: str = "KRW") -> ClosedOrderHistory:
+    def parse_closed_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> ClosedOrderHistory:
         self._raise_not_implemented_error()
 
     def _parse_closed_order_info(self, order: dict, base_market: str = "KRW") -> ClosedOrderInfo:
@@ -100,10 +112,14 @@ class BaseParser:
     def parse_create_order(self, response: dict, base_market: str = "KRW") -> CreateOrderResponse:
         self._raise_not_implemented_error()
 
-    def parse_withdrawal_history(self, response: List[Dict], base_market: str = "KRW") -> WithdrawalHistory:
+    def parse_withdrawal_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> WithdrawalHistory:
         self._raise_not_implemented_error()
 
-    def parse_deposit_history(self, response: List[Dict], base_market: str = "KRW") -> DepositHistory:
+    def parse_deposit_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> DepositHistory:
         self._raise_not_implemented_error()
 
     def _parse_transaction_history_item(self, item: Dict, base_market: str = "KRW") -> TransactionInfo:

ksxt/parser/upbit.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from operator import attrgetter
 from typing import Dict, List, Optional
 
@@ -56,8 +56,22 @@ class UpbitParser(BaseParser):
             warning_code=safer.safe_boolean(market, " market_warning"),
         )
 
-    def parse_historical_data(self, response: List[Dict], symbol: str, base_market: str = "KRW") -> HistoricalDataInfo:
+    def parse_historical_data(
+        self,
+        response: List[Dict],
+        symbol: str,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        base_market: str = "KRW",
+    ) -> HistoricalDataInfo:
         ohlcv = [self._parse_ohlcva(_, base_market) for _ in response]
+
+        # Filter by start and end datetime
+        if start:
+            ohlcv = [data for data in ohlcv if data.datetime.astimezone(timezone.utc) >= start.astimezone(timezone.utc)]
+        if end:
+            ohlcv = [data for data in ohlcv if data.datetime.astimezone(timezone.utc) <= end.astimezone(timezone.utc)]
+
         sorted_ohlcv = sorter.sort_by(ohlcv, key="datetime")
 
         security_name = symbol
@@ -262,8 +276,21 @@ class UpbitParser(BaseParser):
             market_ask_fee=safer.safe_number(response, "maker_ask_fee"),
         )
 
-    def parse_closed_order_history(self, response: List[dict], base_market: str = "KRW") -> ClosedOrderHistory:
+    def parse_closed_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> ClosedOrderHistory:
         orders = [self._parse_closed_order_info(order, base_market) for order in response]
+
+        # Filter by start and end datetime
+        if start:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return ClosedOrderHistory(history=orders)
 
     def _parse_closed_order_info(self, order: dict, base_market: str = "KRW") -> ClosedOrderInfo:
@@ -271,16 +298,30 @@ class UpbitParser(BaseParser):
             uuid=safer.safe_string(order, "uuid"),
             type=safer.safe_string(order, "side"),
             symbol=self.safe_symbol(base_market, safer.safe_string(order, "market")),
-            price=safer.safe_number(order, "price"),
+            price=safer.safe_number(order, "executed_funds") / safer.safe_number(order, "volume"),
             qty=safer.safe_number(order, "volume"),
-            amount=safer.safe_number(order, "price") * safer.safe_number(order, "volume"),
+            amount=safer.safe_number(order, "executed_funds"),
+            tax=0,
             fee=safer.safe_number(order, "paid_fee"),  # Adjusted to 'paid_fee' to match provided data
             created_at=datetime.fromisoformat(safer.safe_string(order, "created_at")),
             order_type=safer.safe_string(order, "ord_type"),
         )
 
-    def parse_open_order_history(self, response: List[dict], base_market: str = "KRW") -> OpenedOrderHistory:
+    def parse_open_order_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> OpenedOrderHistory:
         orders = [self._parse_open_order_info(order, base_market) for order in response]
+
+        # Filter by start and end datetime
+        if start:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            orders = [
+                order for order in orders if order.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return OpenedOrderHistory(history=orders)
 
     def _parse_open_order_info(self, order: dict, base_market: str = "KRW") -> OpenedOrderInfo:
@@ -288,20 +329,55 @@ class UpbitParser(BaseParser):
             uuid=safer.safe_string(order, "uuid"),
             type=safer.safe_string(order, "side"),
             symbol=self.safe_symbol(base_market, safer.safe_string(order, "market")),
-            price=safer.safe_number(order, "price"),
+            price=safer.safe_number(order, "executed_funds") / safer.safe_number(order, "volume"),
             qty=safer.safe_number(order, "volume"),
-            amount=safer.safe_number(order, "price") * safer.safe_number(order, "volume"),
+            amount=safer.safe_number(order, "executed_funds"),
+            tax=0,
             fee=safer.safe_number(order, "reserved_fee"),
             created_at=datetime.fromisoformat(safer.safe_string(order, "created_at")),
             order_type=safer.safe_string(order, "ord_type"),
         )
 
-    def parse_withdrawal_history(self, response: List[Dict], base_market: str = "KRW") -> WithdrawalHistory:
+    def parse_withdrawal_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> WithdrawalHistory:
         parsed_items = [self._parse_transaction_history_item(item, base_market) for item in response]
+
+        # Filter by start and end datetime
+        if start:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return WithdrawalHistory(history=parsed_items)
 
-    def parse_deposit_history(self, response: List[Dict], base_market: str = "KRW") -> DepositHistory:
+    def parse_deposit_history(
+        self, response: List[Dict], start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> DepositHistory:
         parsed_items = [self._parse_transaction_history_item(item, base_market) for item in response]
+
+        # Filter by start and end datetime
+        if start:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) >= start.astimezone(timezone.utc)
+            ]
+        if end:
+            parsed_items = [
+                item
+                for item in parsed_items
+                if item.created_at.astimezone(timezone.utc) <= end.astimezone(timezone.utc)
+            ]
+
         return DepositHistory(history=parsed_items)
 
     def _parse_transaction_history_item(self, item: Dict, base_market: str = "KRW") -> TransactionInfo:
@@ -309,6 +385,7 @@ class UpbitParser(BaseParser):
             uuid=safer.safe_string(item, "uuid"),
             type=safer.safe_string(item, "type"),
             amount=safer.safe_number(item, "amount"),
+            tax=0,
             fee=safer.safe_number(item, "fee"),
             currency=safer.safe_string(item, "currency"),
             created_at=datetime.fromisoformat(safer.safe_string(item, "done_at")),

ksxt/upbit.py

@@ -2,7 +2,7 @@ import hashlib
 import json
 import time
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Literal, Optional
 from urllib.parse import urlencode
 
@@ -123,10 +123,19 @@ class Upbit(RestExchange, ImplicitAPI):
         return ksxt.models.KsxtMarketResponse(header=common_header, response=common_response, info=parsed_info)
 
     def fetch_historical_data(
-        self, symbol: str, time_frame: str, start: str | None = None, end: str | None = None, base_market: str = "KRW"
+        self,
+        symbol: str,
+        time_frame: str,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        base_market: str = "KRW",
     ) -> ksxt.models.KsxtHistoricalDataResponse:
         params = {"market": self.safe_symbol(base_market, symbol), "count": 200}
 
+        if end:
+            end_utc = end.astimezone(timezone.utc)
+            params.update({"to": end_utc.strftime("%Y-%m-%d %H:%M:%S")})
+
         # TODO : time_frame 을 어떻게 고정시킬까? 우리는 분봉, 일봉, 주봉, 월봉 만 지원한다고 가정하면?
         if time_frame.endswith("m"):
             # TODO : parse number
@@ -152,9 +161,13 @@ class Upbit(RestExchange, ImplicitAPI):
         if common_response.success != "0":
             return ksxt.models.KsxtHistoricalDataResponse(header=common_header, response=common_response, info=None)
 
-        parsed_info = self.parser.parse_historical_data(response=response, symbol=symbol, base_market=base_market)
+        parsed_response = self.parser.parse_historical_data(
+            response=response, symbol=symbol, start=start, end=end, base_market=base_market
+        )
 
-        return ksxt.models.KsxtHistoricalDataResponse(header=common_header, response=common_response, info=parsed_info)
+        return ksxt.models.KsxtHistoricalDataResponse(
+            header=common_header, response=common_response, info=parsed_response
+        )
 
     def fetch_ticker(self, symbol: str, base_market: str = "KRW") -> ksxt.models.KsxtTickerResponse:
         params = {"markets": self.safe_symbol(base_market, symbol)}  # 다중 조회 시, 콤마로 구분 ex. 'KRW-BTC, BTC-ETH'
@@ -335,8 +348,8 @@ class Upbit(RestExchange, ImplicitAPI):
         self,
         acc_num: str,
         symbol: Optional[str] = "",
-        start: Optional[str] = None,
-        end: Optional[str] = None,
+        start: datetime | None = None,
+        end: datetime | None = None,
         base_market: str = "KRW",
     ) -> ksxt.models.KsxtClosedOrderResponse:
         params = {"state": "done"}
@@ -352,16 +365,18 @@ class Upbit(RestExchange, ImplicitAPI):
         if common_response.success != "0":
             return ksxt.models.KsxtClosedOrderResponse(header=common_header, response=common_response, info=None)
 
-        parsed_info = self.parser.parse_closed_order_history(response=response, base_market=base_market)
-
+        # 데이터 파싱
+        parsed_info = self.parser.parse_closed_order_history(
+            response=response, start=start, end=end, base_market=base_market
+        )
         return ksxt.models.KsxtClosedOrderResponse(header=common_header, response=common_response, info=parsed_info)
 
     def fetch_open_order(
         self,
         acc_num: str,
-        symbol: str | None = "",
-        start: str | None = None,
-        end: str | None = None,
+        symbol: Optional[str] = "",
+        start: datetime | None = None,
+        end: datetime | None = None,
         base_market: str = "KRW",
     ) -> ksxt.models.KsxtOpenOrderResponse:
         params = {"state": "wait"}
@@ -377,12 +392,15 @@ class Upbit(RestExchange, ImplicitAPI):
         if common_response.success != "0":
             return ksxt.models.KsxtOpenOrderResponse(header=common_header, response=common_response, info=None)
 
-        parsed_info = self.parser.parse_open_order_history(response=response, base_market=base_market)
+        # 데이터 파싱
+        parsed_info = self.parser.parse_open_order_history(
+            response=response, start=start, end=end, base_market=base_market
+        )
 
         return ksxt.models.KsxtOpenOrderResponse(header=common_header, response=common_response, info=parsed_info)
 
     def fetch_withdrawal_history(
-        self, acc_num: str, base_market: str = "KRW"
+        self, acc_num: str, start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
     ) -> ksxt.models.KsxtWithdrawalHistoryResponse:
         params = {"currency": base_market, "state": "DONE"}
 
@@ -394,13 +412,18 @@ class Upbit(RestExchange, ImplicitAPI):
         if common_response.success != "0":
             return ksxt.models.KsxtWithdrawalHistoryResponse(header=common_header, response=common_response, info=None)
 
-        parsed_info = self.parser.parse_withdrawal_history(response=response, base_market=base_market)
+        # 데이터 파싱
+        parsed_info = self.parser.parse_withdrawal_history(
+            response=response, start=start, end=end, base_market=base_market
+        )
 
         return ksxt.models.KsxtWithdrawalHistoryResponse(
             header=common_header, response=common_response, info=parsed_info
         )
 
-    def fetch_deposit_history(self, acc_num: str, base_market: str = "KRW") -> ksxt.models.KsxtDepositHistoryResponse:
+    def fetch_deposit_history(
+        self, acc_num: str, start: datetime | None = None, end: datetime | None = None, base_market: str = "KRW"
+    ) -> ksxt.models.KsxtDepositHistoryResponse:
         params = {"currency": base_market, "state": "ACCEPTED"}
 
         common_header = self.create_common_header(request_params=params)
@@ -411,7 +434,10 @@ class Upbit(RestExchange, ImplicitAPI):
         if common_response.success != "0":
             return ksxt.models.KsxtDepositHistoryResponse(header=common_header, response=common_response, info=None)
 
-        parsed_info = self.parser.parse_deposit_history(response=response, base_market=base_market)
+        # 데이터 파싱
+        parsed_info = self.parser.parse_deposit_history(
+            response=response, start=start, end=end, base_market=base_market
+        )
 
         return ksxt.models.KsxtDepositHistoryResponse(header=common_header, response=common_response, info=parsed_info)
 

{ksxt-1.0.4.dist-info → ksxt-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ksxt
-Version: 1.0.4
+Version: 1.0.5
 License: MIT License
         
         Copyright © 2023 AMOSA