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

bullish/analysis/predefined_filters.py

@@ -3,7 +3,7 @@ import json
 import os
 from datetime import timedelta
 from pathlib import Path
-from typing import Dict, Any, Optional, List, Union, get_args
+from typing import Dict, Any, Optional, List, Union, get_args, Tuple
 
 from bullish.analysis.analysis import AnalysisView
 from bullish.analysis.backtest import (
@@ -12,7 +12,12 @@ from bullish.analysis.backtest import (
     BacktestQueryRange,
     BacktestQuerySelection,
 )
-from bullish.analysis.constants import Europe, Us
+from bullish.analysis.constants import (
+    Europe,
+    Us,
+    HighGrowthIndustry,
+    DefensiveIndustries,
+)
 from bullish.analysis.filter import FilterQuery, BOOLEAN_GROUP_MAPPING
 from pydantic import BaseModel, Field
 
@@ -20,11 +25,15 @@ from bullish.analysis.indicators import Indicators
 from bullish.database.crud import BullishDb
 
 DATE_THRESHOLD = [
-    datetime.date.today() - datetime.timedelta(days=7),
+    datetime.date.today() - datetime.timedelta(days=2),
     datetime.date.today(),
 ]
 
 
+def _get_variants(variants: List[str]) -> List[Tuple[str, ...]]:
+    return [tuple(variants[:i]) for i in range(1, len(variants) + 1)]
+
+
 class NamedFilterQuery(FilterQuery):
     name: str
     description: Optional[str] = None
@@ -126,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 = {
@@ -152,102 +173,154 @@ class NamedFilterQuery(FilterQuery):
         }
         return self._custom_variant("Poor Performers", properties)
 
-    def short_term_profitability(self) -> "NamedFilterQuery":
+    def yearly_fundamentals(self) -> "NamedFilterQuery":
         properties = {
             "income": [
                 "positive_operating_income",
                 "positive_net_income",
+                "growing_net_income",
+                "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": [
-                "positive_free_cash_flow",
                 "quarterly_positive_free_cash_flow",
             ],
-            "eps": [
-                "positive_basic_eps",
-                "positive_diluted_eps",
-                "quarterly_positive_basic_eps",
-                "quarterly_positive_diluted_eps",
-            ],
             "properties": [
-                "positive_return_on_assets",
-                "positive_return_on_equity",
-                "positive_debt_to_equity",
-                "operating_cash_flow_is_higher_than_net_income",
-                "quarterly_positive_return_on_assets",
-                "quarterly_positive_return_on_equity",
-                "quarterly_positive_debt_to_equity",
                 "quarterly_operating_cash_flow_is_higher_than_net_income",
             ],
         }
-        return self._custom_variant("Short-term profitability", properties)
+        return self._custom_variant("Quarterly Fundamentals", properties)
 
-    def long_term_profitability(self) -> "NamedFilterQuery":
+    def growing_quarterly_fundamentals(self) -> "NamedFilterQuery":
         properties = {
             "income": [
-                "growing_net_income",
-                "growing_operating_income",
+                "quarterly_positive_operating_income",
+                "quarterly_positive_net_income",
                 "quarterly_growing_net_income",
-                "quarterly_growing_operating_income",
             ],
             "cash_flow": [
-                "growing_operating_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",
-                "quarterly_growing_basic_eps",
-                "quarterly_growing_diluted_eps",
+                "positive_diluted_eps",  # or positive_basic_eps if diluted not available
+            ],
+            "properties": [
+                "positive_return_on_equity",
+                "operating_cash_flow_is_higher_than_net_income",
             ],
         }
-        return self._custom_variant("Long-term profitability", properties)
-
-    def variants(self) -> List["NamedFilterQuery"]:
-        variants_ = [
-            self.country_variant("Europe", list(get_args(Europe))),
-            self.country_variant("Us", list(get_args(Us))),
-            self.country_variant("Europe", list(get_args(Europe))).top_performers(),
-            self.country_variant("Us", list(get_args(Us))).top_performers(),
-            self.country_variant("Europe", list(get_args(Europe))).poor_performers(),
-            self.country_variant("Us", list(get_args(Us))).poor_performers(),
-            self.country_variant("Europe", list(get_args(Europe)))
-            .update_indicator_filter("RSI 30", "rsi_bullish_crossover_30")
-            .update_indicator_filter("MACD", "macd_12_26_9_bullish_crossover"),
-            self.country_variant("Europe", list(get_args(Europe)))
-            .update_indicator_filter("RSI 40", "rsi_bullish_crossover_40")
-            .update_indicator_filter("MACD", "macd_12_26_9_bullish_crossover"),
-            self.country_variant("Europe", list(get_args(Europe)))
-            .update_indicator_filter("RSI Neutral", "rsi_neutral")
-            .update_indicator_filter("MACD", "macd_12_26_9_bullish_crossover"),
-            self.country_variant("Us", list(get_args(Us)))
-            .update_indicator_filter("RSI 30", "rsi_bullish_crossover_30")
-            .update_indicator_filter("MACD", "macd_12_26_9_bullish_crossover"),
-            self.country_variant("Us", list(get_args(Us)))
-            .update_indicator_filter("RSI 40", "rsi_bullish_crossover_40")
-            .update_indicator_filter("MACD", "macd_12_26_9_bullish_crossover"),
-            self.country_variant("Us", list(get_args(Us)))
-            .update_indicator_filter("RSI Neutral", "rsi_neutral")
-            .update_indicator_filter("MACD", "macd_12_26_9_bullish_crossover"),
-        ]
-        variants_short_term_profitability = [
-            v.short_term_profitability() for v in variants_
-        ]
-        variants_long_term_profitability = [
-            v.long_term_profitability() for v in variants_
-        ]
-        return [
-            *variants_,
-            *variants_short_term_profitability,
-            *variants_long_term_profitability,
-        ]
+        return self._custom_variant("Min Fundamentals", properties)
+
+    def high_growth(self) -> "NamedFilterQuery":
+        properties = {"industry": list(get_args(HighGrowthIndustry))}
+        return self._custom_variant("Growth", properties)
+
+    def defensive(self) -> "NamedFilterQuery":
+        properties = {"industry": list(get_args(DefensiveIndustries))}
+        return self._custom_variant("Defensive", properties)
+
+    def cheap(self) -> "NamedFilterQuery":
+        properties = {"last_price": [1, 30]}
+        return self._custom_variant("Cheap", properties)
+
+    def europe(self) -> "NamedFilterQuery":
+        return self.country_variant("Europe", list(get_args(Europe)))
+
+    def us(self) -> "NamedFilterQuery":
+        return self.country_variant("Us", list(get_args(Us)))
+
+    def rsi_30(self) -> "NamedFilterQuery":
+        return self.update_indicator_filter("RSI 30", "rsi_bullish_crossover_30")
+
+    def rsi_40(self) -> "NamedFilterQuery":
+        return self.update_indicator_filter("RSI 40", "rsi_bullish_crossover_40")
+
+    def macd(self) -> "NamedFilterQuery":
+        return self.update_indicator_filter("MACD", "macd_12_26_9_bullish_crossover")
+
+    def rsi_neutral_(self) -> "NamedFilterQuery":
+        return self.update_indicator_filter("RSI Neutral", "rsi_neutral")
+
+    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()
+            | {
+                "name": f"{self.name} (Earnings Date)",
+                "next_earnings_date": [
+                    datetime.date.today(),
+                    datetime.date.today() + timedelta(days=20),
+                ],
+            }
+        )
+
+    def variants(
+        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_ = []
+        for attributes in _variants:
+            filter__ = self
+            for attr in attributes:
+                filter__ = getattr(filter__, attr)()
+            filters_.append(filter__)
+
+        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 []
 
 
@@ -264,57 +337,52 @@ SMALL_CAP = NamedFilterQuery(
     market_capitalization=[5e7, 5e8],
     properties=["positive_debt_to_equity"],
     average_volume_30=[50000, 5e9],
-    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],
     order_by_desc="market_capitalization",
-).variants()
+).variants(
+    variants=[
+        ["week_top_performers", "min_fundamentals"],
+        ["month_top_performers", "min_fundamentals"],
+        ["earnings_date", "min_fundamentals"],
+        ["rsi_oversold_", "min_fundamentals"],
+    ]
+)
 
 LARGE_CAPS = NamedFilterQuery(
-    name="Large caps",
+    name="Large Cap",
     order_by_desc="market_capitalization",
     market_capitalization=[1e10, 1e14],
-).variants()
+).variants(
+    variants=[
+        ["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"],
+    ]
+)
 
 MID_CAPS = NamedFilterQuery(
-    name="Mid-caps",
+    name="Mid Cap",
     order_by_desc="market_capitalization",
     market_capitalization=[5e8, 1e10],
-).variants()
-
-NEXT_EARNINGS_DATE = NamedFilterQuery(
-    name="Next Earnings date",
-    order_by_desc="market_capitalization",
-    next_earnings_date=[
-        datetime.date.today(),
-        datetime.date.today() + timedelta(days=20),
-    ],
-).variants()
-SEMICONDUCTORS = NamedFilterQuery(
-    name="Semiconductors",
-    order_by_desc="market_capitalization",
-    industry=["Semiconductors"],
-).variants()
-SOFTWARE = NamedFilterQuery(
-    name="Software - Application",
-    order_by_desc="market_capitalization",
-    industry=["Software - Application"],
-).variants()
+).variants(
+    variants=[
+        ["week_top_performers"],
+        ["month_top_performers"],
+        ["earnings_date", "quarterly_fundamentals", "yearly_fundamentals"],
+        ["rsi_oversold_", "macd", "adx"],
+    ]
+)
 
 
 def predefined_filters() -> list[NamedFilterQuery]:
     return [
+        *load_custom_filters(),
         *SMALL_CAP,
-        *LARGE_CAPS,
-        *NEXT_EARNINGS_DATE,
         *MID_CAPS,
-        *SEMICONDUCTORS,
-        *SOFTWARE,
-        *load_custom_filters(),
+        *LARGE_CAPS,
     ]
 
 

