bullishpy 0.13.0__tar.gz → 0.15.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bullishpy
-Version: 0.13.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.13.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,9 +42,11 @@ 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
+
 if TYPE_CHECKING:
     from bullish.database.crud import BullishDb
 
@@ -128,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(
@@ -493,7 +495,37 @@ 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))
     finance_trackers = set(bullish_db._read_tracker(TrackerQuery(), FinancialsTracker))
     tickers = list(price_trackers.intersection(finance_trackers))

bullishpy-0.13.0/bullish/analysis/filter.py → bullishpy-0.15.0/bullish/analysis/constants.py

@@ -1,19 +1,4 @@
-import datetime
-from datetime import date
-from typing import Literal, get_args, Any, Optional, List, Tuple, Type, Dict
-
-from bearish.types import SeriesLength  # type: ignore
-from pydantic import BaseModel, Field, ConfigDict
-from pydantic import create_model
-from pydantic.fields import FieldInfo
-
-from bullish.analysis.analysis import (
-    YearlyFundamentalAnalysis,
-    QuarterlyFundamentalAnalysis,
-    TechnicalAnalysisModels,
-    TechnicalAnalysis,
-    AnalysisView,
-)
+from typing import Literal
 
 Industry = Literal[
     "Publishing",
@@ -162,7 +147,6 @@ Industry = Literal[
     "REIT - Healthcare Facilities",
     "Discount Stores",
 ]
-
 IndustryGroup = Literal[
     "publishing",
     "internet-retail",
@@ -310,7 +294,6 @@ IndustryGroup = Literal[
     "reit-healthcare-facilities",
     "discount-stores",
 ]
-
 Sector = Literal[
     "Communication Services",
     "Consumer Cyclical",
@@ -325,7 +308,6 @@ Sector = Literal[
     "Financial Services",
     "Conglomerates",
 ]
-
 Country = Literal[
     "Australia",
     "China",
@@ -419,232 +401,3 @@ Country = Literal[
     "Liberia",
     "Kenya",
 ]
-SIZE_RANGE = 2
-
-
-def _get_type(name: str, info: FieldInfo) -> Tuple[Any, Any]:
-    alias = info.alias or " ".join(name.capitalize().split("_")).strip()
-    if info.annotation == Optional[float]:  # type: ignore
-        ge = next((item.ge for item in info.metadata if hasattr(item, "ge")), 0)
-        le = next((item.le for item in info.metadata if hasattr(item, "le")), 100)
-        default = [ge, le]
-        return (
-            Optional[List[float]],
-            Field(default=default, alias=alias, description=info.description),
-        )
-    elif info.annotation == Optional[date]:  # type: ignore
-        le = date.today()
-        ge = le - datetime.timedelta(days=30 * 2)  # 30 days * 12 months
-        return (
-            List[date],
-            Field(default=[ge, le], alias=alias, description=info.description),
-        )
-    else:
-        raise NotImplementedError
-
-
-FUNDAMENTAL_ANALYSIS_GROUP = ["income", "cash_flow", "eps"]
-
-
-def _get_fundamental_analysis_boolean_fields() -> List[str]:
-    return [
-        name
-        for name, info in {
-            **YearlyFundamentalAnalysis.model_fields,
-            **QuarterlyFundamentalAnalysis.model_fields,
-        }.items()
-        if info.annotation == Optional[bool]
-    ]
-
-
-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)
-    return [
-        name
-        for name in _get_fundamental_analysis_boolean_fields()
-        if group in name and not any(g in name for g in groups)
-    ]
-
-
-INCOME_GROUP = get_boolean_field_group("income")
-CASH_FLOW_GROUP = get_boolean_field_group("cash_flow")
-EPS_GROUP = get_boolean_field_group("eps")
-PROPERTIES_GROUP = list(
-    set(_get_fundamental_analysis_boolean_fields()).difference(
-        {*INCOME_GROUP, *CASH_FLOW_GROUP, *EPS_GROUP}
-    )
-)
-
-GROUP_MAPPING: Dict[str, List[str]] = {
-    "income": INCOME_GROUP,
-    "cash_flow": CASH_FLOW_GROUP,
-    "eps": EPS_GROUP,
-    "properties": PROPERTIES_GROUP,
-    "country": list(get_args(Country)),
-    "industry": list(get_args(Industry)),
-    "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(),
-}
-
-
-def _create_fundamental_analysis_models() -> List[Type[BaseModel]]:
-    models = []
-    boolean_fields = {
-        "income": (Optional[List[str]], Field(default=None, description="Income")),
-        "cash_flow": (
-            Optional[List[str]],
-            Field(default=None, description="Cash flow"),
-        ),
-        "eps": (
-            Optional[List[str]],
-            Field(default=None, description="Earnings per share"),
-        ),
-        "properties": (
-            Optional[List[str]],
-            Field(default=None, description="General properties"),
-        ),
-    }
-    yearly_fields = {
-        name: _get_type(name, info)
-        for name, info in YearlyFundamentalAnalysis.model_fields.items()
-        if info.annotation != Optional[bool]  # type: ignore
-    }
-    quarterly_fields = {
-        name: _get_type(name, info)
-        for name, info in QuarterlyFundamentalAnalysis.model_fields.items()
-        if info.annotation != Optional[bool]
-    }
-    for property in [
-        (boolean_fields, "Selection filter", "SelectionFilter"),
-        (yearly_fields, "Yearly properties", "YearlyFilter"),
-        (quarterly_fields, "Quarterly properties", "QuarterlyFilter"),
-    ]:
-        model_ = create_model(  # type: ignore
-            property[-1],
-            __config__=ConfigDict(populate_by_name=True),
-            **property[0],
-        )
-        model_._description = property[1]
-        models.append(model_)
-
-    return models
-
-
-def create_technical_analysis_models() -> List[Type[BaseModel]]:
-    models = []
-    for model in TechnicalAnalysisModels:
-        model_ = create_model(  # type: ignore
-            f"{model.__name__}Filter",  # type: ignore
-            __config__=ConfigDict(populate_by_name=True),
-            **{
-                name: _get_type(name, info) for name, info in model.model_fields.items()  # type: ignore
-            },
-        )
-
-        model_._description = model._description  # type: ignore
-        models.append(model_)
-    return models
-
-
-TechnicalAnalysisFilters = create_technical_analysis_models()
-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
-
-    def valid(self) -> bool:
-        return any(
-            bool(v)
-            for _, v in self.model_dump(
-                exclude_defaults=True, exclude_unset=True
-            ).items()
-        )
-
-    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
-
-            if (
-                isinstance(value, list)
-                and all(isinstance(item, str) for item in value)
-                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
-                and all(isinstance(item, (int, float)) for item in value)
-            ):
-                query.append(f"{parameter} BETWEEN {value[0]} AND {value[1]}")
-            elif (
-                isinstance(value, list)
-                and len(value) == SIZE_RANGE
-                and all(isinstance(item, date) for item in value)
-            ):
-                query.append(f"{parameter} BETWEEN '{value[0]}' AND '{value[1]}'")
-            elif (
-                isinstance(value, list)
-                and all(isinstance(item, str) for item in value)
-                and parameter in GeneralFilter.model_fields
-            ):
-                general_filters = [f"'{v}'" for v in value]
-                query.append(f"{parameter} IN ({', '.join(general_filters)})")
-            else:
-                raise NotImplementedError
-        query_ = " AND ".join(query)
-        return f"{query_} {order_by_desc.strip()} {order_by_asc.strip()}".strip()
-
-
-class FilterQueryStored(FilterQuery): ...
-
-
-class FilterUpdate(BaseModel):
-    window_size: SeriesLength = Field("5d")
-    data_age_in_days: int = 1
-    update_financials: bool = False
-    update_analysis_only: bool = False
-
-
-class FilteredResults(BaseModel):
-    name: str
-    filter_query: FilterQueryStored
-    symbols: list[str] = Field(
-        default_factory=list, description="List of filtered tickers."
-    )

bullishpy-0.15.0/bullish/analysis/filter.py

@@ -0,0 +1,247 @@
+import datetime
+from datetime import date
+from typing import get_args, Any, Optional, List, Tuple, Type, Dict
+
+from bearish.types import SeriesLength  # type: ignore
+from pydantic import BaseModel, Field, ConfigDict
+from pydantic import create_model
+from pydantic.fields import FieldInfo
+
+from bullish.analysis.analysis import (
+    YearlyFundamentalAnalysis,
+    QuarterlyFundamentalAnalysis,
+    TechnicalAnalysisModels,
+    TechnicalAnalysis,
+    AnalysisView,
+)
+from bullish.analysis.constants import Industry, IndustryGroup, Sector, Country
+
+SIZE_RANGE = 2
+
+
+def _get_type(name: str, info: FieldInfo) -> Tuple[Any, Any]:
+    alias = info.alias or " ".join(name.capitalize().split("_")).strip()
+    if info.annotation == Optional[float]:  # type: ignore
+        ge = next((item.ge for item in info.metadata if hasattr(item, "ge")), 0)
+        le = next((item.le for item in info.metadata if hasattr(item, "le")), 100)
+        default = [ge, le]
+        return (
+            Optional[List[float]],
+            Field(default=default, alias=alias, description=info.description),
+        )
+    elif info.annotation == Optional[date]:  # type: ignore
+        le = date.today()
+        ge = le - datetime.timedelta(days=30 * 2)  # 30 days * 12 months
+        return (
+            List[date],
+            Field(default=[ge, le], alias=alias, description=info.description),
+        )
+    else:
+        raise NotImplementedError
+
+
+FUNDAMENTAL_ANALYSIS_GROUP = ["income", "cash_flow", "eps"]
+
+
+def _get_fundamental_analysis_boolean_fields() -> List[str]:
+    return [
+        name
+        for name, info in {
+            **YearlyFundamentalAnalysis.model_fields,
+            **QuarterlyFundamentalAnalysis.model_fields,
+        }.items()
+        if info.annotation == Optional[bool]
+    ]
+
+
+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)
+    return [
+        name
+        for name in _get_fundamental_analysis_boolean_fields()
+        if group in name and not any(g in name for g in groups)
+    ]
+
+
+INCOME_GROUP = get_boolean_field_group("income")
+CASH_FLOW_GROUP = get_boolean_field_group("cash_flow")
+EPS_GROUP = get_boolean_field_group("eps")
+PROPERTIES_GROUP = list(
+    set(_get_fundamental_analysis_boolean_fields()).difference(
+        {*INCOME_GROUP, *CASH_FLOW_GROUP, *EPS_GROUP}
+    )
+)
+
+GROUP_MAPPING: Dict[str, List[str]] = {
+    "income": INCOME_GROUP,
+    "cash_flow": CASH_FLOW_GROUP,
+    "eps": EPS_GROUP,
+    "properties": PROPERTIES_GROUP,
+    "country": list(get_args(Country)),
+    "industry": list(get_args(Industry)),
+    "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(),
+}
+
+
+def _create_fundamental_analysis_models() -> List[Type[BaseModel]]:
+    models = []
+    boolean_fields = {
+        "income": (Optional[List[str]], Field(default=None, description="Income")),
+        "cash_flow": (
+            Optional[List[str]],
+            Field(default=None, description="Cash flow"),
+        ),
+        "eps": (
+            Optional[List[str]],
+            Field(default=None, description="Earnings per share"),
+        ),
+        "properties": (
+            Optional[List[str]],
+            Field(default=None, description="General properties"),
+        ),
+    }
+    yearly_fields = {
+        name: _get_type(name, info)
+        for name, info in YearlyFundamentalAnalysis.model_fields.items()
+        if info.annotation != Optional[bool]  # type: ignore
+    }
+    quarterly_fields = {
+        name: _get_type(name, info)
+        for name, info in QuarterlyFundamentalAnalysis.model_fields.items()
+        if info.annotation != Optional[bool]
+    }
+    for property in [
+        (boolean_fields, "Selection filter", "SelectionFilter"),
+        (yearly_fields, "Yearly properties", "YearlyFilter"),
+        (quarterly_fields, "Quarterly properties", "QuarterlyFilter"),
+    ]:
+        model_ = create_model(  # type: ignore
+            property[-1],
+            __config__=ConfigDict(populate_by_name=True),
+            **property[0],
+        )
+        model_._description = property[1]
+        models.append(model_)
+
+    return models
+
+
+def create_technical_analysis_models() -> List[Type[BaseModel]]:
+    models = []
+    for model in TechnicalAnalysisModels:
+        model_ = create_model(  # type: ignore
+            f"{model.__name__}Filter",  # type: ignore
+            __config__=ConfigDict(populate_by_name=True),
+            **{
+                name: _get_type(name, info) for name, info in model.model_fields.items()  # type: ignore
+            },
+        )
+
+        model_._description = model._description  # type: ignore
+        models.append(model_)
+    return models
+
+
+TechnicalAnalysisFilters = create_technical_analysis_models()
+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
+
+    def valid(self) -> bool:
+        return any(
+            bool(v)
+            for _, v in self.model_dump(
+                exclude_defaults=True, exclude_unset=True
+            ).items()
+        )
+
+    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
+
+            if (
+                isinstance(value, list)
+                and all(isinstance(item, str) for item in value)
+                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
+                and all(isinstance(item, (int, float)) for item in value)
+            ):
+                query.append(f"{parameter} BETWEEN {value[0]} AND {value[1]}")
+            elif (
+                isinstance(value, list)
+                and len(value) == SIZE_RANGE
+                and all(isinstance(item, date) for item in value)
+            ):
+                query.append(f"{parameter} BETWEEN '{value[0]}' AND '{value[1]}'")
+            elif (
+                isinstance(value, list)
+                and all(isinstance(item, str) for item in value)
+                and parameter in GeneralFilter.model_fields
+            ):
+                general_filters = [f"'{v}'" for v in value]
+                query.append(f"{parameter} IN ({', '.join(general_filters)})")
+            else:
+                raise NotImplementedError
+        query_ = " AND ".join(query)
+        return f"{query_} {order_by_desc.strip()} {order_by_asc.strip()}".strip()
+
+
+class FilterQueryStored(FilterQuery): ...
+
+
+class FilterUpdate(BaseModel):
+    window_size: SeriesLength = Field("5d")
+    data_age_in_days: int = 1
+    update_financials: bool = False
+    update_analysis_only: bool = False
+
+
+class FilteredResults(BaseModel):
+    name: str
+    filter_query: FilterQueryStored
+    symbols: list[str] = Field(
+        default_factory=list, description="List of filtered tickers."
+    )

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

@@ -1,4 +1,3 @@
-import datetime
 import logging
 from datetime import date
 from typing import Optional, Callable, cast
@@ -16,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
@@ -32,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:
@@ -282,24 +288,6 @@ def compute_price(data: pd.DataFrame) -> pd.DataFrame:
     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))
-
-
 def find_last_true_run_start(series: pd.Series) -> Optional[date]:
     if not series.iloc[-1]:
         return None
@@ -311,12 +299,14 @@ def find_last_true_run_start(series: pd.Series) -> Optional[date]:
     return series.index[last_true_run_start].date()  # type: ignore
 
 
-def momentum(data: pd.DataFrame) -> Optional[date]:
+def sma_50_above_sma_200(data: pd.DataFrame) -> Optional[date]:
+    date_1 = find_last_true_run_start(data.SMA_50 > data.SMA_200)
+    return date_1
+
+
+def price_above_sma50(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)
+    return date_1
 
 
 class IndicatorFunction(BaseModel):