bullishpy 0.4.0__tar.gz → 0.6.0__tar.gz

{bullishpy-0.4.0 → bullishpy-0.6.0}/PKG-INFO

@@ -1,21 +1,20 @@
 Metadata-Version: 2.3
 Name: bullishpy
-Version: 0.4.0
+Version: 0.6.0
 Summary: 
 Author: aan
 Author-email: andoludovic.andriamamonjy@gmail.com
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.12,<3.13
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: bearishpy (>=0.19.0,<0.20.0)
+Requires-Dist: bearishpy (>=0.20.0,<0.21.0)
 Requires-Dist: huey (>=2.5.3,<3.0.0)
 Requires-Dist: pandas-ta (>=0.3.14b0,<0.4.0)
 Requires-Dist: plotly (>=6.1.2,<7.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)
 Description-Content-Type: text/markdown
 

{bullishpy-0.4.0 → bullishpy-0.6.0}/bullish/analysis/analysis.py

@@ -1,5 +1,4 @@
 import logging
-from datetime import date
 from typing import (
     Annotated,
     Any,
@@ -7,13 +6,12 @@ from typing import (
     Optional,
     Sequence,
     Type,
-    cast,
     get_args,
     TYPE_CHECKING,
+    ClassVar,
 )
 
 import pandas as pd
-import pandas_ta as ta  # type: ignore
 from bearish.interface.interface import BearishDbBase  # type: ignore
 from bearish.models.assets.equity import BaseEquity  # type: ignore
 from bearish.models.base import (  # type: ignore
@@ -41,6 +39,8 @@ 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
+
 if TYPE_CHECKING:
     from bullish.database.crud import BullishDb
 
@@ -61,59 +61,6 @@ def to_float(value: Any) -> Optional[float]:
     return float(value)
 
 
-def price_growth(prices: pd.DataFrame, days: int, max: bool = False) -> Optional[float]:
-    prices_ = prices.copy()
-    last_index = prices_.last_valid_index()
-    delta = pd.Timedelta(days=days)
-    start_index = last_index - delta  # type: ignore
-
-    try:
-        closest_index = prices_.index.unique().asof(start_index)  # type: ignore
-        price = (
-            prices_.loc[closest_index].close
-            if not max
-            else prices_[closest_index:].close.max()
-        )
-    except Exception as e:
-        logger.warning(
-            f"""Failing to calculate price growth: {e}.""",
-            exc_info=True,
-        )
-        return None
-    return (  # type: ignore
-        (prices_.loc[last_index].close - price) * 100 / prices_.loc[last_index].close
-    )
-
-
-def buy_opportunity(
-    series_a: pd.Series, series_b: pd.Series  # type: ignore
-) -> Optional[date]:
-    sell = ta.cross(series_a=series_a, series_b=series_b)
-    buy = ta.cross(series_a=series_b, series_b=series_a)
-    if not buy[buy == 1].index.empty and not sell[sell == 1].index.empty:
-        last_buy_signal = pd.Timestamp(buy[buy == 1].index[-1])
-        last_sell_signal = pd.Timestamp(sell[sell == 1].index[-1])
-        if last_buy_signal > last_sell_signal:
-            return last_buy_signal
-    return None
-
-
-def perc(data: pd.Series) -> float:  # type: ignore
-    return cast(float, ((data.iloc[-1] - data.iloc[0]) / data.iloc[0]) * 100)
-
-
-def yoy(prices: pd.DataFrame) -> pd.Series:  # type: ignore
-    return prices.close.resample("YE").apply(perc)  # type: ignore
-
-
-def mom(prices: pd.DataFrame) -> pd.Series:  # type: ignore
-    return prices.close.resample("ME").apply(perc)  # type: ignore
-
-
-def wow(prices: pd.DataFrame) -> pd.Series:  # type: ignore
-    return prices.close.resample("W").apply(perc)  # type: ignore
-
-
 def _load_data(
     data: Sequence[DataSourceBase], symbol: str, class_: Type[DataSourceBase]
 ) -> pd.DataFrame:
@@ -128,23 +75,23 @@ def _load_data(
         return pd.DataFrame(columns=columns).sort_index()
 
 
-def _compute_growth(series: pd.Series) -> bool:  # type: ignore
+def _compute_growth(series: pd.Series) -> bool:
     if series.empty:
         return False
     return all(series.pct_change(fill_method=None).dropna() > 0)
 
 
-def _all_positive(series: pd.Series) -> bool:  # type: ignore
+def _all_positive(series: pd.Series) -> bool:
     if series.empty:
         return False
     return all(series.dropna() > 0)
 
 
-def _get_last(data: pd.Series) -> Optional[float]:  # type: ignore
+def _get_last(data: pd.Series) -> Optional[float]:
     return data.iloc[-1] if not data.empty else None
 
 
-def _abs(data: pd.Series) -> pd.Series:  # type: ignore
+def _abs(data: pd.Series) -> pd.Series:
     try:
         return abs(data)
     except Exception as e:
@@ -152,17 +99,8 @@ def _abs(data: pd.Series) -> pd.Series:  # type: ignore
         return data
 
 
-class TechnicalAnalysis(BaseModel):
-    rsi_last_value: Optional[float] = None
-    macd_12_26_9_buy_date: Optional[date] = None
-    ma_50_200_buy_date: Optional[date] = None
-    slope_7: Optional[float] = None
-    slope_14: Optional[float] = None
-    slope_30: Optional[float] = None
-    slope_60: Optional[float] = None
-    last_adx: Optional[float] = None
-    last_dmp: Optional[float] = None
-    last_dmn: Optional[float] = None
+class TechnicalAnalysisBase(BaseModel):
+    _description: ClassVar[str] = "General technical indicators"
     last_price: Annotated[
         Optional[float],
         BeforeValidator(to_float),
@@ -170,189 +108,113 @@ class TechnicalAnalysis(BaseModel):
             default=None,
         ),
     ]
-    last_price_date: Annotated[
-        Optional[date],
-        Field(
-            default=None,
-        ),
-    ]
-    year_to_date_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_52_weeks_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_week_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_month_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_year_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    year_to_date_max_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_week_max_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_month_max_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    last_year_max_growth: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    macd_12_26_9_buy: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    star_yoy: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    star_wow: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
-    star_mom: Annotated[
-        Optional[float],
-        Field(
-            default=None,
-        ),
-    ]
+
+
+TechnicalAnalysisModels = [*IndicatorModels, TechnicalAnalysisBase]
+
+
+class TechnicalAnalysis(*TechnicalAnalysisModels):  # type: ignore
 
     @classmethod
     def from_data(cls, prices: pd.DataFrame) -> "TechnicalAnalysis":
         try:
-            last_index = prices.last_valid_index()
-            year_to_date_days = (
-                last_index
-                - pd.Timestamp(year=last_index.year, month=1, day=1, tz="UTC")  # type: ignore
-            ).days
-            year_to_date_growth = price_growth(prices, year_to_date_days)
-            last_52_weeks_growth = price_growth(prices=prices, days=399)
-            last_week_growth = price_growth(prices=prices, days=7)
-            last_month_growth = price_growth(prices=prices, days=31)
-            last_year_growth = price_growth(prices=prices, days=365)
-            year_to_date_max_growth = price_growth(prices, year_to_date_days, max=True)
-            last_week_max_growth = price_growth(prices=prices, days=7, max=True)
-            last_month_max_growth = price_growth(prices=prices, days=31, max=True)
-            last_year_max_growth = price_growth(prices=prices, days=365, max=True)
-            prices.ta.sma(50, append=True)
-            prices.ta.sma(200, append=True)
-            prices.ta.adx(append=True)
-            prices["SLOPE_14"] = ta.linreg(prices.close, slope=True, length=14)
-            prices["SLOPE_7"] = ta.linreg(prices.close, slope=True, length=7)
-            prices["SLOPE_30"] = ta.linreg(prices.close, slope=True, length=30)
-            prices["SLOPE_60"] = ta.linreg(prices.close, slope=True, length=60)
-            prices.ta.macd(append=True)
-            prices.ta.rsi(append=True)
-
-            rsi_last_value = prices.RSI_14.iloc[-1]
-            macd_12_26_9_buy_date = buy_opportunity(
-                prices.MACDs_12_26_9, prices.MACD_12_26_9
-            )
-            star_yoy = yoy(prices).median()
-            star_mom = mom(prices).median()
-            star_wow = wow(prices).median()
-            try:
-                macd_12_26_9_buy = (
-                    prices.MACD_12_26_9.iloc[-1] > prices.MACDs_12_26_9.iloc[-1]
-                )
-            except Exception as e:
-                logger.warning(
-                    f"Failing to calculate MACD buy date: {e}", exc_info=True
-                )
-                macd_12_26_9_buy = None
-            ma_50_200_buy_date = buy_opportunity(prices.SMA_200, prices.SMA_50)
-            return cls(
-                rsi_last_value=rsi_last_value,
-                macd_12_26_9_buy_date=macd_12_26_9_buy_date,
-                macd_12_26_9_buy=macd_12_26_9_buy,
-                ma_50_200_buy_date=ma_50_200_buy_date,
-                last_price=prices.close.iloc[-1],
-                last_price_date=prices.index[-1],
-                last_adx=prices.ADX_14.iloc[-1],
-                last_dmp=prices.DMP_14.iloc[-1],
-                last_dmn=prices.DMN_14.iloc[-1],
-                slope_7=prices.SLOPE_7.iloc[-1],
-                slope_14=prices.SLOPE_14.iloc[-1],
-                slope_30=prices.SLOPE_30.iloc[-1],
-                slope_60=prices.SLOPE_60.iloc[-1],
-                year_to_date_growth=year_to_date_growth,
-                last_52_weeks_growth=last_52_weeks_growth,
-                last_week_growth=last_week_growth,
-                last_month_growth=last_month_growth,
-                last_year_growth=last_year_growth,
-                year_to_date_max_growth=year_to_date_max_growth,
-                last_week_max_growth=last_week_max_growth,
-                last_month_max_growth=last_month_max_growth,
-                last_year_max_growth=last_year_max_growth,
-                star_yoy=star_yoy,
-                star_mom=star_mom,
-                star_wow=star_wow,
-            )
+            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)
-            return cls()  # type: ignore
+            return cls()
 
 
 class BaseFundamentalAnalysis(BaseModel):
-    positive_free_cash_flow: Optional[float] = None
-    growing_operating_cash_flow: Optional[float] = None
-    operating_cash_flow_is_higher_than_net_income: Optional[float] = None
-    mean_capex_ratio: Optional[float] = None
-    max_capex_ratio: Optional[float] = None
-    min_capex_ratio: Optional[float] = None
-    mean_dividend_payout_ratio: Optional[float] = None
-    max_dividend_payout_ratio: Optional[float] = None
-    min_dividend_payout_ratio: Optional[float] = None
-    positive_net_income: Optional[float] = None
-    positive_operating_income: Optional[float] = None
-    growing_net_income: Optional[float] = None
-    growing_operating_income: Optional[float] = None
-    positive_diluted_eps: Optional[float] = None
-    positive_basic_eps: Optional[float] = None
-    growing_basic_eps: Optional[float] = None
-    growing_diluted_eps: Optional[float] = None
-    positive_debt_to_equity: Optional[float] = None
-    positive_return_on_assets: Optional[float] = None
-    positive_return_on_equity: Optional[float] = None
-    earning_per_share: Optional[float] = None
+    positive_debt_to_equity: Optional[bool] = Field(
+        None,
+        description="True if the company's debt-to-equity ratio is favorable (typically low or improving).",
+    )
+    positive_return_on_assets: Optional[bool] = Field(
+        None,
+        description="True if the company reports a positive return on assets (ROA), "
+        "indicating efficient use of its assets.",
+    )
+    positive_return_on_equity: Optional[bool] = Field(
+        None,
+        description="True if the return on equity (ROE) is positive, "
+        "showing profitability relative to shareholder equity.",
+    )
+    positive_diluted_eps: Optional[bool] = Field(
+        None,
+        description="True if the diluted earnings per share (EPS), "
+        "which includes the effect of convertible securities, is positive.",
+    )
+    positive_basic_eps: Optional[bool] = Field(
+        None,
+        description="True if the basic earnings per share (EPS) is positive, reflecting profitable operations.",
+    )
+    growing_basic_eps: Optional[bool] = Field(
+        None,
+        description="True if the basic EPS has shown consistent growth over a defined time period.",
+    )
+    growing_diluted_eps: Optional[bool] = Field(
+        None,
+        description="True if the diluted EPS has consistently increased over time.",
+    )
+    positive_net_income: Optional[bool] = Field(
+        None,
+        description="True if the net income is positive, indicating overall profitability.",
+    )
+    positive_operating_income: Optional[bool] = Field(
+        None,
+        description="True if the company has positive operating income from its core business operations.",
+    )
+    growing_net_income: Optional[bool] = Field(
+        None, description="True if net income has shown consistent growth over time."
+    )
+    growing_operating_income: Optional[bool] = Field(
+        None,
+        description="True if the operating income has consistently increased over a period.",
+    )
+    positive_free_cash_flow: Optional[bool] = Field(
+        None,
+        description="True if the company has positive free cash flow, indicating financial flexibility and health.",
+    )
+    growing_operating_cash_flow: Optional[bool] = Field(
+        None,
+        description="True if the company's operating cash flow is growing steadily.",
+    )
+    operating_cash_flow_is_higher_than_net_income: Optional[bool] = Field(
+        None,
+        description="True if the operating cash flow exceeds net income, often a sign of high-quality earnings.",
+    )
+
+    # Capital Expenditure Ratios
+    mean_capex_ratio: Optional[float] = Field(
+        None,
+        description="Average capital expenditure (CapEx) ratio, usually "
+        "calculated as CapEx divided by revenue or operating cash flow.",
+    )
+    max_capex_ratio: Optional[float] = Field(
+        None, description="Maximum observed CapEx ratio over the evaluation period."
+    )
+    min_capex_ratio: Optional[float] = Field(
+        None, description="Minimum observed CapEx ratio over the evaluation period."
+    )
+
+    # Dividend Payout Ratios
+    mean_dividend_payout_ratio: Optional[float] = Field(
+        None,
+        description="Average dividend payout ratio, representing the proportion of earnings paid out as dividends.",
+    )
+    max_dividend_payout_ratio: Optional[float] = Field(
+        None, description="Maximum dividend payout ratio observed over the period."
+    )
+    min_dividend_payout_ratio: Optional[float] = Field(
+        None, description="Minimum dividend payout ratio observed over the period."
+    )
+
+    # EPS Value
+    earning_per_share: Optional[float] = Field(
+        None,
+        description="The latest or most relevant value of earnings per share (EPS), indicating net income per share.",
+    )
 
     def is_empty(self) -> bool:
         return all(getattr(self, field) is None for field in self.model_fields)
@@ -481,13 +343,15 @@ class BaseFundamentalAnalysis(BaseModel):
             return cls()
 
 
-class YearlyFundamentalAnalysis(BaseFundamentalAnalysis):
-    ...
+class YearlyFundamentalAnalysis(BaseFundamentalAnalysis): ...
 
 
 fields_with_prefix = {
-    f"{QUARTERLY}_{name}": (Optional[float], Field(default=None))
-    for name in BaseFundamentalAnalysis.model_fields
+    f"{QUARTERLY}_{name}": (
+        field_info.annotation,
+        Field(default=None, description=field_info.description),
+    )
+    for name, field_info in BaseFundamentalAnalysis.model_fields.items()
 }
 
 # Create the new model
@@ -507,7 +371,7 @@ class QuarterlyFundamentalAnalysis(BaseQuarterlyFundamentalAnalysis):  # type: i
             cash_flows=financials.quarterly_cash_flows,
             ticker=ticker,
         )
-        return cls.model_validate({f"{QUARTERLY}_{k}": v for k, v in base_financial_analisys.model_dump().items()})  # type: ignore # noqa: E501
+        return cls.model_validate({f"{QUARTERLY}_{k}": v for k, v in base_financial_analisys.model_dump().items()})  # type: ignore
 
 
 class FundamentalAnalysis(YearlyFundamentalAnalysis, QuarterlyFundamentalAnalysis):