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

investing_algorithm_framework/domain/models/backtesting/backtest_reports_evaluation.py

@@ -1,243 +0,0 @@
-from typing import List, Dict
-
-from investing_algorithm_framework.domain.exceptions import \
-    OperationalException
-from investing_algorithm_framework.domain.models.backtesting\
-    .backtest_date_range import BacktestDateRange
-from .backtest_report import BacktestReport
-
-
-class BacktestReportsEvaluation:
-    """
-    A class to evaluate backtest reports.
-
-    This class is used to evaluate backtest reports and order them based on
-    different metrics. It also groups the reports by backtest date range.
-
-    The class has methods to get the best algorithm based on profit and growth.
-    """
-    report_groupings: Dict[BacktestDateRange, List[BacktestReport]]
-
-    def __init__(self, backtest_reports: List[BacktestReport]):
-
-        if backtest_reports is None:
-            raise OperationalException("No backtest reports to evaluate")
-
-        self.backtest_reports = backtest_reports
-        self.group_reports(self.backtest_reports)
-        self.profit_order = {}
-        self.profit_order_grouped_by_date = {}
-        self.growth_order = {}
-        self.growth_order_grouped_by_date = {}
-        self.percentage_positive_trades_order = {}
-        self.percentage_positive_trades_order_grouped_by_date = {}
-
-        # Calculate all metrics and group reports
-        for key in self.report_groupings:
-            self.profit_order_grouped_by_date[key] = self.order_on_profit(
-                self.report_groupings[key].copy()
-            )
-            self.growth_order_grouped_by_date[key] = self.order_on_growth(
-                self.report_groupings[key].copy()
-            )
-            self.percentage_positive_trades_order_grouped_by_date[key] = \
-                self.order_on_positive_trades(
-                    self.report_groupings[key].copy()
-                )
-
-        # Overall ordered reports
-        self.percentage_positive_trades_order = \
-            self.order_on_positive_trades(self.backtest_reports)
-        self.growth_order = self.order_on_growth(self.backtest_reports)
-        self.profit_order = self.order_on_profit(self.backtest_reports)
-
-    def order_on_profit(self, reports: List[BacktestReport]):
-        return sorted(reports, key=lambda x: x.total_net_gain, reverse=True)
-
-    def order_on_growth(self, reports: List[BacktestReport]):
-        return sorted(reports, key=lambda x: x.growth_rate, reverse=True)
-
-    def order_on_positive_trades(self, reports: List[BacktestReport]):
-        return sorted(
-            reports, key=lambda x: x.percentage_positive_trades, reverse=True
-        )
-
-    def group_reports(self, reports: List[BacktestReport]):
-        """
-        Group reports by backtest start and end date.
-        """
-        self.report_groupings = {}
-
-        for report in reports:
-            key = report.backtest_date_range
-            if key not in self.report_groupings:
-                self.report_groupings[key] = []
-            self.report_groupings[key].append(report)
-
-    def get_date_ranges(self):
-        """
-        Get the date ranges of the backtest reports.
-        """
-        return list(self.report_groupings.keys())
-
-    def get_profit_order(
-        self, backtest_date_range: BacktestDateRange = None
-    ) -> List[BacktestReport]:
-        """
-        Function to get profit order of all the backtest reports
-        in an ordered list.
-
-        :param backtest_date_range: Tuple with two datetime objects
-        :return: List of backtest reports
-        """
-
-        if backtest_date_range is None:
-            return self.profit_order
-        else:
-
-            if backtest_date_range in self.profit_order_grouped_by_date:
-                return self.profit_order_grouped_by_date[backtest_date_range]
-
-            raise OperationalException("No matches for given date range")
-
-    def get_growth_order(
-        self, backtest_date_range: BacktestDateRange = None
-    ) -> List[BacktestReport]:
-        """
-        Function to get growth order of all the backtest reports
-        in an ordered list.
-
-        :param backtest_date_range: Tuple with two datetime objects
-        :return: List of backtest reports
-        """
-
-        if backtest_date_range is None:
-            return self.growth_order
-        else:
-
-            if backtest_date_range in self.growth_order_grouped_by_date:
-                return self.growth_order_grouped_by_date[backtest_date_range]
-
-            raise OperationalException("No matches for given date range")
-
-    def get_percentage_positive_trades_order(
-        self, backtest_date_range: BacktestDateRange = None
-    ) -> List[BacktestReport]:
-        """
-        Function to get growth order of all the backtest reports
-        in an ordered list.
-
-        :param backtest_date_range: Tuple with two datetime objects
-        :return: List of backtest reports
-        """
-
-        if backtest_date_range is None:
-            return self.percentage_positive_trades_order
-        else:
-
-            if backtest_date_range in \
-                    self.percentage_positive_trades_order_grouped_by_date:
-                return self.percentage_positive_trades_order_grouped_by_date[
-                    backtest_date_range
-                ]
-
-            raise OperationalException("No matches for given date range")
-
-    def rank(
-        self,
-        weight_profit=0.7,
-        weight_growth=0.3,
-        backtest_date_range: BacktestDateRange = None
-    ) -> str:
-        """
-        Function to get the best overall algorithm based on the
-        weighted sum of profit and growth.
-
-        :param weight_profit: Weight for profit
-        :param weight_growth: Weight for growth
-        :return: Name of the best algorithm
-        """
-
-        # Create a dictionary with the algorithm name as key and group
-        # the reports by name
-        ordered_reports = {}
-
-        if backtest_date_range is not None:
-            reports = self.report_groupings[backtest_date_range]
-        else:
-            reports = self.backtest_reports
-
-        for report in reports:
-            if report.name not in ordered_reports:
-                ordered_reports[report.name] = []
-            ordered_reports[report.name].append(report)
-
-        best_algorithm = None
-        best_score = 0
-        profit_score = 0
-        growth_score = 0
-
-        for algorithm in ordered_reports:
-            profit_score += sum(
-                [report.total_net_gain for
-                 report in ordered_reports[algorithm]]
-            )
-            growth_score += sum(
-                [report.growth for report in
-                 ordered_reports[algorithm]]
-            )
-            score = weight_profit * profit_score + weight_growth * growth_score
-
-            if score > best_score:
-                best_score = score
-                best_algorithm = algorithm
-
-            profit_score = 0
-            growth_score = 0
-
-        return best_algorithm
-
-    def get_reports(
-        self, name: str = None, backtest_date_range: BacktestDateRange = None
-    ) -> List[BacktestReport]:
-        """
-        Function to get all the reports for a given algorithm name.
-
-        :param name: Name of the algorithm
-        :param backtest_date_range: Tuple with two datetime objects
-        :return: List of backtest reports
-        """
-
-        if name is not None and backtest_date_range is not None:
-            return [
-                report for report in self.report_groupings[backtest_date_range]
-                if report.name == name
-            ]
-
-        if name is not None:
-            return [
-                report for report in self.backtest_reports
-                if report.name == name
-            ]
-
-        if backtest_date_range is not None:
-            return self.report_groupings[backtest_date_range]
-
-    def get_report(
-        self, name: str, backtest_date_range: BacktestDateRange = None
-    ):
-        """
-        Function to get the report for a given algorithm name and date range.
-
-        :param name: Name of the algorithm
-        :param backtest_date_range: Tuple with two datetime objects
-        :return: Backtest report
-        """
-        reports = self.get_reports(name, backtest_date_range)
-
-        if len(reports) == 0:
-            raise OperationalException(
-                "No matches for given name and date range"
-            )
-
-        return reports[0]

investing_algorithm_framework/domain/models/trading_data_types.py

@@ -1,47 +0,0 @@
-from enum import Enum
-
-
-class TradingDataType(Enum):
-    TICKER = 'TICKER'
-    ORDER_BOOK = 'ORDER_BOOK'
-    OHLCV = "OHLCV"
-
-    @staticmethod
-    def from_value(value):
-
-        if isinstance(value, TradingDataType):
-            for trading_data_type in TradingDataType:
-
-                if value == trading_data_type:
-                    return trading_data_type
-
-        elif isinstance(value, str):
-            return TradingDataType.from_string(value)
-
-        raise ValueError(
-            "Could not convert value to trading data type"
-        )
-
-    @staticmethod
-    def from_string(value: str):
-
-        if isinstance(value, str):
-            for order_type in TradingDataType:
-
-                if value.upper() == order_type.value:
-                    return order_type
-
-        raise ValueError(
-            "Could not convert value to trading data type"
-        )
-
-    def equals(self, other):
-
-        if other is None:
-            return False
-
-        if isinstance(other, Enum):
-            return self.value == other.value
-
-        else:
-            return TradingDataType.from_string(other) == self

investing_algorithm_framework/domain/models/trading_time_frame.py

@@ -1,223 +0,0 @@
-from datetime import timedelta, datetime
-from enum import Enum
-
-from investing_algorithm_framework.domain.exceptions import \
-    OperationalException
-
-
-class TradingTimeFrame(Enum):
-    ONE_MINUTE = "ONE_MINUTE"
-    FIFTEEN_MINUTE = "FIFTEEN_MINUTE"
-    ONE_HOUR = "ONE_HOUR"
-    TWO_HOUR = "TWO_HOUR"
-    ONE_DAY = 'ONE_DAY'
-    ONE_MONTH = "ONE_MONTH"
-    ONE_YEAR = "ONE_YEAR"
-
-    def create_time_frame_from_limit(self, limit: int = 50):
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            hold = 1
-            start_date = datetime.now() - timedelta(minutes=limit)
-        elif TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            hold = 15
-            start_date = datetime.now() - timedelta(minutes=(limit * 15))
-        elif TradingTimeFrame.ONE_HOUR.equals(self):
-            hold = 60
-            start_date = datetime.now() - timedelta(hours=limit)
-        elif TradingTimeFrame.TWO_HOUR.equals(self):
-            hold = 60 * 2
-            start_date = datetime.now() - timedelta(hours=limit)
-        elif TradingTimeFrame.ONE_DAY.equals(self):
-            hold = 60 * 24
-            start_date = datetime.now() - timedelta(days=limit)
-        elif TradingTimeFrame.ONE_MONTH.equals(self):
-            hold = 60 * 24 * 30
-            start_date = datetime.now() - timedelta(weeks=(4 * limit))
-        else:
-            hold = 60 * 24 * 365
-            start_date = datetime.now() - timedelta(days=(limit * 365))
-
-        iteration = 1
-        dates = []
-        while iteration < limit or \
-                start_date + timedelta(minutes=hold) < datetime.now():
-            dates.append(start_date + timedelta(minutes=hold))
-            start_date += timedelta(minutes=hold)
-            iteration += 1
-
-        dates.append(datetime.now())
-        return dates
-
-    def create_time_frame_from_start_date(self, start_date: datetime):
-
-        if start_date > datetime.now():
-            raise OperationalException("Start date cannot be in the future")
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            hold = 1
-        elif TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            hold = 15
-        elif TradingTimeFrame.ONE_HOUR.equals(self):
-            hold = 60
-        elif TradingTimeFrame.TWO_HOUR.equals(self):
-            hold = 60 * 2
-        elif TradingTimeFrame.ONE_DAY.equals(self):
-            hold = 60 * 24
-        elif TradingTimeFrame.ONE_MONTH.equals(self):
-            hold = 60 * 24 * 30
-        else:
-            hold = 60 * 24 * 365
-
-        iteration = 1
-        dates = []
-
-        while start_date < datetime.now():
-            dates.append(start_date + timedelta(minutes=hold))
-            start_date += timedelta(minutes=hold)
-            iteration += 1
-
-        dates.append(datetime.now())
-        return dates
-
-    def to_ccxt_string(self):
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            return "1m"
-
-        if TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            return "15m"
-
-        if TradingTimeFrame.ONE_HOUR.equals(self):
-            return "1h"
-
-        if TradingTimeFrame.TWO_HOUR.equals(self):
-            return "2h"
-
-        if TradingTimeFrame.ONE_DAY.equals(self):
-            return "1d"
-
-        if TradingTimeFrame.ONE_MONTH.equals(self):
-            return "1m"
-
-        if TradingTimeFrame.ONE_YEAR.equals(self):
-            return "1y"
-
-        raise OperationalException("Data time unit value is not supported")
-
-    @staticmethod
-    def from_value(value):
-
-        if isinstance(value, TradingTimeFrame):
-            for data_time_unit in TradingTimeFrame:
-
-                if value == data_time_unit:
-                    return data_time_unit
-
-        elif isinstance(value, str):
-            return TradingTimeFrame.from_string(value)
-
-        raise ValueError(
-            "Could not convert value to data time unit"
-        )
-
-    @staticmethod
-    def from_string(value: str):
-
-        if isinstance(value, str):
-            for data_time_unit in TradingTimeFrame:
-
-                if value.upper() == data_time_unit.value:
-                    return data_time_unit
-
-        raise ValueError(
-            "Could not convert value to data time unit"
-        )
-
-    def equals(self, other):
-
-        if other is None:
-            return False
-
-        if isinstance(other, Enum):
-            return self.value == other.value
-
-        else:
-            return TradingTimeFrame.from_string(other) == self
-
-    def create_start_date(self, limit=50):
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            return datetime.now() - timedelta(minutes=limit)
-
-        if TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            return datetime.now() - timedelta(minutes=(limit * 15))
-
-        if TradingTimeFrame.ONE_HOUR.equals(self):
-            return datetime.now() - timedelta(hours=limit)
-
-        if TradingTimeFrame.TWO_HOUR.equals(self):
-            return datetime.now() - timedelta(hours=limit * 2)
-
-        if TradingTimeFrame.ONE_DAY.equals(self):
-            return datetime.now() - timedelta(days=limit)
-
-        if TradingTimeFrame.ONE_MONTH.equals(self):
-            return datetime.now() - timedelta(weeks=(4 * limit))
-
-        if TradingTimeFrame.ONE_YEAR.equals(self):
-            return datetime.now() - timedelta(days=(limit * 365))
-
-        raise OperationalException("Data time unit value is not supported")
-
-    @property
-    def minutes(self):
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            return 1
-
-        if TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            return 15
-
-        if TradingTimeFrame.ONE_HOUR.equals(self):
-            return 60
-
-        if TradingTimeFrame.TWO_HOUR.equals(self):
-            return 120
-
-        if TradingTimeFrame.ONE_DAY.equals(self):
-            return 60 * 24
-
-        if TradingTimeFrame.ONE_MONTH.equals(self):
-            return 60 * 24 * 30
-
-        if TradingTimeFrame.ONE_YEAR.equals(self):
-            return 60 * 24 * 365
-
-        raise OperationalException("Data time frame value is not supported")
-
-    @property
-    def milliseconds(self):
-
-        if TradingTimeFrame.ONE_MINUTE.equals(self):
-            return 60 * 1000
-
-        if TradingTimeFrame.FIFTEEN_MINUTE.equals(self):
-            return 15 * 60 * 1000
-
-        if TradingTimeFrame.ONE_HOUR.equals(self):
-            return 60 * 60 * 1000
-
-        if TradingTimeFrame.TWO_HOUR.equals(self):
-            return 2 * 60 * 60 * 1000
-
-        if TradingTimeFrame.ONE_DAY.equals(self):
-            return 60 * 60 * 24 * 1000
-
-        if TradingTimeFrame.ONE_MONTH.equals(self):
-            return 60 * 60 * 24 * 30 * 1000
-
-        if TradingTimeFrame.ONE_YEAR.equals(self):
-            return 60 * 60 * 24 * 365 * 1000
-
-        raise OperationalException("Data time frame value is not supported")