bullishpy 0.13.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

bullish/analysis/indicators.py

@@ -1,14 +1,12 @@
 import logging
 from datetime import date
-from typing import Optional, List, Callable, Any, Literal, Dict, Union
+from typing import Optional, List, Callable, Any, Literal, Dict
 
 import numpy as np
 import pandas as pd
 from pydantic import BaseModel, Field, PrivateAttr, create_model
 
 from bullish.analysis.functions import (
-    cross,
-    cross_value,
     ADX,
     MACD,
     RSI,
@@ -19,20 +17,44 @@ from bullish.analysis.functions import (
     SMA,
     ADOSC,
     PRICE,
-    compute_percentile_return_after_rsi_crossover,
-    momentum,
+    cross_simple,
+    cross_value_series,
+    find_last_true_run_start,
 )
 
 logger = logging.getLogger(__name__)
 SignalType = Literal["Short", "Long", "Oversold", "Overbought", "Value"]
 
 
+def _last_date(d: pd.Series) -> Optional[date]:
+    d_valid = d[d == 1]
+    if d_valid.empty:
+        return None
+    last_index = d_valid.last_valid_index()
+    return last_index.date() if last_index is not None else None  # type: ignore
+
+
+class ProcessingFunction(BaseModel):
+    date: Callable[[pd.Series], Optional[date]] = Field(default=_last_date)
+    number: Callable[[pd.Series], Optional[float]] = Field(
+        default=lambda d: d.iloc[-1] if not d.dropna().empty else None
+    )
+
+
+class SignalSeries(BaseModel):
+    name: str
+    date: date
+    value: float
+    symbol: str
+
+
 class Signal(BaseModel):
     name: str
     type_info: SignalType
     type: Any
     range: Optional[List[float]] = None
-    function: Callable[[pd.DataFrame], Optional[Union[date, float]]]
+    function: Callable[[pd.DataFrame], pd.Series]
+    processing: ProcessingFunction = Field(default_factory=ProcessingFunction)
     description: str
     date: Optional[date] = None
     value: Optional[float] = None
@@ -45,11 +67,22 @@ class Signal(BaseModel):
         else:
             raise NotImplementedError
 
+    def apply_function(self, data: pd.DataFrame) -> pd.Series:
+        result = self.function(data)
+        if not isinstance(result, pd.Series):
+            raise ValueError(
+                f"Function for signal {self.name} must return a pandas Series"
+            )
+        return result
+
     def compute(self, data: pd.DataFrame) -> None:
         if self.is_date():
-            self.date = self.function(data)  # type: ignore
+            self.date = self.processing.date(self.apply_function(data))
         else:
-            self.value = self.function(data)  # type: ignore
+            self.value = self.processing.number(self.apply_function(data))
+
+    def compute_series(self, data: pd.DataFrame) -> pd.Series:
+        return self.apply_function(data)
 
 
 class Indicator(BaseModel):
@@ -67,9 +100,9 @@ class Indicator(BaseModel):
                 f"Expected columns {self.expected_columns}, but got {results.columns.tolist()}"
             )
         self._data = results
-        self._signals()
+        self.compute_signals()
 
-    def _signals(self) -> None:
+    def compute_signals(self) -> None:
         for signal in self.signals:
             try:
                 signal.compute(self._data)
@@ -78,6 +111,33 @@ class Indicator(BaseModel):
                     f"Fail to compute signal {signal.name} for indicator {self.name}: {e}"
                 )
 
