bullishpy 0.55.0__py3-none-any.whl → 0.75.0__py3-none-any.whl

bullish/analysis/analysis.py

@@ -497,6 +497,11 @@ class AnalysisView(BaseModel):
     weekly_growth: Optional[float] = None
     monthly_growth: Optional[float] = None
     upside: Optional[float] = None
+    oai_high_price_target: Optional[float] = None
+    oai_low_price_target: Optional[float] = None
+    rsi: Optional[float] = None
+    oai_recommendation: Optional[str] = None
+    oai_moat: Optional[bool] = None
 
 
 def json_loads(value: Any) -> Any:
@@ -527,11 +532,26 @@ class SubjectAnalysis(BaseModel):
     ] = None
     summary: Annotated[Optional[Dict[str, Any]], BeforeValidator(json_loads)] = None
     upside: Optional[float] = None
+    downside: Optional[float] = None
+
+    oai_high_price_target: Optional[float] = None
+    oai_low_price_target: Optional[float] = None
+    oai_news_date: Optional[datetime] = None
+    oai_recent_news: Optional[str] = None
+    oai_recommendation: Optional[str] = None
+    oai_explanation: Optional[str] = None
+    oai_moat: Optional[bool] = None
 
     def compute_upside(self, last_price: float) -> None:
-        if self.high_price_target is not None:
+        if self.oai_high_price_target is not None:
             self.upside = (
-                (float(self.high_price_target) - float(last_price))
+                (float(self.oai_high_price_target) - float(last_price))
+                * 100
+                / float(last_price)
+            )
+        if self.oai_low_price_target is not None:
+            self.downside = (
+                (float(last_price) - float(self.oai_low_price_target))
                 * 100
                 / float(last_price)
             )
@@ -541,12 +561,17 @@ class SubjectAnalysis(BaseModel):
             return None
         return "".join(
             [
-                f"<p>{scrub(t.get('content').replace("\n",""))}</p>"  # type: ignore
+                f"<p>{t.get('content').replace("\n","")}</p>"  # type: ignore
                 for t in self.news_summary
                 if t.get("content")
             ]
         )
 
+    def to_date(self) -> Optional[date]:
+        if self.news_date:
+            return self.news_date.date()
+        return None
+
 
 class Analysis(SubjectAnalysis, AnalysisEarningsDate, AnalysisView, BaseEquity, TechnicalAnalysis, FundamentalAnalysis):  # type: ignore
 

bullish/analysis/constants.py

@@ -400,3 +400,57 @@ Country = Literal[
     "Liberia",
     "Kenya",
 ]
+
+
+HighGrowthIndustry = Literal[
+    "Software - Infrastructure",
+    "Software - Application",
+    "Internet Retail",
+    "Internet Content & Information",
+    "Electronic Gaming & Multimedia",
+    "Semiconductors",
+    "Semiconductor Equipment & Materials",
+    "Information Technology Services",
+    "Communication Equipment",
+    "Consumer Electronics",
+    "Health Information Services",
+    "Biotechnology",
+    "Medical Devices",
+    "Diagnostics & Research",
+    "Medical Instruments & Supplies",
+    "Drug Manufacturers - Specialty & Generic",
+]
+
+DefensiveIndustries = Literal[
+    "Utilities - Independent Power Producers",
+    "Utilities - Diversified",
+    "Utilities - Renewable",
+    "Utilities - Regulated Gas",
+    "Utilities - Regulated Water",
+    "Utilities - Regulated Electric",
+    "Household & Personal Products",
+    "Food Distribution",
+    "Packaged Foods",
+    "Grocery Stores",
+    "Beverages - Non - Alcoholic",
+    "Beverages - Brewers",
+    "Confectioners",
+    "Tobacco",
+    "Paper & Paper Products",
+    "Medical Devices",
+    "Drug Manufacturers - Specialty & Generic",
+    "Medical Instruments & Supplies",
+    "Medical Distribution",
+    "Medical Care Facilities",
+    "Drug Manufacturers - General",
+    "Healthcare Plans",
+    "Pharmaceutical Retailers",
+    "Waste Management",
+    "Pollution & Treatment Controls",
+    "Insurance Brokers",
+    "Insurance - Property & Casualty",
+    "Insurance - Specialty",
+    "Insurance - Reinsurance",
+    "Insurance - Diversified",
+    "Insurance - Life",
+]

bullish/analysis/filter.py

@@ -191,7 +191,9 @@ class FilterQuery(GeneralFilter, *TechnicalAnalysisFilters, *FundamentalAnalysis
         )
 
     def to_query(self) -> str:  # noqa: C901
-        parameters = self.model_dump(exclude_defaults=True, exclude_unset=True)
+        parameters = self.model_dump(
+            exclude_defaults=True, exclude_unset=True, exclude={"name"}
+        )
         query = []
         order_by_desc = ""
         order_by_asc = ""

bullish/analysis/functions.py

