bullishpy 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

bullish/analysis/analysis.py

@@ -116,12 +116,21 @@ TechnicalAnalysisModels = [*IndicatorModels, TechnicalAnalysisBase]
 class TechnicalAnalysis(*TechnicalAnalysisModels):  # type: ignore
 
     @classmethod
-    def from_data(cls, prices: pd.DataFrame) -> "TechnicalAnalysis":
+    def from_data(cls, prices: pd.DataFrame, ticker: Ticker) -> "TechnicalAnalysis":
+        if "close" not in prices.columns:
+            logger.warning(
+                f"Ticker {ticker.symbol} does not have valid 'close' values.",
+                exc_info=True,
+            )
+            return cls()
         try:
             res = Indicators().to_dict(prices)
             return cls(last_price=prices.close.iloc[-1], **res)
         except Exception as e:
-            logger.error(f"Failing to calculate technical analysis: {e}", exc_info=True)
+            logger.error(
+                f"Failing to calculate technical analysis for {ticker.symbol}: {e}",
+                exc_info=True,
+            )
             return cls()
 
 
@@ -426,10 +435,20 @@ class AnalysisView(BaseModel):
         Optional[str],
         Field(None, description="Full name of the company"),
     ]
+    price_per_earning_ratio: Optional[float] = None
+    last_price: Annotated[
+        Optional[float],
+        BeforeValidator(to_float),
+        Field(
+            default=None,
+        ),
+    ]
+    median_yearly_growth: Optional[float] = None
+    median_weekly_growth: Optional[float] = None
+    median_monthly_growth: Optional[float] = None
 
 
 class Analysis(AnalysisView, BaseEquity, TechnicalAnalysis, FundamentalAnalysis):  # type: ignore
-    price_per_earning_ratio: Optional[float] = None
 
     @classmethod
     def from_ticker(cls, bearish_db: BearishDbBase, ticker: Ticker) -> "Analysis":
@@ -443,7 +462,7 @@ class Analysis(AnalysisView, BaseEquity, TechnicalAnalysis, FundamentalAnalysis)
         financials = Financials.from_ticker(bearish_db, ticker)
         fundamental_analysis = FundamentalAnalysis.from_financials(financials, ticker)
         prices = Prices.from_ticker(bearish_db, ticker)
