bullishpy 0.14.0__tar.gz → 0.15.0__tar.gz

{bullishpy-0.14.0 → bullishpy-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bullishpy
-Version: 0.14.0
+Version: 0.15.0
 Summary: 
 Author: aan
 Author-email: andoludovic.andriamamonjy@gmail.com
@@ -12,12 +12,13 @@ Requires-Dist: click (>=7.0,<=8.1)
 Requires-Dist: huey (>=2.5.3,<3.0.0)
 Requires-Dist: joblib (>=1.5.1,<2.0.0)
 Requires-Dist: pandas-ta (>=0.3.14b0,<0.4.0)
-Requires-Dist: plotly (>=6.1.2,<7.0.0)
+Requires-Dist: plotly (>=4.12.0,<6.0.0)
 Requires-Dist: streamlit (>=1.45.1,<2.0.0)
 Requires-Dist: streamlit-file-browser (>=3.2.22,<4.0.0)
 Requires-Dist: streamlit-pydantic (>=v0.6.1-rc.3,<0.7.0)
 Requires-Dist: ta-lib (>=0.6.4,<0.7.0)
 Requires-Dist: tickermood (>=0.4.0,<0.5.0)
+Requires-Dist: vectorbt (>=0.28.0,<0.29.0)
 Description-Content-Type: text/markdown
 
 ## Bullish

{bullishpy-0.14.0 → bullishpy-0.15.0}/bullish/analysis/analysis.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from itertools import batched
+from itertools import batched, chain
 from pathlib import Path
 from typing import (
     Annotated,
@@ -42,7 +42,7 @@ from bearish.models.query.query import AssetQuery, Symbols  # type: ignore
 from bearish.types import TickerOnlySources  # type: ignore
 from pydantic import BaseModel, BeforeValidator, Field, create_model
 
-from bullish.analysis.indicators import Indicators, IndicatorModels
+from bullish.analysis.indicators import Indicators, IndicatorModels, SignalSeries
 from joblib import Parallel, delayed  # type: ignore
 
 from bullish.analysis.industry_views import compute_industry_view
@@ -130,7 +130,7 @@ class TechnicalAnalysis(*TechnicalAnalysisModels):  # type: ignore
             )
             return cls()
         try:
-            res = Indicators().to_dict(prices)
+            res = Indicators().compute(prices)
             return cls(last_price=prices.close.iloc[-1], **res)
         except Exception as e:
             logger.error(
@@ -495,6 +495,35 @@ def compute_analysis(database_path: Path, ticker: Ticker) -> Analysis:
     return Analysis.from_ticker(bullish_db, ticker)
 
 
+def compute_signal_series(database_path: Path, ticker: Ticker) -> List[SignalSeries]:
+    from bullish.database.crud import BullishDb
+
+    bullish_db = BullishDb(database_path=database_path)
+    indicators = Indicators()
+    prices = Prices.from_ticker(bullish_db, ticker)
+    signal_series = indicators.compute_series(prices.to_dataframe(), ticker.symbol)
+    return signal_series
+
+
+def run_signal_series_analysis(bullish_db: "BullishDb") -> None:
+    price_trackers = set(bullish_db._read_tracker(TrackerQuery(), PriceTracker))
+    finance_trackers = set(bullish_db._read_tracker(TrackerQuery(), FinancialsTracker))
+    tickers = list(price_trackers.intersection(finance_trackers))
+    parallel = Parallel(n_jobs=-1)
+
+    for batch_ticker in batched(tickers, 100):
+        start = time.perf_counter()
+        many_signal_series = parallel(
+            delayed(compute_signal_series)(bullish_db.database_path, ticker)
+            for ticker in batch_ticker
+        )
+        bullish_db.write_signal_series(list(chain.from_iterable(many_signal_series)))
+        elapsed_time = time.perf_counter() - start
+        print(
+            f"Computed signal series for {len(batch_ticker)} tickers in {elapsed_time:.2f} seconds."
+        )
+
+
 def run_analysis(bullish_db: "BullishDb") -> None:
     compute_industry_view(bullish_db)
     price_trackers = set(bullish_db._read_tracker(TrackerQuery(), PriceTracker))

{bullishpy-0.14.0 → bullishpy-0.15.0}/bullish/analysis/functions.py

@@ -15,10 +15,17 @@ except Exception:
     logger.warning("Talib is not installed, skipping analysis")
 
 
+def cross_simple(
+    series_a: pd.Series, series_b: pd.Series, above: bool = True
+) -> pd.Series:
+    crossing = ta.cross(series_a=series_a, series_b=series_b, above=above)
+    return crossing  # type: ignore
+
+
 def cross(
     series_a: pd.Series, series_b: pd.Series, above: bool = True
 ) -> Optional[date]:
-    crossing = ta.cross(series_a=series_a, series_b=series_b, above=above)
+    crossing = cross_simple(series_a=series_a, series_b=series_b, above=above)
     if not crossing[crossing == 1].index.empty:
         return crossing[crossing == 1].last_valid_index().date()  # type: ignore
     return None
@@ -31,10 +38,10 @@ def cross_value(series: pd.Series, number: int, above: bool = True) -> Optional[
 def cross_value_series(
     series_a: pd.Series, number: int, above: bool = True
 ) -> pd.Series:
-    crossing = ta.cross(
-        series_a=series_a, series_b=pd.Series(number, index=series_a.index), above=above
+    crossing = cross_simple(
+        series_a, pd.Series(number, index=series_a.index), above=above
     )
-    return crossing  # type: ignore
+    return crossing
 
 
 def compute_adx(data: pd.DataFrame) -> pd.DataFrame:
@@ -302,14 +309,6 @@ def price_above_sma50(data: pd.DataFrame) -> Optional[date]:
     return date_1
 
 
-def momentum(data: pd.DataFrame) -> Optional[date]:
-    date_1 = find_last_true_run_start(data.SMA_50 < data.CLOSE)
-    date_2 = find_last_true_run_start(data.SMA_200 < data.SMA_50)
-    if date_1 is None or date_2 is None:
-        return None
-    return max(date_1, date_2)
-
-
 class IndicatorFunction(BaseModel):
     expected_columns: list[str]
     functions: list[Callable[[pd.DataFrame], pd.DataFrame]]

{bullishpy-0.14.0 → bullishpy-0.15.0}/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,21 +17,44 @@ from bullish.analysis.functions import (
     SMA,
     ADOSC,
     PRICE,
-    momentum,
-    sma_50_above_sma_200,
-    price_above_sma50,
+    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
@@ -46,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):
@@ -68,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)
@@ -79,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 [
@@ -93,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),
                 ),
             ],
         ),
