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

investing_algorithm_framework/app/reporting/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/app/reporting/metrics/risk_free_rate.py

@@ -1,8 +0,0 @@
-import yfinance as yf
-
-
-def get_risk_free_rate_us():
-    ten_year = yf.Ticker("^TNX")
-    hist = ten_year.history(period="5d")
-    latest_yield = hist["Close"].iloc[-1] / 100
-    return latest_yield

investing_algorithm_framework/app/reporting/metrics/volatility.py

@@ -1,69 +0,0 @@
-"""
-Volatility is a statistical measure of the dispersion of returns for a
-given portfolio. In finance, it is commonly used as a proxy for risk.
-This function calculates the standard deviation of daily log returns and
-annualizes it, giving an estimate of how much the portfolio's value
-fluctuates on a yearly basis.
-
-| **Annual Volatility** | **Risk Level** | **Typical for...**                                                     | **Comments**                                                                    |
-| --------------------- | -------------- | ---------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
-| **< 5%**              | Very Low Risk  | Cash equivalents, short-term bonds                                     | Low return expectations; often used for capital preservation                    |
-| **5% – 10%**          | Low Risk       | Diversified bond portfolios, conservative allocation strategies        | Suitable for risk-averse investors                                              |
-| **10% – 15%**         | Moderate Risk  | Balanced portfolios, large-cap equity indexes (e.g., S\&P 500 ≈ \~15%) | Standard for traditional diversified portfolios                                 |
-| **15% – 25%**         | High Risk      | Growth stocks, hedge funds, active equity strategies                   | Higher return potential, but more drawdowns                                     |
-| **> 25%**             | Very High Risk | Crypto, leveraged ETFs, speculative strategies                         | High potential returns, but prone to large losses; often not suitable long-term |
-
-"""
-
-from typing import List
-
-import pandas as pd
-import numpy as np
-
-from investing_algorithm_framework.domain import PortfolioSnapshot
-
-
-def get_annual_volatility(snapshots: List[PortfolioSnapshot]) -> float:
-    """
-    Calculate the annualized volatility of portfolio net values.
-
-    Args:
-        snapshots (List[PortfolioSnapshot]): List of portfolio snapshots
-            from the backtest report.
-
-    Returns:
-        Float: Annualized volatility as a float
-    """
-
-    if len(snapshots) < 2:
-        return 0.0  # Not enough data to calculate volatility
-
-    # Build DataFrame from snapshots
-    records = [
-        (snapshot.total_value, snapshot.created_at) for snapshot in snapshots
-    ]
-    df = pd.DataFrame(records, columns=['total_value', 'created_at'])
-    df['created_at'] = pd.to_datetime(df['created_at'])
-    df = df.sort_values('created_at').drop_duplicates('created_at').copy()
-
-    # Calculate log returns
-    df['log_return'] = np.log(df['total_value'] / df['total_value'].shift(1))
-    df = df.dropna()
-
-    if df.empty:
-        return 0.0
-
-    daily_volatility = df['log_return'].std()
-
-    start_date = snapshots[0].created_at
-    end_date = snapshots[-1].created_at
-    # Estimate trading days per year based on snapshot frequency
-    total_days = (end_date - start_date).days
-    num_observations = len(df)
-
-    if total_days > 0:
-        trading_days_per_year = (num_observations / total_days) * 365
-    else:
-        trading_days_per_year = 365  # Default fallback
-
-    return daily_volatility * np.sqrt(trading_days_per_year)

investing_algorithm_framework/cli/templates/requirements_azure_function.txt.template

@@ -1,3 +0,0 @@
-investing-algorithm-framework>=6.8.2
-azure-functions==1.17.0
-pyindicators>=0.5.4

investing_algorithm_framework/domain/models/backtesting/__init__.py

@@ -1,9 +0,0 @@
-from .backtest_position import BacktestPosition
-from .backtest_results import BacktestResult
-from .backtest_date_range import BacktestDateRange
-
-__all__ = [
-    "BacktestResult",
-    "BacktestPosition",
-    "BacktestDateRange"
-]

investing_algorithm_framework/domain/models/backtesting/backtest_date_range.py