-        technical_analysis = TechnicalAnalysis.from_data(prices.to_dataframe())
+        technical_analysis = TechnicalAnalysis.from_data(prices.to_dataframe(), ticker)
         return cls.model_validate(
             equity.model_dump()
             | fundamental_analysis.model_dump()

bullish/analysis/filter.py

@@ -11,6 +11,8 @@ from bullish.analysis.analysis import (
     YearlyFundamentalAnalysis,
     QuarterlyFundamentalAnalysis,
     TechnicalAnalysisModels,
+    TechnicalAnalysis,
+    AnalysisView,
 )
 
 Industry = Literal[
@@ -455,6 +457,16 @@ def _get_fundamental_analysis_boolean_fields() -> List[str]:
     ]
 
 
+def _get_technical_analysis_float_fields() -> List[str]:
+    return [
+        name
+        for name, info in (
+            TechnicalAnalysis.model_fields | AnalysisView.model_fields
+        ).items()
+        if info.annotation == Optional[float]
+    ]
+
+
 def get_boolean_field_group(group: str) -> List[str]:
     groups = FUNDAMENTAL_ANALYSIS_GROUP.copy()
     groups.remove(group)
@@ -484,6 +496,8 @@ GROUP_MAPPING: Dict[str, List[str]] = {
     "industry_group": list(get_args(IndustryGroup)),
     "sector": list(get_args(Sector)),
     "symbol": [],
+    "order_by_asc": _get_technical_analysis_float_fields(),
+    "order_by_desc": _get_technical_analysis_float_fields(),
 }
 
 
@@ -552,11 +566,14 @@ FundamentalAnalysisFilters = _create_fundamental_analysis_models()
 
 class GeneralFilter(BaseModel):
     country: Optional[List[str]] = None
+    order_by_asc: Optional[str] = None
+    order_by_desc: Optional[str] = None
     industry: Optional[List[str]] = None
     industry_group: Optional[List[str]] = None
     sector: Optional[List[str]] = None
     symbol: Optional[List[str]] = None
     market_capitalization: Optional[List[float]] = Field(default=[5e8, 1e12])
+    price_per_earning_ratio: Optional[List[float]] = Field(default=[0.0, 1000.0])
 
 
 class FilterQuery(GeneralFilter, *TechnicalAnalysisFilters, *FundamentalAnalysisFilters):  # type: ignore
@@ -572,6 +589,8 @@ class FilterQuery(GeneralFilter, *TechnicalAnalysisFilters, *FundamentalAnalysis
     def to_query(self) -> str:
         parameters = self.model_dump(exclude_defaults=True, exclude_unset=True)
         query = []
+        order_by_desc = ""
+        order_by_asc = ""
         for parameter, value in parameters.items():
             if not value:
                 continue
@@ -582,6 +601,12 @@ class FilterQuery(GeneralFilter, *TechnicalAnalysisFilters, *FundamentalAnalysis
                 and parameter not in GeneralFilter.model_fields
             ):
                 query.append(" AND ".join([f"{v}=1" for v in value]))
+            elif (
+                isinstance(value, str) and bool(value) and parameter == "order_by_desc"
+            ):
+                order_by_desc = f"ORDER BY {value} DESC"
+            elif isinstance(value, str) and bool(value) and parameter == "order_by_asc":
+                order_by_asc = f"ORDER BY {value} ASC"
             elif (
                 isinstance(value, list)
                 and len(value) == SIZE_RANGE
@@ -604,7 +629,7 @@ class FilterQuery(GeneralFilter, *TechnicalAnalysisFilters, *FundamentalAnalysis
             else:
                 raise NotImplementedError
         query_ = " AND ".join(query)
-        return query_
+        return f"{query_} {order_by_desc.strip()} {order_by_asc.strip()}".strip()
 
 
 class FilterQueryStored(FilterQuery): ...

bullish/analysis/functions.py

@@ -1,7 +1,9 @@
+import datetime
 import logging
 from datetime import date
-from typing import Optional, Callable
+from typing import Optional, Callable, cast
 
+import numpy as np
 import pandas as pd
 import pandas_ta as ta  # type: ignore
 
@@ -19,7 +21,7 @@ def cross(
 ) -> Optional[date]:
     crossing = ta.cross(series_a=series_a, series_b=series_b, above=above)
     if not crossing[crossing == 1].index.empty:
-        return pd.Timestamp(crossing[crossing == 1].index[-1]).date()
+        return crossing[crossing == 1].last_valid_index().date()  # type: ignore
     return None
 
 
@@ -27,6 +29,15 @@ def cross_value(series: pd.Series, number: int, above: bool = True) -> Optional[
     return cross(series, pd.Series(number, index=series.index), above=above)
 
 
+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
+    )
+    return crossing  # type: ignore
+
+
 def compute_adx(data: pd.DataFrame) -> pd.DataFrame:
     results = pd.DataFrame(index=data.index)
     results["ADX_14"] = talib.ADX(data.high, data.low, close=data.close)  # type: ignore
@@ -69,12 +80,14 @@ def compute_pandas_ta_macd(data: pd.DataFrame) -> pd.DataFrame:
 def compute_rsi(data: pd.DataFrame) -> pd.DataFrame:
     results = pd.DataFrame(index=data.index)
     results["RSI"] = talib.RSI(data.close)  # type: ignore
+    results["CLOSE"] = data.close
     return results
 
 
 def compute_pandas_ta_rsi(data: pd.DataFrame) -> pd.DataFrame:
     results = pd.DataFrame(index=data.index)
     results["RSI"] = ta.rsi(data.close, length=14)
+    results["CLOSE"] = data.close
     return results
 
 
@@ -244,6 +257,12 @@ def compute_patterns(data: pd.DataFrame) -> pd.DataFrame:
     return results
 
 
+def perc(data: pd.Series) -> float:
+    if len(data) < 2 or data.iloc[0] == 0:
+        return np.nan
+    return cast(float, ((data.iloc[-1] - data.iloc[0]) / data.iloc[0]) * 100)
+
+
 def compute_price(data: pd.DataFrame) -> pd.DataFrame:
     results = pd.DataFrame(index=data.index)
     results["200_DAY_HIGH"] = data.close.rolling(window=200).max()
@@ -251,9 +270,30 @@ def compute_price(data: pd.DataFrame) -> pd.DataFrame:
     results["20_DAY_HIGH"] = data.close.rolling(window=20).max()
     results["20_DAY_LOW"] = data.close.rolling(window=20).min()
     results["LAST_PRICE"] = data.close
+    results["WEEKLY_GROWTH"] = data.close.resample("W").transform(perc)  # type: ignore
+    results["MONTHLY_GROWTH"] = data.close.resample("ME").transform(perc)  # type: ignore
+    results["YEARLY_GROWTH"] = data.close.resample("YE").transform(perc)  # type: ignore
     return results
 
 
+def compute_percentile_return_after_rsi_crossover(
+    data: pd.DataFrame, rsi_threshold: int = 45, period: int = 90
+) -> float:
+    data_ = cross_value_series(data.RSI, rsi_threshold)
+    values = []
+    for crossing_date in data_[data_ == 1].index:
+        data_crossed = data[
+            (data.index >= crossing_date)
+            & (data.index <= crossing_date + datetime.timedelta(days=period))
+        ]
+        v = (
+            data_crossed.CLOSE.pct_change(periods=len(data_crossed.CLOSE) - 1).iloc[-1]
+            * 100
+        )
+        values.append(v)
+    return float(np.percentile(values, 30))
+
+
 class IndicatorFunction(BaseModel):
     expected_columns: list[str]
     functions: list[Callable[[pd.DataFrame], pd.DataFrame]]
@@ -265,7 +305,7 @@ class IndicatorFunction(BaseModel):
                 data_ = function(data)
                 break
             except Exception as e:
-                logger.warning(f"Fail to compute function {function.__name__}: {e}")
+                logger.error(f"Fail to compute function {function.__name__}: {e}")
         if data_ is None:
             raise ValueError("No data returned from indicator functions.")
         if not set(self.expected_columns).issubset(set(data_.columns)):
@@ -347,6 +387,9 @@ PRICE = IndicatorFunction(
         "20_DAY_HIGH",
         "20_DAY_LOW",
         "LAST_PRICE",
+        "WEEKLY_GROWTH",
+        "MONTHLY_GROWTH",
+        "YEARLY_GROWTH",
     ],
     functions=[compute_price],
 )

bullish/analysis/indicators.py

@@ -1,10 +1,10 @@
 import logging
 from datetime import date
-from typing import Optional, List, Callable, Any, Literal, Dict, Union, Self
+from typing import Optional, List, Callable, Any, Literal, Dict, Union
 
 import numpy as np
 import pandas as pd
-from pydantic import BaseModel, Field, PrivateAttr, create_model, model_validator
+from pydantic import BaseModel, Field, PrivateAttr, create_model
 
 from bullish.analysis.functions import (
     cross,
@@ -19,6 +19,7 @@ from bullish.analysis.functions import (
     SMA,
     ADOSC,
     PRICE,
+    compute_percentile_return_after_rsi_crossover,
 )
 
 logger = logging.getLogger(__name__)
@@ -49,14 +50,6 @@ class Signal(BaseModel):
         else:
             self.value = self.function(data)  # type: ignore
 
-    @model_validator(mode="after")
-    def _validate(self) -> Self:
-        if self.type == Optional[float] and self.range is None:
-            raise ValueError(
-                "Range must be defined for signals of type Optional[float]"
-            )
-        return self
-
 
 class Indicator(BaseModel):
     name: str
@@ -100,7 +93,7 @@ def indicators_factory() -> List[Indicator]:
                     type=Optional[date],
                     function=lambda d: d[
                         (d.ADX_14 > 20) & (d.PLUS_DI > d.MINUS_DI)
-                    ].index[-1],
+                    ].last_valid_index(),
                 ),
                 Signal(
                     name="ADX_14_SHORT",
@@ -109,7 +102,7 @@ def indicators_factory() -> List[Indicator]:
                     type=Optional[date],
                     function=lambda d: d[
                         (d.ADX_14 > 20) & (d.MINUS_DI > d.PLUS_DI)
-                    ].index[-1],
+                    ].last_valid_index(),
                 ),
             ],
         ),
