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

investing_algorithm_framework/domain/graphs.py

@@ -1,382 +0,0 @@
-import pandas as pd
-import plotly.graph_objs as go
-
-
-def create_rsi_graph(data: pd.DataFrame):
-    """
-    Create a graph for the RSI metric.
-    :param data: DataFrame with a 'RSI' column and a Datetime index
-    :return: Plotly graph object
-    """
-
-    # Check if the index is of type datetime
-    if not isinstance(data.index, pd.DatetimeIndex):
-        raise ValueError("The index of the data should be of type datetime")
-
-    # Check if the 'RSI' column exists
-    if 'RSI' not in data.columns:
-        raise ValueError("The data should have a 'RSI' column")
-
-    return go.Scatter(
-        x=data.index,
-        y=data['RSI'],
-        mode='lines',
-        line=dict(color="green", width=1),
-        name="RSI"
-    )
-
-
-def create_prices_graph(
-    data: pd.DataFrame,
-    data_key="Close",
-    graph_name="Price",
-    color="blue",
-    line_width=1
-):
-    """
-    Create a graph for the close prices. By default, the key is set to 'Close'.
-
-    Args:
-        data (pd.DataFrame): The data to plot
-        data_key (str): The key to use for the prices
-        graph_name (str): The name of the graph
-        color (str): The color of the graph
-        line_width (int): The width of the line
-
-    Returns:
-        go.Scatter: The Plotly graph object
-    """
-
-    # Check if the index is of type datetime
-    if not isinstance(data.index, pd.DatetimeIndex):
-        raise ValueError("The index of the data should be of type datetime")
-
-    # Check if the 'Close' column exists
-    if data_key not in data.columns:
-        raise ValueError("The data should have a 'Close' column")
-
-    return go.Scatter(
-        x=data.index,
-        y=data[data_key],
-        mode='lines',
-        line=dict(color=color, width=line_width),
-        name=graph_name
-    )
-
-
-def create_adx_graph(data: pd.DataFrame):
-    """
-    Create a graph for the ADX metric.
-    :param data: DataFrame with a 'ADX' column and a Datetime index
-    :return: Plotly graph object
-    """
-
-    # Check if the index is of type datetime
-    if not isinstance(data.index, pd.DatetimeIndex):
-        raise ValueError("The index of the data should be of type datetime")
-
-    # Check if the 'ADX' column exists
-    if 'ADX' not in data.columns:
-        raise ValueError("The data should have a 'ADX' column")
-
-    return go.Scatter(
-        x=data.index,
-        y=data['ADX'],
-        mode='lines',
-        line=dict(color="green", width=1),
-        name="ADX"
-    )
-
-
-def create_di_plus_graph(data: pd.DataFrame):
-    """
-    Create a graph for the DI+ metric.
-    :param data: DataFrame with a '+DI' column and a Datetime index
-    :return: Plotly graph object
-    """
-
-    # Check if the index is of type datetime
-    if not isinstance(data.index, pd.DatetimeIndex):
-        raise ValueError("The index of the data should be of type datetime")
-
-    # Check if the '+DI' column exists
-    if '+DI' not in data.columns:
-        raise ValueError("The data should have a '+DI' column")
-
-    return go.Scatter(
-        x=data.index,
-        y=data['+DI'],
-        mode='lines',
-        line=dict(color="orange", width=1),
-        name="+DI"
-    )
-
-
-def create_di_minus_graph(data: pd.DataFrame):
-    """
-    Create a graph for the DI- metric.
-    :param data: DataFrame with a '-DI' column and a Datetime index
-    :return: Plotly graph object
-    """
-
-    # Check if the index is of type datetime
-    if not isinstance(data.index, pd.DatetimeIndex):
-        raise ValueError("The index of the data should be of type datetime")
-
-    # Check if the '-DI' column exists
-    if '-DI' not in data.columns:
-        raise ValueError("The data should have a '-DI' column")
-
-    return go.Scatter(
-        x=data.index,
-        y=data['-DI'],
-        mode='lines',
-        line=dict(color="purple", width=1),
-        name="-DI"
-    )
-
-
-def create_di_plus_di_minus_crossover_graph(data: pd.DataFrame):
-    """
-    Create a graph for the DI- and DI+ crossover.
-    """
-
-    # Check if the index is of type datetime
-    if not isinstance(data.index, pd.DatetimeIndex):
-        raise ValueError("The index of the data should be of type datetime")
-
-    # Check if the '-DI' and '+DI' columns exist
-    if '-DI' not in data.columns or '+DI' not in data.columns:
-        raise ValueError("The data should have a '-DI' and '+DI' column")
-
-    # Get all crossover indexes
-    crossover_index = data[(data['+DI'] < data['-DI']) &
-                           (data['+DI'].shift(1) > data['-DI'].shift(1))].index
-
-    # Use .loc to get the corresponding 'Close' values
-    crossover_close_values = data.loc[crossover_index, '+DI']
-
-    return go.Scatter(
-        x=crossover_index,
-        y=crossover_close_values,
-        mode='markers',
-        marker=dict(symbol='circle', size=10, color='blue'),
-        name='DI- DI+ Crossover'
-    )
-
-
-def create_ema_graph(data: pd.DataFrame, key, color="blue"):
-    # Check if the index is of type datetime
-    if not isinstance(data.index, pd.DatetimeIndex):
-        raise ValueError("The index of the data should be of type datetime")
-
-    # Check if the key columns exist
-    if key not in data.columns:
-        raise ValueError(f"The data should have a {key} column")
-
-    return go.Scatter(
-        x=data.index,
-        y=data[key],
-        mode='lines',
-        line=dict(color=color, width=1),
-        name=key
-    )
-
-
-def create_crossover_graph(data: pd.DataFrame, key_one, key_two, color="blue"):
-    # Check if the index is of type datetime
-    if not isinstance(data.index, pd.DatetimeIndex):
-        raise ValueError("The index of the data should be of type datetime")
-
-    # Check if the key columns exist
-    if key_one not in data.columns or key_two not in data.columns:
-        raise ValueError(f"The data should have a {key_one} "
-                         f"and {key_two} column")
-
-    # Get all crossover indexes
-    crossover_index = data[
-        (data[key_one] <= data[key_two]) &
-        (data[key_one].shift(1) >= data[key_two].shift(1))
-    ].index
-
-    # Use .loc to get the corresponding 'Close' values
-    crossover_close_values = data.loc[crossover_index, key_one]
-
-    return go.Scatter(
-        x=crossover_index,
-        y=crossover_close_values,
-        mode='markers',
-        marker=dict(symbol='circle', size=10, color=color),
-        name=f'{key_one} {key_two} Crossover'
-    )
-
-
-def create_peaks_chart(data: pd.DataFrame, key="Close", order=5):
-
-    # Check if the index is of type datetime
-    if not isinstance(data.index, pd.DatetimeIndex):
-        raise ValueError("The index of the data should be of type datetime")
-
-    keys = [f'{key}_highs', f'{key}_lows']
-
-    for key_column in keys:
-        if key_column not in data.columns:
-            raise ValueError(f"The data should have a '{key_column}' column")
-
-    # Get all peak indexes
-    hh_close_index = data[data[f'{key}_highs'] == 1].index
-    lh_close_index = data[data[f'{key}_highs'] == -1].index
-    ll_close_index = data[data[f'{key}_lows'] == 1].index
-    hl_close_index = data[data[f'{key}_lows'] == -1].index
-
-    # Use .loc to get the corresponding 'Close' values if
-    # the index is in the DataFrame
-    hh_close_values = data.loc[hh_close_index, key]
-    lh_close_values = data.loc[lh_close_index, key]
-    ll_close_values = data.loc[ll_close_index, key]
-    hl_close_values = data.loc[hl_close_index, key]
-
-    # Add higher highs
-    higher_high_graph = go.Scatter(
-        x=hh_close_index,
-        # x=dates[hh_close_index - order].values,
-        y=hh_close_values,
-        mode='markers',
-        marker=dict(symbol='triangle-up', size=10, color='blue'),
-        name='Higher High Confirmation'
-    )
-
-    # Add lower highs
-    lower_high_graph = go.Scatter(
-        x=lh_close_index,
-        y=lh_close_values,
-        mode='markers',
-        marker=dict(symbol='triangle-down', size=10, color='red'),
-        name='Lower High Confirmation'
-    )
-
-    # Add lower lows
-    lower_lows_graph = go.Scatter(
-        x=ll_close_index,
-        y=ll_close_values,
-        mode='markers',
-        marker=dict(symbol='triangle-down', size=10, color='green'),
-        name='Lower Lows Confirmation'
-    )
-
-    # Add higher lows
-    higher_lows = go.Scatter(
-        x=hl_close_index,
-        y=hl_close_values,
-        mode='markers',
-        marker=dict(symbol='triangle-up', size=10, color='purple'),
-        name='Higher Lows Confirmation'
-    )
-
-    return higher_high_graph, lower_high_graph, lower_lows_graph, higher_lows
-
-
-def create_bullish_divergence_chart(
-    data: pd.DataFrame, key_one, key_two, color='red'
-):
-    """
-    A bullish divergence occurs when the "<key_one>_lows" makes
-    a new low but the "<key_two>_lows" makes a higher low.
-
-    For example, if the RSI makes a new low but the close price
-    makes a higher low, then we have a bullish divergence.
-    """
-    divergence_index = data[(data[f'{key_one}_lows'] == -1)
-                            & (data[f'{key_two}_lows'] == 1)].index
-    divergence_close_values = data.loc[divergence_index, 'Close']
-
-    return go.Scatter(
-        x=divergence_index,
-        y=divergence_close_values,
-        mode='markers',
-        marker=dict(symbol='circle', size=10, color=color),
-        name='Bullish Divergence'
-    )
-
-
-def create_bearish_divergence_chart(
-    data: pd.DataFrame, key_one, key_two, color='red'
-):
-    """
-    A bearish divergence occurs when the "<key_one>_highs" makes a
-    new high but the "<key_two>_highs" makes a lower high.
-
-    For example, if the RSI makes a new high but the close price makes
-    a lower high, then we have a bearish divergence.
-    """
-
-    # Add divergence charts
-    divergence_index = data[(data[f'{key_one}_highs'] == -1)
-                            & (data[f'{key_two}_highs'] == 1)].index
-    divergence_close_values = data.loc[divergence_index, 'Close']
-
-    return go.Scatter(
-        x=divergence_index,
-        y=divergence_close_values,
-        mode='markers',
-        marker=dict(symbol='circle', size=10, color=color),
-        name='Bearish Divergence'
-    )
-
-
-def create_entry_graph(data: pd.DataFrame):
-    # Iterate over each row in the DataFrame and check if there is a
-    # bullish divergence between the RSI and the close price
-    # and if there is a crossover between the DI+ and DI- for
-    # the last 12 hours (6 candles)
-    # Get all crossover indexes
-    crossover_index = data[(data['+DI'] <= data['-DI']) &
-                           (data['+DI'].shift(1) >= data['-DI'].shift(1))]\
-        .index
-    data['di_crossover'] = 0
-    data.loc[crossover_index, 'di_crossover'] = 1
-
-    entry_indexes = []
-
-    for row in data.itertuples():
-
-        if row.di_crossover == 1:
-            match = False
-            # Check if there was a bullish divergence between
-            # the RSI and the close price in the last 2 days
-            rsi_window = data.loc[
-                         row.Index - pd.Timedelta(days=2):row.Index,
-                         'RSI_lows'
-                         ]
-            close_window = data.loc[
-                           row.Index - pd.Timedelta(days=2):row.Index,
-                           'Close_lows'
-                           ]
-
-            # Go over each row and check if there is a bullish
-            # divergence between the RSI and the close price
-            for rsi_row, close_row in zip(rsi_window, close_window):
-
-                if rsi_row == -1 and close_row == 1:
-                    entry_indexes.append(row.Index)
-                    match = True
-                    break
-
-            if not match:
-                # Check if the RSI had decreased
-                rsi_window = data.loc[
-                             row.Index - pd.Timedelta(days=1):row.Index, 'RSI'
-                             ]
-                rsi_diff = rsi_window.diff().mean()
-
-                if rsi_diff < -2:
-                    entry_indexes.append(row.Index)
-
-    entry_close_values = data.loc[entry_indexes, 'Close']
-    return go.Scatter(
-        x=entry_indexes,
-        y=entry_close_values,
-        mode='markers',
-        marker=dict(symbol='circle', size=10, color='green'),
-        name='Entry Signal'
-    )

investing_algorithm_framework/domain/metrics/__init__.py

@@ -1,6 +0,0 @@
-from .price_efficiency import get_price_efficiency_ratio
-
-
-__all__ = [
-    "get_price_efficiency_ratio"
-]

investing_algorithm_framework/domain/models/backtesting/__init__.py

@@ -1,11 +0,0 @@
-from .backtest_position import BacktestPosition
-from .backtest_report import BacktestReport
-from .backtest_reports_evaluation import BacktestReportsEvaluation
-from .backtest_date_range import BacktestDateRange
-
-__all__ = [
-    "BacktestReport",
-    "BacktestPosition",
-    "BacktestReportsEvaluation",
-    "BacktestDateRange"
-]

investing_algorithm_framework/domain/models/backtesting/backtest_date_range.py

@@ -1,43 +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."
-            )
-
-    @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 __str__(self):
-        return f"{self.name}: {self._start_date} - {self._end_date}"

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
-        }