investing-algorithm-framework 3.5.2__tar.gz → 3.6.0__tar.gz

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: investing-algorithm-framework
-Version: 3.5.2
+Version: 3.6.0
 Summary: A framework for creating trading bots
 Author: MDUYN
 Requires-Python: >=3.8.1,<4.0.0

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/__init__.py

@@ -9,7 +9,8 @@ from investing_algorithm_framework.domain import ApiException, \
     Trade, OHLCVMarketDataSource, OrderBookMarketDataSource, SYMBOLS, \
     TickerMarketDataSource, MarketService, BacktestReportsEvaluation, \
     pretty_print_backtest_reports_evaluation, load_backtest_reports, \
-    RESERVED_BALANCES, APP_MODE, AppMode, DATETIME_FORMAT
+    RESERVED_BALANCES, APP_MODE, AppMode, DATETIME_FORMAT, \
+    load_backtest_report, BacktestDateRange
 from investing_algorithm_framework.infrastructure import \
     CCXTOrderBookMarketDataSource, CCXTOHLCVMarketDataSource, \
     CCXTTickerMarketDataSource, CSVOHLCVMarketDataSource, \
@@ -61,4 +62,6 @@ __all__ = [
     "APP_MODE",
     "AppMode",
     "DATETIME_FORMAT",
+    "load_backtest_report",
+    "BacktestDateRange",
 ]

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/app/algorithm.py

@@ -1,8 +1,8 @@
 import inspect
 import logging
-from typing import List
+from typing import List, Dict
 
-from investing_algorithm_framework.domain import OrderStatus, OrderFee, \
+from investing_algorithm_framework.domain import OrderStatus, \
     Position, Order, Portfolio, OrderType, OrderSide, \
     BACKTESTING_FLAG, BACKTESTING_INDEX_DATETIME, MarketService, TimeUnit, \
     OperationalException, random_string, RoundingService
@@ -16,8 +16,22 @@ logger = logging.getLogger("investing_algorithm_framework")
 
 
 class Algorithm:
-
-    def __init__(self, name=None, description=None):
+    """
+    Class to represent an algorithm. An algorithm is a collection of
+    strategies that are executed in a specific order. The algorithm
+    class is responsible for managing the strategies and executing
+    them in the correct order.
+
+    :param name: The name of the algorithm
+    :param description: The description of the algorithm
+    :param context: The context of the algorithm, for backtest references
+    """
+    def __init__(
+        self,
+        name: str = None,
+        description: str = None,
+        context: Dict[str, str] = None
+    ):
         self._name = name
 
         if name is None:
@@ -28,6 +42,21 @@ class Algorithm:
         if description is not None:
             self._description = description
 
+        self._context = context
+
+        if self.context is None:
+            self._context = {}
+
+        # Check if the context is a dictionary with only string,
+        # float or int values
+        for key, value in self.context.items():
+            if not isinstance(key, str) or \
+                    not isinstance(value, (str, float, int)):
+                raise OperationalException(
+                    "The context of the algorithm must be a dictionary with "
+                    "only string, float or int values."
+                )
+
         self._strategies = []
         self._tasks = []
         self.portfolio_service: PortfolioService
@@ -108,6 +137,20 @@ class Algorithm:
         """
         return self.configuration_service.config
 
+    @property
+    def description(self):
+        """
+        Function to get the description of the algorithm
+        """
+        return self._description
+
+    @property
+    def context(self):
+        """
+        Function to get the context of the algorithm
+        """
+        return self._context
+
     @property
     def running(self) -> bool:
         """
@@ -362,9 +405,6 @@ class Algorithm:
             }
         )
 