@@ -156,16 +149,30 @@ def indicators_factory() -> List[Indicator]:
         Indicator(
             name="RSI",
             description="Relative Strength Index",
-            expected_columns=["RSI"],
+            expected_columns=RSI.expected_columns,
             function=RSI.call,
             signals=[
                 Signal(
-                    name="RSI_BULLISH_CROSSOVER",
+                    name="RSI_BULLISH_CROSSOVER_30",
                     description="RSI Bullish Crossover",
                     type_info="Long",
                     type=Optional[date],
                     function=lambda d: cross_value(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),
+                ),
+                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),
+                ),
                 Signal(
                     name="RSI_BEARISH_CROSSOVER",
                     description="RSI Bearish Crossover",
@@ -178,21 +185,32 @@ def indicators_factory() -> List[Indicator]:
                     description="RSI Oversold Signal",
                     type_info="Oversold",
                     type=Optional[date],
-                    function=lambda d: d[(d.RSI < 30) & (d.RSI > 0)].index[-1],
+                    function=lambda d: d[(d.RSI < 30) & (d.RSI > 0)].last_valid_index(),
                 ),
                 Signal(
                     name="RSI_OVERBOUGHT",
                     description="RSI Overbought Signal",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: d[(d.RSI < 100) & (d.RSI > 70)].index[-1],
+                    function=lambda d: d[
+                        (d.RSI < 100) & (d.RSI > 70)
+                    ].last_valid_index(),
                 ),
                 Signal(
                     name="RSI_NEUTRAL",
                     description="RSI Neutral Signal",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: d[(d.RSI < 60) & (d.RSI > 40)].index[-1],
+                    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),
                 ),
             ],
         ),
