bullishpy 0.28.0__tar.gz → 0.30.0__tar.gz

{bullishpy-0.28.0 → bullishpy-0.30.0}/PKG-INFO

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

{bullishpy-0.28.0 → bullishpy-0.30.0}/bullish/analysis/analysis.py

@@ -1,5 +1,6 @@
 import logging
 import time
+from datetime import date
 from itertools import batched, chain
 from pathlib import Path
 from typing import (
@@ -15,7 +16,6 @@ from typing import (
 )
 
 import pandas as pd
-from bearish.interface.interface import BearishDbBase  # type: ignore
 from bearish.models.assets.equity import BaseEquity  # type: ignore
 from bearish.models.base import (  # type: ignore
     DataSourceBase,
@@ -87,10 +87,10 @@ def _compute_growth(series: pd.Series) -> bool:
     return all(series.pct_change(fill_method=None).dropna() > 0)
 
 
-def _all_positive(series: pd.Series) -> bool:
+def _all_positive(series: pd.Series, threshold: int = 0) -> bool:
     if series.empty:
         return False
-    return all(series.dropna() > 0)
+    return all(series.dropna() > threshold)
 
 
 def _get_last(data: pd.Series) -> Optional[float]:
@@ -274,7 +274,7 @@ class BaseFundamentalAnalysis(BaseModel):
             debt_to_equity = (
                 balance_sheet.total_liabilities / balance_sheet.total_shareholder_equity
             ).dropna()
-            positive_debt_to_equity = _all_positive(debt_to_equity)
+            positive_debt_to_equity = _all_positive(debt_to_equity, threshold=1)
 
             # Add relevant balance sheet data to financials
             financial["total_shareholder_equity"] = balance_sheet[
@@ -433,6 +433,10 @@ class FundamentalAnalysis(YearlyFundamentalAnalysis, QuarterlyFundamentalAnalysi
         ]
 
 
+class AnalysisEarningsDate(BaseModel):
+    next_earnings_date: Optional[date] = None
+
+
 class AnalysisView(BaseModel):
     sector: Annotated[
         Optional[str],
@@ -484,15 +488,15 @@ class AnalysisView(BaseModel):
             default=None,
         ),
     ]
-    median_yearly_growth: Optional[float] = None
-    median_weekly_growth: Optional[float] = None
-    median_monthly_growth: Optional[float] = None
+    yearly_growth: Optional[float] = None
+    weekly_growth: Optional[float] = None
+    monthly_growth: Optional[float] = None
 
 
-class Analysis(AnalysisView, BaseEquity, TechnicalAnalysis, FundamentalAnalysis):  # type: ignore
+class Analysis(AnalysisEarningsDate, AnalysisView, BaseEquity, TechnicalAnalysis, FundamentalAnalysis):  # type: ignore
 
     @classmethod
-    def from_ticker(cls, bearish_db: BearishDbBase, ticker: Ticker) -> "Analysis":
+    def from_ticker(cls, bearish_db: "BullishDb", ticker: Ticker) -> "Analysis":
         asset = bearish_db.read_assets(
             AssetQuery(
                 symbols=Symbols(equities=[ticker]),
@@ -504,11 +508,13 @@ class Analysis(AnalysisView, BaseEquity, TechnicalAnalysis, FundamentalAnalysis)
         fundamental_analysis = FundamentalAnalysis.from_financials(financials, ticker)
         prices = Prices.from_ticker(bearish_db, ticker)
         technical_analysis = TechnicalAnalysis.from_data(prices.to_dataframe(), ticker)
+        next_earnings_date = bearish_db.read_next_earnings_date(ticker.symbol)
         return cls.model_validate(
             equity.model_dump()
             | fundamental_analysis.model_dump()
             | technical_analysis.model_dump()
             | {
+                "next_earnings_date": next_earnings_date,
                 "price_per_earning_ratio": (
                     (
                         technical_analysis.last_price
@@ -518,7 +524,7 @@ class Analysis(AnalysisView, BaseEquity, TechnicalAnalysis, FundamentalAnalysis)
                     and fundamental_analysis.earning_per_share != 0
                     and fundamental_analysis.earning_per_share is not None
                     else None
-                )
+                ),
             }
         )
 

{bullishpy-0.28.0 → bullishpy-0.30.0}/bullish/analysis/constants.py

@@ -308,23 +308,20 @@ Sector = Literal[
     "Financial Services",
     "Conglomerates",
 ]
-
-SubCountry = Literal["United kingdom", "United states", "Germany", "Belgium", "France"]
+Europe = Literal["Germany", "Belgium", "France"]
+Us = Literal["United states"]
+WesternCountries = Literal["United kingdom", Europe, Us]
 Country = Literal[
+    WesternCountries,
     "Australia",
     "China",
     "Japan",
-    "United kingdom",
-    "United states",
     "Poland",
     "Switzerland",
     "Canada",
     "Greece",
     "Spain",
-    "Germany",
     "Indonesia",
-    "Belgium",
-    "France",
     "Netherlands",
     "British virgin islands",
     "Italy",

{bullishpy-0.28.0 → bullishpy-0.30.0}/bullish/analysis/filter.py

@@ -172,6 +172,10 @@ class GeneralFilter(BaseModel):
     industry_group: Optional[List[str]] = None
     sector: Optional[List[str]] = None
     symbol: Optional[List[str]] = None
+    limit: Optional[str] = None
+    next_earnings_date: List[date] = Field(
+        default=[date.today(), date.today() + datetime.timedelta(days=30 * 12)],
+    )
     market_capitalization: Optional[List[float]] = Field(default=[5e8, 1e12])
     price_per_earning_ratio: Optional[List[float]] = Field(default=[0.0, 1000.0])
 
@@ -186,11 +190,12 @@ class FilterQuery(GeneralFilter, *TechnicalAnalysisFilters, *FundamentalAnalysis
             ).items()
         )
 
-    def to_query(self) -> str:
+    def to_query(self) -> str:  # noqa: C901
         parameters = self.model_dump(exclude_defaults=True, exclude_unset=True)
         query = []
         order_by_desc = ""
         order_by_asc = ""
+        limit = None
         for parameter, value in parameters.items():
             if not value:
                 continue
@@ -207,10 +212,20 @@ class FilterQuery(GeneralFilter, *TechnicalAnalysisFilters, *FundamentalAnalysis
                 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, str) and bool(value) and parameter == "limit":
+                limit = f" LIMIT {int(value)}"
             elif (
-                isinstance(value, list)
-                and len(value) == SIZE_RANGE
-                and all(isinstance(item, (int, float)) for item in value)
+                (
+                    isinstance(value, list)
+                    and len(value) == SIZE_RANGE
+                    and all(isinstance(item, date) for item in value)
+                )
+                and parameter == "next_earnings_date"
+                or (
+                    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 (
@@ -229,7 +244,12 @@ class FilterQuery(GeneralFilter, *TechnicalAnalysisFilters, *FundamentalAnalysis
             else:
                 raise NotImplementedError
         query_ = " AND ".join(query)
-        return f"{query_} {order_by_desc.strip()} {order_by_asc.strip()}".strip()
+        query__ = f"{query_} {order_by_desc.strip()} {order_by_asc.strip()}".strip()
+        if limit is not None:
+            query__ += limit
+        else:
+            query__ += " LIMIT 1000"
+        return query__
 
 
 class FilterQueryStored(FilterQuery): ...

{bullishpy-0.28.0 → bullishpy-0.30.0}/bullish/analysis/functions.py

@@ -282,9 +282,17 @@ def compute_price(data: pd.DataFrame) -> pd.DataFrame:
     results["20_DAY_HIGH"] = data.close.rolling(window=20).max()
     results["20_DAY_LOW"] = data.close.rolling(window=20).min()
     results["LAST_PRICE"] = data.close
-    results["WEEKLY_GROWTH"] = data.close.resample("W").transform(perc)  # type: ignore
-    results["MONTHLY_GROWTH"] = data.close.resample("ME").transform(perc)  # type: ignore
-    results["YEARLY_GROWTH"] = data.close.resample("YE").transform(perc)  # type: ignore
+    results["WEEKLY_GROWTH"] = data.close.resample("W").transform(perc).ffill()  # type: ignore
+    results["MONTHLY_GROWTH"] = data.close.resample("ME").transform(perc).ffill()  # type: ignore
+    results["YEARLY_GROWTH"] = data.close.resample("YE").transform(perc).ffill()  # type: ignore
+    return results
+
+
+def compute_volume(data: pd.DataFrame) -> pd.DataFrame:
+    results = pd.DataFrame(index=data.index)
+    results["AVERAGE_VOLUME_10"] = data.volume.rolling(window=10).mean()
+    results["AVERAGE_VOLUME_30"] = data.volume.rolling(window=30).mean()
+    results["VOLUME"] = data.volume
     return results
 
 
@@ -397,6 +405,10 @@ TRANGE = IndicatorFunction(
     expected_columns=["TRANGE"],
     functions=[compute_trange, compute_pandas_ta_trange],
 )
+VOLUME = IndicatorFunction(
+    expected_columns=["AVERAGE_VOLUME_10", "AVERAGE_VOLUME_30", "VOLUME"],
+    functions=[compute_volume],
+)
 PRICE = IndicatorFunction(
     expected_columns=[
         "200_DAY_HIGH",

{bullishpy-0.28.0 → bullishpy-0.30.0}/bullish/analysis/indicators.py

@@ -20,6 +20,7 @@ from bullish.analysis.functions import (
     cross_simple,
     cross_value_series,
     find_last_true_run_start,
+    VOLUME,
 )
 
 logger = logging.getLogger(__name__)
@@ -389,6 +390,27 @@ def indicators_factory() -> List[Indicator]:
                     type=Optional[date],
                     function=lambda d: 0.6 * d["20_DAY_HIGH"] > d.LAST_PRICE,
                 ),
+                Signal(
+                    name="WEEKLY_GROWTH",
+                    description="weekly growth",
+                    type_info="Oversold",
+                    type=Optional[float],
+                    function=lambda d: d.WEEKLY_GROWTH,
+                ),
+                Signal(
+                    name="MONTHLY_GROWTH",
+                    description="Median monthly growth",
+                    type_info="Oversold",
+                    type=Optional[float],
+                    function=lambda d: d.MONTHLY_GROWTH,
+                ),
+                Signal(
+                    name="YEARLY_GROWTH",
+                    description="Median yearly growth",
+                    type_info="Oversold",
+                    type=Optional[float],
+                    function=lambda d: d.YEARLY_GROWTH,
+                ),
                 Signal(
                     name="MEDIAN_WEEKLY_GROWTH",
                     description="Median weekly growth",
@@ -419,6 +441,42 @@ def indicators_factory() -> List[Indicator]:
                         number=lambda v: np.median(v.unique())
                     ),
                 ),
+                Signal(
+                    name="LOWER_THAN_20_DAY_HIGH",
+                    description="Current price is lower than the 20-day high",
+                    type_info="Oversold",
+                    type=Optional[date],
+                    function=lambda d: 0.6 * d["20_DAY_HIGH"] > d.LAST_PRICE,
+                ),
+            ],
+        ),
+        Indicator(
+            name="VOLUME",
+            description="Volume based indicators",
+            expected_columns=VOLUME.expected_columns,
+            function=VOLUME.call,
+            signals=[
+                Signal(
+                    name="AVERAGE_VOLUME_10",
+                    type_info="Value",
+                    description="Average volume over the last 10 days",
+                    type=Optional[float],
+                    function=lambda d: d.AVERAGE_VOLUME_10,
+                ),
+                Signal(
+                    name="AVERAGE_VOLUME_30",
+                    type_info="Value",
+                    description="Average volume over the last 30 days",
+                    type=Optional[float],
+                    function=lambda d: d.AVERAGE_VOLUME_30,
+                ),
+                Signal(
+                    name="VOLUME_ABOVE_AVERAGE",
+                    type_info="Value",
+                    description="Volume above average volume over the last 30 days",
+                    type=Optional[date],
+                    function=lambda d: d.AVERAGE_VOLUME_30 < d.VOLUME,
+                ),
             ],
         ),
         Indicator(

{bullishpy-0.28.0 → bullishpy-0.30.0}/bullish/analysis/industry_views.py

@@ -23,7 +23,7 @@ from bullish.analysis.constants import (
     IndustryGroup,
     Sector,
     Country,
-    SubCountry,
+    WesternCountries,
 )
 
 if TYPE_CHECKING:
@@ -61,7 +61,7 @@ def get_industry_comparison_data(
         normalized_symbol = compute_normalized_close(symbol_data.close).rename("symbol")
         normalized_industry = industry_data.normalized_close.rename(industry)
         data = [normalized_symbol, normalized_industry]
-        for country in get_args(SubCountry):
+        for country in get_args(WesternCountries):
             views = bullish_db.read_returns(type, industry, country)
             if views:
                 industry_data = IndustryViews.from_views(views).to_dataframe()

bullishpy-0.30.0/bullish/analysis/predefined_filters.py

@@ -0,0 +1,196 @@
+import datetime
+from datetime import timedelta
+from typing import Dict, Any, Optional, List, Union, get_args
+
+from bullish.analysis.analysis import AnalysisView
+from bullish.analysis.backtest import (
+    BacktestQueryDate,
+    BacktestQueries,
+    BacktestQueryRange,
+    BacktestQuerySelection,
+)
+from bullish.analysis.constants import Europe, Us
+from bullish.analysis.filter import FilterQuery, BOOLEAN_GROUP_MAPPING
+from pydantic import BaseModel, Field
+
+from bullish.analysis.indicators import Indicators
+from bullish.database.crud import BullishDb
+
+DATE_THRESHOLD = [
+    datetime.date.today() - datetime.timedelta(days=7),
+    datetime.date.today(),
+]
+
+
+class NamedFilterQuery(FilterQuery):
+    name: str
+    description: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self.model_dump(
+            exclude_unset=True,
+            exclude_none=True,
+            exclude_defaults=True,
+            exclude={"name"},
+        )
+
+    def to_backtesting_query(
+        self, backtest_start_date: datetime.date
+    ) -> BacktestQueries:
+        queries: List[
+            Union[BacktestQueryRange, BacktestQueryDate, BacktestQuerySelection]
+        ] = []
+        in_use_backtests = Indicators().in_use_backtest()
+        for in_use in in_use_backtests:
+            value = self.to_dict().get(in_use)
+            if value and self.model_fields[in_use].annotation == List[datetime.date]:
+                delta = value[1] - value[0]
+                queries.append(
+                    BacktestQueryDate(
+                        name=in_use.upper(),
+                        start=backtest_start_date - delta,
+                        end=backtest_start_date,
+                        table="signalseries",
+                    )
+                )
+        for field in self.to_dict():
+            if field in BOOLEAN_GROUP_MAPPING:
+                value = self.to_dict().get(field)
+                if value and self.model_fields[field].annotation == Optional[List[str]]:  # type: ignore
+                    queries.extend(
+                        [
+                            BacktestQueryDate(
+                                name=v.upper(),
+                                start=backtest_start_date - timedelta(days=252),
+                                end=backtest_start_date,
+                                table="signalseries",
+                            )
+                            for v in value
+                        ]
+                    )
+
+            if field in AnalysisView.model_fields:
+                value = self.to_dict().get(field)
+                if (
+                    value
+                    and self.model_fields[field].annotation == Optional[List[float]]  # type: ignore
+                    and len(value) == 2
+                ):
+                    queries.append(
+                        BacktestQueryRange(
+                            name=field.lower(),
+                            min=value[0],
+                            max=value[1],
+                            table="analysis",
+                        )
+                    )
+                if value and self.model_fields[field].annotation == Optional[List[str]]:  # type: ignore
+                    queries.append(
+                        BacktestQuerySelection(
+                            name=field.lower(),
+                            selections=value,
+                            table="analysis",
+                        )
+                    )
+
+        return BacktestQueries(queries=queries)
+
+    def get_backtesting_symbols(
+        self, bullish_db: BullishDb, backtest_start_date: datetime.date
+    ) -> List[str]:
+        queries = self.to_backtesting_query(backtest_start_date)
+
+        return bullish_db.read_query(queries.to_query())["symbol"].tolist()  # type: ignore
+
+    def country_variant(self, suffix: str, countries: List[str]) -> "NamedFilterQuery":
+        return NamedFilterQuery.model_validate(
+            self.model_dump()
+            | {"name": f"{self.name} ({suffix})", "country": countries}
+        )
+
+    def variants(self) -> List["NamedFilterQuery"]:
+        return [
+            self.country_variant("Europe", list(get_args(Europe))),
+            self.country_variant("Us", list(get_args(Us))),
+        ]
+
+
+SMALL_CAP = NamedFilterQuery(
+    name="Small Cap",
+    last_price=[1, 20],
+    market_capitalization=[5e7, 5e8],
+    properties=["positive_debt_to_equity"],
+    average_volume_30=[50000, 5e9],
+    order_by_desc="market_capitalization",
+).variants()
+
+TOP_PERFORMERS = NamedFilterQuery(
+    name="Top Performers",
+    sma_50_above_sma_200=[
+        datetime.date.today() - datetime.timedelta(days=5000),
+        datetime.date.today() - datetime.timedelta(days=10),
+    ],
+    price_above_sma_50=[
+        datetime.date.today() - datetime.timedelta(days=5000),
+        datetime.date.today() - datetime.timedelta(days=10),
+    ],
+    volume_above_average=DATE_THRESHOLD,
+    weekly_growth=[1, 100],
+    monthly_growth=[8, 100],
+    order_by_desc="market_capitalization",
+).variants()
+
+LARGE_CAPS = NamedFilterQuery(
+    name="Large caps",
+    order_by_desc="market_capitalization",
+    limit="50",
+).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=10),
+    ],
+).variants()
+
+RSI_CROSSOVER_40 = NamedFilterQuery(
+    name="RSI cross-over 40",
+    rsi_bullish_crossover_40=DATE_THRESHOLD,
+    market_capitalization=[5e8, 1e13],
+    order_by_desc="market_capitalization",
+    country=["Germany", "United states", "France", "United kingdom", "Canada", "Japan"],
+).variants()
+
+RSI_CROSSOVER_30 = NamedFilterQuery(
+    name="RSI cross-over 30",
+    price_per_earning_ratio=[10, 500],
+    rsi_bullish_crossover_30=DATE_THRESHOLD,
+    market_capitalization=[5e8, 1e13],
+    order_by_desc="market_capitalization",
+).variants()
+
+
+def predefined_filters() -> list[NamedFilterQuery]:
+    return [
+        *SMALL_CAP,
+        *TOP_PERFORMERS,
+        *LARGE_CAPS,
+        *NEXT_EARNINGS_DATE,
+        *RSI_CROSSOVER_40,
+        *RSI_CROSSOVER_30,
+    ]
+
+
+class PredefinedFilters(BaseModel):
+    filters: list[NamedFilterQuery] = Field(default_factory=predefined_filters)
+
+    def get_predefined_filter_names(self) -> list[str]:
+        return [filter.name for filter in self.filters]
+
+    def get_predefined_filter(self, name: str) -> Dict[str, Any]:
+        for filter in self.filters:
+            if filter.name == name:
+                return filter.to_dict()
+        raise ValueError(f"Filter with name '{name}' not found.")

{bullishpy-0.28.0 → bullishpy-0.30.0}/bullish/app/app.py

@@ -146,14 +146,20 @@ def build_filter(model: Type[BaseModel], data: Dict[str, Any]) -> Dict[str, Any]
         if data.get(field) and data[field] != info.default:
             default = data[field]
         if info.annotation == Optional[List[str]]:  # type: ignore
+            mapping = groups_mapping().get(field)
+            if not mapping:
+                continue
             data[field] = st.multiselect(
                 name,
-                groups_mapping()[field],
+                mapping,
                 default=default,
                 key=hash((model.__name__, field)),
             )
         elif info.annotation == Optional[str]:  # type: ignore
-            options = ["", *groups_mapping()[field]]
+            mapping = groups_mapping().get(field)
+            if not mapping:
+                continue
+            options = ["", *mapping]
             data[field] = st.selectbox(
                 name,
                 options,
@@ -183,7 +189,7 @@ def build_filter(model: Type[BaseModel], data: Dict[str, Any]) -> Dict[str, Any]
             except Exception as e:
                 logger.error(
                     f"Error building filter for {model.__name__}.{field} "
-                    f"with the parameters {(info.annotation, name, ge, le, tuple(default))}: {e}"
+                    f"with the parameters {(info.annotation, name, ge, le)}: {e}"
                 )
                 raise e
     return data

bullishpy-0.30.0/bullish/database/alembic/versions/d0e58e050845_.py

@@ -0,0 +1,39 @@
+"""
+
+Revision ID: d0e58e050845
+Revises: ff0cc4ba40ec
+Create Date: 2025-08-05 14:02:54.407561
+
+"""
+
+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 = "d0e58e050845"
+down_revision: Union[str, None] = "ff0cc4ba40ec"
+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("next_earnings_date", sa.Date(), nullable=True))
+        batch_op.create_index(
+            "ix_analysis_next_earnings_date", ["next_earnings_date"], 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_next_earnings_date")
+        batch_op.drop_column("next_earnings_date")
+
+    # ### end Alembic commands ###

bullishpy-0.30.0/bullish/database/alembic/versions/ff0cc4ba40ec_.py

@@ -0,0 +1,69 @@
+"""
+
+Revision ID: ff0cc4ba40ec
+Revises: 79bc71ec6f9e
+Create Date: 2025-08-05 12:09:12.108606
+
+"""
+
+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 = "ff0cc4ba40ec"
+down_revision: Union[str, None] = "79bc71ec6f9e"
+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("average_volume_10", sa.Float(), nullable=True))
+        batch_op.add_column(sa.Column("average_volume_30", sa.Float(), nullable=True))
+        batch_op.add_column(sa.Column("volume_above_average", sa.Date(), nullable=True))
+        batch_op.add_column(sa.Column("weekly_growth", sa.Float(), nullable=True))
+        batch_op.add_column(sa.Column("monthly_growth", sa.Float(), nullable=True))
+        batch_op.add_column(sa.Column("yearly_growth", sa.Float(), nullable=True))
+        batch_op.create_index(
+            "ix_analysis_average_volume_10", ["average_volume_10"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_average_volume_30", ["average_volume_30"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_monthly_growth", ["monthly_growth"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_volume_above_average", ["volume_above_average"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_weekly_growth", ["weekly_growth"], unique=False
+        )
+        batch_op.create_index(
+            "ix_analysis_yearly_growth", ["yearly_growth"], 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_yearly_growth")
+        batch_op.drop_index("ix_analysis_weekly_growth")
+        batch_op.drop_index("ix_analysis_volume_above_average")
+        batch_op.drop_index("ix_analysis_monthly_growth")
+        batch_op.drop_index("ix_analysis_average_volume_30")
+        batch_op.drop_index("ix_analysis_average_volume_10")
+        batch_op.drop_column("yearly_growth")
+        batch_op.drop_column("monthly_growth")
+        batch_op.drop_column("weekly_growth")
+        batch_op.drop_column("volume_above_average")
+        batch_op.drop_column("average_volume_30")
+        batch_op.drop_column("average_volume_10")
+
+    # ### end Alembic commands ###

{bullishpy-0.28.0 → bullishpy-0.30.0}/bullish/database/crud.py

@@ -331,3 +331,13 @@ class BullishDb(BearishDb, BullishDbBase):  # type: ignore
                 return [BacktestResult.model_validate(r) for r in results]
             else:
                 return []
+
+    def read_next_earnings_date(self, symbol: str) -> Optional[date]:
+        with Session(self._engine) as session:
+            stmt = select(EarningsDateORM.date).where(
+                EarningsDateORM.symbol == symbol, EarningsDateORM.date > date.today()
+            )
+            result = session.exec(stmt).first()
+            if result:
+                return result.date()  # type: ignore
+            return None

{bullishpy-0.28.0 → bullishpy-0.30.0}/bullish/interface/interface.py

@@ -35,7 +35,7 @@ class BullishDbBase(BearishDbBase):  # type: ignore
         query_ = query.to_query()
         fields = ",".join(list(AnalysisView.model_fields))
         query_str: str = f""" 
-        SELECT {fields} FROM analysis WHERE {query_} LIMIT 1000
+        SELECT {fields} FROM analysis WHERE {query_}
         """  # noqa: S608
         return self._read_filter_query(query_str)
 
@@ -149,3 +149,6 @@ class BullishDbBase(BearishDbBase):  # type: ignore
     def read_many_backtest_results(
         self, query: Optional[BacktestResultQuery] = None
     ) -> List[BacktestResult]: ...
+
+    @abc.abstractmethod
+    def read_next_earnings_date(self, symbol: str) -> Optional[date]: ...

{bullishpy-0.28.0 → bullishpy-0.30.0}/bullish/jobs/tasks.py

@@ -111,4 +111,4 @@ def news(
     task: Optional[Task] = None,
 ) -> None:
     database_config = DatabaseConfig(database_path=database_path, no_migration=True)
-    get_news(symbols, database_config, headless=headless, model_name = "gpt-4o-mini")
+    get_news(symbols, database_config, headless=headless, model_name="gpt-4o-mini")

{bullishpy-0.28.0 → bullishpy-0.30.0}/pyproject.toml

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

bullishpy-0.28.0/bullish/analysis/predefined_filters.py

@@ -1,391 +0,0 @@
-import datetime
-from datetime import timedelta
-from typing import Dict, Any, Optional, List, Union
-
-from bullish.analysis.analysis import AnalysisView
-from bullish.analysis.backtest import (
-    BacktestQueryDate,
-    BacktestQueries,
-    BacktestQueryRange,
-    BacktestQuerySelection,
-)
-from bullish.analysis.filter import FilterQuery, BOOLEAN_GROUP_MAPPING
-from pydantic import BaseModel, Field
-
-from bullish.analysis.indicators import Indicators
-from bullish.database.crud import BullishDb
-
-DATE_THRESHOLD = [
-    datetime.date.today() - datetime.timedelta(days=7),
-    datetime.date.today(),
-]
-
-
-class NamedFilterQuery(FilterQuery):
-    name: str
-    description: Optional[str] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        return self.model_dump(
-            exclude_unset=True,
-            exclude_none=True,
-            exclude_defaults=True,
-            exclude={"name"},
-        )
-
-    def to_backtesting_query(
-        self, backtest_start_date: datetime.date
-    ) -> BacktestQueries:
-        queries: List[
-            Union[BacktestQueryRange, BacktestQueryDate, BacktestQuerySelection]
-        ] = []
-        in_use_backtests = Indicators().in_use_backtest()
-        for in_use in in_use_backtests:
-            value = self.to_dict().get(in_use)
-            if value and self.model_fields[in_use].annotation == List[datetime.date]:
-                delta = value[1] - value[0]
-                queries.append(
-                    BacktestQueryDate(
-                        name=in_use.upper(),
-                        start=backtest_start_date - delta,
-                        end=backtest_start_date,
-                        table="signalseries",
-                    )
-                )
-        for field in self.to_dict():
-            if field in BOOLEAN_GROUP_MAPPING:
-                value = self.to_dict().get(field)
-                if value and self.model_fields[field].annotation == Optional[List[str]]:  # type: ignore
-                    queries.extend(
-                        [
-                            BacktestQueryDate(
-                                name=v.upper(),
-                                start=backtest_start_date - timedelta(days=252),
-                                end=backtest_start_date,
-                                table="signalseries",
-                            )
-                            for v in value
-                        ]
-                    )
-
-            if field in AnalysisView.model_fields:
-                value = self.to_dict().get(field)
-                if (
-                    value
-                    and self.model_fields[field].annotation == Optional[List[float]]  # type: ignore
-                    and len(value) == 2
-                ):
-                    queries.append(
-                        BacktestQueryRange(
-                            name=field.lower(),
-                            min=value[0],
-                            max=value[1],
-                            table="analysis",
-                        )
-                    )
-                if value and self.model_fields[field].annotation == Optional[List[str]]:  # type: ignore
-                    queries.append(
-                        BacktestQuerySelection(
-                            name=field.lower(),
-                            selections=value,
-                            table="analysis",
-                        )
-                    )
-
-        return BacktestQueries(queries=queries)
-
-    def get_backtesting_symbols(
-        self, bullish_db: BullishDb, backtest_start_date: datetime.date
-    ) -> List[str]:
-        queries = self.to_backtesting_query(backtest_start_date)
-
-        return bullish_db.read_query(queries.to_query())["symbol"].tolist()  # type: ignore
-
-
-STRONG_FUNDAMENTALS = NamedFilterQuery(
-    name="Strong Fundamentals",
-    income=[
-        "positive_operating_income",
-        "growing_operating_income",
-        "positive_net_income",
-        "growing_net_income",
-    ],
-    cash_flow=["positive_free_cash_flow", "growing_operating_cash_flow"],
-    eps=["positive_diluted_eps", "growing_diluted_eps"],
-    properties=[
-        "operating_cash_flow_is_higher_than_net_income",
-        "positive_return_on_equity",
-        "positive_return_on_assets",
-        "positive_debt_to_equity",
-    ],
-    market_capitalization=[1e10, 1e12],  # 1 billion to 1 trillion
-    rsi_bullish_crossover_30=DATE_THRESHOLD,
-)
-
-GOOD_FUNDAMENTALS = NamedFilterQuery(
-    name="Good Fundamentals",
-    income=[
-        "positive_operating_income",
-        "positive_net_income",
-    ],
-    cash_flow=["positive_free_cash_flow"],
-    eps=["positive_diluted_eps"],
-    properties=[
-        "positive_return_on_equity",
-        "positive_return_on_assets",
-        "positive_debt_to_equity",
-    ],
-    market_capitalization=[1e10, 1e12],  # 1 billion to 1 trillion
-    rsi_bullish_crossover_30=DATE_THRESHOLD,
-)
-
-RSI_CROSSOVER_30_GROWTH_STOCK_STRONG_FUNDAMENTAL = NamedFilterQuery(
-    name="RSI cross-over 30 growth stock strong fundamental",
-    income=[
-        "positive_operating_income",
-        "growing_operating_income",
-        "positive_net_income",
-        "growing_net_income",
-    ],
-    cash_flow=["positive_free_cash_flow"],
-    properties=["operating_cash_flow_is_higher_than_net_income"],
-    price_per_earning_ratio=[10, 100],
-    rsi_bullish_crossover_30=DATE_THRESHOLD,
-    market_capitalization=[5e8, 1e12],
-    order_by_desc="market_capitalization",
-    country=["Germany", "United states", "France", "United kingdom", "Canada", "Japan"],
-)
-RSI_CROSSOVER_40_GROWTH_STOCK_STRONG_FUNDAMENTAL = NamedFilterQuery(
-    name="RSI cross-over 40 growth stock strong fundamental",
-    income=[
-        "positive_operating_income",
-        "growing_operating_income",
-        "positive_net_income",
-        "growing_net_income",
-    ],
-    cash_flow=["positive_free_cash_flow"],
-    properties=["operating_cash_flow_is_higher_than_net_income"],
-    price_per_earning_ratio=[10, 500],
-    rsi_bullish_crossover_40=DATE_THRESHOLD,
-    market_capitalization=[5e8, 1e12],
-    order_by_desc="market_capitalization",
-    country=["Germany", "United states", "France", "United kingdom", "Canada", "Japan"],
-)
-
-RSI_CROSSOVER_30_GROWTH_STOCK = NamedFilterQuery(
-    name="RSI cross-over 30 growth stock",
-    price_per_earning_ratio=[10, 500],
-    rsi_bullish_crossover_30=DATE_THRESHOLD,
-    market_capitalization=[1e10, 1e13],
-    order_by_desc="market_capitalization",
-    country=[
-        "Germany",
-        "United states",
-        "France",
-        "United kingdom",
-        "Canada",
-        "Japan",
-        "Belgium",
-    ],
-)
-
-MEDIAN_YEARLY_GROWTH = NamedFilterQuery(
-    name="Median yearly growth",
-    market_capitalization=[1e6, 1e13],
-    median_yearly_growth=[40, 1000],
-    last_price=[1, 100],
-    order_by_asc="last_price",
-    country=[
-        "Germany",
-        "United states",
-        "France",
-        "Belgium",
-    ],
-)
-RSI_CROSSOVER_40_GROWTH_STOCK = NamedFilterQuery(
-    name="RSI cross-over 40 growth stock",
-    price_per_earning_ratio=[10, 500],
-    rsi_bullish_crossover_40=DATE_THRESHOLD,
-    market_capitalization=[1e10, 1e13],
-    order_by_desc="market_capitalization",
-    country=[
-        "Germany",
-        "United states",
-        "France",
-        "United kingdom",
-        "Canada",
-        "Japan",
-        "Belgium",
-    ],
-)
-
-
-MOMENTUM_GROWTH_GOOD_FUNDAMENTALS = NamedFilterQuery(
-    name="Momentum Growth Good Fundamentals (RSI 30)",
-    cash_flow=["positive_free_cash_flow"],
-    properties=["operating_cash_flow_is_higher_than_net_income"],
-    price_per_earning_ratio=[10, 500],
-    rsi_bullish_crossover_30=[
-        datetime.date.today() - datetime.timedelta(days=7),
-        datetime.date.today(),
-    ],
-    macd_12_26_9_bullish_crossover=[
-        datetime.date.today() - datetime.timedelta(days=7),
-        datetime.date.today(),
-    ],
-    sma_50_above_sma_200=[
-        datetime.date.today() - datetime.timedelta(days=5000),
-        datetime.date.today() - datetime.timedelta(days=10),
-    ],
-    market_capitalization=[5e8, 1e12],
-    order_by_desc="momentum",
-    country=[
-        "Germany",
-        "United states",
-        "France",
-        "United kingdom",
-        "Canada",
-        "Japan",
-        "Belgium",
-    ],
-)
-
-MOMENTUM_GROWTH_STRONG_FUNDAMENTALS = NamedFilterQuery(
-    name="Momentum Growth Strong Fundamentals (RSI 30)",
-    income=[
-        "positive_operating_income",
-        "growing_operating_income",
-        "positive_net_income",
-        "growing_net_income",
-    ],
-    cash_flow=["positive_free_cash_flow"],
-    properties=["operating_cash_flow_is_higher_than_net_income"],
-    price_per_earning_ratio=[10, 500],
-    rsi_bullish_crossover_30=[
-        datetime.date.today() - datetime.timedelta(days=7),
-        datetime.date.today(),
-    ],
-    macd_12_26_9_bullish_crossover=[
-        datetime.date.today() - datetime.timedelta(days=7),
-        datetime.date.today(),
-    ],
-    sma_50_above_sma_200=[
-        datetime.date.today() - datetime.timedelta(days=5000),
-        datetime.date.today() - datetime.timedelta(days=10),
-    ],
-    market_capitalization=[5e8, 1e12],
-    order_by_desc="momentum",
-    country=[
-        "Germany",
-        "United states",
-        "France",
-        "United kingdom",
-        "Canada",
-        "Japan",
-        "Belgium",
-    ],
-)
-MOMENTUM_GROWTH_RSI_30 = NamedFilterQuery(
-    name="Momentum Growth Screener (RSI 30)",
-    price_per_earning_ratio=[10, 500],
-    rsi_bullish_crossover_30=[
-        datetime.date.today() - datetime.timedelta(days=7),
-        datetime.date.today(),
-    ],
-    macd_12_26_9_bullish_crossover=[
-        datetime.date.today() - datetime.timedelta(days=7),
-        datetime.date.today(),
-    ],
-    sma_50_above_sma_200=[
-        datetime.date.today() - datetime.timedelta(days=5000),
-        datetime.date.today() - datetime.timedelta(days=10),
-    ],
-    market_capitalization=[5e8, 1e12],
-    order_by_desc="momentum",
-    country=[
-        "Germany",
-        "United states",
-        "France",
-        "United kingdom",
-        "Canada",
-        "Japan",
-        "Belgium",
-    ],
-)
-MOMENTUM_GROWTH_RSI_40 = NamedFilterQuery(
-    name="Momentum Growth Screener (RSI 40)",
-    price_per_earning_ratio=[10, 500],
-    rsi_bullish_crossover_40=[
-        datetime.date.today() - datetime.timedelta(days=7),
-        datetime.date.today(),
-    ],
-    macd_12_26_9_bullish_crossover=[
-        datetime.date.today() - datetime.timedelta(days=7),
-        datetime.date.today(),
-    ],
-    sma_50_above_sma_200=[
-        datetime.date.today() - datetime.timedelta(days=5000),
-        datetime.date.today() - datetime.timedelta(days=10),
-    ],
-    market_capitalization=[5e8, 1e12],
-    order_by_desc="momentum",
-    country=[
-        "Germany",
-        "United states",
-        "France",
-        "United kingdom",
-        "Canada",
-        "Japan",
-        "Belgium",
-    ],
-)
-
-GOLDEN_CROSS_LAST_SEVEN_DAYS = NamedFilterQuery(
-    name="Golden cross in the last five days",
-    price_per_earning_ratio=[10, 500],
-    last_price=[1, 10000],
-    golden_cross=[
-        datetime.date.today() - datetime.timedelta(days=7),
-        datetime.date.today(),
-    ],
-    order_by_desc="market_capitalization",
-    country=[
-        "Germany",
-        "United states",
-        "France",
-        "United kingdom",
-        "Canada",
-        "Japan",
-        "Belgium",
-    ],
-)
-
-
-def predefined_filters() -> list[NamedFilterQuery]:
-    return [
-        STRONG_FUNDAMENTALS,
-        GOOD_FUNDAMENTALS,
-        RSI_CROSSOVER_30_GROWTH_STOCK_STRONG_FUNDAMENTAL,
-        RSI_CROSSOVER_40_GROWTH_STOCK_STRONG_FUNDAMENTAL,
-        RSI_CROSSOVER_30_GROWTH_STOCK,
-        RSI_CROSSOVER_40_GROWTH_STOCK,
-        MOMENTUM_GROWTH_GOOD_FUNDAMENTALS,
-        MOMENTUM_GROWTH_STRONG_FUNDAMENTALS,
-        MOMENTUM_GROWTH_RSI_30,
-        MOMENTUM_GROWTH_RSI_40,
-        GOLDEN_CROSS_LAST_SEVEN_DAYS,
-        MEDIAN_YEARLY_GROWTH,
-    ]
-
-
-class PredefinedFilters(BaseModel):
-    filters: list[NamedFilterQuery] = Field(default_factory=predefined_filters)
-
-    def get_predefined_filter_names(self) -> list[str]:
-        return [filter.name for filter in self.filters]
-
-    def get_predefined_filter(self, name: str) -> Dict[str, Any]:
-        for filter in self.filters:
-            if filter.name == name:
-                return filter.to_dict()
-        raise ValueError(f"Filter with name '{name}' not found.")