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

investing_algorithm_framework/infrastructure/services/performance_service/performance_service.py

@@ -1,350 +0,0 @@
-import logging
-
-from investing_algorithm_framework.domain import OrderStatus, OrderSide
-
-logger = logging.getLogger(__name__)
-
-
-class PerformanceService:
-    """
-    Service to calculate the performance of a portfolio.
-    """
-
-    def __init__(
-        self,
-        order_repository,
-        position_repository,
-        portfolio_repository,
-    ):
-        self.order_repository = order_repository
-        self.position_repository = position_repository
-        self.portfolio_repository = portfolio_repository
-
-    def get_total_net_gain(self, portfolio_id):
-        pass
-
-    def get_total_size(self, portfolio_id):
-        pass
-
-    def get_percentage_change(self, portfolio_id, time_frame):
-        pass
-
-    def get_total_cost(self, portfolio_id):
-        pass
-
-    def get_number_of_trades_closed(self, portfolio_id):
-        """"
-        Get the number of trades closed. This function will
-        return the number of trades that are already closed.
-
-        param portfolio_id: The id of the portfolio
-        type portfolio_id: str
-
-        return: The number of trades closed
-        """
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        number_of_trades_closed = 0
-        orders = self.order_repository.get_all(
-            {
-                "portfolio_id": portfolio.id,
-                "order_side": OrderSide.BUY.value,
-            }
-        )
-
-        for order in orders:
-            if order.get_trade_closed_at() is not None:
-                number_of_trades_closed += 1
-
-        return number_of_trades_closed
-
-    def get_number_of_trades_open(self, portfolio_id):
-        """
-        Get the number of trades open. This function will
-        return the number of trades that are still open.
-
-        param portfolio_id: The id of the portfolio
-        type portfolio_id: str
-
-        return: The number of trades open
-        """
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        number_of_trades_open = 0
-        orders = self.order_repository.get_all(
-            {
-                "portfolio_id": portfolio.id,
-                "order_side": OrderSide.BUY.value,
-            }
-        )
-
-        for order in orders:
-            if order.get_trade_closed_at() is None:
-                number_of_trades_open += 1
-
-        return number_of_trades_open
-
-    def get_percentage_positive_trades(self, portfolio_id):
-        """
-        Get the percentage of positive trades. This function will
-        calculate the percentage of positive trades by dividing the
-        total number of positive trades by the total number of trades
-        and then multiplying it by 100.
-
-        param portfolio_id: The id of the portfolio
-        type portfolio_id: str
-
-        return: The percentage of positive trades
-        """
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        orders = self.order_repository.get_all(
-            {"portfolio_id": portfolio.id, "status": OrderStatus.CLOSED.value}
-        )
-        total_number_of_orders = len(orders)
-
-        if total_number_of_orders == 0:
-            return 0.0
-
-        positive_orders = [
-            order for order in orders if order.get_net_gain() > 0
-        ]
-        total_number_of_positive_orders = len(positive_orders)
-        return total_number_of_positive_orders / total_number_of_orders * 100
-
-    def get_percentage_negative_trades(self, portfolio_id):
-        """
-        Get the percentage of negative trades. This function will
-        calculate the percentage of negative trades by dividing the
-        total number of negative trades by the total number of trades
-        and then multiplying it by 100.
-
-        param portfolio_id: The id of the portfolio
-        type portfolio_id: str
-
-        return: The percentage of negative trades
-        """
-
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        orders = self.order_repository.get_all(
-            {"portfolio_id": portfolio.id, "status": OrderStatus.CLOSED.value}
-        )
-        total_number_of_orders = len(orders)
-
-        if total_number_of_orders == 0:
-            return 0.0
-
-        negative_orders = [
-            order for order in orders if order.get_net_gain() < 0
-        ]
-        total_number_of_negative_orders = len(negative_orders)
-        return total_number_of_negative_orders / total_number_of_orders * 100
-
-    def get_growth_rate_of_backtest(
-        self, portfolio_id, tickers, backtest_profile
-    ):
-        """
-        Get the growth rate of the backtest. This function will
-        calculate the total value of the portfolio and then
-        calculate the growth rate of the portfolio.
-
-        param portfolio_id: The id of the portfolio
-        type portfolio_id: str
-        param tickers: list of tickers of all the used symbols
-        type tickers: dict
-
-        return: The growth rate of the backtest
-        """
-        total_value = self.get_total_value(
-            portfolio_id, tickers, backtest_profile
-        )
-        gain = total_value - backtest_profile.initial_unallocated
-        return gain / backtest_profile.initial_unallocated * 100
-
-    def get_growth_of_backtest(self, portfolio_id, tickers, backtest_profile):
-        """
-        Get the growth of the backtest. This function will
-        calculate the total value of the portfolio and then
-        calculate the growth of the portfolio.
-
-        param portfolio_id: The id of the portfolio
-        type portfolio_id: str
-        param tickers: The tickers of the market
-        type tickers: dict
-
-        return: The growth of the backtest
-        """
-        total_value = self.get_total_value(
-            portfolio_id, tickers, backtest_profile
-        )
-        return total_value - backtest_profile.initial_unallocated
-
-    def get_total_net_gain_percentage_of_backtest(
-        self, portfolio_id, backtest_profile
-    ):
-        """
-        Get the total net gain percentage of the backtest. This function
-        will calculate the total net gain percentage of the portfolio
-        by dividing the total net gain by the initial unallocated value
-        of the portfolio and then multiplying it by 100.
-
-        param portfolio_id: The id of the portfolio
-        type portfolio_id: str
-        param backtest_profile: The backtest profile
-        type backtest_profile: BacktestProfile
-
-        return: The total net gain percentage of the backtest
-        """
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        return portfolio.total_net_gain \
-            / backtest_profile.initial_unallocated * 100
-
-    def get_total_value(self, portfolio_id, tickers, backtest_profile):
-        """
-        Get the total value of the portfolio. This functions
-        will calculate the allocated value, pending buy value,
-        pending sell value and unallocated value.
-
-        At the end, it will sum all these values and return the
-        total value of the portfolio.
-
-        param portfolio_id: The id of the portfolio
-        type portfolio_id: str
-        param tickers: The tickers of the market
-        type tickers: dict
-        param backtest_profile: The backtest profile
-        type backtest_profile: BacktestProfile
-
-        return: The total value of the portfolio
-        rtype: float
-        """
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        positions = self.position_repository.get_all(
-            {"portfolio_id": portfolio.id}
-        )
-        allocated = 0
-
-        for position in positions:
-
-            if position.symbol == portfolio.trading_symbol:
-                continue
-
-            ticker_symbol = f"{position.symbol.upper()}" \
-                            f"/{portfolio.trading_symbol.upper()}"
-            if ticker_symbol not in tickers:
-                logger.warning(
-                    f"Symbol {position.symbol} not found in tickers, "
-                    f"cannot calculate the total value of the position"
-                )
-                continue
-
-            allocated += position.amount * tickers[ticker_symbol]["bid"]
-
-        # Calculate the pending sell value
-        pending_sell_orders = self.order_repository.get_all(
-            {
-                "portfolio_id": portfolio.id,
-                "status": OrderStatus.OPEN.value,
-                "order_side": OrderSide.SELL.value,
-            }
-        )
-
-        for order in pending_sell_orders:
-
-            if order.get_symbol() in tickers:
-                allocated += order.get_amount() \
-                             * tickers[order.get_symbol()]["bid"]
-            else:
-                logger.warning(
-                    f"Symbol {order.get_symbol()} not found in tickers, "
-                    f"cannot calculate the total value of sell orders"
-                )
-
-        # Calculate the unallocated value by summing the unallocated and
-        # pending buy value
-        unallocated = portfolio.unallocated
-        pending_buy_orders = self.order_repository.get_all(
-            {
-                "portfolio_id": portfolio.id,
-                "status": OrderStatus.OPEN.value,
-                "order_side": OrderSide.BUY.value,
-            }
-        )
-
-        for order in pending_buy_orders:
-            if order.get_symbol() in tickers:
-                unallocated += order.get_amount() \
-                             * tickers[order.get_symbol()]["ask"]
-            else:
-                logger.warning(
-                    f"Symbol {order.get_symbol()} not found in tickers, "
-                    f"cannot calculate the total value of buy orders"
-                )
-
-        # Add everything together
-        return allocated + unallocated
-
-    def get_average_trade_duration(self, portfolio_id):
-        """
-        Get the average trade duration. This function will
-        calculate the average trade duration by summing the
-        duration of all the trades and then dividing it by the
-        total number of trades.
-
-        param portfolio_id: The id of the portfolio
-        type portfolio_id: str
-
-        return: The average trade duration
-        """
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        buy_orders = self.order_repository.get_all(
-            {
-                "portfolio_id": portfolio.id,
-                "order_side": OrderSide.BUY.value,
-            }
-        )
-        buy_orders_with_trade_closed = [
-            order for order in buy_orders
-            if order.get_trade_closed_at() is not None
-        ]
-
-        if len(buy_orders_with_trade_closed) == 0:
-            return 0
-
-        total_duration = 0
-
-        for order in buy_orders_with_trade_closed:
-            duration = order.get_trade_closed_at() - order.get_created_at()
-            total_duration += duration.total_seconds() / 3600
-
-        return total_duration / len(buy_orders_with_trade_closed)
-
-    def get_average_trade_size(self, portfolio_id):
-        """
-        Get the average trade size. This function will calculate
-        the average trade size by summing the size of all the trades
-        and then dividing it by the total number of trades.
-
-        param portfolio_id: The id of the portfolio
-        type portfolio_id: str
-
-        return: The average trade size
-        """
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        buy_orders = self.order_repository.get_all(
-            {
-                "portfolio_id": portfolio.id,
-                "order_side": OrderSide.BUY.value,
-            }
-        )
-        closed_buy_orders = [
-            order for order in buy_orders
-            if order.get_trade_closed_at() is not None
-        ]
-
-        if len(closed_buy_orders) == 0:
-            return 0
-
-        total_size = 0
-
-        for order in closed_buy_orders:
-            total_size += order.get_amount() * order.get_price()
-
-        return total_size / len(closed_buy_orders)

