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

ksxt/parser/bithumb.py

@@ -1,6 +1,6 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from operator import attrgetter
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from ksxt.models.transaction import (
     ClosedOrderHistory,
@@ -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
@@ -160,9 +174,19 @@ class BithumbParser(BaseParser):
 
         return ask_data, bid_data
 
-    def parse_balance(self, response: List[Dict], base_market: str = "KRW") -> BalanceInfo:
-        # currency가 'KRW'가 아닌 항목만 필터링
-        filtered_data = [data for data in response if data["currency"] != base_market]
+    def parse_balance(
+        self, response: List[Dict], base_market: str = "KRW", excluded_symbols: Optional[list[str]] = None
+    ) -> BalanceInfo:
+        # 1. Filter out entries where 'currency' is not the base_market
+        # 2. Ensure 'unit_currency' is the base_market
+        # 3. Exclude entries where 'currency' is in excluded_symbols
+        filtered_data = [
+            data
+            for data in response
+            if data["currency"] != base_market
+            and data["unit_currency"] == base_market
+            and (excluded_symbols is None or data["currency"] not in excluded_symbols)
+        ]
 
         # Initialize balance list
         balances = [self._parse_balance(data, base_market) for data in filtered_data]
@@ -196,8 +220,11 @@ class BithumbParser(BaseParser):
         )
 
     def parse_cash(self, response: List[Dict], base_market: str = "KRW") -> CashInfo:
-        # currency가 'KRW'인 항목만 필터링
-        filtered_data = [data for data in response if data["currency"] == base_market]
+        # 1. Filter entries where 'currency' is equal to 'base_market'
+        # 2. Ensure 'unit_currency' is also equal to 'base_market'
+        filtered_data = [
+            data for data in response if data["currency"] == base_market and data["unit_currency"] == base_market
+        ]
 
         # 필터링된 데이터가 없으면 기본값으로 CashInfo 반환
         if not filtered_data:
@@ -243,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:
@@ -255,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:
@@ -272,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"),
@@ -283,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:
@@ -296,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

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from ksxt.models.balance import BalanceData, BalanceInfo
 from ksxt.models.cash import CashInfo
@@ -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
@@ -153,11 +181,17 @@ class KoreaInvestParser(BaseParser):
 
         return ask_data, bid_data
 
-    def parse_balance(self, response: List[Dict], base_market: str = "KRW") -> BalanceInfo:
+    def parse_balance(
+        self, response: List[Dict], base_market: str = "KRW", excluded_symbols: Optional[list[str]] = None
+    ) -> BalanceInfo:
         safe_response = safer.safe_value(response, "output1")
 
-        # Initialize balance list
-        balances = [self._parse_balance(_, base_market) for _ in safe_response]
+        # Initialize balance list with filtering
+        balances = [
+            self._parse_balance(_, base_market)
+            for _ in safe_response
+            if excluded_symbols is None or safer.safe_string(_, "pdno") not in excluded_symbols
+        ]
 
         # 총 매입금액
         total_amount = sum(bal.price * bal.qty for bal in balances)
@@ -236,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":
@@ -254,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":
@@ -278,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,4 +1,5 @@
-from typing import Dict, List
+from datetime import datetime
+from typing import Dict, List, Optional
 import inspect
 
 from ksxt.models.balance import BalanceData, BalanceInfo
@@ -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:
@@ -62,7 +70,9 @@ class BaseParser:
     ) -> tuple[OrderBookData, OrderBookData]:
         self._raise_not_implemented_error()
 
-    def parse_balance(self, response: List[Dict], base_market: str = "KRW") -> BalanceInfo:
+    def parse_balance(
+        self, response: List[Dict], base_market: str = "KRW", excluded_symbols: Optional[list[str]] = None
+    ) -> BalanceInfo:
         self._raise_not_implemented_error()
 
     def _parse_balance(self, data: Dict, base_market: str = "KRW") -> BalanceData:
@@ -77,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:
@@ -98,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,6 +1,6 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from operator import attrgetter
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from ksxt.models.balance import BalanceData, BalanceInfo
 from ksxt.models.cash import CashInfo
@@ -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
@@ -166,9 +180,19 @@ class UpbitParser(BaseParser):
 
         return ask_data, bid_data
 
-    def parse_balance(self, response: List[Dict], base_market: str = "KRW") -> BalanceInfo:
-        # currency가 'KRW'가 아닌 항목만 필터링
-        filtered_data = [data for data in response if data["currency"] != base_market]
+    def parse_balance(
+        self, response: List[Dict], base_market: str = "KRW", excluded_symbols: Optional[list[str]] = None
+    ) -> BalanceInfo:
+        # 1. Filter out entries where 'currency' is not the base_market
+        # 2. Ensure 'unit_currency' is the base_market
+        # 3. Exclude entries where 'currency' is in excluded_symbols
+        filtered_data = [
+            data
+            for data in response
+            if data["currency"] != base_market
+            and data["unit_currency"] == base_market
+            and (excluded_symbols is None or data["currency"] not in excluded_symbols)
+        ]
 
         # Initialize balance list
         balances = [self._parse_balance(data, base_market) for data in filtered_data]
@@ -202,8 +226,11 @@ class UpbitParser(BaseParser):
         )
 
     def parse_cash(self, response: List[Dict], base_market: str = "KRW") -> CashInfo:
-        # currency가 'KRW'인 항목만 필터링
-        filtered_data = [data for data in response if data["currency"] == base_market]
+        # 1. Filter entries where 'currency' is equal to 'base_market'
+        # 2. Ensure 'unit_currency' is also equal to 'base_market'
+        filtered_data = [
+            data for data in response if data["currency"] == base_market and data["unit_currency"] == base_market
+        ]
 
         # 필터링된 데이터가 없으면 기본값으로 CashInfo 반환
         if not filtered_data:
@@ -249,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:
@@ -258,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:
@@ -275,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:
@@ -296,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")),