+    def compute_series(self, data: pd.DataFrame, symbol: str) -> pd.DataFrame:
+        series = []
+        results = self.function(data)
+        if not set(self.expected_columns).issubset(results.columns):
+            raise ValueError(
+                f"Expected columns {self.expected_columns}, but got {results.columns.tolist()}"
+            )
+        for signal in self.signals:
+            try:
+                series_ = signal.compute_series(results)
+                if signal.type == Optional[date]:
+                    series__ = pd.DataFrame(series_[series_ == 1].rename("value"))
+                else:
+                    series__ = pd.DataFrame(series_.rename("value"))
+
+                series__["name"] = signal.name
+                series__["date"] = series__.index.date  # type: ignore
+                series__["symbol"] = symbol
+                series__ = series__.reset_index(drop=True)
+                series.append(series__)
+            except Exception as e:  # noqa: PERF203
+                logger.error(
+                    f"Fail to compute signal {signal.name} for indicator {self.name}: {e}"
+                )
+        data = pd.concat(series).reset_index(drop=True)
+        return data
+
 
 def indicators_factory() -> List[Indicator]:
     return [
@@ -92,18 +152,14 @@ def indicators_factory() -> List[Indicator]:
                     description="ADX 14 Long Signal",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[
-                        (d.ADX_14 > 20) & (d.PLUS_DI > d.MINUS_DI)
-                    ].last_valid_index(),
+                    function=lambda d: (d.ADX_14 > 20) & (d.PLUS_DI > d.MINUS_DI),
                 ),
                 Signal(
                     name="ADX_14_SHORT",
                     description="ADX 14 Short Signal",
                     type_info="Short",
                     type=Optional[date],
-                    function=lambda d: d[
-                        (d.ADX_14 > 20) & (d.MINUS_DI > d.PLUS_DI)
-                    ].last_valid_index(),
+                    function=lambda d: (d.ADX_14 > 20) & (d.MINUS_DI > d.PLUS_DI),
                 ),
             ],
         ),
@@ -122,28 +178,34 @@ def indicators_factory() -> List[Indicator]:
                     description="MACD 12-26-9 Bullish Crossover",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: cross(d.MACD_12_26_9, d.MACD_12_26_9_SIGNAL),
+                    function=lambda d: cross_simple(
+                        d.MACD_12_26_9, d.MACD_12_26_9_SIGNAL
+                    ),
                 ),
                 Signal(
                     name="MACD_12_26_9_BEARISH_CROSSOVER",
                     description="MACD 12-26-9 Bearish Crossover",
                     type_info="Short",
                     type=Optional[date],
-                    function=lambda d: cross(d.MACD_12_26_9_SIGNAL, d.MACD_12_26_9),
+                    function=lambda d: cross_simple(
+                        d.MACD_12_26_9_SIGNAL, d.MACD_12_26_9
+                    ),
                 ),
                 Signal(
                     name="MACD_12_26_9_ZERO_LINE_CROSS_UP",
                     description="MACD 12-26-9 Zero Line Cross Up",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: cross_value(d.MACD_12_26_9, 0),
+                    function=lambda d: cross_value_series(d.MACD_12_26_9, 0),
                 ),
                 Signal(
                     name="MACD_12_26_9_ZERO_LINE_CROSS_DOWN",
                     description="MACD 12-26-9 Zero Line Cross Down",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: cross_value(d.MACD_12_26_9, 0, above=False),
+                    function=lambda d: cross_value_series(
+                        d.MACD_12_26_9, 0, above=False
+                    ),
                 ),
             ],
         ),
@@ -158,60 +220,49 @@ def indicators_factory() -> List[Indicator]:
                     description="RSI Bullish Crossover",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: cross_value(d.RSI, 30),
+                    function=lambda d: cross_value_series(d.RSI, 30),
                 ),
                 Signal(
                     name="RSI_BULLISH_CROSSOVER_40",
                     description="RSI Bullish Crossover 40",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: cross_value(d.RSI, 40),
+                    function=lambda d: cross_value_series(d.RSI, 40),
                 ),
                 Signal(
                     name="RSI_BULLISH_CROSSOVER_45",
                     description="RSI Bullish Crossover 45",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: cross_value(d.RSI, 45),
+                    function=lambda d: cross_value_series(d.RSI, 45),
                 ),
                 Signal(
                     name="RSI_BEARISH_CROSSOVER",
                     description="RSI Bearish Crossover",
                     type_info="Short",
                     type=Optional[date],
-                    function=lambda d: cross_value(d.RSI, 70, above=False),
+                    function=lambda d: cross_value_series(d.RSI, 70, above=False),
                 ),
                 Signal(
                     name="RSI_OVERSOLD",
                     description="RSI Oversold Signal",
                     type_info="Oversold",
                     type=Optional[date],
-                    function=lambda d: d[(d.RSI < 30) & (d.RSI > 0)].last_valid_index(),
+                    function=lambda d: (d.RSI < 30) & (d.RSI > 0),
                 ),
                 Signal(
                     name="RSI_OVERBOUGHT",
                     description="RSI Overbought Signal",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: d[
-                        (d.RSI < 100) & (d.RSI > 70)
-                    ].last_valid_index(),
+                    function=lambda d: (d.RSI < 100) & (d.RSI > 70),
                 ),
                 Signal(
                     name="RSI_NEUTRAL",
                     description="RSI Neutral Signal",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: d[
-                        (d.RSI < 60) & (d.RSI > 40)
-                    ].last_valid_index(),
-                ),
-                Signal(
-                    name="RETURN_AFTER_RSI_CROSSOVER_45_PERIOD_90",
-                    description="Percentile 30 return after RSI crossover 45 in the next 90 days",
-                    type_info="Long",
-                    type=Optional[float],
-                    function=lambda d: compute_percentile_return_after_rsi_crossover(d),
+                    function=lambda d: (d.RSI < 60) & (d.RSI > 40),
                 ),
             ],
         ),