investing_algorithm_framework/services/backtesting/backtest_report_writer_service.py

@@ -1,53 +0,0 @@
-import json
-import os
-
-from investing_algorithm_framework.domain import BacktestReport, \
-    DATETIME_FORMAT_BACKTESTING
-
-
-class BacktestReportWriterService:
-    """
-    Service to write backtest reports to a file.
-
-    Service supports writing backtest reports to the following formats:
-    - JSON
-    """
-
-    def write_report_to_json(
-        self, report: BacktestReport, output_directory: str
-    ):
-        if not os.path.exists(output_directory):
-            os.makedirs(output_directory)
-        backtest_start_date = report.backtest_date_range.start_date\
-            .strftime(DATETIME_FORMAT_BACKTESTING)
-        backtest_end_date = report.backtest_date_range.end_date\
-            .strftime(DATETIME_FORMAT_BACKTESTING)
-        created_at = report.created_at.strftime(DATETIME_FORMAT_BACKTESTING)
-        json_file_path = os.path.join(
-            output_directory,
-            f"report_{report.name}_backtest_start_date_"
-            f"{backtest_start_date}_backtest_end_date_"
-            f"{backtest_end_date}_created_at_{created_at}.json"
-        )
-        report_dict = report.to_dict()
-        # Convert dictionary to JSON
-        json_data = json.dumps(report_dict, indent=4)
-
-        # Write JSON data to a .json file
-        with open(json_file_path, "w") as json_file:
-            json_file.write(json_data)
-
-    @staticmethod
-    def create_report_name(report, output_directory, extension=".json"):
-        backtest_start_date = report.backtest_start_date \
-            .strftime(DATETIME_FORMAT_BACKTESTING)
-        backtest_end_date = report.backtest_end_date \
-            .strftime(DATETIME_FORMAT_BACKTESTING)
-        created_at = report.created_at.strftime(DATETIME_FORMAT_BACKTESTING)
-        file_path = os.path.join(
-            output_directory,
-            f"report_{report.name}_backtest_start_date_"
-            f"{backtest_start_date}_backtest_end_date_"
-            f"{backtest_end_date}_created_at_{created_at}{extension}"
-        )
-        return file_path

investing_algorithm_framework/services/backtesting/graphs.py

@@ -1,61 +0,0 @@
-from typing import List
-
-import pandas as pd
-from plotly import graph_objects as go
-
-from investing_algorithm_framework.domain import Trade
-
-
-def create_prices_chart(df, column="Close"):
-    """
-    Function to create a prices chart.
-    """
-    return go.Scatter(
-        x=df.index,
-        y=df[column],
-        mode='lines',
-        line=dict(color="blue", width=1),
-        name="Close"
-    )
-
-
-def create_trade_entry_markers_chart(df, trades: List[Trade]):
-    df['entry_prices'] = None
-
-    for trade in trades:
-        opened_index = df.index.get_indexer(
-            [pd.to_datetime(trade.opened_at)], method='nearest'
-        )
-        df.at[df.index[opened_index[0]], 'entry_prices'] = df.at[
-            df.index[opened_index[0]], 'Close']
-
-    return go.Scatter(
-        x=df.index,
-        y=df["entry_prices"],
-        marker_symbol="arrow-up",
-        marker=dict(color='green'),
-        mode='markers',
-        name='Buy'
-    )
-
-
-def create_trade_exit_markers_chart(df, trades: List[Trade]):
-    df['exit_prices'] = None
-
-    for trade in trades:
-
-        if trade.closed_at is not None:
-            closed_index = df.index.get_indexer(
-                [pd.to_datetime(trade.closed_at)], method='nearest'
-            )
-            df.at[df.index[closed_index[0]], 'exit_prices'] = df.at[
-                df.index[closed_index[0]], 'Close']
-
-    return go.Scatter(
-        x=df.index,
-        y=df["exit_prices"],
-        marker_symbol="arrow-down",
-        marker=dict(color='red'),
-        mode='markers',
-        name='Sell'
-    )

investing_algorithm_framework/services/market_data_source_service/__init__.py

@@ -1,8 +0,0 @@
-from .backtest_market_data_source_service import \
-    BacktestMarketDataSourceService
-from .market_data_source_service import MarketDataSourceService
-
-__all__ = [
-    "MarketDataSourceService",
-    "BacktestMarketDataSourceService"
-]

investing_algorithm_framework/services/market_data_source_service/backtest_market_data_source_service.py

@@ -1,150 +0,0 @@
-from typing import List
-
-from tqdm import tqdm
-
-from investing_algorithm_framework.domain import MarketService, \
-    BacktestMarketDataSource, BACKTESTING_END_DATE, BACKTESTING_START_DATE, \
-    BACKTESTING_INDEX_DATETIME, OperationalException
-from investing_algorithm_framework.services.configuration_service import \
-    ConfigurationService
-from investing_algorithm_framework.services.market_credential_service \
-    import MarketCredentialService
-from .market_data_source_service import MarketDataSourceService
-
-
-class BacktestMarketDataSourceService(MarketDataSourceService):
-    """
-    BacktestMarketDataSourceService is a subclass of MarketDataSourceService.
-    It is used to create market data sources for backtesting.
-
-    In the constructor, it takes a list of BacktestMarketDataSource objects.
-    These objects are used to prepare the data for backtesting.
-
-    The prepare_data method of BacktestMarketDataSource is called in the
-    constructor.
-    """
-    def __init__(
-        self,
-        market_data_sources: List[BacktestMarketDataSource],
-        market_service: MarketService,
-        market_credential_service: MarketCredentialService,
-        configuration_service: ConfigurationService,
-    ):
-        super().__init__(
-            market_service=market_service,
-            market_data_sources=None,
-            market_credential_service=market_credential_service,
-        )
-        self.market_data_sources = []
-
-        # Add all market data sources to the list
-        if market_data_sources is not None:
-            for market_data_source in market_data_sources:
-                self.add(market_data_source)
-
-        self._configuration_service: ConfigurationService = \
-            configuration_service
-
-        for backtest_market_data_source in tqdm(
-            market_data_sources,
-            total=len(self._market_data_sources),
-            desc="Preparing backtest market data",
-            colour="GREEN"
-        ):
-
-            if backtest_market_data_source is not None:
-                backtest_market_data_source.market_credentials_service = \
-                    self._market_credential_service
-                backtest_market_data_source.prepare_data(
-                    config=configuration_service.get_config(),
-                    backtest_start_date=configuration_service
-                    .get_config()[BACKTESTING_START_DATE],
-                    backtest_end_date=configuration_service
-                    .get_config()[BACKTESTING_END_DATE],
-                    market_credential_service=self._market_credential_service
-                )
-
-    def get_data(self, identifier):
-        """
-        This method is used to get the data for backtesting. It loops
-        over all the backtest market data sources and returns the data
-        for the given identifier (If there is a match).
-        """
-        for backtest_market_data_source in self._market_data_sources:
-            if backtest_market_data_source.identifier == identifier:
-                backtest_market_data_source.market_credentials_service = \
-                    self._market_credential_service
-                return backtest_market_data_source.get_data(
-                    backtest_index_date=self._configuration_service
-                    .config[BACKTESTING_INDEX_DATETIME],
-                )
-
-        raise OperationalException(
-            f"Backtest market data source not found for {identifier}"
-        )
-
-    def get_ticker(self, symbol, market):
-        market_data_source = self.get_ticker_market_data_source(
-            symbol=symbol, market=market
-        )
-
-        if market_data_source is None:
-            raise OperationalException(
-                f"Backtest ticker data source "
-                f"not found for {symbol} and market {market}"
-            )
-
-        market_data_source.market_credentials_service = \
-            self._market_credential_service
-        return market_data_source.get_data(
-            backtest_index_date=self._configuration_service
-            .config[BACKTESTING_INDEX_DATETIME],
-        )
-
-    def get_order_book(self, symbol, market):
-        market_data_source = self.get_order_book_market_data_source(
-            symbol=symbol, market=market
-        )
-        market_data_source.market_credential_service = \
-            self._market_credential_service
-        return market_data_source.get_data(
-            backtest_index_date=self._configuration_service
-            .config[BACKTESTING_INDEX_DATETIME],
-        )
-
-    def get_ohlcv(
-        self,
-        symbol,
-        from_timestamp,
-        time_frame=None,
-        market=None,
-        to_timestamp=None
-    ):
-        market_data_source = self.get_ohlcv_market_data_source(
-            symbol=symbol, market=market, time_frame=time_frame
-        )
-        market_data_source.market_credential_service = \
-            self._market_credential_service
-        return market_data_source.get_data(
-            from_timestamp=from_timestamp,
-            to_timestamp=to_timestamp,
-            backtest_index_date=self._configuration_service
-            .config[BACKTESTING_INDEX_DATETIME],
-        )
-
-    def is_ohlcv_data_source_present(self, symbol, time_frame, market):
-        market_data_source = self.get_ohlcv_market_data_source(
-            symbol=symbol, market=market, time_frame=time_frame
-        )
-        return market_data_source is not None
-
-    def add(self, market_data_source):
-
-        # Check if there is already a market data source with the same
-        # identifier
-        for existing_market_data_source in self._market_data_sources:
-            if existing_market_data_source.get_identifier() == \
-                    market_data_source.get_identifier():
-                return
-
-        self._market_data_sources.append(market_data_source)