investing-algorithm-framework 6.5.2__tar.gz → 6.5.4__tar.gz

{investing_algorithm_framework-6.5.2 → investing_algorithm_framework-6.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: investing-algorithm-framework
-Version: 6.5.2
+Version: 6.5.4
 Summary: A framework for creating trading bots
 Author: MDUYN
 Requires-Python: >=3.10
@@ -105,9 +105,8 @@ The following example connects to Binance and buys BTC every 2 hours.
 import logging.config
 from dotenv import load_dotenv
 
-from investing_algorithm_framework import create_app, TimeUnit, \
-    CCXTOHLCVMarketDataSource, CCXTTickerMarketDataSource, \
-    DEFAULT_LOGGING_CONFIG, Algorithm, Context
+from investing_algorithm_framework import create_app, TimeUnit, Context, \
+    CCXTOHLCVMarketDataSource, CCXTTickerMarketDataSource, DEFAULT_LOGGING_CONFIG
 
 load_dotenv()
 logging.config.dictConfig(DEFAULT_LOGGING_CONFIG)
@@ -130,10 +129,9 @@ bitvavo_btc_eur_ticker = CCXTTickerMarketDataSource(
 app = create_app()
 # Registered bitvavo market, credentials are read from .env file by default
 app.add_market(market="BITVAVO", trading_symbol="EUR", initial_balance=100)
-algorithm = Algorithm(name="test_algorithm")
 
 # Define a strategy for the algorithm that will run every 10 seconds
-@algorithm.strategy(
+@app.strategy(
     time_unit=TimeUnit.SECOND,
     interval=10,
     market_data_sources=[bitvavo_btc_eur_ticker, bitvavo_btc_eur_ohlcv_2h]
@@ -148,8 +146,6 @@ def perform_strategy(context: Context, market_data: dict):
     open_trades = context.get_open_trades()
     closed_trades = context.get_closed_trades()
 
-app.add_algorithm(algorithm)
-
 if __name__ == "__main__":
     app.run()
 ```

{investing_algorithm_framework-6.5.2 → investing_algorithm_framework-6.5.4}/README.md

@@ -72,9 +72,8 @@ The following example connects to Binance and buys BTC every 2 hours.
 import logging.config
 from dotenv import load_dotenv
 
-from investing_algorithm_framework import create_app, TimeUnit, \
-    CCXTOHLCVMarketDataSource, CCXTTickerMarketDataSource, \
-    DEFAULT_LOGGING_CONFIG, Algorithm, Context
+from investing_algorithm_framework import create_app, TimeUnit, Context, \
+    CCXTOHLCVMarketDataSource, CCXTTickerMarketDataSource, DEFAULT_LOGGING_CONFIG
 
 load_dotenv()
 logging.config.dictConfig(DEFAULT_LOGGING_CONFIG)
@@ -97,10 +96,9 @@ bitvavo_btc_eur_ticker = CCXTTickerMarketDataSource(
 app = create_app()
 # Registered bitvavo market, credentials are read from .env file by default
 app.add_market(market="BITVAVO", trading_symbol="EUR", initial_balance=100)
-algorithm = Algorithm(name="test_algorithm")
 
 # Define a strategy for the algorithm that will run every 10 seconds
-@algorithm.strategy(
+@app.strategy(
     time_unit=TimeUnit.SECOND,
     interval=10,
     market_data_sources=[bitvavo_btc_eur_ticker, bitvavo_btc_eur_ohlcv_2h]
@@ -115,8 +113,6 @@ def perform_strategy(context: Context, market_data: dict):
     open_trades = context.get_open_trades()
     closed_trades = context.get_closed_trades()
 
-app.add_algorithm(algorithm)
-
 if __name__ == "__main__":
     app.run()
 ```

investing_algorithm_framework-6.5.4/investing_algorithm_framework/app/algorithm/__init__.py

@@ -0,0 +1,7 @@
+from .algorithm_factory import AlgorithmFactory
+from .algorithm import Algorithm
+
+__all__ = [
+    "AlgorithmFactory",
+    "Algorithm"
+]

investing_algorithm_framework-6.5.4/investing_algorithm_framework/app/algorithm/algorithm.py

@@ -0,0 +1,275 @@
+import inspect
+import logging
+import re
+from typing import List
+
+from investing_algorithm_framework.app.app_hook import AppHook
+from investing_algorithm_framework.app.strategy import TradingStrategy
+from investing_algorithm_framework.domain import OperationalException, \
+    MarketDataSource
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class Algorithm:
+    """
+    Class to represent an algorithm. An algorithm is a collection of
+    strategies that are executed in a specific order.
+
+    Attributes:
+        _name: The name of the algorithm. It should be a string and
+            can only contain letters and numbers.
+        _description: The description of the algorithm. It should be a string.
+        _strategies: A list of strategies that are part of the algorithm.
+        _tasks: A list of tasks that are part of the algorithm.
+        _data_sources: A list of data sources that are part of the algorithm.
+        _on_strategy_run_hooks: A list of hooks that will be called when a
+    """
+    def __init__(
+        self,
+        name: str = None,
+        description: str = None,
+        strategy=None,
+        strategies=None,
+        tasks: List = None,
+        data_sources: List[MarketDataSource] = None,
+        on_strategy_run_hooks=None
+    ):
+        self._name = name
+        self._context = {}
+        self._description = None
+
+        if description is not None:
+            self._description = description
+
+        self._strategies = []
+        self._tasks = []
+        self._data_sources = []
+        self._on_strategy_run_hooks = []
+
+        if data_sources is not None:
+            self._data_sources = data_sources
+
+        if strategies is not None:
+            self.strategies = strategies
+
+        if tasks is not None:
+            self.tasks = tasks
+
+        if strategy is not None:
+            self.add_strategy(strategy, throw_exception=True)
+
+        if on_strategy_run_hooks is not None:
+            for hook in on_strategy_run_hooks:
+                self.add_on_strategy_run_hook(hook)
+
+    @staticmethod
+    def _validate_name(name):
+        """
+        Function to validate the name of the algorithm. This function
+        will check if the name of the algorithm is a string and raise
+        an exception if it is not.
+
+        Name can only contain letters, numbers
+
+        Parameters:
+            name: The name of the algorithm
+
+        Returns:
+            None
+        """
+        if not isinstance(name, str):
+            raise OperationalException(
+                "The name of the algorithm must be a string"
+            )
+
+        pattern = re.compile(r"^[a-zA-Z0-9]*$")
+
+        if not pattern.match(name):
+            raise OperationalException(
+                "The name of the algorithm can only contain" +
+                " letters and numbers"
+            )
+
+        illegal_chars = r"[\/:*?\"<>|]"
+
+        if re.search(illegal_chars, name):
+            raise OperationalException(
+                f"Illegal characters detected in algorithm: {name}. "
+                f"Illegal characters: / \\ : * ? \" < > |"
+            )
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        Algorithm._validate_name(name)
+        self._name = name
+
+    @property
+    def data_sources(self):
+        return self._data_sources
+
+    @data_sources.setter
+    def data_sources(self, data_sources):
+        self._data_sources = data_sources
+
+    @property
+    def description(self):
+        """
+        Function to get the description of the algorithm
+        """
+        return self._description
+
+    @property
+    def strategies(self):
+        return self._strategies
+
+    @property
+    def on_strategy_run_hooks(self):
+        return self._on_strategy_run_hooks
+
+    @strategies.setter
+    def strategies(self, strategies):
+
+        for strategy in strategies:
+            self.add_strategy(strategy)
+
+    @property
+    def tasks(self):
+        return self._tasks
+
+    @tasks.setter
+    def tasks(self, tasks):
+
+        for task in tasks:
+            self.add_task(task)
+
+    def get_strategy(self, strategy_id):
+        for strategy in self._strategies:
+            if strategy.worker_id == strategy_id:
+                return strategy
+
+        return None
+
+    def get_strategies(self):
+
+        if self._strategies is None:
+            raise OperationalException(
+                "No strategies have been added to the algorithm"
+            )
+        return self._strategies
+
+    def add_strategy(self, strategy, throw_exception=True) -> None:
+        """
+        Function to add a strategy to the algorithm. The strategy should be an
+        instance of TradingStrategy or a subclass based on the TradingStrategy
+        class.
+
+        Args:
+            strategy: Instance of TradingStrategy
+            throw_exception: Flag to allow for throwing an exception when
+                the provided strategy is not inline with what the application
+                expects.
+
+        Returns:
+            None
+        """
+
+        if inspect.isclass(strategy):
+
+            if not issubclass(strategy, TradingStrategy):
+                raise OperationalException(
+                    "The strategy must be a subclass of TradingStrategy"
+                )
+
+            strategy = strategy()
+
+        if not isinstance(strategy, TradingStrategy):
+
+            if throw_exception:
+                raise OperationalException(
+                    "Strategy should be an instance of TradingStrategy"
+                )
+            else:
+                return
+
+        has_duplicates = False
+
+        for i in range(len(self._strategies)):
+            for j in range(i + 1, len(self._strategies)):
+                if self._strategies[i].worker_id == strategy.worker_id:
+                    has_duplicates = True
+                    break
+
+        if has_duplicates:
+            raise OperationalException(
+                "Can't add strategy, there already exists a strategy "
+                "with the same id in the algorithm"
+            )
+
+        if strategy.market_data_sources is not None:
+            self.add_data_sources(strategy.market_data_sources)
+
+        self._strategies.append(strategy)
+
+    def add_task(self, task):
+        if inspect.isclass(task):
+            task = task()
+
+        self._tasks.append(task)
+
+    def add_data_source(self, data_source) -> None:
+        """
+        Function to add a data source to the app. The data source should
+        be an instance of DataSource.
+
+        Args:
+            data_source: Instance of DataSource
+
+        Returns:
+            None
+        """
+        if inspect.isclass(data_source):
+            if not issubclass(data_source, MarketDataSource):
+                raise OperationalException(
+                    "Data source should be an instance of MarketDataSource"
+                )
+
+            data_source = data_source()
+
+        self.data_sources.append(data_source)
+
+    def add_data_sources(self, data_sources) -> None:
+        """
+        Function to add a list of data sources to the app. The data sources
+        should be instances of DataSource.
+
+        Args:
+            data_sources: List of DataSource
+
+        Returns:
+            None
+        """
+        for data_source in data_sources:
+            self.add_data_source(data_source)
+
+    def add_on_strategy_run_hook(self, app_hook):
+        """
+        Function to add a hook that will be called when a strategy is run.
+
+        Args:
+            app_hook: The hook function to be added.
+        """
+        # Check if the app_hook inherits from AppHook
+        if inspect.isclass(app_hook) and not issubclass(app_hook, AppHook):
+            raise OperationalException(
+                "App hook should be an instance of AppHook"
+            )
+
+        if inspect.isclass(app_hook):
+            app_hook = app_hook()
+
+        self._on_strategy_run_hooks.append(app_hook)

investing_algorithm_framework-6.5.4/investing_algorithm_framework/app/algorithm/algorithm_factory.py

@@ -0,0 +1,107 @@
+import re
+from .algorithm import Algorithm
+from investing_algorithm_framework.domain import OperationalException
+
+
+def validate_algorithm_name(name, illegal_chars=r"[\/:*?\"<>|]"):
+    """
+    Validate an algorithm name for illegal characters and throw an
+        exception if any are found.
+
+    Args:
+        name (str): The name to validate.
+        illegal_chars (str): A regex pattern for characters considered
+            illegal (default: r"[/:*?\"<>|]").
+
+    Raises:
+        ValueError: If illegal characters are found in the filename.
+    """
+    if re.search(illegal_chars, name):
+        raise OperationalException(
+            f"Illegal characters detected in filename: {name}. "
+            f"Illegal characters: {illegal_chars}"
+        )
+
+
+class AlgorithmFactory:
+    """
+    Factory class for creating an algorithm instance.
+    """
+
+    @staticmethod
+    def create_algorithm_name(algorithm):
+        """
+        Create a name for the algorithm based on its
+        strategies.
+
+        Args:
+            algorithm (Algorithm): Instance of Algorithm.
+
+        Returns:
+            str: Name of the algorithm.
+        """
+        first_strategy = algorithm.strategies[0] \
+            if algorithm.strategies else None
+
+        if first_strategy is not None:
+            return f"{first_strategy.__class__.__name__}"
+
+        return "DefaultAlgorithm"
+
+    @staticmethod
+    def create_algorithm(
+        name=None,
+        algorithm=None,
+        strategy=None,
+        strategies=None,
+        tasks=None,
+        on_strategy_run_hooks=None,
+        data_sources=None
+    ) -> Algorithm:
+        """
+        Create an instance of the specified algorithm type.
+
+        Args:
+            name (str): Name of the algorithm.
+            algorithm (Algorithm): Instance of Algorithm to be used.
+            strategy (TradingStrategy): Single TradingStrategy instance.
+            strategies (list): List of TradingStrategy instances.
+            tasks (list): List of Task instances.
+            on_strategy_run_hooks (list): List of hooks to be called
+                when a strategy is run.
+            data_sources (list): List of MarketDataSource instances.
+
+        Returns:
+            Algorithm: Instance of Algorithm.
+        """
+        name = name
+        strategies = strategies or []
+        tasks = tasks or []
+        on_strategy_run_hooks = on_strategy_run_hooks or []
+        data_sources = data_sources or []
+
+        if algorithm is not None:
+
+            for task in tasks:
+                algorithm.add_task(task)
+
+            for app_hook in on_strategy_run_hooks:
+                algorithm.add_on_strategy_run_hook(app_hook)
+
+            return algorithm
+
+        algorithm = Algorithm(
+            name=name,
+            strategy=strategy,
+            strategies=strategies,
+            tasks=tasks,
+            on_strategy_run_hooks=on_strategy_run_hooks,
+            data_sources=data_sources
+        )
+
+        if algorithm.name is None:
+            algorithm.name = AlgorithmFactory.create_algorithm_name(algorithm)
+
+        # Validate the algorithm name
+        validate_algorithm_name(algorithm.name)
+        return algorithm