bullishpy 0.66.0__py3-none-any.whl → 0.68.0__py3-none-any.whl

bullish/analysis/analysis.py

@@ -528,6 +528,13 @@ class SubjectAnalysis(BaseModel):
     summary: Annotated[Optional[Dict[str, Any]], BeforeValidator(json_loads)] = None
     upside: 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
+
     def compute_upside(self, last_price: float) -> None:
         if self.high_price_target is not None:
             self.upside = (
@@ -541,12 +548,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/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:

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

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(

bullish/analysis/openai.py

@@ -0,0 +1,89 @@
+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
+}}
+
+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
+
+    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-mini", 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

bullish/analysis/predefined_filters.py

@@ -135,17 +135,29 @@ class NamedFilterQuery(FilterQuery):
             self.model_dump() | {"name": f"{self.name} ({suffix})", **properties}
         )
 
-    def top_performers(self) -> "NamedFilterQuery":
+    def week_top_performers(self) -> "NamedFilterQuery":
+        properties = {
+            "volume_above_average": DATE_THRESHOLD,
+            "weekly_growth": [1, 100],
+        }
+        return self._custom_variant("Week Top Performers", properties)
+
+    def month_top_performers(self) -> "NamedFilterQuery":
+        properties = {
+            "monthly_growth": [8, 100],
+        }
+        return self._custom_variant("Month Top Performers", properties)
+
+    def year_top_performers(self) -> "NamedFilterQuery":
         properties = {
             "volume_above_average": DATE_THRESHOLD,
             "sma_50_above_sma_200": [
                 datetime.date.today() - datetime.timedelta(days=5000),
                 datetime.date.today(),
             ],
-            "weekly_growth": [1, 100],
-            "monthly_growth": [8, 100],
+            "yearly_growth": [30, 100],
         }
-        return self._custom_variant("Top Performers", properties)
+        return self._custom_variant("Yearly Top Performers", properties)
 
     def poor_performers(self) -> "NamedFilterQuery":
         properties = {
@@ -161,7 +173,7 @@ class NamedFilterQuery(FilterQuery):
         }
         return self._custom_variant("Poor Performers", properties)
 
-    def fundamentals(self) -> "NamedFilterQuery":
+    def yearly_fundamentals(self) -> "NamedFilterQuery":
         properties = {
             "income": [
                 "positive_operating_income",
@@ -170,20 +182,63 @@ class NamedFilterQuery(FilterQuery):
                 "growing_operating_income",
             ],
             "cash_flow": ["positive_free_cash_flow", "growing_operating_cash_flow"],
+            "properties": [
+                "positive_return_on_equity",
+                "operating_cash_flow_is_higher_than_net_income",
+            ],
+        }
+        return self._custom_variant("Yearly Fundamentals", properties)
+
+    def quarterly_fundamentals(self) -> "NamedFilterQuery":
+        properties = {
+            "income": [
+                "quarterly_positive_operating_income",
+                "quarterly_positive_net_income",
+            ],
+            "cash_flow": [
+                "quarterly_positive_free_cash_flow",
+            ],
+            "properties": [
+                "quarterly_operating_cash_flow_is_higher_than_net_income",
+            ],
+        }
+        return self._custom_variant("Quarterly Fundamentals", properties)
+
+    def growing_quarterly_fundamentals(self) -> "NamedFilterQuery":
+        properties = {
+            "income": [
+                "quarterly_positive_operating_income",
+                "quarterly_positive_net_income",
+                "quarterly_growing_net_income",
+            ],
+            "cash_flow": [
+                "quarterly_positive_free_cash_flow",
+                "quarterly_growing_operating_cash_flow",
+            ],
+            "properties": [
+                "quarterly_operating_cash_flow_is_higher_than_net_income",
+            ],
+        }
+        return self._custom_variant("Growing Quarterly Fundamentals", properties)
+
+    def min_fundamentals(self) -> "NamedFilterQuery":
+        properties = {
+            "income": [
+                "positive_operating_income",
+                "positive_net_income",
+            ],
+            "cash_flow": [
+                "positive_free_cash_flow",
+            ],
             "eps": [
-                "growing_basic_eps",
-                "growing_diluted_eps",
-                "positive_basic_eps",
-                "positive_diluted_eps",
+                "positive_diluted_eps",  # or positive_basic_eps if diluted not available
             ],
             "properties": [
-                "positive_return_on_assets",
                 "positive_return_on_equity",
-                "positive_debt_to_equity",
                 "operating_cash_flow_is_higher_than_net_income",
             ],
         }