@@ -123,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
+                    ),
                 ),
             ],
         ),
@@ -159,53 +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(),
+                    function=lambda d: (d.RSI < 60) & (d.RSI > 40),
                 ),
             ],
         ),
@@ -220,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),
                 ),
             ],
         ),
@@ -246,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),
                 ),
             ],
         ),
@@ -268,35 +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),
-                ),
-                Signal(
-                    name="MOMENTUM_TIME_SPAN",
-                    description="Momentum time span",
-                    type_info="Overbought",
-                    type=Optional[date],
-                    function=lambda d: momentum(d),
+                    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: sma_50_above_sma_200(d),
+                    function=lambda d: d.SMA_50 > d.SMA_200,
+                    processing=ProcessingFunction(date=find_last_true_run_start),
                 ),
                 Signal(
                     name="PRICE_ABOVE_SMA_50",
                     description="Price is above SMA 50",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: price_above_sma50(d),
+                    function=lambda d: d.SMA_50 < d.CLOSE,
+                    processing=ProcessingFunction(date=find_last_true_run_start),
                 ),
             ],
         ),
@@ -311,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())
+                    ),
                 ),
             ],
         ),
@@ -358,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,
                 ),
             ],
         ),
@@ -415,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
                 ),
             ],
         ),
@@ -447,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,
                 ),
             ],
         ),
@@ -503,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)
@@ -514,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:

bullishpy-0.15.0/bullish/database/alembic/versions/3e1a14c41916_.py

