bullishpy 0.12.0__tar.gz → 0.14.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bullishpy
-Version: 0.12.0
+Version: 0.14.0
 Summary: 
 Author: aan
 Author-email: andoludovic.andriamamonjy@gmail.com

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

@@ -45,6 +45,8 @@ from pydantic import BaseModel, BeforeValidator, Field, create_model
 from bullish.analysis.indicators import Indicators, IndicatorModels
 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
 
@@ -494,6 +496,7 @@ def compute_analysis(database_path: Path, ticker: Ticker) -> Analysis:
 
 
 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.12.0/bullish/analysis/filter.py → bullishpy-0.14.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.14.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.12.0 → bullishpy-0.14.0}/bullish/analysis/functions.py

@@ -1,4 +1,3 @@
-import datetime
 import logging
 from datetime import date
 from typing import Optional, Callable, cast
@@ -122,6 +121,9 @@ def compute_roc(data: pd.DataFrame) -> pd.DataFrame:
     results["ROC_7"] = talib.ROC(data.close, timeperiod=7)  # type: ignore
     results["ROC_1"] = talib.ROC(data.close, timeperiod=1)  # type: ignore
     results["ROC_30"] = talib.ROC(data.close, timeperiod=30)  # type: ignore
+    mom = talib.MOM(data.close, timeperiod=252)  # type: ignore
+    results["MOM"] = mom.shift(21)  # type: ignore
+
     return results
 
 
@@ -137,6 +139,7 @@ def compute_sma(data: pd.DataFrame) -> pd.DataFrame:
     results = pd.DataFrame(index=data.index)
     results["SMA_50"] = talib.SMA(data.close, timeperiod=50)  # type: ignore
     results["SMA_200"] = talib.SMA(data.close, timeperiod=200)  # type: ignore
+    results["CLOSE"] = data.close
     return results
 
 
@@ -144,6 +147,8 @@ def compute_pandas_ta_sma(data: pd.DataFrame) -> pd.DataFrame:
     results = pd.DataFrame(index=data.index)
     results["SMA_50"] = ta.sma(data.close, length=50)
     results["SMA_200"] = ta.sma(data.close, length=200)
+    results["CLOSE"] = data.close
+
     return results
 
 
@@ -276,22 +281,33 @@ 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
+    arr = series.to_numpy()
+    change_points = np.flatnonzero(np.r_[True, arr[1:] != arr[:-1]])
+    run_starts = change_points
+    true_runs = run_starts[arr[run_starts]]
+    last_true_run_start = true_runs[-1]
+    return series.index[last_true_run_start].date()  # type: ignore
+
+
+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)
+    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):
@@ -334,7 +350,7 @@ MFI = IndicatorFunction(
     expected_columns=["MFI"], functions=[compute_mfi, compute_pandas_ta_mfi]
 )
 ROC = IndicatorFunction(
-    expected_columns=["ROC_7", "ROC_1", "ROC_30"],
+    expected_columns=["ROC_7", "ROC_1", "ROC_30", "MOM"],
     functions=[compute_roc, compute_pandas_ta_roc],
 )
 CANDLESTOCK_PATTERNS = IndicatorFunction(
@@ -351,7 +367,7 @@ CANDLESTOCK_PATTERNS = IndicatorFunction(
 )
 
 SMA = IndicatorFunction(
-    expected_columns=["SMA_50", "SMA_200"],
+    expected_columns=["SMA_50", "SMA_200", "CLOSE"],
     functions=[compute_sma, compute_pandas_ta_sma],
 )