@@ -226,18 +277,14 @@ def indicators_factory() -> List[Indicator]:
                     description="Stoch Oversold Signal",
                     type_info="Oversold",
                     type=Optional[date],
-                    function=lambda d: d[
-                        (d.SLOW_K < 20) & (d.SLOW_K > 0)
-                    ].last_valid_index(),
+                    function=lambda d: (d.SLOW_K < 20) & (d.SLOW_K > 0),
                 ),
                 Signal(
                     name="STOCH_OVERBOUGHT",
                     description="Stoch Overbought Signal",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: d[
-                        (d.SLOW_K < 100) & (d.SLOW_K > 80)
-                    ].last_valid_index(),
+                    function=lambda d: (d.SLOW_K < 100) & (d.SLOW_K > 80),
                 ),
             ],
         ),
@@ -252,14 +299,14 @@ def indicators_factory() -> List[Indicator]:
                     description="MFI Oversold Signal",
                     type_info="Oversold",
                     type=Optional[date],
-                    function=lambda d: d[(d.MFI < 20)].last_valid_index(),
+                    function=lambda d: (d.MFI < 20),
                 ),
                 Signal(
                     name="MFI_OVERBOUGHT",
                     description="MFI Overbought Signal",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: d[(d.MFI > 80)].last_valid_index(),
+                    function=lambda d: (d.MFI > 80),
                 ),
             ],
         ),
@@ -274,21 +321,30 @@ def indicators_factory() -> List[Indicator]:
                     description="Golden cross: SMA 50 crosses above SMA 200",
                     type_info="Oversold",
                     type=Optional[date],
-                    function=lambda d: cross(d.SMA_50, d.SMA_200),
+                    function=lambda d: cross_simple(d.SMA_50, d.SMA_200),
                 ),
                 Signal(
                     name="DEATH_CROSS",
                     description="Death cross: SMA 50 crosses below SMA 200",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: cross(d.SMA_50, d.SMA_200, above=False),
+                    function=lambda d: cross_simple(d.SMA_50, d.SMA_200, above=False),
+                ),
+                Signal(
+                    name="SMA_50_ABOVE_SMA_200",
+                    description="SMA 50 is above SMA 200",
+                    type_info="Overbought",
+                    type=Optional[date],
+                    function=lambda d: d.SMA_50 > d.SMA_200,
+                    processing=ProcessingFunction(date=find_last_true_run_start),
                 ),
                 Signal(
-                    name="MOMENTUM_TIME_SPAN",
-                    description="Momentum time span",
+                    name="PRICE_ABOVE_SMA_50",
+                    description="Price is above SMA 50",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: momentum(d),
+                    function=lambda d: d.SMA_50 < d.CLOSE,
+                    processing=ProcessingFunction(date=find_last_true_run_start),
                 ),
             ],
         ),
@@ -303,39 +359,44 @@ def indicators_factory() -> List[Indicator]:
                     description="Current price is lower than the 200-day high",
                     type_info="Oversold",
                     type=Optional[date],