@@ -0,0 +1,51 @@
+"""
+
+Revision ID: 3e1a14c41916
+Revises: 040b15fba458
+Create Date: 2025-07-17 15:07:44.125783
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import sqlite
+import sqlmodel
+
+# revision identifiers, used by Alembic.
+revision: str = "3e1a14c41916"
+down_revision: Union[str, None] = "040b15fba458"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "signalseries",
+        sa.Column("date", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("value", sa.Float(), nullable=False),
+        sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("symbol", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.PrimaryKeyConstraint("date", "name", "symbol"),
+    )
+    with op.batch_alter_table("analysis", schema=None) as batch_op:
+        batch_op.drop_index(batch_op.f("ix_analysis_momentum_time_span"))
+        batch_op.drop_column("momentum_time_span")
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("analysis", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("momentum_time_span", sa.DATE(), nullable=True))
+        batch_op.create_index(
+            batch_op.f("ix_analysis_momentum_time_span"),
+            ["momentum_time_span"],
+            unique=False,
+        )
+
+    op.drop_table("signalseries")
+    # ### end Alembic commands ###

{bullishpy-0.14.0 → bullishpy-0.15.0}/bullish/database/crud.py

@@ -16,6 +16,7 @@ from sqlmodel import Session, select
 
 from bullish.analysis.analysis import Analysis
 from bullish.analysis.constants import Industry, IndustryGroup, Sector, Country
+from bullish.analysis.indicators import SignalSeries
 from bullish.analysis.industry_views import Type, IndustryView
 
 from bullish.database.schemas import (
@@ -23,6 +24,7 @@ from bullish.database.schemas import (
     JobTrackerORM,
     FilteredResultsORM,
     IndustryViewORM,
+    SignalSeriesORM,
 )
 from bullish.database.scripts.upgrade import upgrade
 from bullish.exceptions import DatabaseFileNotFoundError
@@ -261,3 +263,24 @@ class BullishDb(BearishDb, BullishDbBase):  # type: ignore
             )
             result = session.exec(stmt).all()
             return [IndustryView.model_validate(r) for r in result]
+
+    def write_signal_series(self, signal_series: List[SignalSeries]) -> None:
+        with Session(self._engine) as session:
+            stmt = (
+                insert(SignalSeriesORM)
+                .prefix_with("OR REPLACE")
+                .values([a.model_dump() for a in signal_series])
+            )
+            session.exec(stmt)  # type: ignore
+            session.commit()
+
+    def read_signal_series(
+        self, name: str, start_date: date, end_date: date
+    ) -> List[str]:
+        with Session(self._engine) as session:
+            stmt = select(SignalSeriesORM.symbol).where(
+                SignalSeriesORM.name == name,
+                SignalSeriesORM.date >= start_date,  # type: ignore
+                SignalSeriesORM.date <= end_date,  # type: ignore
+            )
+            return list(set(session.exec(stmt).all()))

{bullishpy-0.14.0 → bullishpy-0.15.0}/bullish/database/schemas.py

@@ -4,6 +4,7 @@ from sqlmodel import Field, SQLModel
 from sqlalchemy import Column, JSON
 from bullish.analysis.analysis import Analysis
 from bullish.analysis.filter import FilteredResults
+from bullish.analysis.indicators import SignalSeries
 from bullish.analysis.industry_views import IndustryView
 
 from bullish.jobs.models import JobTracker
@@ -48,6 +49,14 @@ class FilteredResultsORM(SQLModel, FilteredResults, table=True):
     filter_query: Dict[str, Any] = Field(sa_column=Column(JSON))  # type: ignore
 
 
+class SignalSeriesORM(SQLModel, SignalSeries, table=True):
+    __tablename__ = "signalseries"
+    __table_args__ = {"extend_existing": True}  # noqa:RUF012
+    date: str = Field(primary_key=True)  # type: ignore
+    name: str = Field(primary_key=True)
+    symbol: str = Field(primary_key=True)
+
+
 class IndustryViewORM(SQLModel, IndustryView, table=True):
     __tablename__ = "industryview"
     __table_args__ = {"extend_existing": True}  # noqa:RUF012

{bullishpy-0.14.0 → bullishpy-0.15.0}/bullish/interface/interface.py

@@ -12,6 +12,7 @@ from bearish.types import Sources  # type: ignore
 from bullish.analysis.analysis import Analysis, AnalysisView
 from bullish.analysis.constants import Industry, Sector, IndustryGroup, Country
 from bullish.analysis.filter import FilterQuery, FilteredResults
+from bullish.analysis.indicators import SignalSeries
 from bullish.analysis.industry_views import Type, IndustryView
 from bullish.jobs.models import JobTracker, JobTrackerStatus, add_icons
 
@@ -125,3 +126,11 @@ class BullishDbBase(BearishDbBase):  # type: ignore
     def read_returns(
         self, type: Type, industry: Industry, country: Country
     ) -> List[IndustryView]: ...
+
+    @abc.abstractmethod
+    def write_signal_series(self, signal_series: List[SignalSeries]) -> None: ...
+
+    @abc.abstractmethod
+    def read_signal_series(
+        self, name: str, start_date: date, end_date: date
+    ) -> List[str]: ...

{bullishpy-0.14.0 → bullishpy-0.15.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "bullishpy"
-version = "0.14.0"
+version = "0.15.0"
 description = ""
 authors = ["aan <andoludovic.andriamamonjy@gmail.com>"]
 readme = "README.md"
@@ -14,10 +14,11 @@ streamlit-pydantic = "^v0.6.1-rc.3"
 streamlit-file-browser = "^3.2.22"
 huey = "^2.5.3"
 pandas-ta = "^0.3.14b0"
-plotly = "^6.1.2"
+plotly = ">=4.12.0,<6.0.0"
 ta-lib = "^0.6.4"
 click = ">=7.0,<=8.1"
 joblib = "^1.5.1"
+vectorbt = "^0.28.0"
 
 [tool.poetry.scripts]
 bullish = "bullish.cli:app"