@@ -4,7 +4,7 @@ from typing import Optional, Callable, cast
 
 import numpy as np
 import pandas as pd
-import pandas_ta as ta  # type: ignore
+import pandas_ta as ta
 
 from pydantic import BaseModel
 
@@ -18,7 +18,7 @@ except Exception:
 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)
+    crossing = ta.cross(x=series_a, y=series_b, above=above)  # type: ignore
     return crossing  # type: ignore
 
 
@@ -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  # type: ignore
+    )
+    return bbands

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(
@@ -266,7 +280,7 @@ def indicators_factory() -> List[Indicator]:
                     description="RSI Oversold Signal",
                     type_info="Oversold",
                     type=Optional[date],
-                    function=lambda d: (d.RSI < 30) & (d.RSI > 0),
+                    function=lambda d: (d.RSI <= 30) & (d.RSI > 0),
                     in_use_backtest=True,
                 ),
                 Signal(
@@ -281,7 +295,14 @@ def indicators_factory() -> List[Indicator]:
                     description="RSI Neutral Signal",
                     type_info="Overbought",
                     type=Optional[date],
-                    function=lambda d: (d.RSI < 60) & (d.RSI > 40),
+                    function=lambda d: (d.RSI < 60) & (d.RSI > 30),
+                ),
+                Signal(
+                    name="RSI",
+                    description="RSI value",
+                    type_info="Overbought",
+                    type=Optional[float],
+                    function=lambda d: d.RSI,
                 ),
             ],
         ),

bullish/analysis/openai.py

@@ -0,0 +1,91 @@
+import json
+import logging
+import os
+from datetime import date
+from typing import Optional, List, TYPE_CHECKING
+
+from pydantic import BaseModel, Field
+from openai import OpenAI
+
+if TYPE_CHECKING:
+    from bullish.database.crud import BullishDb
+
+logger = logging.getLogger(__name__)
+
+
+def prompt(ticker: str) -> str:
+    return f"""
+You are a financial analysis assistant.
+
+Using the latest reliable public data from the web — including analyst price targets from multiple reputable 
+sources — analyze the stock ticker {ticker}.
+
+Return ONLY valid JSON matching EXACTLY the schema below — no explanations, no preamble, no markdown, no code 
+fences, no extra text:
+
+{{
+    "high_price_target": float,  // Analyst consensus high price target in USD (based on multiple sources)
+    "low_price_target": float,   // Analyst consensus low price target in USD (based on multiple sources)
+    "recent_news": str,          // Detailed, multi-sentence summary of recent news affecting the company; 
+    include credible source names inline
+    "recommendation": str,       // One of: "Strong Buy", "Buy", "Hold", "Sell", "Strong Sell"
+    "explanation": str           // Concise explanation for the recommendation above, covering key pros/cons 
+    for investors
+    "moat": bool           // Give as a boolean true or false if the company has a strong economic moat
+}}
+
+Formatting rules:
+- Output must be a single valid JSON object with no surrounding text or formatting.
+- Use plain numbers for high_price_target and low_price_target (no currency symbols, no commas).
+- All text fields must be professional, investor-oriented, and reference credible named sources in `recent_news`.
+- If exact data is unavailable, estimate based on web search results and note uncertainty in the relevant field.
+"""
+
+
+class OpenAINews(BaseModel):
+    symbol: str
+    news_date: date = Field(default_factory=date.today)
+    high_price_target: Optional[float] = None
+    low_price_target: Optional[float] = None
+    recent_news: Optional[str] = None
+    recommendation: Optional[str] = None
+    explanation: Optional[str] = None
+    moat: Optional[bool] = None
+
+    def valid(self) -> bool:
+        return bool(
+            self.model_dump(
+                exclude_none=True,
+                exclude_unset=True,
+                exclude_defaults=True,
+                exclude={"symbol"},
+            )
+        )
+
+    @classmethod
+    def from_ticker(cls, ticker: str) -> "OpenAINews":
+        if "OPENAI_API_KEY" not in os.environ:
+            return cls(symbol=ticker)
+        print(f"Fetching OpenAI news for {ticker}...")
+        client = OpenAI()
+        resp = client.responses.create(
+            model="gpt-4o", input=prompt(ticker), tools=[{"type": "web_search"}]  # type: ignore
+        )
+        try:
+            return cls.model_validate(json.loads(resp.output_text) | {"symbol": ticker})
+        except Exception as e:
+            logger.error(f"Failed to parse OpenAI response for {ticker}: {e}")
+            return cls(symbol=ticker)
+
+    @classmethod
+    def from_tickers(cls, tickers: List[str]) -> List["OpenAINews"]:
+        return [cls.from_ticker(t) for t in tickers]
+
+
+def get_open_ai_news(bullish_db: "BullishDb", tickers: List[str]) -> bool:
+    news = OpenAINews.from_tickers(tickers)
+    valid_news = [n for n in news if n.valid()]
+    if valid_news:
+        bullish_db.write_many_openai_news(valid_news)
+        return True
+    return False