bullish/app/app.py

@@ -35,6 +35,7 @@ from bullish.utils.checks import (
     compatible_bullish_database,
     empty_analysis_table,
 )
+from mysec.services import sec  # type: ignore
 
 CACHE_SHELVE = "user_cache"
 DB_KEY = "db_path"
@@ -80,7 +81,7 @@ def on_table_select() -> None:
 
     db = bearish_db(st.session_state.database_path)
     if st.session_state.data.empty or (
-        not st.session_state.data.iloc[row]["symbol"].to_numpy()
+        not st.session_state.data.iloc[row]["symbol"].to_numpy().size > 0
     ):
         return
 
@@ -123,7 +124,7 @@ def dialog_pick_database() -> None:
                 f"The database {db_path} has not the necessary data to run this application. "
                 "A backround job will be started to update the data."
             )
-            analysis(db_path)
+            analysis(db_path, "Update analysis")
         st.rerun()
     if event is None:
         st.stop()
@@ -290,15 +291,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>
@@ -414,13 +421,15 @@ def main() -> None:
 
     if st.session_state.database_path is None:
         dialog_pick_database()
+    if "initialized" not in st.session_state:
         initialize(
             database_path=st.session_state.database_path,
             job_type="Initialize",
         )
+        st.session_state.initialized = True
     bearish_db_ = bearish_db(st.session_state.database_path)
 
