investing-algorithm-framework 6.9.1__py3-none-any.whl → 7.19.15__py3-none-any.whl

investing_algorithm_framework/app/strategy.py

@@ -1,11 +1,12 @@
-from typing import List, Dict, Any
+from datetime import datetime
+from typing import List, Dict, Any, Union
+
 import pandas as pd
-from datetime import datetime, timezone
 
-from investing_algorithm_framework.domain import OperationalException, Position
-from investing_algorithm_framework.domain import \
-    TimeUnit, StrategyProfile, Trade, ENVIRONMENT, Environment, \
-    BACKTESTING_INDEX_DATETIME
+from investing_algorithm_framework.domain import OperationalException, \
+    Position, PositionSize, TimeUnit, StrategyProfile, Trade, \
+    DataSource, OrderSide, StopLossRule, TakeProfitRule, Order, \
+    INDEX_DATETIME
 from .context import Context
 
 
@@ -23,40 +24,62 @@ class TradingStrategy:
         worker_id (optional): str - the id of the worker
         strategy_id (optional): str - the id of the strategy
         decorated (optional): function - the decorated function
-        market_data_sources (optional): list - the list of market data
-            sources to use for the strategy. This will be passed to the
-            run_strategy function.
+        data_sources (List[DataSource] optional): the list of data
+            sources to use for the strategy. The data sources will be used
+            to indentify data providers that will be called to gather data
+            and pass to the strategy before its run.
+        metadata (optional): Dict[str, Any] - a dictionary
+            containing metadata about the strategy. This can be used to
+            store additional information about the strategy, such as its
+            author, version, description, params etc.
     """
-    time_unit: str = None
+    time_unit: TimeUnit = None
     interval: int = None
     worker_id: str = None
     strategy_id: str = None
     decorated = None
-    market_data_sources = None
+    data_sources: List[DataSource] = []
     traces = None
     context: Context = None
+    metadata: Dict[str, Any] = None
+    position_sizes: List[PositionSize] = []
+    stop_loss_rules: List[StopLossRule] = []
+    take_profit_rules: List[TakeProfitRule] = []
+    symbols: List[str] = []
+    trading_symbol: str = None
 
     def __init__(
         self,
         strategy_id=None,
         time_unit=None,
         interval=None,
-        market_data_sources=None,
+        data_sources=None,
+        metadata=None,
+        position_sizes=None,
+        symbols=None,
+        trading_symbol=None,
         worker_id=None,
         decorated=None
     ):
-
         if time_unit is not None:
             self.time_unit = TimeUnit.from_value(time_unit)
+        else:
+            # Check if time_unit is None
+            if self.time_unit is None:
+                raise OperationalException(
+                    f"Time unit attribute not set for "
+                    f"strategy instance {self.strategy_id}"
+                )
+
+            self.time_unit = TimeUnit.from_value(self.time_unit)
 
         if interval is not None:
             self.interval = interval
 
-        if time_unit is not None:
-            self.time_unit = TimeUnit.from_value(time_unit)
+        if data_sources is not None:
+            self.data_sources = data_sources
 
-        if market_data_sources is not None:
-            self.market_data_sources = market_data_sources
+        self.metadata = metadata
 
         if decorated is not None:
             self.decorated = decorated
@@ -73,12 +96,14 @@ class TradingStrategy:
         else:
             self.strategy_id = self.worker_id
 
-        # Check if time_unit is None
-        if self.time_unit is None:
-            raise OperationalException(
-                f"Time unit attribute not set for "
-                f"strategy instance {self.strategy_id}"
-            )
+        if position_sizes is not None:
+            self.position_sizes = position_sizes
+
+        if symbols is not None:
+            self.symbols = symbols
+
+        if trading_symbol is not None:
+            self.trading_symbol = trading_symbol
 
         # Check if interval is None
         if self.interval is None:
@@ -89,12 +114,97 @@ class TradingStrategy:
         # context initialization
         self._context = None
         self._last_run = None
+        self.stop_loss_rules_lookup = {}
+        self.take_profit_rules_lookup = {}
+        self.position_sizes_lookup = {}
 
-    def run_strategy(self, context: Context, market_data: Dict[str, Any]):
+    def generate_buy_signals(
+        self, data: Dict[str, Any]
+    ) -> Dict[str, pd.Series]:
         """