@@ -207,14 +225,18 @@ 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)].index[-1],
+                    function=lambda d: d[
+                        (d.SLOW_K < 20) & (d.SLOW_K > 0)
+                    ].last_valid_index(),
                 ),
                 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)].index[-1],
+                    function=lambda d: d[
+                        (d.SLOW_K < 100) & (d.SLOW_K > 80)
+                    ].last_valid_index(),
                 ),
             ],
         ),
@@ -229,14 +251,14 @@ def indicators_factory() -> List[Indicator]:
                     description="MFI Oversold Signal",
                     type_info="Oversold",
                     type=Optional[date],
-                    function=lambda d: d[(d.MFI < 20)].index[-1],
+                    function=lambda d: d[(d.MFI < 20)].last_valid_index(),
                 ),
                 Signal(
                     name="MFI_OVERBOUGHT",
                     description="MFI Overbought Signal",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: d[(d.MFI > 80)].index[-1],
+                    function=lambda d: d[(d.MFI > 80)].last_valid_index(),
                 ),
             ],
         ),
@@ -273,18 +295,39 @@ 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].index[
-                        -1
-                    ],
+                    function=lambda d: d[
+                        0.6 * d["200_DAY_HIGH"] > d.LAST_PRICE
+                    ].last_valid_index(),
                 ),
                 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].index[
-                        -1
-                    ],
+                    function=lambda d: d[
+                        0.6 * d["20_DAY_HIGH"] > d.LAST_PRICE
+                    ].last_valid_index(),
+                ),
+                Signal(
+                    name="MEDIAN_WEEKLY_GROWTH",
+                    description="Median weekly growth",
+                    type_info="Oversold",
+                    type=Optional[float],
+                    function=lambda d: np.median(d.WEEKLY_GROWTH.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()),
+                ),
+                Signal(
+                    name="MEDIAN_YEARLY_GROWTH",
+                    description="Median yearly growth",
+                    type_info="Oversold",
+                    type=Optional[float],
+                    function=lambda d: np.median(d.YEARLY_GROWTH.unique()),
                 ),
             ],
         ),
@@ -299,7 +342,6 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Value",
                     description="Median daily Rate of Change of the last 30 days",
                     type=Optional[float],