@@ -1,47 +0,0 @@
-from datetime import datetime
-from dateutil.parser import parse
-
-
-class BacktestDateRange:
-    """
-    Represents a date range for a backtest
-    """
-    def __init__(self, start_date, end_date=None, name=None):
-
-        if isinstance(start_date, str):
-            start_date = parse(start_date)
-
-        if end_date is not None and isinstance(end_date, str):
-            end_date = parse(end_date)
-
-        self._start_date = start_date
-        self._end_date = end_date
-        self._name = name
-
-        if end_date is None:
-            self._end_date = datetime.now()
-
-        if end_date < start_date:
-            raise ValueError(
-                "End date cannot be before start date for a backtest "
-                "date range. " +
-                f"(start_date: {start_date}, end_date: {end_date})"
-            )
-
-    @property
-    def start_date(self):
-        return self._start_date
-
-    @property
-    def end_date(self):
-        return self._end_date
-
-    @property
-    def name(self):
-        return self._name
-
-    def __repr__(self):
-        return f"{self.name}: {self._start_date} - {self._end_date}"
-
-    def __str__(self):
-        return self.__repr__()

investing_algorithm_framework/domain/models/backtesting/backtest_position.py

@@ -1,120 +0,0 @@
-from investing_algorithm_framework.domain.models.base_model import BaseModel
-
-
-class BacktestPosition(BaseModel):
-
-    def __init__(
-        self,
-        position,
-        trading_symbol=False,
-        amount_pending_buy=0.0,
-        amount_pending_sell=0.0,
-        total_value_portfolio=0.0
-    ):
-        self._symbol = position.symbol
-        self._amount = position.amount + amount_pending_sell
-        self._cost = position.cost
-        self._price = 0.0
-        self._trading_symbol = trading_symbol
-        self._amount_pending_buy = amount_pending_buy
-        self._amount_pending_sell = amount_pending_sell
-        self._total_value_portfolio = total_value_portfolio
-
-    @property
-    def price(self):
-        return self._price
-
-    @price.setter
-    def price(self, value):
-        self._price = value
-
-    @property
-    def cost(self):
-
-        if self._trading_symbol:
-            return self.amount
-
-        return self._cost
-
-    @property
-    def value(self):
-
-        if self._trading_symbol:
-            return self.amount
-
-        return self._price * self.amount
-
-    @property
-    def growth(self):
-
-        if self._amount == 0:
-            return 0.0
-
-        if self._trading_symbol:
-            return 0.0
-
-        return self.value - self.cost
-
-    @property
-    def growth_rate(self):
-
-        if self._trading_symbol:
-            return 0.0
-
-        if self.cost == 0:
-            return 0.0
-
-        return self.growth / self.cost * 100
-
-    @property
-    def symbol(self):
-        return self._symbol
-
-    @property
-    def amount(self):
-        return self._amount
-
-    @property
-    def amount_pending_sell(self):
-        return self._amount_pending_sell
-
-    @amount_pending_sell.setter
-    def amount_pending_sell(self, value):
-        self._amount_pending_sell = value
-
-    @property
-    def amount_pending_buy(self):
-        return self._amount_pending_buy
-
-    @amount_pending_buy.setter
-    def amount_pending_buy(self, value):
-        self._amount_pending_buy = value
-
-    @property
-    def percentage_of_portfolio(self):
-
-        if self._total_value_portfolio == 0:
-            return 0.0
-
-        return (self.value / self._total_value_portfolio) * 100
-
-    def get_percentage_of_portfolio(self):
-
-        if self._total_value_portfolio == 0:
-            return 0.0
-
-        return self.value / self._total_value_portfolio * 100
-
-    def to_dict(self):
-        return {
-            "symbol": self.symbol,
-            "amount": self.amount,
-            "cost": self.cost,
-            "price": self.price,
-            "value": self.value,
-            "growth": self.growth,
-            "growth_rate": self.growth_rate,
-            "amount_pending_buy": self.amount_pending_buy,
-            "amount_pending_sell": self.amount_pending_sell,
-            "percentage_of_portfolio": self.percentage_of_portfolio
-        }