-        return self._custom_variant("Fundamentals", properties)
+        return self._custom_variant("Min Fundamentals", properties)
 
     def high_growth(self) -> "NamedFilterQuery":
         properties = {"industry": list(get_args(HighGrowthIndustry))}
@@ -218,6 +273,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 +292,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 [self, *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 []
 
 
@@ -269,10 +340,10 @@ SMALL_CAP = NamedFilterQuery(
     order_by_desc="market_capitalization",
 ).variants(
     variants=[
-        ["europe", "top_performers", "fundamentals"],
-        ["us", "top_performers", "fundamentals"],
-        ["europe", "earnings_date"],
-        ["us", "earnings_date"],
+        ["week_top_performers", "min_fundamentals"],
+        ["month_top_performers", "min_fundamentals"],
+        ["earnings_date", "min_fundamentals"],
+        ["rsi_oversold_", "min_fundamentals"],
     ]
 )
 
@@ -282,16 +353,13 @@ LARGE_CAPS = NamedFilterQuery(
     market_capitalization=[1e10, 1e14],
 ).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"],
-        ["europe", "top_performers", "cheap"],
-        ["us", "top_performers", "cheap"],
-        ["europe", "earnings_date"],
-        ["us", "earnings_date"],
+        ["rsi_oversold_", "macd", "yearly_fundamentals"],
+        ["rsi_neutral_", "macd", "adx", "yearly_fundamentals"],
+        ["rsi_30", "macd", "adx", "yearly_fundamentals"],
+        ["rsi_oversold_", "macd", "quarterly_fundamentals"],
+        ["rsi_neutral_", "macd", "adx", "quarterly_fundamentals"],
+        ["rsi_30", "macd", "adx", "quarterly_fundamentals"],
+        ["earnings_date", "quarterly_fundamentals", "yearly_fundamentals"],
     ]
 )
 
@@ -301,10 +369,10 @@ MID_CAPS = NamedFilterQuery(
     market_capitalization=[5e8, 1e10],
 ).variants(
     variants=[
-        ["europe", "top_performers", "fundamentals"],
-        ["us", "top_performers", "fundamentals"],
-        ["europe", "earnings_date"],
-        ["us", "earnings_date"],
+        ["week_top_performers"],
+        ["month_top_performers"],
+        ["earnings_date", "quarterly_fundamentals", "yearly_fundamentals"],
+        ["rsi_oversold_", "macd", "adx"],
     ]
 )
 

bullish/app/app.py

@@ -290,15 +290,21 @@ def dialog_plot_figure() -> None:
             <div class="news-hover" >
               📰 <span class="label">News</span>
               <div class="tooltip">
-                <h2>Date: {st.session_state.ticker_news.news_date.date()}</h2>
+                <h2>Date: {st.session_state.ticker_news.to_date()}</h2>
                 <h2>Price targets</h2>
                 <p>High price target: {st.session_state.ticker_news.high_price_target}</p>
                 <p>Low price target: {st.session_state.ticker_news.low_price_target}</p>
+                <p>OpenAI High price target: {st.session_state.ticker_news.oai_high_price_target}</p>
+                <p>OpenAI Low price target: {st.session_state.ticker_news.oai_low_price_target}</p>
                 <h2>Recommendation: {st.session_state.ticker_news.recommendation}</h2>
+                <h2>OpenAI Recommendation: {st.session_state.ticker_news.oai_recommendation}</h2>
                 <h2>Consensus: {st.session_state.ticker_news.consensus}</h2>
                 <h2>Explanation & reasons</h2>
                 <p>{st.session_state.ticker_news.explanation}</p>
                 <p>{st.session_state.ticker_news.reason}</p>
