bullishpy 0.66.0__tar.gz → 0.67.0__tar.gz

{bullishpy-0.66.0 → bullishpy-0.67.0}/PKG-INFO

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

{bullishpy-0.66.0 → bullishpy-0.67.0}/bullish/analysis/filter.py

@@ -180,7 +180,6 @@ class GeneralFilter(BaseModel):
     price_per_earning_ratio: Optional[List[float]] = Field(default=[0.0, 1000.0])
 
 
-
 class FilterQuery(GeneralFilter, *TechnicalAnalysisFilters, *FundamentalAnalysisFilters):  # type: ignore
 
     def valid(self) -> bool:

{bullishpy-0.66.0 → bullishpy-0.67.0}/bullish/analysis/functions.py

@@ -434,3 +434,38 @@ def add_indicators(data: pd.DataFrame) -> pd.DataFrame:
             f"Expected columns {expected_columns} not found in data columns {data.columns.tolist()}"
         )
     return data
+
+
+class Line(BaseModel):
+    value: float
+    previous: float
+
+
+class SupportResistance(BaseModel):
+    support: Line
+    resistance: Line
+
+
+def support_resistance(df: pd.DataFrame, window: int = 5) -> SupportResistance:
+
+    w = window * 2 + 1
+    highs = df.high.rolling(w, center=True).max()
+    lows = df.low.rolling(w, center=True).min()
+    swing_high_mask = df.high == highs
+    swing_low_mask = df.low == lows
+
+    raw_res = df.loc[swing_high_mask, "high"].to_numpy()
+    raw_sup = df.loc[swing_low_mask, "low"].to_numpy()
+    return SupportResistance(
+        support=Line(value=float(raw_sup[-1]), previous=float(raw_sup[-2])),
+        resistance=Line(value=float(raw_res[-1]), previous=float(raw_res[-2])),
+    )
+
+
+def bollinger_bands(
+    data: pd.DataFrame, window: int = 20, std_dev: float = 2.0
+) -> pd.DataFrame:
+    bbands = ta.bbands(
+        data.close, timeperiod=window, nbdevup=std_dev, nbdevdn=std_dev, matype=0
+    )
+    return bbands  # type: ignore

{bullishpy-0.66.0 → bullishpy-0.67.0}/bullish/analysis/indicators.py

@@ -175,6 +175,20 @@ def indicators_factory() -> List[Indicator]:
                     type=Optional[date],
                     function=lambda d: (d.ADX_14 > 20) & (d.MINUS_DI > d.PLUS_DI),
                 ),