-    def get_order_fee(self, order_id) -> OrderFee:
-        return self.order_service.get_order_fee(order_id)
-
     def get_positions(
         self,
         market=None,

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/app/app.py

@@ -7,7 +7,7 @@ from abc import abstractmethod
 from datetime import datetime
 from distutils.sysconfig import get_python_lib
 from time import sleep
-from typing import List, Optional, Tuple
+from typing import List, Optional
 
 from flask import Flask
 
@@ -20,7 +20,7 @@ from investing_algorithm_framework.domain import DATABASE_NAME, TimeUnit, \
     SQLALCHEMY_DATABASE_URI, OperationalException, BACKTESTING_FLAG, \
     BACKTESTING_START_DATE, BACKTESTING_END_DATE, BacktestReport, \
     BACKTESTING_PENDING_ORDER_CHECK_INTERVAL, APP_MODE, MarketCredential, \
-    AppMode
+    AppMode, BacktestDateRange
 from investing_algorithm_framework.infrastructure import setup_sqlalchemy, \
     create_all_tables
 from investing_algorithm_framework.services import OrderBacktestService, \
@@ -319,7 +319,6 @@ class App:
         self.container.order_service.override(
             OrderBacktestService(
                 order_repository=self.container.order_repository(),
-                order_fee_repository=self.container.order_fee_repository(),
                 position_repository=self.container.position_repository(),
                 portfolio_repository=self.container.portfolio_repository(),
                 portfolio_configuration_service=self.container
@@ -729,7 +728,7 @@ class App:
                 "backtest_reports"
             )
 
-        backtest_report_writer_service.write_report_to_csv(
+        backtest_report_writer_service.write_report_to_json(
             report=report, output_directory=output_directory
         )
 
@@ -740,7 +739,7 @@ class App:
         algorithms,
         start_date: Optional[datetime] = None,
         end_date: Optional[datetime] = None,
-        date_ranges: Optional[Tuple[datetime, datetime]] = None,
+        date_ranges: Optional[List[BacktestDateRange]] = None,
         pending_order_check_interval=None,
         output_directory=None
     ) -> List[BacktestReport]:
@@ -754,7 +753,7 @@ class App:
         :param end_date: The end date of the backtest
         :param pending_order_check_interval: The interval at which to check
         :param date_ranges: The date ranges to run the backtests for (list of
-        tuples of start and end dates)
+        BacktestDateRange instances representing a start and end date)
         pending orders
         :param output_directory: The directory to write the backtest report to
         :return: List of BacktestReport intances
@@ -767,7 +766,9 @@ class App:
             if end_date is None:
                 end_date = datetime.utcnow()
 
-            date_ranges = [(start_date, end_date)]
+            date_ranges = [
+                BacktestDateRange(start_date=start_date, end_date=end_date)
+            ]
         else:
             if date_ranges is None:
                 raise OperationalException("No date ranges specified")
@@ -776,7 +777,9 @@ class App:
             .get_market_data_sources()
 
         for date_range in date_ranges:
-            start_date, end_date = date_range
+            date_range: BacktestDateRange = date_range
+            start_date = date_range.start_date
+            end_date = date_range.end_date
             self._initialize_app_for_backtest(
                 backtest_start_date=start_date,
                 backtest_end_date=end_date,
@@ -804,6 +807,11 @@ class App:
                     start_date=start_date,
                     end_date=end_date
                 )
+
+                # Add date range name to report if present
+                if date_range.name is not None:
+                    report.date_range_name = date_range.name
+
                 backtest_report_writer_service = self.container \
                     .backtest_report_writer_service()
 
@@ -813,7 +821,7 @@ class App:
                         "backtest_reports"
                     )
 
-                backtest_report_writer_service.write_report_to_csv(
+                backtest_report_writer_service.write_report_to_json(
                     report=report, output_directory=output_directory
                 )
                 reports.append(report)

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/dependency_container.py

@@ -3,7 +3,7 @@ from dependency_injector import containers, providers
 from investing_algorithm_framework.app.algorithm import Algorithm
 from investing_algorithm_framework.infrastructure import SQLOrderRepository, \
     SQLPositionRepository, SQLPortfolioRepository, \
-    SQLOrderFeeRepository, SQLPortfolioSnapshotRepository, \
+    SQLPortfolioSnapshotRepository, \
     SQLPositionSnapshotRepository, PerformanceService, CCXTMarketService
 from investing_algorithm_framework.services import OrderService, \
     PositionService, PortfolioService, StrategyOrchestratorService, \
@@ -33,7 +33,6 @@ class DependencyContainer(containers.DeclarativeContainer):
         MarketCredentialService
     )
     order_repository = providers.Factory(SQLOrderRepository)