+                <p>{st.session_state.ticker_news.oai_explanation}</p>
+                <h2>Recent news</h2>
+                <p>{st.session_state.ticker_news.oai_recent_news}</p>
                 <h2>News summaries</h2>
                 {st.session_state.ticker_news.to_news()}
               </div>

bullish/database/alembic/versions/b36c310f49ec_.py

@@ -0,0 +1,43 @@
+"""
+
+Revision ID: b36c310f49ec
+Revises: 260fcff7212e
+Create Date: 2025-08-14 22:39:38.207093
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import sqlite
+import sqlmodel
+
+# revision identifiers, used by Alembic.
+revision: str = "b36c310f49ec"
+down_revision: Union[str, None] = "cc28171c21a4"
+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! ###
+    op.create_table(
+        "openai",
+        sa.Column("symbol", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("news_date", sa.Date(), nullable=False),
+        sa.Column("high_price_target", sa.Float(), nullable=True),
+        sa.Column("low_price_target", sa.Float(), nullable=True),
+        sa.Column("recent_news", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("recommendation", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("explanation", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.PrimaryKeyConstraint("symbol", "news_date"),
+    )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table("openai")
+    # ### end Alembic commands ###

bullish/database/alembic/versions/c828e29e1105_.py

@@ -0,0 +1,87 @@
+"""
+
+Revision ID: c828e29e1105
+Revises: b36c310f49ec
+Create Date: 2025-08-15 17:57:09.541454
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import sqlite
+import sqlmodel
+
+# revision identifiers, used by Alembic.
+revision: str = "c828e29e1105"
+down_revision: Union[str, None] = "b36c310f49ec"
+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("oai_high_price_target", sa.Float(), nullable=True)
+        )
+        batch_op.add_column(
+            sa.Column("oai_low_price_target", sa.Float(), nullable=True)
+        )
+        batch_op.add_column(sa.Column("oai_news_date", sa.DateTime(), nullable=True))
+        batch_op.add_column(
+            sa.Column(
+                "oai_recent_news", sqlmodel.sql.sqltypes.AutoString(), nullable=True
+            )
+        )
+        batch_op.add_column(
+            sa.Column(
+                "oai_recommendation", sqlmodel.sql.sqltypes.AutoString(), nullable=True
+            )
+        )
+        batch_op.add_column(
+            sa.Column(
+                "oai_explanation", sqlmodel.sql.sqltypes.AutoString(), nullable=True
+            )
+        )
+        batch_op.create_index(
+            "ix_analysis_oai_explanation", ["oai_explanation"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_oai_high_price_target", ["oai_high_price_target"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_oai_low_price_target", ["oai_low_price_target"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_oai_news_date", ["oai_news_date"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_oai_recent_news", ["oai_recent_news"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_oai_recommendation", ["oai_recommendation"], 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_oai_recommendation")
+        batch_op.drop_index("ix_analysis_oai_recent_news")
+        batch_op.drop_index("ix_analysis_oai_news_date")
+        batch_op.drop_index("ix_analysis_oai_low_price_target")
+        batch_op.drop_index("ix_analysis_oai_high_price_target")
+        batch_op.drop_index("ix_analysis_oai_explanation")
+        batch_op.drop_column("oai_explanation")
+        batch_op.drop_column("oai_recommendation")
+        batch_op.drop_column("oai_recent_news")
+        batch_op.drop_column("oai_news_date")
+        batch_op.drop_column("oai_low_price_target")
+        batch_op.drop_column("oai_high_price_target")
+
+    # ### end Alembic commands ###

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 ###

bullish/database/crud.py

@@ -3,7 +3,7 @@ import logging
 from datetime import date
 from functools import cached_property
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, List, Optional
+from typing import TYPE_CHECKING, Any, List, Optional, Dict
 
 import pandas as pd
 from bearish.database.crud import BearishDb  # type: ignore
@@ -22,6 +22,7 @@ from bullish.analysis.constants import Industry, IndustryGroup, Sector, Country
 from bullish.analysis.filter import FilteredResults
 from bullish.analysis.indicators import SignalSeries
 from bullish.analysis.industry_views import Type, IndustryView
+
 from bullish.database.schemas import (
     AnalysisORM,
     JobTrackerORM,
@@ -29,6 +30,7 @@ from bullish.database.schemas import (
     IndustryViewORM,
     SignalSeriesORM,
     BacktestResultORM,
+    OpenAINewsORM,
 )
 from bullish.database.scripts.upgrade import upgrade
 from bullish.exceptions import DatabaseFileNotFoundError
@@ -38,6 +40,7 @@ from tickermood.database.scripts.upgrade import upgrade as tickermood_upgrade  #
 
 if TYPE_CHECKING:
     from bullish.analysis.backtest import BacktestResult, BacktestResultQuery
+    from bullish.analysis.openai import OpenAINews
 
 logger = logging.getLogger(__name__)
 
@@ -358,11 +361,52 @@ class BullishDb(BearishDb, BullishDbBase):  # type: ignore
             LIMIT  1
         """
         )
+        sql_oai = text(
+            """
+            SELECT *
+            FROM   openai
+            WHERE  symbol = :symbol
+            ORDER  BY news_date DESC
+            LIMIT  1
+        """
+        )
 
         with Session(self._engine) as session:
             row = session.execute(sql, {"symbol": symbol}).mappings().one_or_none()
+            row_oai = (
+                session.execute(sql_oai, {"symbol": symbol}).mappings().one_or_none()
+            )
+            row_dict = {}
             if row:
                 row_dict = dict(row)
                 row_dict = row_dict | {"news_date": row_dict["date"]}
-                return SubjectAnalysis.model_validate(row_dict)
-            return None
+            if row_oai:
+                row_dict_oai = dict(row_oai)
+                row_dict = row_dict | {
+                    "oai_news_date": row_dict_oai.get("news_date"),
+                    "oai_recent_news": row_dict_oai.get("recent_news"),
+                    "oai_recommendation": row_dict_oai.get("recommendation"),
+                    "oai_explanation": row_dict_oai.get("explanation"),
+                    "oai_high_price_target": row_dict_oai.get("high_price_target"),
+                    "oai_low_price_target": row_dict_oai.get("low_price_target"),
+                }
+
+            return SubjectAnalysis.model_validate(row_dict)
+
+    def write_many_openai_news(self, openai_news: List["OpenAINews"]) -> None:
+        with Session(self._engine) as session:
+            stmt = (
+                insert(OpenAINewsORM)
+                .prefix_with("OR REPLACE")
+                .values([a.model_dump() for a in openai_news])
+            )
+            session.exec(stmt)  # type: ignore
+            session.commit()
+
+    def update_analysis(self, symbol: str, fields: Dict[str, Any]) -> None:
+        with Session(self._engine) as session:
+            stmt = (
+                update(AnalysisORM).where(AnalysisORM.symbol == symbol).values(**fields)  # type: ignore
+            )
+            session.exec(stmt)  # type: ignore
+            session.commit()

bullish/database/schemas.py

@@ -1,3 +1,4 @@
+from datetime import date
 from typing import Dict, Any, List, Optional
 
 from sqlmodel import Field, SQLModel
@@ -7,6 +8,7 @@ from bullish.analysis.backtest import BacktestResult
 from bullish.analysis.filter import FilteredResults
 from bullish.analysis.indicators import SignalSeries
 from bullish.analysis.industry_views import IndustryView
+from bullish.analysis.openai import OpenAINews
 
 from bullish.jobs.models import JobTracker
 from sqlalchemy import Index
@@ -22,6 +24,13 @@ dynamic_indexes = tuple(
 )
 
 
+class OpenAINewsORM(SQLModel, OpenAINews, table=True):
+    __tablename__ = "openai"
+    __table_args__ = {"extend_existing": True}  # noqa:RUF012
+    symbol: str = Field(primary_key=True)
+    news_date: date = Field(primary_key=True)
+
+
 class AnalysisORM(BaseTable, Analysis, table=True):
     __tablename__ = "analysis"
     __table_args__ = {"extend_existing": True}  # noqa:RUF012

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

bullish/interface/interface.py

@@ -1,7 +1,7 @@
 import abc
 import logging
 from datetime import date
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
 
 import pandas as pd
 from bearish.interface.interface import BearishDbBase  # type: ignore
@@ -15,6 +15,7 @@ from bullish.analysis.constants import Industry, Sector, IndustryGroup, Country
 from bullish.analysis.filter import FilterQuery, FilteredResults
 from bullish.analysis.indicators import SignalSeries
 from bullish.analysis.industry_views import Type, IndustryView
+from bullish.analysis.openai import OpenAINews
 from bullish.jobs.models import JobTracker, JobTrackerStatus, add_icons
 
 logger = logging.getLogger(__name__)
@@ -155,3 +156,8 @@ class BullishDbBase(BearishDbBase):  # type: ignore
 
     @abc.abstractmethod
     def read_subject(self, symbol: str) -> Optional[SubjectAnalysis]: ...
+    @abc.abstractmethod
+    def write_many_openai_news(self, openai_news: List[OpenAINews]) -> None: ...
+
+    @abc.abstractmethod
+    def update_analysis(self, symbol: str, fields: Dict[str, Any]) -> None: ...

bullish/jobs/tasks.py

@@ -15,6 +15,7 @@ from .models import JobTrackerStatus, JobTracker, JobType
 from ..analysis.analysis import run_analysis, run_signal_series_analysis
 from ..analysis.backtest import run_many_tests, BackTestConfig
 from ..analysis.industry_views import compute_industry_view
+from ..analysis.openai import get_open_ai_news
 from ..analysis.predefined_filters import predefined_filters, load_custom_filters
 from ..database.crud import BullishDb
 from bullish.analysis.filter import FilterUpdate
@@ -186,6 +187,23 @@ def news(
     headless: bool = True,
     task: Optional[Task] = None,
 ) -> None:
+    bullish_db = BullishDb(database_path=database_path)
+    if get_open_ai_news(bullish_db, symbols):
+        for symbol in symbols:
+            subject = bullish_db.read_subject(symbol)
+            if subject:
+                logger.debug(
+                    f"extracting news for {symbol} subject: {subject.model_dump()}"
+                )
+                bullish_db.update_analysis(
+                    symbol,
+                    subject.model_dump(
+                        exclude_none=True,
+                        exclude_unset=True,
+                        exclude_defaults=True,
+                        exclude={"symbol"},
+                    ),
+                )
     base_news(
         database_path=database_path,
         job_type=job_type,
@@ -195,7 +213,7 @@ def news(
     )
 
 
-@huey.periodic_task(crontab(minute="0", hour="3"), context=True)  # type: ignore
+@huey.periodic_task(crontab(minute="0", hour="8"), context=True)  # type: ignore
 def cron_news(
     task: Optional[Task] = None,
 ) -> None:

{bullishpy-0.66.0.dist-info → bullishpy-0.68.0.dist-info}/METADATA

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

{bullishpy-0.66.0.dist-info → bullishpy-0.68.0.dist-info}/RECORD

@@ -1,15 +1,16 @@
 bullish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bullish/analysis/analysis.py,sha256=Bcupt-qROPddj1hGTNAY8vhu0pnFqNvXoDtUNhRXErY,24217
+bullish/analysis/analysis.py,sha256=SVAWg0a3-B3mtDwEDatTtjxie_EhH37l02O7gXMvxOw,24614
 bullish/analysis/backtest.py,sha256=x91ek5kOzJHvYq0TmJh1Q8wBDDduIaieE0zDaoZFXew,14325
 bullish/analysis/constants.py,sha256=j3vQwjGhY-4dEEV-TkeKMDUTo2GM7M97Hcpi19LDcFQ,11458
-bullish/analysis/filter.py,sha256=DB6uqPDdHbeaBri43uJvc-RkSEjNsnpyyW0trtHPcUo,9327
-bullish/analysis/functions.py,sha256=CuMgOjpQeg4KsDMUBdHRlxL1dRlos16KRyLhQe8PYUQ,14819
-bullish/analysis/indicators.py,sha256=Seig6LaY6qr8QhgWF_qKNR68GSer9HN0VZIkAMfdUXc,27649
+bullish/analysis/filter.py,sha256=VvQALnYNyYylXkorYR3oGhsF4L_sAUSE7-aop4Trp9o,9326
+bullish/analysis/functions.py,sha256=lrbPvTo3GLtylDCfeIKoXCKF5gaY5QFFToNqtuj7xhI,15794
+bullish/analysis/indicators.py,sha256=kdjDVhIFiDBhezJJg9ifGheMC6oCR0gC87d_FiW_tjI,28183
 bullish/analysis/industry_views.py,sha256=-B4CCAYz2arGQtWTXLLMpox0loO_MGdVQd2ycCRMOQQ,6799
-bullish/analysis/predefined_filters.py,sha256=zIp1po5SOIwqfEbzmrdV6frfxUAb7RZ8o5HFyoyoGqQ,11512
+bullish/analysis/openai.py,sha256=RK-1GbuBUKY1jR1S9PE4w6zMp7l_sY9BlSh9bLT8HbI,3313
+bullish/analysis/predefined_filters.py,sha256=E65qrTSaDFuUxoaeZ8D72K5AobumobpQdpcTIF308D4,14053
 bullish/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bullish/app/app.py,sha256=7hWVVd2jBM-Es9S904ck1mtIMSadWgFqwns0bTwrKOU,16720
+bullish/app/app.py,sha256=dnTzlyKrG2XTKDeLnJwfdvIf24eXM8fd29bvJWmMr8k,17190
 bullish/cli.py,sha256=yYqiEQAvOIQ-pTn77RPuE449gwaEGBeQwNHHAJ5yQDM,2739
 bullish/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/database/alembic/README,sha256=heMzebYwlGhnE8_4CWJ4LS74WoEZjBy-S-mIJRxAEKI,39
@@ -31,33 +32,36 @@ bullish/database/alembic/versions/6d252e23f543_.py,sha256=izF-ejdXk733INkAokGqjA
 bullish/database/alembic/versions/73564b60fe24_.py,sha256=MTlDRDNHj3E9gK7IMeAzv2UxxxYtWiu3gI_9xTLE-wg,1008
 bullish/database/alembic/versions/79bc71ec6f9e_.py,sha256=4nShut2NEd1F3piSckIIBtke0GEsFAxYw5TZl5YYRzc,1140
 bullish/database/alembic/versions/ae444f338124_.py,sha256=u8RphcniLCQce-HvN666QgCJpLsv6A91-a4R-Nif4bU,3672
+bullish/database/alembic/versions/b36c310f49ec_.py,sha256=L0B3wyo9i0R14_H5fcDAxAm_5P1zIFsHUY888Do-pbI,1379
 bullish/database/alembic/versions/b76079e9845f_.py,sha256=W8eeTABjI9tT1dp3hlK7g7tiKqDhmA8AoUX9Sw-ykLI,1165
 bullish/database/alembic/versions/bf6b86dd5463_.py,sha256=fKB8knCprGmiL6AEyFdhybVmB7QX_W4MPFF9sPzUrSM,1094
+bullish/database/alembic/versions/c828e29e1105_.py,sha256=rO9qwNay8HohSVHIJgYq7VWhtgn-jpF10h98WCu-wjU,3052
+bullish/database/alembic/versions/cc28171c21a4_.py,sha256=ZsHFzqo6cfTXDodxaXRzkoKl0zK2TR15nD4SJeDlRi0,1401
 bullish/database/alembic/versions/d0e58e050845_.py,sha256=x_LS3J27FNyy_WD99uvZzNehly-jpgn9abOYN-VjjZc,1164
 bullish/database/alembic/versions/d663166c531d_.py,sha256=U92l6QXqPniAYrPeu2Bt77ReDbXveLj4aGXtgd806JY,1915
 bullish/database/alembic/versions/ec25c8fa449f_.py,sha256=8Yts74KEjK4jg20zIo90_0atw-sOBuE3hgCKl-rfS5E,2271
 bullish/database/alembic/versions/ee5baabb35f8_.py,sha256=nBMEY-_C8AsSXVPyaDdUkwrFFo2gxShzJhmrjejDwtc,1632
 bullish/database/alembic/versions/fc191121f522_.py,sha256=0sstF6TpAJ09-Mt-Vek9SdSWksvi4C58a5D92rBtuY8,1894
 bullish/database/alembic/versions/ff0cc4ba40ec_.py,sha256=74lxga54ig_LoNZYK9toJL9iRwGbNRezh1zvO1YI40U,2719
-bullish/database/crud.py,sha256=69dq-vvhPQI3aopGIwaBSowBW37EGUnN0f7olVbOmEM,14180
-bullish/database/schemas.py,sha256=fQ4RZeOjlFoIor7rjwpisbHRNDd7-zbyDdzNKaiNGQQ,3637
+bullish/database/crud.py,sha256=5fcnOQftnf1YtRA_ndcKOihyO0sREnu_vLyC-_6Quik,15888
+bullish/database/schemas.py,sha256=HudFJ9lsIkVaEYjQUWammrsDnYSmEe4hOCbim3dN_4A,3946
 bullish/database/scripts/create_revision.py,sha256=rggIf-3koPqJNth8FIg89EOfnIM7a9QrvL8X7UJsP0g,628
 bullish/database/scripts/stamp.py,sha256=PWgVUEBumjNUMjTnGw46qmU3p221LeN-KspnW_gFuu4,839
 bullish/database/scripts/upgrade.py,sha256=-Gz7aFNPEt9y9e1kltqXE76-j_8QeNtet_VlwY5AWjo,806
 bullish/database/settings.py,sha256=nMudufmF7iC_62_PHrGSMjlqDLN2I0qTbtz9JKZHSko,164
 bullish/exceptions.py,sha256=4z_i-dD-CDz1bkGmZH9DOf1L_awlCPCgdUDPF7dhWAI,106
 bullish/figures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bullish/figures/figures.py,sha256=EpJQOiSqSp7cHvZoGlZrF6UVpyv-fFyDApAfskqdUkU,4562
+bullish/figures/figures.py,sha256=aeMAZGr8HkcF6CIf8ed4cnxJ1YkOY2-euP5egwm0ELk,4750
 bullish/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bullish/interface/interface.py,sha256=R2qVEMyBl9mBlPUO40zXp4vhfLKH7pgl_u2BmAVlD4w,5250
+bullish/interface/interface.py,sha256=6uZAY19WNtDRKdOitqzqMEo6JTep2M3HC8iFUKYntHA,5518
 bullish/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/jobs/app.py,sha256=5MJ5KXUo7JSNAvOPgkpIMasD11VTrjQvGzM7vmCY65E,77
 bullish/jobs/models.py,sha256=rBXxtGFBpgZprrxq5_X2Df-bh8BLYEfw-VLMRucrqa8,784
-bullish/jobs/tasks.py,sha256=7_zKZaLpbmh7XxvjhfWcowdDAp9sEABULB2PSkasfbM,6509
+bullish/jobs/tasks.py,sha256=13oK53fBXd5pjMLLMeOoQ4vG-yH-6dfrodhb9KzAYVw,7230
 bullish/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/utils/checks.py,sha256=g-5QXNWNe1_BwHKrc2PtvPiLraL0tqGgxnzG7u-Wkgo,2189
-bullishpy-0.66.0.dist-info/LICENSE,sha256=nYb7AJFegu6ndlQhbbk54MjT-GH-0x9RF6Ls-ggJ_g4,1075
-bullishpy-0.66.0.dist-info/METADATA,sha256=tR47cS9eMeBPdoTLVQ7y99ZvPtMAl8lTpxKLnL3faKk,3009
-bullishpy-0.66.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-bullishpy-0.66.0.dist-info/entry_points.txt,sha256=eaPpmL6vmSBFo0FBtwibCXGqAW4LFJ83whJzT1VjD-0,43
-bullishpy-0.66.0.dist-info/RECORD,,
+bullishpy-0.68.0.dist-info/LICENSE,sha256=nYb7AJFegu6ndlQhbbk54MjT-GH-0x9RF6Ls-ggJ_g4,1075
+bullishpy-0.68.0.dist-info/METADATA,sha256=VSQAgksxrpSo6pc0TdVZoL7WAbZgPS2n-a4ShDUxX64,3009
+bullishpy-0.68.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+bullishpy-0.68.0.dist-info/entry_points.txt,sha256=eaPpmL6vmSBFo0FBtwibCXGqAW4LFJ83whJzT1VjD-0,43
+bullishpy-0.68.0.dist-info/RECORD,,