-        Main function for running your strategy. This function will be called
+        Function that needs to be implemented by the user.
+        This function should return a pandas Series containing the buy signals.
+
+        Args:
+            data (Dict[str, Any]): All the data that matched the
+                data sources of the strategy.
+
+        Returns:
+            Dict[str, Series]: A dictionary where the keys are the
+                symbols and the values are pandas Series containing
+                the buy signals. The series must be a pandas Series with
+                a boolean value for each row in the data source, e.g.
+                pd.Series([True, False, False, True, ...], index=data.index)
+                Also the return dictionary must look like:
+                {
+                    "BTC": pd.Series([...]),
+                    "ETH": pd.Series([...]),
+                    ...
+                }
+                where the symbols are exactly the same as defined in the
+                symbols attribute of the strategy.
+        """
+        raise NotImplementedError(
+            "generate_buy_signals method not implemented"
+        )
+
+    def generate_sell_signals(
+        self, data: Dict[str, Any]
+    ) -> Dict[str, pd.Series]:
+        """
+        Function that needs to be implemented by the user.
+        This function should return a pandas Series containing
+        the sell signals.
+
+        Args:
+            data (Dict[str, Any]): All the data that is defined in the
+                data sources of the strategy. E.g. if there is a data source
+                defined as DataSource(identifier="bitvavo_btc_eur_1h",
+                symbol="BTC/EUR", time_frame="1h", data_type=DataType.OHLCV,
+                window_size=100, market="BITVAVO"), the data dictionary
+                will contain a key "bitvavo_btc_eur_1h"
+                with the corresponding data as a polars DataFrame.
+
+        Returns:
+            Dict[str, Series]: A dictionary where the keys are the
+                symbols and the values are pandas Series containing
+                the sell signals. The series must be a pandas Series with
+                a boolean value for each row in the data source, e.g.
+                pd.Series([True, False, False, True, ...], index=data.index)
+                Also the return dictionary must look like:
+                {
+                    "BTC": pd.Series([...]),
+                    "ETH": pd.Series([...]),
+                    ...
+                }
+                where the symbols are exactly the same as defined in the
+                symbols attribute of the strategy.
+        """
+        raise NotImplementedError(
+            "generate_sell_signals method not implemented"
+        )
+
+    def run_strategy(self, context: Context, data: Dict[str, Any]):
+        """
+        Main function for running the strategy. This function will be called
         by the framework when the trigger of your strategy is met.
 
+        The flow of this function is as follows:
+        1. Loop through all the symbols defined in the strategy.
+        2. For each symbol, check if there are any open orders.
+            A. If there are open orders, skip to the next symbol.
+        3. If there is no open position, generate buy signals
+            A. Generate buy signals
+            B. If there is a buy signal, retrieve the position size
+                defined for the symbol.
+            C. If there is a take profit or stop loss rule defined
+                for the symbol, register them for the trade that
+                has been created as part of the order execution.
+        4. If there is an open position, generate sell signals
+            A. Generate sell signals
+            B. If there is a sell signal, create a limit order to
+                sell the position.
+
         During execution of this function, the context and market data
         will be passed to the function. The context is an instance of
         the Context class, this class has various methods to do operations
@@ -103,40 +213,129 @@ class TradingStrategy:
         The market data is a dictionary containing all the data retrieved
         from the specified data sources.
 
+        When buy or sell signals are generated, the strategy will create
+        limit orders to buy or sell the assets based on the generated signals.
+        For each symbol a corresponding position size must be defined. If
+        no position size is defined, an OperationalException will be raised.
+
+        Before creating new orders, the strategy will check if there are any
+        stop losses or take profits for symbol registered. It will
+        use the function get_stop_losses and get_take_profits, these functions
+        can be overridden by the user to provide custom stop losses and
+        take profits logic. The default functions will return the stop losses
+        and take profits that are registered for the symbol if any.
+
         Args:
             context (Context): The context of the strategy. This is an instance
                 of the Context class, this class has various methods to do
                 operations with your portfolio, orders, trades, positions and
                 other components.
