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

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

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

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:

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

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()))

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

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.dist-info → bullishpy-0.15.0.dist-info}/METADATA

@@ -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.dist-info → bullishpy-0.15.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 bullish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bullish/analysis/analysis.py,sha256=ZTRf7YaEnFL9HBVkamY7JXys3XJtkLGNMkU4FbkV_04,19270
+bullish/analysis/analysis.py,sha256=ag1wAfNDKWmPxJz7sd1mNhuh4CZfEleTp2_a3DIkEL4,20524
 bullish/analysis/constants.py,sha256=tVDPQEufH8lytMj4DdUdvXt79b7cvWaDwSUOpeqMWts,9851
 bullish/analysis/filter.py,sha256=kSG6fXZrnwqE1HvKQW6O3yVNV49qhVleer9M_7BIDpg,8381
-bullish/analysis/functions.py,sha256=A2eFBqNx5XohEhJFU_LvyU0_s0ozErtsiYUqVSb3Wvs,14367
-bullish/analysis/indicators.py,sha256=9-768_ntZRxNgeNXj3MbRO9QCq97uYKMHQ-9hQMu7Mo,20938
+bullish/analysis/functions.py,sha256=ebCXxYeKlWhvcRRFMbX8E63bL7OquxyoWsYIy0o0SCA,14277
+bullish/analysis/indicators.py,sha256=S3pUsWn4MC_BKPhY1iFQDNNuHcqulez8jOsfWJdht_8,23470
 bullish/analysis/industry_views.py,sha256=1B5V39Fm9rNQEsun1xrwELfOiKlGdTie0ZolS2UBh2w,6247
 bullish/analysis/predefined_filters.py,sha256=28e42hGaH7Qb6SPNeH7EK9YIhjERj-qpbY-7xLahvDM,8361
 bullish/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -20,6 +20,7 @@ bullish/database/alembic/versions/040b15fba458_.py,sha256=scSauB4wZe0sMFHOAMHkx-
 bullish/database/alembic/versions/08ac1116e055_.py,sha256=zMEiCbraMEAZItT4ibc3evAH7-7mkXpdgnZy4tPVYeg,27263
 bullish/database/alembic/versions/11d35a452b40_.py,sha256=j2PaU1RssLQ20OevGmBC7S9E9ocWiXpBue9SOS4AQoY,11521
 bullish/database/alembic/versions/17e51420e7ad_.py,sha256=xeiVIm1YUZb08opE9rocHZP1__9WQWXsKsXgeFV9cvs,2960
+bullish/database/alembic/versions/3e1a14c41916_.py,sha256=TmpfLl4dBw-CqHsnxwnnBc00nlUtHb0Hh8cc3yLBRME,1668
 bullish/database/alembic/versions/49c83f9eb5ac_.py,sha256=kCBItp7KmqpJ03roy5ikQjhefZia1oKgfZwournQDq8,3890
 bullish/database/alembic/versions/4b0a2f40b7d3_.py,sha256=G0K7w7pOPYjPZkXTB8LWhxoxuWBPcPwOfnubTBtdeEY,1827
 bullish/database/alembic/versions/5b10ee7604c1_.py,sha256=YlqaagPasR3RKASv7acME1jPS8p26VoTE2BvpOwdCpY,1463
@@ -30,8 +31,8 @@ bullish/database/alembic/versions/d663166c531d_.py,sha256=U92l6QXqPniAYrPeu2Bt77
 bullish/database/alembic/versions/ec25c8fa449f_.py,sha256=8Yts74KEjK4jg20zIo90_0atw-sOBuE3hgCKl-rfS5E,2271
 bullish/database/alembic/versions/ee5baabb35f8_.py,sha256=nBMEY-_C8AsSXVPyaDdUkwrFFo2gxShzJhmrjejDwtc,1632
 bullish/database/alembic/versions/fc191121f522_.py,sha256=0sstF6TpAJ09-Mt-Vek9SdSWksvi4C58a5D92rBtuY8,1894
-bullish/database/crud.py,sha256=ubRXV88GAo4prDQPylouEn8DBvoyNtM6hx12HPhD_2w,9889
-bullish/database/schemas.py,sha256=gI6hWYv1C4G9xRXiNTSLxXftkgIOANDyfct2_KwSavo,2442
+bullish/database/crud.py,sha256=EIXCnhvPAxwldicUG4fwsdiXiq08TjXoZ8wSt27ph0g,10808
+bullish/database/schemas.py,sha256=ySTaw77X9rvLg-4PAKaOH6fPe8Bgi8kTtPc8DvsR6F8,2791
 bullish/database/scripts/create_revision.py,sha256=rggIf-3koPqJNth8FIg89EOfnIM7a9QrvL8X7UJsP0g,628
 bullish/database/scripts/stamp.py,sha256=PWgVUEBumjNUMjTnGw46qmU3p221LeN-KspnW_gFuu4,839
 bullish/database/scripts/upgrade.py,sha256=-Gz7aFNPEt9y9e1kltqXE76-j_8QeNtet_VlwY5AWjo,806
@@ -40,14 +41,14 @@ bullish/exceptions.py,sha256=4z_i-dD-CDz1bkGmZH9DOf1L_awlCPCgdUDPF7dhWAI,106
 bullish/figures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/figures/figures.py,sha256=imrvIIcL9L-z-3vzWK5hDEsNttZs60QxlFI-PLw0hJQ,4829
 bullish/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bullish/interface/interface.py,sha256=UB2ATVtUsnXetnLCrSmNVrFpIvCw_0kuVxKHZC7sT7U,4233
+bullish/interface/interface.py,sha256=QbjC_tWLbhvQr8vaiQl8ymrb6f_vR_KCxEmzJ5lA1Zg,4528
 bullish/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/jobs/app.py,sha256=5MJ5KXUo7JSNAvOPgkpIMasD11VTrjQvGzM7vmCY65E,77
 bullish/jobs/models.py,sha256=ndrGTMP08S57yGLGEG9TQt8Uw2slc4HvbG-TZtEEuN0,744
 bullish/jobs/tasks.py,sha256=V_b0c8_GQC0-KIxaHDlLFhtkclQJOsck0gXaW6OlC_w,3055
 bullish/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/utils/checks.py,sha256=Va10_xDVVnxYkOD2hafvyQ-TFV8FQpOkr4huJ7XgpDM,2188
-bullishpy-0.14.0.dist-info/METADATA,sha256=BH2BdzlEth8FoZFyxME0sbOlPnqqPdbHoxdHJ3X_GHg,784
-bullishpy-0.14.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-bullishpy-0.14.0.dist-info/entry_points.txt,sha256=eaPpmL6vmSBFo0FBtwibCXGqAW4LFJ83whJzT1VjD-0,43
-bullishpy-0.14.0.dist-info/RECORD,,
+bullishpy-0.15.0.dist-info/METADATA,sha256=j-VPiqIl7LJyJ56b4oolBx4ZAsJljbxw-NA6wKzmir8,828
+bullishpy-0.15.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+bullishpy-0.15.0.dist-info/entry_points.txt,sha256=eaPpmL6vmSBFo0FBtwibCXGqAW4LFJ83whJzT1VjD-0,43
+bullishpy-0.15.0.dist-info/RECORD,,