-                    function=lambda d: d[
-                        0.6 * d["200_DAY_HIGH"] > d.LAST_PRICE
-                    ].last_valid_index(),
+                    function=lambda d: 0.6 * d["200_DAY_HIGH"] > d.LAST_PRICE,
                 ),
                 Signal(
                     name="LOWER_THAN_20_DAY_HIGH",
                     description="Current price is lower than the 20-day high",
                     type_info="Oversold",
                     type=Optional[date],
-                    function=lambda d: d[
-                        0.6 * d["20_DAY_HIGH"] > d.LAST_PRICE
-                    ].last_valid_index(),
+                    function=lambda d: 0.6 * d["20_DAY_HIGH"] > d.LAST_PRICE,
                 ),
                 Signal(
                     name="MEDIAN_WEEKLY_GROWTH",
                     description="Median weekly growth",
                     type_info="Oversold",
                     type=Optional[float],
-                    function=lambda d: np.median(d.WEEKLY_GROWTH.unique()),
+                    function=lambda d: d.WEEKLY_GROWTH,
+                    processing=ProcessingFunction(
+                        number=lambda v: np.median(v.unique())
+                    ),
                 ),
                 Signal(
                     name="MEDIAN_MONTHLY_GROWTH",
                     description="Median monthly growth",
                     type_info="Oversold",
                     type=Optional[float],
-                    function=lambda d: np.median(d.MONTHLY_GROWTH.unique()),
+                    function=lambda d: d.MONTHLY_GROWTH,
+                    processing=ProcessingFunction(
+                        number=lambda v: np.median(v.unique())
+                    ),
                 ),
                 Signal(
                     name="MEDIAN_YEARLY_GROWTH",
                     description="Median yearly growth",
                     type_info="Oversold",
                     type=Optional[float],
-                    function=lambda d: np.median(d.YEARLY_GROWTH.unique()),
+                    function=lambda d: d.YEARLY_GROWTH,
+                    processing=ProcessingFunction(
+                        number=lambda v: np.median(v.unique())
+                    ),
                 ),
             ],
         ),
@@ -350,49 +411,61 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Value",
                     description="Median daily Rate of Change of the last 30 days",
                     type=Optional[float],
-                    function=lambda d: np.median(d.ROC_1.tolist()[-30:]),
+                    function=lambda d: d.ROC_1,
+                    processing=ProcessingFunction(
+                        number=lambda v: np.median(v.tolist()[-30:])
+                    ),
                 ),
                 Signal(
                     name="MEDIAN_RATE_OF_CHANGE_7_4",
                     type_info="Value",
                     description="Median weekly Rate of Change of the last 4 weeks",
                     type=Optional[float],
-                    function=lambda d: np.median(d.ROC_7.tolist()[-4:]),
+                    function=lambda d: d.ROC_7,
+                    processing=ProcessingFunction(
+                        number=lambda v: np.median(v.tolist()[-4:])
+                    ),
                 ),
                 Signal(
                     name="MEDIAN_RATE_OF_CHANGE_7_12",
                     type_info="Value",
                     description="Median weekly Rate of Change of the last 12 weeks",
                     type=Optional[float],
-                    function=lambda d: np.median(d.ROC_7.tolist()[-12:]),
+                    function=lambda d: d.ROC_7,
+                    processing=ProcessingFunction(
+                        number=lambda v: np.median(v.tolist()[-12:])
+                    ),
                 ),
                 Signal(
                     name="MEDIAN_RATE_OF_CHANGE_30",
                     type_info="Value",
                     description="Median monthly Rate of Change of the last 12 Months",
                     type=Optional[float],
-                    function=lambda d: np.median(d.ROC_30.tolist()[-12:]),
+                    function=lambda d: d.ROC_30,
+                    processing=ProcessingFunction(
+                        number=lambda v: np.median(v.tolist()[-12:])
+                    ),
                 ),
                 Signal(
                     name="RATE_OF_CHANGE_30",
                     type_info="Value",
                     description="30-day Rate of Change",
                     type=Optional[float],
-                    function=lambda d: d.ROC_30.tolist()[-1],
+                    function=lambda d: d.ROC_30,
                 ),
                 Signal(
                     name="RATE_OF_CHANGE_7",
                     type_info="Value",
                     description="7-day Rate of Change",
                     type=Optional[float],
-                    function=lambda d: d.ROC_7.tolist()[-1],
+                    function=lambda d: d.ROC_7,
                 ),
                 Signal(
                     name="MOMENTUM",
                     type_info="Value",
                     description="7-day Rate of Change",
                     type=Optional[float],
-                    function=lambda d: d.MOM.iloc[-1],
+                    function=lambda d: d.MOM,
                 ),
             ],
         ),