+                Signal(
+                    name="ADX_14",
+                    description="ADX 14",
+                    type_info="Short",
+                    type=Optional[date],
+                    function=lambda d: (d.ADX_14 > 25),
+                ),
+                Signal(
+                    name="ADX_14_OVERBOUGHT",
+                    description="ADX 14 OVERBOUGHT",
+                    type_info="Short",
+                    type=Optional[date],
+                    function=lambda d: (d.ADX_14 > 50),
+                ),
             ],
         ),
         Indicator(

{bullishpy-0.66.0 → bullishpy-0.67.0}/bullish/analysis/predefined_filters.py

@@ -218,6 +218,12 @@ class NamedFilterQuery(FilterQuery):
     def rsi_oversold_(self) -> "NamedFilterQuery":
         return self.update_indicator_filter("RSI Oversold", "rsi_oversold")
 
+    def rsi_overbought_(self) -> "NamedFilterQuery":
+        return self.update_indicator_filter("RSI Overbought", "rsi_overbought")
+
+    def adx(self) -> "NamedFilterQuery":
+        return self.update_indicator_filter("ADX 14", "adx_14")
+
     def earnings_date(self) -> "NamedFilterQuery":
         return NamedFilterQuery.model_validate(
             self.model_dump()
@@ -231,25 +237,35 @@ class NamedFilterQuery(FilterQuery):
         )
 
     def variants(
-        self, variants: Optional[List[List[str]]] = None
+        self,
+        variants: Optional[List[List[str]]] = None,
+        filters: Optional[List[str]] = None,
     ) -> List["NamedFilterQuery"]:
+        if filters and self.name not in filters:
+            return [self]
         variants = variants or [["europe"], ["us"]]
 
         _variants = {v for variant in variants for v in _get_variants(variant)}
-        filters = []
+        filters_ = []
         for attributes in _variants:
-            filter = self
+            filter__ = self
             for attr in attributes:
-                filter = getattr(filter, attr)()
-            filters.append(filter)
+                filter__ = getattr(filter__, attr)()
+            filters_.append(filter__)
 
-        return filters
+        return filters_
 
 
 def load_custom_filters() -> List[NamedFilterQuery]:
     if "CUSTOM_FILTERS_PATH" in os.environ:
         custom_filters_path = os.environ["CUSTOM_FILTERS_PATH"]
-        return read_custom_filters(Path(custom_filters_path))
+        return [
+            variant
+            for f in read_custom_filters(Path(custom_filters_path))
+            for variant in f.variants(
+                variants=[["rsi_overbought_"]], filters=["portfolio", "Portfolio"]
+            )
+        ]
     return []
 
 
@@ -283,11 +299,11 @@ LARGE_CAPS = NamedFilterQuery(
 ).variants(
     variants=[
         ["europe", "rsi_oversold_", "macd", "fundamentals"],
-        ["us", "rsi_oversold_", "macd", "fundamentals"],
-        ["europe", "rsi_neutral_", "macd", "fundamentals"],
-        ["us", "rsi_neutral_", "macd", "fundamentals"],
-        ["europe", "rsi_30", "macd", "fundamentals"],
-        ["us", "rsi_30", "macd", "fundamentals"],
+        ["us", "rsi_oversold_", "macd", "adx", "fundamentals"],
+        ["europe", "rsi_neutral_", "macd", "adx", "fundamentals"],
+        ["us", "rsi_neutral_", "macd", "adx", "fundamentals"],
+        ["europe", "rsi_30", "macd", "adx", "fundamentals"],
+        ["us", "rsi_30", "macd", "adx", "fundamentals"],
         ["europe", "top_performers", "cheap"],
         ["us", "top_performers", "cheap"],
         ["europe", "earnings_date"],

bullishpy-0.67.0/bullish/database/alembic/versions/cc28171c21a4_.py

@@ -0,0 +1,43 @@
+"""
+
+Revision ID: cc28171c21a4
+Revises: 260fcff7212e
+Create Date: 2025-08-15 17:04:59.467407
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import sqlite
+
+# revision identifiers, used by Alembic.
+revision: str = "cc28171c21a4"
+down_revision: Union[str, None] = "260fcff7212e"
+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! ###
+    with op.batch_alter_table("analysis", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("adx_14", sa.Date(), nullable=True))
+        batch_op.add_column(sa.Column("adx_14_overbought", sa.Date(), nullable=True))
+        batch_op.create_index("ix_analysis_adx_14", ["adx_14"], unique=False)
+        batch_op.create_index(
+            "ix_analysis_adx_14_overbought", ["adx_14_overbought"], unique=False
+        )
+
+    # ### 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.drop_index("ix_analysis_adx_14_overbought")
+        batch_op.drop_index("ix_analysis_adx_14")
+        batch_op.drop_column("adx_14_overbought")
+        batch_op.drop_column("adx_14")
+
+    # ### end Alembic commands ###

{bullishpy-0.66.0 → bullishpy-0.67.0}/bullish/figures/figures.py

@@ -5,7 +5,10 @@ import pandas as pd
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 
-from bullish.analysis.functions import add_indicators
+from bullish.analysis.functions import (
+    add_indicators,
+    support_resistance,
+)
 from datetime import date
 
 
@@ -17,6 +20,8 @@ def plot(
     industry_data: Optional[pd.DataFrame] = None,
 ) -> go.Figure:
     data = add_indicators(data)
+    supports = support_resistance(data)
+
     fig = make_subplots(
         rows=7,
         cols=1,
@@ -36,8 +41,8 @@ def plot(
             f"RSI ({symbol} [{name}])",
             f"MACD ({symbol} [{name}])",
             f"ADX ({symbol} [{name}])",
-            f"OBV ({symbol} [{name}])",
-            f"Industry ({symbol} [{name}])",
+            f"ATR ({symbol} [{name}])",
+            f"ADOSC ({symbol} [{name}])",
         ),
     )
     # Row 1: Candlestick + SMAs
@@ -114,28 +119,15 @@ def plot(
         col=1,
     )
     fig.add_trace(
-        go.Scatter(x=data.index, y=data.OBV, name="OBV", mode="lines"),
+        go.Scatter(x=data.index, y=data.ATR, name="ATR", mode="lines"),
         row=6,
         col=1,
     )
     fig.add_trace(
         go.Scatter(x=data.index, y=data.ADOSC, name="ADOSC", mode="lines"),
-        row=6,
+        row=7,
         col=1,
     )
-    if industry_data is not None and not industry_data.empty:
-        for c in industry_data.columns:
-            fig.add_trace(
-                go.Scatter(
-                    x=industry_data.index,
-                    y=industry_data[c],
-                    name=c,
-                    mode="lines",
-                    opacity=0.5 if c != "symbol" else 1.0,
-                ),
-                row=7,
-                col=1,
-            )
 
     if dates is not None and dates:
         for date in dates:
@@ -166,5 +158,23 @@ def plot(
     fig.add_hline(y=70, line_dash="dash", line_color="red", row=3, col=1)
     fig.add_hline(y=30, line_dash="dash", line_color="green", row=3, col=1)
     fig.add_hline(y=25, line_dash="dash", line_color="red", row=5, col=1)
+    fig.add_hline(
+        y=supports.support.value,
+        line_dash="dash",
+        line_color="rgba(26, 188, 156, 1)",  # teal, fully opaque
+        annotation_text=f"Support ({supports.support.value:.2f})",
+        line_width=0.75,
+        row=1,
+        col=1,
+    )
+    fig.add_hline(
+        y=supports.resistance.value,
+        line_dash="dash",
+        line_color="rgba(230, 126, 34, 1)",  # orange, fully opaque
+        annotation_text=f"Resistance ({supports.resistance.value:.2f})",
+        line_width=0.75,
+        row=1,
+        col=1,
+    )
 
     return fig

{bullishpy-0.66.0 → bullishpy-0.67.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "bullishpy"
-version = "0.66.0"
+version = "0.67.0"
 description = ""
 authors = ["aan <andoludovic.andriamamonjy@gmail.com>"]
 readme = "README.md"