-            market_data (Dict[str, Any]): The data for the strategy.
+            data (Dict[str, Any]): The data for the strategy.
                 This is a dictionary containing all the data retrieved from the
-                specified data sources.
+                specified data sources. The keys are either the
+                identifiers of the data sources or a generated key, usually
+                <target_symbol>_<trading_symbol>_<time_frame> e.g. BTC-EUR_1h.
 
         Returns:
             None
         """
         self.context = context
-        config = self.context.get_config()
-
-        if config[ENVIRONMENT] == Environment.BACKTEST.value:
-            self._update_trades_and_orders_for_backtest(market_data)
-        else:
-            self._update_trades_and_orders(market_data)
-
-        self._check_stop_losses()
-        self._check_take_profits()
-
-        # Run user defined strategy
-        self.apply_strategy(context=context, market_data=market_data)
-
-        if config[ENVIRONMENT] == Environment.BACKTEST.value:
-            self._last_run = config[BACKTESTING_INDEX_DATETIME]
-        else:
-            self._last_run = datetime.now(tz=timezone.utc)
-
-    def apply_strategy(self, context, market_data):
+        index_datetime = context.config[INDEX_DATETIME]
+        buy_signals = self.generate_buy_signals(data)
+        sell_signals = self.generate_sell_signals(data)
+
+        for symbol in self.symbols:
+
+            if self.has_open_orders(symbol):
+                continue
+
+            if not self.has_position(symbol):
+
+                if symbol not in buy_signals:
+                    continue
+
+                signals = buy_signals[symbol]
+                last_row = signals.iloc[-1]
+
+                if last_row:
+                    position_size = self.get_position_size(symbol)
+                    full_symbol = (f"{symbol}/"
+                                   f"{self.context.get_trading_symbol()}")
+                    price = self.context.get_latest_price(full_symbol)
+                    amount = position_size.get_size(
+                        self.context.get_portfolio(), price
+                    )
+                    order_amount = amount / price
+                    order = self.create_limit_order(
+                        target_symbol=symbol,
+                        order_side=OrderSide.BUY,
+                        amount=order_amount,
+                        price=price,
+                        execute=True,
+                        validate=True,
+                        sync=True
+                    )
+
+                    # Retrieve stop loss and take profit rules if any
+                    stop_loss_rule = self.get_stop_loss_rule(symbol)
+                    take_profit_rule = self.get_take_profit_rule(symbol)
+
+                    if stop_loss_rule is not None:
+                        trade = self.context.get_trade(
+                            order_id=order.id
+                        )
+                        self.context.add_stop_loss(
+                            trade=trade,
+                            percentage=stop_loss_rule.percentage_threshold,
+                            trailing=stop_loss_rule.trailing,
+                            sell_percentage=stop_loss_rule.sell_percentage,
+                            created_at=index_datetime
+                        )
+
+                    if take_profit_rule is not None:
+                        trade = self.context.get_trade(
+                            order_id=order.id
+                        )
+                        self.context.add_take_profit(
+                            trade=trade,
+                            percentage=take_profit_rule.percentage_threshold,
+                            trailing=take_profit_rule.trailing,
+                            sell_percentage=take_profit_rule.sell_percentage,
+                            created_at=index_datetime
+                        )
+            else:
+                # Check in the last row if there is a sell signal
+                if symbol not in sell_signals:
+                    continue
+
+                signals = sell_signals[symbol]
+                last_row = signals.iloc[-1]
+
+                if last_row:
+                    position = self.get_position(symbol)
+
+                    if position is None:
+                        raise OperationalException(
+                            f"No position found for symbol {symbol} "
+                            f"in strategy {self.strategy_id}"
+                        )
+
+                    full_symbol = (f"{symbol}/"
+                                   f"{self.context.get_trading_symbol()}")
+                    price = self.context.get_latest_price(full_symbol)
+                    self.create_limit_order(
+                        target_symbol=symbol,
+                        order_side=OrderSide.SELL,
+                        amount=position.amount,
+                        execute=True,
+                        validate=True,
+                        sync=True,
+                        price=price
+                    )
+
+    def apply_strategy(self, context, data):
         if self.decorated:
-            self.decorated(context=context, market_data=market_data)
+            self.decorated(context=context, data=data)
         else:
             raise NotImplementedError("Apply strategy is not implemented")
 
@@ -146,44 +345,84 @@ class TradingStrategy:
             strategy_id=self.worker_id,
             interval=self.interval,
             time_unit=self.time_unit,
-            market_data_sources=self.market_data_sources
+            data_sources=self.data_sources
         )
 
-    def _update_trades_and_orders(self, market_data):
-        self.context.order_service.check_pending_orders()
-        self.context.trade_service\
-            .update_trades_with_market_data(market_data)
+    def get_take_profit_rule(self, symbol: str) -> Union[TakeProfitRule, None]:
+        """
+        Get the take profit definition for a given symbol.
 