-                    range=[-100, 100],
                     function=lambda d: np.median(d.ROC_1.tolist()[-30:]),
                 ),
                 Signal(
@@ -307,7 +349,6 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Value",
                     description="Median weekly Rate of Change of the last 4 weeks",
                     type=Optional[float],
-                    range=[-100, 100],
                     function=lambda d: np.median(d.ROC_7.tolist()[-4:]),
                 ),
                 Signal(
@@ -315,7 +356,6 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Value",
                     description="Median weekly Rate of Change of the last 12 weeks",
                     type=Optional[float],
-                    range=[-100, 100],
                     function=lambda d: np.median(d.ROC_7.tolist()[-12:]),
                 ),
                 Signal(
@@ -323,7 +363,6 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Value",
                     description="Median monthly Rate of Change of the last 12 Months",
                     type=Optional[float],
-                    range=[-100, 100],
                     function=lambda d: np.median(d.ROC_30.tolist()[-12:]),
                 ),
                 Signal(
@@ -331,7 +370,6 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Value",
                     description="30-day Rate of Change",
                     type=Optional[float],
-                    range=[-100, 100],
                     function=lambda d: d.ROC_30.tolist()[-1],
                 ),
                 Signal(
@@ -339,7 +377,6 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Value",
                     description="7-day Rate of Change",
                     type=Optional[float],
-                    range=[-100, 100],
                     function=lambda d: d.ROC_7.tolist()[-1],
                 ),
             ],
@@ -362,9 +399,9 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Oversold",
                     description="20-day breakout confirmed by positive ADOSC",
                     type=Optional[date],
-                    function=lambda d: d[(d.ADOSC_SIGNAL == True)].index[  # noqa: E712
-                        -1
-                    ],
+                    function=lambda d: d[
+                        (d.ADOSC_SIGNAL == True)  # noqa: E712
+                    ].last_valid_index(),
                 ),
             ],
         ),
@@ -387,49 +424,53 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Long",
                     description="Morning Star Candlestick Pattern",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDLMORNINGSTAR == 100)].index[-1],
+                    function=lambda d: d[(d.CDLMORNINGSTAR == 100)].last_valid_index(),
                 ),
                 Signal(
                     name="CDL3LINESTRIKE",
                     description="3 Line Strike Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDL3LINESTRIKE == 100)].index[-1],
+                    function=lambda d: d[(d.CDL3LINESTRIKE == 100)].last_valid_index(),
                 ),
                 Signal(
                     name="CDL3WHITESOLDIERS",
                     description="3 White Soldiers Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDL3WHITESOLDIERS == 100)].index[-1],
+                    function=lambda d: d[
+                        (d.CDL3WHITESOLDIERS == 100)
+                    ].last_valid_index(),
                 ),
                 Signal(
                     name="CDLABANDONEDBABY",
                     description="Abandoned Baby Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDLABANDONEDBABY == 100)].index[-1],
+                    function=lambda d: d[
+                        (d.CDLABANDONEDBABY == 100)
+                    ].last_valid_index(),
                 ),
                 Signal(
                     name="CDLTASUKIGAP",
                     description="Tasukigap Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDLTASUKIGAP == 100)].index[-1],
+                    function=lambda d: d[(d.CDLTASUKIGAP == 100)].last_valid_index(),
                 ),
                 Signal(
                     name="CDLPIERCING",
                     description="Piercing Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDLPIERCING == 100)].index[-1],
+                    function=lambda d: d[(d.CDLPIERCING == 100)].last_valid_index(),
                 ),
                 Signal(
                     name="CDLENGULFING",
                     description="Engulfing Candlestick Pattern",
                     type_info="Long",
                     type=Optional[date],
-                    function=lambda d: d[(d.CDLENGULFING == 100)].index[-1],
+                    function=lambda d: d[(d.CDLENGULFING == 100)].last_valid_index(),
                 ),
             ],
         ),
@@ -441,7 +482,11 @@ class Indicators(BaseModel):
 
     def compute(self, data: pd.DataFrame) -> None:
         for indicator in self.indicators:
-            indicator.compute(data)
+            try:
+                indicator.compute(data)
+            except Exception as e:
+                logger.error(f"Failed to compute indicator {indicator.name}: {e}")
+                continue
             logger.info(
                 f"Computed {indicator.name} with {len(indicator.signals)} signals"
             )