-    order_fee_repository = providers.Factory(SQLOrderFeeRepository)
     position_repository = providers.Factory(SQLPositionRepository)
     portfolio_repository = providers.Factory(SQLPortfolioRepository)
     position_snapshot_repository = providers.Factory(
@@ -70,7 +69,6 @@ class DependencyContainer(containers.DeclarativeContainer):
         OrderService,
         configuration_service=configuration_service,
         order_repository=order_repository,
-        order_fee_repository=order_fee_repository,
         portfolio_repository=portfolio_repository,
         position_repository=position_repository,
         market_service=market_service,

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/domain/__init__.py

@@ -15,9 +15,9 @@ from .exceptions import OperationalException, ApiException, \
 from .models import OrderStatus, OrderSide, OrderType, TimeInterval, \
     TimeUnit, TimeFrame, TradingTimeFrame, TradingDataType, \
     PortfolioConfiguration, Portfolio, Position, Order, TradeStatus, \
-    OrderFee, BacktestReport, PortfolioSnapshot, StrategyProfile, \
+    BacktestReport, PortfolioSnapshot, StrategyProfile, \
     BacktestPosition, Trade, MarketCredential, PositionSnapshot, \
-    BacktestReportsEvaluation, AppMode
+    BacktestReportsEvaluation, AppMode, BacktestDateRange
 from .services import TickerMarketDataSource, OrderBookMarketDataSource, \
     OHLCVMarketDataSource, BacktestMarketDataSource, MarketDataSource, \
     MarketService, MarketCredentialService, AbstractPortfolioSyncService, \
@@ -27,6 +27,7 @@ from .stateless_actions import StatelessActions
 from .strategy import Strategy
 from .utils import random_string, append_dict_as_row_to_csv, \
     add_column_headers_to_csv, get_total_amount_of_rows, \
+    load_backtest_report, \
     csv_to_list, StoppableThread, pretty_print_backtest_reports_evaluation, \
     pretty_print_backtest, load_csv_into_dict, load_backtest_reports
 
@@ -70,7 +71,6 @@ __all__ = [
     "Strategy",
     "DATETIME_FORMAT",
     "StatelessActions",
-    "OrderFee",
     "parse_decimal_to_string",
     "parse_string_to_decimal",
     "BacktestReport",
@@ -112,4 +112,6 @@ __all__ = [
     "APP_MODE",
     "AppMode",
     "RoundingService",
+    "BacktestDateRange",
+    "load_backtest_report",
 ]

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/domain/models/__init__.py

@@ -1,8 +1,8 @@
 from .app_mode import AppMode
 from .backtesting import BacktestReport, BacktestPosition, \
-    BacktestReportsEvaluation
+    BacktestReportsEvaluation, BacktestDateRange
 from .market import MarketCredential
-from .order import OrderStatus, OrderSide, OrderType, Order, OrderFee
+from .order import OrderStatus, OrderSide, OrderType, Order
 from .portfolio import PortfolioConfiguration, Portfolio, PortfolioSnapshot
 from .position import Position, PositionSnapshot
 from .strategy_profile import StrategyProfile
@@ -26,7 +26,6 @@ __all__ = [
     "PortfolioConfiguration",
     "Position",
     "Portfolio",
-    "OrderFee",
     "BacktestReport",
     "PositionSnapshot",
     "PortfolioSnapshot",
@@ -36,5 +35,6 @@ __all__ = [
     "MarketCredential",
     "TradeStatus",
     "BacktestReportsEvaluation",
-    "AppMode"
+    "AppMode",
+    "BacktestDateRange"
 ]

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/domain/models/backtesting/__init__.py

@@ -1,9 +1,11 @@
 from .backtest_position import BacktestPosition
 from .backtest_report import BacktestReport
 from .backtest_reports_evaluation import BacktestReportsEvaluation
+from .backtest_date_range import BacktestDateRange
 
 __all__ = [
     "BacktestReport",
     "BacktestPosition",
     "BacktestReportsEvaluation",
+    "BacktestDateRange"
 ]

investing_algorithm_framework-3.6.0/investing_algorithm_framework/domain/models/backtesting/backtest_date_range.py

@@ -0,0 +1,26 @@
+from datetime import datetime
+
+
+class BacktestDateRange:
+    """
+    Represents a date range for a backtest
+    """
+    def __init__(self, start_date, end_date=None, name=None):
+        self._start_date = start_date
+        self._end_date = end_date
+        self._name = name
+
+        if end_date is None:
+            self._end_date = datetime.now()
+
+    @property
+    def start_date(self):
+        return self._start_date
+
+    @property
+    def end_date(self):
+        return self._end_date
+
+    @property
+    def name(self):
+        return self._name

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/domain/models/backtesting/backtest_position.py

@@ -104,3 +104,17 @@ class BacktestPosition(BaseModel):
             return 0.0
 
         return self.value / self._total_value_portfolio * 100
+
+    def to_dict(self):
+        return {
+            "symbol": self.symbol,
+            "amount": self.amount,
+            "cost": self.cost,
+            "price": self.price,
+            "value": self.value,
+            "growth": self.growth,
+            "growth_rate": self.growth_rate,
+            "amount_pending_buy": self.amount_pending_buy,
+            "amount_pending_sell": self.amount_pending_sell,
+            "percentage_of_portfolio": self.percentage_of_portfolio
+        }

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/domain/models/backtesting/backtest_report.py

@@ -2,6 +2,7 @@ from datetime import datetime
 
 from investing_algorithm_framework.domain.models.base_model import BaseModel
 from investing_algorithm_framework.domain.models.time_unit import TimeUnit
+from investing_algorithm_framework.domain.constants import DATETIME_FORMAT
 
 
 class BacktestReport(BaseModel):
@@ -18,7 +19,6 @@ class BacktestReport(BaseModel):
         backtest_data_index_date=None,
         backtest_start_date=None,
         backtest_end_date=None,
-        backtest_index_date=None,
         trading_time_frame=None,
         trading_time_frame_start_date=None,
         symbols=None,
@@ -42,14 +42,15 @@ class BacktestReport(BaseModel):
         average_trade_duration=0,
         average_trade_size=0.0,
         trades=None,
-        created_at: datetime = None
+        orders=None,
+        created_at: datetime = None,
+        context=None,
     ):
         self._name = name
         self._strategy_identifiers = strategy_identifiers
         self._backtest_start_date_data = backtest_start_date_data
         self._backtest_start_date = backtest_start_date
         self._backtest_end_date = backtest_end_date
-        self._backtest_index_date = backtest_index_date
         self._number_of_runs = number_of_runs
         self._trading_time_frame = trading_time_frame
         self._trading_time_frame_start_date = trading_time_frame_start_date
@@ -72,13 +73,15 @@ class BacktestReport(BaseModel):
         self._total_net_gain = total_net_gain
         self._backtest_data_index_date = backtest_data_index_date
         self._total_value = total_value
-        self.positions = positions
+        self._positions = positions
+        self._orders = orders
         self._average_trade_duration = average_trade_duration
         self._average_trade_size = average_trade_size
         self._trades = trades
         self._created_at: datetime = created_at
         self._interval = interval
         self._time_unit = time_unit
+        self._context = context
 
     @property
     def name(self):
@@ -116,10 +119,6 @@ class BacktestReport(BaseModel):
     def backtest_end_date(self):
         return self._backtest_end_date
 
-    @property
-    def backtest_index_date(self):
-        return self._backtest_index_date
-
     @property
     def trading_time_frame(self):
         return self._trading_time_frame
@@ -160,10 +159,6 @@ class BacktestReport(BaseModel):
     def backtest_end_date(self, value):
         self._backtest_end_date = value
 
-    @backtest_index_date.setter
-    def backtest_index_date(self, value):
-        self._backtest_index_date = value
-
     @number_of_runs.setter
     def number_of_runs(self, value):
         self._number_of_runs = value
@@ -316,6 +311,14 @@ class BacktestReport(BaseModel):
     def positions(self, value):
         self._positions = value
 
+    @property
+    def orders(self):
+        return self._orders
+
+    @orders.setter
+    def orders(self, value):
+        self._orders = value
+
     @property
     def average_trade_duration(self):
         return self._average_trade_duration
@@ -348,6 +351,14 @@ class BacktestReport(BaseModel):
     def interval(self, value):
         self._interval = value
 
+    @property
+    def context(self):
+        return self._context
+
+    @context.setter
+    def context(self, value):
+        self._context = value
+
     @property
     def time_unit(self):
         return self._time_unit
@@ -372,7 +383,6 @@ class BacktestReport(BaseModel):
             name=self.name,
             start_date=self.backtest_start_date,
             end_date=self.backtest_end_date,
-            backtest_index_date=self.backtest_index_date,
             start_date_data=self.backtest_start_date_data,
         )
 
@@ -383,9 +393,12 @@ class BacktestReport(BaseModel):
         """
         return {
             "name": self.name,
+            "context": self.context if self.context is not None else {},
             "strategy_identifiers": self.strategy_identifiers,
-            "backtest_start_date": self.backtest_start_date,
-            "backtest_end_date": self.backtest_end_date,
+            "backtest_start_date": self.backtest_start_date
+            .strftime(DATETIME_FORMAT),
+            "backtest_end_date": self.backtest_end_date
+            .strftime(DATETIME_FORMAT),
             "number_of_runs": self.number_of_runs,
             "symbols": self.symbols,
             "market": self.market,
@@ -404,10 +417,16 @@ class BacktestReport(BaseModel):
             "trading_symbol": self.trading_symbol,
             "total_net_gain_percentage": self.total_net_gain_percentage,
             "total_net_gain": self.total_net_gain,
-            "backtest_data_index_date": self.backtest_data_index_date,
             "total_value": self.total_value,
             "average_trade_duration": self.average_trade_duration,
             "average_trade_size": self.average_trade_size,
+            "positions": [position.to_dict() for position in self.positions],
+            "trades": [trade.to_dict() for trade in self.trades],
+            "orders": [
+                order.to_dict(datetime_format=DATETIME_FORMAT)
+                for order in self.orders
+            ],
+            "created_at": self.created_at.strftime(DATETIME_FORMAT),
         }
 
     @staticmethod
@@ -438,7 +457,6 @@ class BacktestReport(BaseModel):
             trading_symbol=data["trading_symbol"],
             total_net_gain_percentage=float(data["total_net_gain_percentage"]),
             total_net_gain=float(data["total_net_gain"]),
-            backtest_data_index_date=data["backtest_data_index_date"],
             total_value=float(data["total_value"]),
             average_trade_duration=data["average_trade_duration"],
             average_trade_size=float(data["average_trade_size"]),

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/domain/models/order/__init__.py

@@ -1,7 +1,6 @@
 from .order import Order
-from .order_fee import OrderFee
 from .order_side import OrderSide
 from .order_status import OrderStatus
 from .order_type import OrderType
 
-__all__ = ["OrderType", "OrderStatus", "OrderSide", "Order", "OrderFee"]
+__all__ = ["OrderType", "OrderStatus", "OrderSide", "Order"]

{investing_algorithm_framework-3.5.2 → investing_algorithm_framework-3.6.0}/investing_algorithm_framework/domain/models/order/order.py

@@ -5,20 +5,20 @@ from dateutil.parser import parse
 from investing_algorithm_framework.domain.exceptions import \
     OperationalException
 from investing_algorithm_framework.domain.models.base_model import BaseModel
+from investing_algorithm_framework.domain.models.order.order_side import \
+    OrderSide
 from investing_algorithm_framework.domain.models.order.order_status import \
     OrderStatus
 from investing_algorithm_framework.domain.models.order.order_type import \
     OrderType
-from investing_algorithm_framework.domain.models.order.order_side import \
-    OrderSide
-from investing_algorithm_framework.domain.models.order.order_fee import \
-    OrderFee
 
 logger = logging.getLogger("investing_algorithm_framework")
 
 
 class Order(BaseModel):
-
+    """
+    Order model class to represent an order of the trading bot
+    """
     def __init__(
         self,
         order_type,
@@ -40,10 +40,9 @@ class Order(BaseModel):
         cost=None,
         fee=None,
         position_id=None,
-        stop_loss=None,
-        stop_loss_percentage=None,
-        trailing_stop_loss=None,
-        trailing_stop_loss_percentage=None,
+        order_fee=None,
+        order_fee_currency=None,
+        order_fee_rate=None
     ):
         if target_symbol is None:
             raise OperationalException("Target symbol is not specified")
@@ -80,11 +79,10 @@ class Order(BaseModel):
         self.remaining = remaining
         self.cost = cost
         self.fee = fee
-        self.stop_loss = stop_loss
-        self.stop_loss_percentage = stop_loss_percentage
-        self.trailing_stop_loss = trailing_stop_loss
-        self.trailing_stop_loss_percentage = trailing_stop_loss_percentage
         self._available_amount = self.filled
+        self.order_fee = order_fee
+        self.order_fee_currency = order_fee_currency
+        self.order_fee_rate = order_fee_rate
 
     def get_id(self):
         return self.id
@@ -107,6 +105,24 @@ class Order(BaseModel):
     def set_price(self, price):
         self.price = price
 
+    def get_order_fee_currency(self):
+        return self.order_fee_currency
+
+    def set_order_fee_currency(self, order_fee_currency):
+        self.order_fee_currency = order_fee_currency
+
+    def get_order_fee_rate(self):
+        return self.order_fee_rate
+
+    def set_order_fee_rate(self, order_fee_rate):
+        self.order_fee_rate = order_fee_rate
+
+    def get_order_fee(self):
+        return self.order_fee
+
+    def set_order_fee(self, order_fee):
+        self.order_fee = order_fee
+
     def get_order_size(self):
         return self.order_side
 
@@ -232,7 +248,20 @@ class Order(BaseModel):
     def available_amount(self, available_amount):
         self.set_available_amount(available_amount)
 
-    def to_dict(self):
+    def to_dict(self, datetime_format=None):
+
+        if datetime_format is not None:
+            created_at = self.created_at.strftime(datetime_format) \
+                if self.created_at else None
+            updated_at = self.updated_at.strftime(datetime_format) \
+                if self.updated_at else None
+            trade_closed_at = self.trade_closed_at.strftime(datetime_format) \
+                if self.trade_closed_at else None
+        else:
+            created_at = self.created_at
+            updated_at = self.updated_at
+            trade_closed_at = self.trade_closed_at
+
         return {
             "external_id": self.external_id,
             "target_symbol": self.target_symbol,
@@ -243,18 +272,16 @@ class Order(BaseModel):
             "price": self.price,
             "amount": self.amount,
             "net_gain": self.net_gain,
-            "trade_closed_at": self.trade_closed_at,
+            "trade_closed_at": trade_closed_at,
             "trade_closed_price": self.trade_closed_price,
-            "created_at": self.created_at,
-            "updated_at": self.updated_at,
+            "created_at": created_at,
+            "updated_at": updated_at,
             "filled": self.filled,
             "remaining": self.remaining,
             "cost": self.cost,
-            "fee": self.fee.to_dict() if self.fee is not None else None,
-            "stop_loss": self.stop_loss,
-            "stop_loss_percentage": self.stop_loss_percentage,
-            "trailing_stop_loss": self.trailing_stop_loss,
-            "trailing_stop_loss_percentage": self.trailing_stop_loss_percentage
+            "order_fee_currency": self.order_fee_currency,
+            "order_fee_rate": self.order_fee_rate,
+            "order_fee": self.order_fee,
         }
 
     @staticmethod
@@ -290,14 +317,32 @@ class Order(BaseModel):
             cost=data.get("cost", None),
             fee=data.get("fee", None),
             created_at=created_at,
-            updated_at=updated_at
+            updated_at=updated_at,
+            order_fee=data.get("order_fee", None),
+            order_fee_currency=data.get("order_fee_currency", None),
+            order_fee_rate=data.get("order_fee_rate", None),
         )
 
     @staticmethod
     def from_ccxt_order(ccxt_order):
+        """
+        Create an Order object from a ccxt order object
+        :param ccxt_order: ccxt order object
+        :return: Order object
+        """
         status = OrderStatus.from_value(ccxt_order["status"])
         target_symbol = ccxt_order.get("symbol").split("/")[0]
         trading_symbol = ccxt_order.get("symbol").split("/")[1]
+        ccxt_fee = ccxt_order.get("fee", None)
+        order_fee = None
+        order_fee_currency = None
+        order_fee_rate = None
+
+        if ccxt_fee is not None:
+            order_fee = ccxt_fee.get("cost", None)
+            order_fee_currency = ccxt_fee.get("currency", None)
+            order_fee_rate = ccxt_fee.get("rate", None)
+
         return Order(
             external_id=ccxt_order.get("id", None),
             target_symbol=target_symbol,
@@ -310,7 +355,9 @@ class Order(BaseModel):
             filled=ccxt_order.get("filled", None),
             remaining=ccxt_order.get("remaining", None),
             cost=ccxt_order.get("cost", None),
-            fee=OrderFee.from_ccxt_fee(ccxt_order.get("fee", None)),
+            order_fee=order_fee,
+            order_fee_currency=order_fee_currency,
+            order_fee_rate=order_fee_rate,
             created_at=parse(ccxt_order.get("datetime", None))
         )