-    def _update_trades_and_orders_for_backtest(self, market_data):
-        self.context.order_service.check_pending_orders(market_data)
-        self.context.trade_service\
-            .update_trades_with_market_data(market_data)
+        Args:
+            symbol (str): The symbol of the asset.
 
-    def _check_stop_losses(self):
+        Returns:
+            Union[TakeProfitRule, None]: The take profit rule if found,
+              None otherwise.
         """
-        Check if there are any stop losses that result in trades being closed.
+
+        if len(self.take_profit_rules) == 0:
+            return None
+
+        if self.take_profit_rules_lookup == {}:
+            for tp in self.take_profit_rules:
+                self.take_profit_rules_lookup[tp.symbol] = tp
+
+        return self.take_profit_rules_lookup.get(symbol, None)
+
+    def get_stop_loss_rule(self, symbol: str) -> Union[StopLossRule, None]:
         """
-        trade_service = self.context.trade_service
+        Get the stop loss definition for a given symbol.
 
-        stop_losses_orders_data = trade_service\
-            .get_triggered_stop_loss_orders()
+        Args:
+            symbol (str): The symbol of the asset.
+
+        Returns:
+            Union[StopLossRule, None]: The stop loss rule if found,
+              None otherwise.
+        """
 
-        order_service = self.context.order_service
+        if len(self.stop_loss_rules) == 0:
+            return None
 
-        for stop_loss_order in stop_losses_orders_data:
-            order_service.create(stop_loss_order)
+        if self.stop_loss_rules_lookup == {}:
+            for sl in self.stop_loss_rules:
+                self.stop_loss_rules_lookup[sl.symbol] = sl
 
-    def _check_take_profits(self):
+        return self.stop_loss_rules_lookup.get(symbol, None)
+
+    def get_position_size(self, symbol: str) -> Union[PositionSize, None]:
         """