@@ -407,16 +480,14 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Oversold",
                     description="Bullish momentum in money flow",
                     type=Optional[date],
-                    function=lambda d: cross_value(d.ADOSC, 0, above=True),
+                    function=lambda d: cross_value_series(d.ADOSC, 0, above=True),
                 ),
                 Signal(
                     name="POSITIVE_ADOSC_20_DAY_BREAKOUT",
                     type_info="Oversold",
                     description="20-day breakout confirmed by positive ADOSC",
                     type=Optional[date],
-                    function=lambda d: d[
-                        (d.ADOSC_SIGNAL == True)  # noqa: E712
-                    ].last_valid_index(),
+                    function=lambda d: (d.ADOSC_SIGNAL == True),  # noqa: E712
                 ),
             ],
         ),
@@ -439,53 +510,49 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Long",
                     description="Morning Star Candlestick Pattern",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDLMORNINGSTAR == 100)].last_valid_index(),
+                    function=lambda d: d.CDLMORNINGSTAR == 100,
                 ),
                 Signal(
                     name="CDL3LINESTRIKE",
                     description="3 Line Strike Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDL3LINESTRIKE == 100)].last_valid_index(),
+                    function=lambda d: d.CDL3LINESTRIKE == 100,
                 ),
                 Signal(
                     name="CDL3WHITESOLDIERS",
                     description="3 White Soldiers Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[
-                        (d.CDL3WHITESOLDIERS == 100)
-                    ].last_valid_index(),
+                    function=lambda d: d.CDL3WHITESOLDIERS == 100,
                 ),
                 Signal(
                     name="CDLABANDONEDBABY",
                     description="Abandoned Baby Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[
-                        (d.CDLABANDONEDBABY == 100)
-                    ].last_valid_index(),
+                    function=lambda d: d.CDLABANDONEDBABY == 100,
                 ),
                 Signal(
                     name="CDLTASUKIGAP",
                     description="Tasukigap Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDLTASUKIGAP == 100)].last_valid_index(),
+                    function=lambda d: d.CDLTASUKIGAP == 100,
                 ),
                 Signal(
                     name="CDLPIERCING",
                     description="Piercing Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDLPIERCING == 100)].last_valid_index(),
+                    function=lambda d: d.CDLPIERCING == 100,
                 ),
                 Signal(
                     name="CDLENGULFING",
                     description="Engulfing Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDLENGULFING == 100)].last_valid_index(),
+                    function=lambda d: d.CDLENGULFING == 100,
                 ),
             ],
         ),
@@ -495,7 +562,7 @@ def indicators_factory() -> List[Indicator]:
 class Indicators(BaseModel):
     indicators: List[Indicator] = Field(default_factory=indicators_factory)
 
-    def compute(self, data: pd.DataFrame) -> None:
+    def _compute(self, data: pd.DataFrame) -> None:
         for indicator in self.indicators:
             try:
                 indicator.compute(data)
@@ -506,8 +573,16 @@ class Indicators(BaseModel):
                 f"Computed {indicator.name} with {len(indicator.signals)} signals"
             )
 
-    def to_dict(self, data: pd.DataFrame) -> Dict[str, Any]:
-        self.compute(data)
+    def compute_series(self, data: pd.DataFrame, symbol: str) -> List[SignalSeries]:
+        data__ = pd.concat(
+            [indicator.compute_series(data, symbol) for indicator in self.indicators]
+        )
+        return [
+            SignalSeries.model_validate(s) for s in data__.to_dict(orient="records")
+        ]
+
+    def compute(self, data: pd.DataFrame) -> Dict[str, Any]:
+        self._compute(data)
         res = {}
         for indicator in self.indicators:
             for signal in indicator.signals: