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

investing_algorithm_framework/infrastructure/services/performance_service/performance_service.py

@@ -1,322 +0,0 @@
-import logging
-
-from investing_algorithm_framework.domain import OrderStatus, OrderSide, \
-    TradeStatus
-
-logger = logging.getLogger(__name__)
-
-
-class PerformanceService:
-    """
-    Service to calculate the performance of a portfolio.
-    """
-
-    def __init__(
-        self,
-        order_repository,
-        position_repository,
-        portfolio_repository,
-        trade_repository,
-    ):
-        self.order_repository = order_repository
-        self.position_repository = position_repository
-        self.portfolio_repository = portfolio_repository
-        self.trade_repository = trade_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})
-        return self.trade_repository.count(
-            {"portfolio_id": portfolio.id, "status": TradeStatus.OPEN.value}
-        )
-
-    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})
-        return self.trade_repository.count(
-            {"portfolio_id": portfolio.id, "status": TradeStatus.OPEN.value}
-        )
-
-    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})
-        trades = self.trade_repository.get_all(
-            {"portfolio_id": portfolio.id, "status": OrderStatus.CLOSED.value}
-        )
-        total_number_of_trades = len(trades)
-
-        if total_number_of_trades == 0:
-            return 0.0
-
-        positive_trades = [
-            trade for trade in trades if trade.net_gain > 0
-        ]
-        total_number_of_positive_trades = len(positive_trades)
-        return total_number_of_positive_trades / total_number_of_trades * 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})
-        trades = self.trade_repository.get_all(
-            {"portfolio_id": portfolio.id, "status": TradeStatus.CLOSED.value}
-        )
-        total_number_of_trades = len(trades)
-
-        if total_number_of_trades == 0:
-            return 0.0
-
-        negative_trades = [
-            trade for trade in trades if trade.net_gain < 0
-        ]
-        total_number_of_negative_trades = len(negative_trades)
-        return total_number_of_negative_trades / total_number_of_trades * 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})
-
-        if portfolio.total_net_gain == 0:
-            return 0
-
-        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})
-        trades = self.trade_repository.get_all(
-            {"portfolio_id": portfolio.id, "status": TradeStatus.CLOSED.value}
-        )
-
-        if len(trades) == 0:
-            return 0
-
-        total_duration = 0
-
-        for trade in trades:
-            duration = trade.closed_at - trade.opened_at
-            total_duration += duration.total_seconds() / 3600
-
-        return total_duration / len(trades)
-
-    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})
-        portfolio = self.portfolio_repository.find({"id": portfolio_id})
-        trades = self.trade_repository.get_all({"portfolio_id": portfolio.id})
-
-        if len(trades) == 0:
-            return 0
-
-        total_size = 0
-
-        for trade in trades:
-            total_size += trade.amount * trade.open_price
-
-        return total_size / len(trades)

investing_algorithm_framework/services/market_data_source_service/__init__.py

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

investing_algorithm_framework/services/market_data_source_service/backtest_market_data_source_service.py

@@ -1,269 +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, OHLCVMarketDataSource, \
-    TickerMarketDataSource, OrderBookMarketDataSource, MarketDataType, \
-    TimeFrame
-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.
-
-    The main difference between MarketDataSourceService and
-    the BacktestMarketDataSourceService is that it will
-    prepare the data for backtesting in the constructor.
-    """
-    def __init__(
-        self,
-        market_service: MarketService,
-        market_credential_service: MarketCredentialService,
-        configuration_service: ConfigurationService,
-        market_data_sources: List[BacktestMarketDataSource] = None
-    ):
-        super().__init__(
-            market_service=market_service,
-            market_data_sources=None,
-            market_credential_service=market_credential_service,
-            configuration_service=configuration_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)
-
-    def initialize_market_data_sources(self):
-        config = self._configuration_service.get_config()
-        backtest_start_date = config[BACKTESTING_START_DATE]
-        backtest_end_date = config[BACKTESTING_END_DATE]
-        backtest_market_data_sources = [
-            market_data_source.to_backtest_market_data_source() for
-            market_data_source in self._market_data_sources
-        ]
-
-        # Filter out the None values
-        backtest_market_data_sources = [
-            market_data_source for market_data_source in
-            backtest_market_data_sources if market_data_source is not None
-        ]
-
-        for backtest_market_data_source in tqdm(
-            backtest_market_data_sources,
-            total=len(self._market_data_sources),
-            desc="Preparing backtest market data",
-            colour="GREEN"
-        ):
-            backtest_market_data_source.market_credential_service = \
-                self._market_credential_service
-            backtest_market_data_source.prepare_data(
-                config=config,
-                backtest_start_date=backtest_start_date,
-                backtest_end_date=backtest_end_date
-            )
-
-        self.clear_market_data_sources()
-        self.market_data_sources = backtest_market_data_sources
-
-    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).
-
-        If there is no match, it raises an OperationalException.
-
-        Args:
-            identifier: The identifier of the market data source
-
-        Returns:
-            The data for the given identifier
-        """
-        config = self._configuration_service.get_config()
-        backtest_index_date = config[BACKTESTING_INDEX_DATETIME]
-
-        for market_data_source in self._market_data_sources:
-
-            if market_data_source.get_identifier() == identifier:
-                config = self._configuration_service.get_config()
-                backtest_index_date = config[BACKTESTING_INDEX_DATETIME]
-                data = market_data_source.get_data(
-                    date=backtest_index_date, config=config
-                )
-
-                result = {
-                    "data": data,
-                    "type": None,
-                    "symbol": None,
-                    "time_frame": None
-                }
-
-                # Add metadata to the data
-                if isinstance(market_data_source, OHLCVMarketDataSource):
-                    result["type"] = MarketDataType.OHLCV
-                    time_frame = TimeFrame.from_value(
-                        market_data_source.time_frame
-                    )
-                    result["time_frame"] = time_frame.value
-                    result["symbol"] = market_data_source.symbol
-                    return result
-
-                if isinstance(market_data_source, TickerMarketDataSource):
-                    result["type"] = MarketDataType.TICKER
-                    result["time_frame"] = TimeFrame.CURRENT
-                    result["symbol"] = market_data_source.symbol
-                    return result
-
-                if isinstance(market_data_source, OrderBookMarketDataSource):
-                    result["type"] = MarketDataType.ORDER_BOOK
-                    result["time_frame"] = TimeFrame.CURRENT
-                    result["symbol"] = market_data_source.symbol
-                    return result
-
-                result["type"] = MarketDataType.CUSTOM
-                result["time_frame"] = TimeFrame.CURRENT
-                result["symbol"] = market_data_source.symbol
-                return result
-
-        raise OperationalException(
-            f"Backtest market data source not found for {identifier}"
-        )
-
-    def get_ticker(self, symbol, market=None):
-        ticker_market_data_source = self.get_ticker_market_data_source(
-            symbol=symbol, market=market
-        )
-        ohlcv_market_data_source = self.get_ohlcv_market_data_source(
-            symbol=symbol, market=market
-        )
-        if ohlcv_market_data_source is not None and \
-                ticker_market_data_source is None:
-            data = ohlcv_market_data_source.get_data(
-                date=self._configuration_service.get_config()[
-                    BACKTESTING_INDEX_DATETIME
-                ],
-                config=self._configuration_service.get_config()
-            )
-
-            # Get last row of the OHLCV data polars dataframe
-            close = data.tail(1)["Close"][0]
-            timestamp = data.tail(1)["Datetime"][0]
-            open = data.tail(1)["Open"][0]
-            high = data.tail(1)["High"][0]
-            low = data.tail(1)["Low"][0]
-            volume = data.tail(1)["Volume"][0]
-
-            spread = close * 0.001
-            bid = close - spread
-            ask = close + spread
-
-            ticker_data = {
-                "symbol": symbol,
-                "market": market,
-                "timestamp": timestamp,
-                # or the appropriate time column
-                "open": open,
-                "high": high,
-                "low": low,
-                "close": close,
-                "last": close,
-                "volume": volume,
-                "bid": bid,
-                "ask": ask,
-            }
-            return ticker_data
-
-        if ticker_market_data_source is None:
-            identifiers = self.get_market_data_source_identifiers()
-            raise OperationalException(
-                "Backtest ticker data source "
-                f"not found for {symbol} and market {market}, the available "
-                f"data sources are: {identifiers}"
-            )
-
-        config = self._configuration_service.get_config()
-        backtest_index_date = config[BACKTESTING_INDEX_DATETIME]
-        return ticker_market_data_source.get_data(
-            date=backtest_index_date, config=config
-        )
-
-    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
-        config = self._configuration_service.get_config()
-        backtest_index_date = config[BACKTESTING_INDEX_DATETIME]
-        return market_data_source.get_data(
-            date=backtest_index_date, config=config
-        )
-
-    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
-        config = self._configuration_service.get_config()
-        backtest_index_date = config[BACKTESTING_INDEX_DATETIME]
-        return market_data_source.get_data(
-            date=backtest_index_date, config=config
-        )
-
-    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):
-
-        if market_data_source is None:
-            return
-
-        # 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)
-
-    def has_ticker_market_data_source(self, symbol, market=None):
-        ticker_market_data_source = self.get_ticker_market_data_source(
-            symbol=symbol, market=market
-        )
-        ohlcv_market_data_source = self.get_ohlcv_market_data_source(
-            symbol=symbol, market=market
-        )
-
-        if ohlcv_market_data_source is not None or \
-                ticker_market_data_source is not None:
-            return True
-
-        return False