-        Check if there are any take profits that result in trades being closed.
+        Get the position size definition for a given symbol.
+
+        Args:
+            symbol (str): The symbol of the asset.
+
+        Returns:
+            Union[PositionSize, None]: The position size if found,
+              None otherwise.
         """
-        trade_service = self.context.trade_service
-        take_profit_orders_data = trade_service.\
-            get_triggered_take_profit_orders()
-        order_service = self.context.order_service
 
-        for take_profit_order in take_profit_orders_data:
-            order_service.create(take_profit_order)
+        if len(self.position_sizes) == 0:
+            raise OperationalException(
+                f"No position size defined for symbol "
+                f"{symbol} in strategy "
+                f"{self.strategy_id}"
+            )
+
+        if self.position_sizes_lookup == {}:
+            for ps in self.position_sizes:
+                self.position_sizes_lookup[ps.symbol] = ps
+
+        position_size = self.position_sizes_lookup.get(symbol, None)
+
+        if position_size is None:
+            raise OperationalException(
+                f"No position size defined for symbol "
+                f"{symbol} in strategy "
+                f"{self.strategy_id}"
+            )
+
+        return position_size
 
     def on_trade_closed(self, context: Context, trade: Trade):
         pass
@@ -240,67 +479,6 @@ class TradingStrategy:
 
         return self.worker_id
 
-    def add_trace(
-        self,
-        symbol: str,
-        data,
-        drop_duplicates=True
-    ) -> None:
-        """
-        Add data to the straces object for a given symbol
-
-        Args:
-            symbol (str): The symbol
-            data (pd.DataFrame): The data to add to the tracing
-            drop_duplicates (bool): Drop duplicates
-
-        Returns:
-            None
-        """
-
-        # Check if data is a DataFrame
-        if not isinstance(data, pd.DataFrame):
-            raise ValueError(
-                "Currently only pandas DataFrames are "
-                "supported as tracing data objects."
-            )
-
-        data: pd.DataFrame = data
-
-        # Check if index is a datetime object
-        if not isinstance(data.index, pd.DatetimeIndex):
-            raise ValueError("Dataframe Index must be a datetime object.")
-
-        if self.traces is None:
-            self.traces = {}
-
-        # Check if the key is already in the context dictionary
-        if symbol in self.traces:
-            # If the key is already in the context dictionary,
-            # append the new data to the existing data
-            combined = pd.concat([self.traces[symbol], data])
-        else:
-            # If the key is not in the context dictionary,
-            # add the new data to the context dictionary
-            combined = data
-
-        if drop_duplicates:
-            # Drop duplicates and sort the data by the index
-            combined = combined[~combined.index.duplicated(keep='first')]
-
-        # Set the datetime column as the index
-        combined.set_index(pd.DatetimeIndex(combined.index), inplace=True)
-        self.traces[symbol] = combined
-
-    def get_traces(self) -> dict:
-        """
-        Get the traces object
-
-        Returns:
-            dict: The traces object
-        """
-        return self.traces
-
     def has_open_orders(
         self, target_symbol=None, identifier=None, market=None
     ) -> bool:
@@ -335,7 +513,7 @@ class TradingStrategy:
         execute=True,
         validate=True,
         sync=True
-    ):
+    ) -> Order:
         """
         Function to create a limit order. This function will create
         a limit order and execute it if the execute parameter is set to True.
@@ -367,7 +545,7 @@ class TradingStrategy:
         Returns:
             Order: Instance of the order created
         """
-        self.context.create_limit_order(
+        return self.context.create_limit_order(
             target_symbol=target_symbol,
             price=price,
             order_side=order_side,
@@ -383,47 +561,9 @@ class TradingStrategy:
             sync=sync
         )
 
-    def create_market_order(
-        self,
-        target_symbol,
-        order_side,
-        amount,
-        market=None,
-        execute=False,
-        validate=False,
-        sync=True
-    ):
-        """
-        Function to create a market order. This function will create a market
-        order and execute it if the execute parameter is set to True. If the
-        validate parameter is set to True, the order will be validated
-
-        Args:
-            target_symbol: The symbol of the asset to trade
-            order_side: The side of the order
-            amount: The amount of the asset to trade
-            market: The market to trade the asset
-            execute: If set to True, the order will be executed
-            validate: If set to True, the order will be validated
-            sync: If set to True, the created order will be synced with the
-                portfolio of the context
-
-        Returns:
-            Order: Instance of the order created
-        """
-        self.context.create_market_order(
-            target_symbol=target_symbol,
-            order_side=order_side,
-            amount=amount,
-            market=market,
-            execute=execute,
-            validate=validate,
-            sync=sync
-        )
-
     def close_position(
         self, symbol, market=None, identifier=None, precision=None
-    ):
+    ) -> Order:
         """
         Function to close a position. This function will close a position
         by creating a market order to sell the position. If the precision
@@ -439,7 +579,7 @@ class TradingStrategy:
         Returns:
             None
         """
-        self.context.close_position(
+        return self.context.close_position(
             symbol=symbol,
             market=market,
             identifier=identifier,

investing_algorithm_framework/app/task.py

@@ -31,9 +31,11 @@ class Task:
         else:
             self.worker_id = self.__class__.__name__
 
-    def run(self, algorithm):
+    def run(self, context):
 
         if self.decorated:
-            self.decorated(algorithm=algorithm)
+            self.decorated(context=context)
         else:
-            raise NotImplementedError("Apply strategy is not implemented")
+            raise NotImplementedError(
+                "run method must be implemented in the subclass"
+            )