-    charts_tab, jobs_tab = st.tabs(["Charts", "Jobs"])
+    charts_tab, jobs_tab, sec_tab = st.tabs(["Charts", "Jobs", "Sec"])
     if "data" not in st.session_state:
         st.session_state.data = load_analysis_data(bearish_db_)
 
@@ -471,6 +480,8 @@ def main() -> None:
             use_container_width=True,
             hide_index=True,
         )
+    with sec_tab:
+        st.plotly_chart(sec(bearish_db_), use_container_width=True)
 
 
 if __name__ == "__main__":

bullish/database/alembic/versions/65662e214031_.py

@@ -0,0 +1,48 @@
+"""
+
+Revision ID: 65662e214031
+Revises: 660897c02c00
+Create Date: 2025-08-20 17:30:47.973725
+
+"""
+
+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 = "65662e214031"
+down_revision: Union[str, None] = "660897c02c00"
+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("downside", sa.Float(), nullable=True))
+        batch_op.add_column(sa.Column("oai_moat", sa.Boolean(), nullable=True))
+        batch_op.create_index("ix_analysis_downside", ["downside"], unique=False)
+        batch_op.create_index("ix_analysis_oai_moat", ["oai_moat"], unique=False)
+
+    with op.batch_alter_table("openai", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("moat", sa.Boolean(), nullable=True))
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("openai", schema=None) as batch_op:
+        batch_op.drop_column("moat")
+
+    with op.batch_alter_table("analysis", schema=None) as batch_op:
+        batch_op.drop_index("ix_analysis_oai_moat")
+        batch_op.drop_index("ix_analysis_downside")
+        batch_op.drop_column("oai_moat")
+        batch_op.drop_column("downside")
+
+    # ### end Alembic commands ###

bullish/database/alembic/versions/660897c02c00_.py

@@ -0,0 +1,36 @@
+"""
+
+Revision ID: 660897c02c00
+Revises: c828e29e1105
+Create Date: 2025-08-20 17:19:05.423318
+
+"""
+
+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 = "660897c02c00"
+down_revision: Union[str, None] = "c828e29e1105"
+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("rsi", sa.Float(), nullable=True))
+        batch_op.create_index("ix_analysis_rsi", ["rsi"], 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_rsi")
+        batch_op.drop_column("rsi")

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