bullishpy 0.14.0__tar.gz → 0.16.0__tar.gz

{bullishpy-0.14.0 → bullishpy-0.16.0}/PKG-INFO

@@ -1,23 +1,24 @@
 Metadata-Version: 2.3
 Name: bullishpy
-Version: 0.14.0
+Version: 0.16.0
 Summary: 
 Author: aan
 Author-email: andoludovic.andriamamonjy@gmail.com
 Requires-Python: >=3.12,<3.13
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: bearishpy (>=0.22.0,<0.23.0)
+Requires-Dist: bearishpy (>=0.26.0,<0.27.0)
 Requires-Dist: click (>=7.0,<=8.1)
 Requires-Dist: huey (>=2.5.3,<3.0.0)
 Requires-Dist: joblib (>=1.5.1,<2.0.0)
 Requires-Dist: pandas-ta (>=0.3.14b0,<0.4.0)
-Requires-Dist: plotly (>=6.1.2,<7.0.0)
+Requires-Dist: plotly (>=4.12.0,<6.0.0)
 Requires-Dist: streamlit (>=1.45.1,<2.0.0)
 Requires-Dist: streamlit-file-browser (>=3.2.22,<4.0.0)
 Requires-Dist: streamlit-pydantic (>=v0.6.1-rc.3,<0.7.0)
 Requires-Dist: ta-lib (>=0.6.4,<0.7.0)
 Requires-Dist: tickermood (>=0.4.0,<0.5.0)
+Requires-Dist: vectorbt (>=0.28.0,<0.29.0)
 Description-Content-Type: text/markdown
 
 ## Bullish

{bullishpy-0.14.0 → bullishpy-0.16.0}/bullish/analysis/analysis.py

@@ -1,6 +1,6 @@
 import logging
 import time
-from itertools import batched
+from itertools import batched, chain
 from pathlib import Path
 from typing import (
     Annotated,
@@ -28,7 +28,7 @@ from bearish.models.financials.balance_sheet import (  # type: ignore
     BalanceSheet,
     QuarterlyBalanceSheet,
 )
-from bearish.models.financials.base import Financials  # type: ignore
+from bearish.models.financials.base import Financials, FinancialsWithDate  # type: ignore
 from bearish.models.financials.cash_flow import (  # type: ignore
     CashFlow,
     QuarterlyCashFlow,
@@ -42,7 +42,7 @@ from bearish.models.query.query import AssetQuery, Symbols  # type: ignore
 from bearish.types import TickerOnlySources  # type: ignore
 from pydantic import BaseModel, BeforeValidator, Field, create_model
 
-from bullish.analysis.indicators import Indicators, IndicatorModels
+from bullish.analysis.indicators import Indicators, IndicatorModels, SignalSeries
 from joblib import Parallel, delayed  # type: ignore
 
 from bullish.analysis.industry_views import compute_industry_view
@@ -130,7 +130,7 @@ class TechnicalAnalysis(*TechnicalAnalysisModels):  # type: ignore
             )
             return cls()
         try:
-            res = Indicators().to_dict(prices)
+            res = Indicators().compute(prices)
             return cls(last_price=prices.close.iloc[-1], **res)
         except Exception as e:
             logger.error(
@@ -404,6 +404,24 @@ class FundamentalAnalysis(YearlyFundamentalAnalysis, QuarterlyFundamentalAnalysi
             yearly_analysis.model_dump() | quarterly_analysis.model_dump()
         )
 
+    @classmethod
+    def compute_series(
+        cls, financials: FinancialsWithDate, ticker: Ticker
+    ) -> List[SignalSeries]:
+        fundamendal_analysis = FundamentalAnalysis.from_financials(financials, ticker)
+        fundamental_analysis_ = fundamendal_analysis.model_dump(
+            exclude_none=True, exclude_unset=True, exclude_defaults=True
+        )
+        fundamental_analysis_ = {
+            k: v for k, v in fundamental_analysis_.items() if v is True
+        }
+        return [
+            SignalSeries(
+                name=k.upper(), symbol=ticker.symbol, value=v, date=financials.date
+            )
+            for k, v in fundamental_analysis_.items()
+        ]
+
 
 class AnalysisView(BaseModel):
     sector: Annotated[
@@ -488,6 +506,16 @@ class Analysis(AnalysisView, BaseEquity, TechnicalAnalysis, FundamentalAnalysis)
         )
 
 
+def compute_financials_series(
+    financials_: Financials, ticker: Ticker
+) -> List[SignalSeries]:
+    financials_with_dates = FinancialsWithDate.from_financials(financials_)
+    series = []
+    for f in financials_with_dates:
+        series.extend(FundamentalAnalysis.compute_series(f, ticker))
+    return series
+
+
 def compute_analysis(database_path: Path, ticker: Ticker) -> Analysis:
     from bullish.database.crud import BullishDb
 
@@ -495,6 +523,36 @@ def compute_analysis(database_path: Path, ticker: Ticker) -> Analysis:
     return Analysis.from_ticker(bullish_db, ticker)
 
 
+def compute_signal_series(database_path: Path, ticker: Ticker) -> List[SignalSeries]:
+    from bullish.database.crud import BullishDb
+
+    bullish_db = BullishDb(database_path=database_path)
+    indicators = Indicators()
+    prices = Prices.from_ticker(bullish_db, ticker)
+    signal_series = indicators.compute_series(prices.to_dataframe(), ticker.symbol)
+    financials = Financials.from_ticker(bullish_db, ticker)
+    financial_series = compute_financials_series(financials, ticker)
+    return signal_series + financial_series
+
+
+def run_signal_series_analysis(bullish_db: "BullishDb") -> None:
+    price_trackers = set(bullish_db._read_tracker(TrackerQuery(), PriceTracker))
+    finance_trackers = set(bullish_db._read_tracker(TrackerQuery(), FinancialsTracker))
+    tickers = list(price_trackers.intersection(finance_trackers))
+    parallel = Parallel(n_jobs=-1)
+
+    for batch_ticker in batched(tickers, 1):
+        many_signal_series = parallel(
+            delayed(compute_signal_series)(bullish_db.database_path, ticker)
+            for ticker in batch_ticker
+        )
+        series = list(chain.from_iterable(many_signal_series))
+        try:
+            bullish_db.write_signal_series(series)
+        except Exception as e:
+            logger.error(f"Failed to compute signal series for {batch_ticker}: {e}")
+
+
 def run_analysis(bullish_db: "BullishDb") -> None:
     compute_industry_view(bullish_db)
     price_trackers = set(bullish_db._read_tracker(TrackerQuery(), PriceTracker))

bullishpy-0.16.0/bullish/analysis/backtest.py

@@ -0,0 +1,422 @@
+import json
+import logging
+import random
+from datetime import date, timedelta
+from typing import TYPE_CHECKING, Optional, Union, List, Dict, Any
+
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel, Field, model_validator
+
+
+import plotly.graph_objects as go
+
+if TYPE_CHECKING:
+    from bullish.analysis.predefined_filters import NamedFilterQuery
+    from bullish.database.crud import BullishDb
+
+logger = logging.getLogger(__name__)
+COLOR = {
+    "mean": "#1f77b4",  # A refined blue (Plotly default)
+    "upper": "#d62728",  # Strong red
+    "lower": "#2ca02c",  # Rich green
+    "median": "#ff7f0e",  # Bright orange
+}
+
+
+class BacktestQueryBase(BaseModel):
+    name: str
+    table: str
+
+
+class BacktestQueryDate(BacktestQueryBase):
+
+    start: date
+    end: date
+
+
+class BacktestQueryRange(BacktestQueryBase):
+
+    min: float
+    max: float
+
+
+class BacktestQuerySelection(BacktestQueryBase):
+
+    selections: List[str]
+
+    def to_selections(self) -> str:
+        return ", ".join([f"'{s}'" for s in self.selections])
+
+
+class BacktestQueries(BaseModel):
+    queries: list[Union[BacktestQueryDate, BacktestQueryRange, BacktestQuerySelection]]
+
+    def to_query(self) -> str:
+        query_parts = []
+        for query in self.queries:
+            if isinstance(query, (BacktestQueryDate)):
+                query_parts.append(
+                    f"SELECT symbol FROM {query.table} WHERE name='{query.name}' "  # noqa: S608
+                    f"AND date >='{query.start}' AND date <='{query.end}'"
+                )
+            if isinstance(query, (BacktestQueryRange)):
+                query_parts.append(
+                    f"SELECT symbol FROM {query.table} WHERE "  # noqa: S608
+                    f"{query.name} >= {query.min} AND {query.name} <= {query.max}"
+                )
+            if isinstance(query, (BacktestQuerySelection)):
+                query_parts.append(
+                    f"SELECT symbol FROM {query.table} WHERE "  # noqa: S608
+                    f"{query.name} IN ({query.to_selections()})"
+                )
+
+        if len(query_parts) == 1:
+            return query_parts[0]
+        else:
+            return " INTERSECT ".join(query_parts)
+
+
+class ReturnPercentage(BaseModel):
+    return_percentage: float = Field(
+        default=12, description="Return percentage of the backtest"
+    )
+
+
+class BaseBacktestResult(BaseModel):
+    start: date = Field(default=date.today() - timedelta(days=252))
+    end: date = Field(default=date.today())
+    investment: float = Field(default=1000)
+    holding_period: int = Field(default=30 * 3)
+    extend_days: int = Field(
+        default=5,
+        description="Extend the backtest by this many days if no symbols are found",
+    )
+    percentage: int = Field(default=12, description="Return percentage of the backtest")
+    iterations: int = Field(default=200, description="Number of iterations to run")
+
+
+class BacktestResultQuery(BaseBacktestResult):
+    name: str
+
+
+class BacktestResult(BacktestResultQuery):
+    data: Dict[str, Any]
+
+    def to_dataframe(self) -> pd.DataFrame:
+        return pd.read_json(json.dumps(self.data)).sort_index()
+
+
+class BacktestResults(BaseModel):
+    results: List[BacktestResult]
+
+    def figure(self, type: str = "mean") -> go.Figure:
+        fig = go.Figure()
+        for result in self.results:
+            data = result.to_dataframe()[type]
+            fig.add_trace(
+                go.Scatter(
+                    x=data.index,
+                    y=data,
+                    mode="lines",
+                    name=f"{result.name} ({type})",
+                    line={"width": 1},
+                    hovertemplate=(
+                        "Date: %{x}<br>"
+                        + "Price: %{y:.2f}<br>"
+                        + f"Percentage: {result.percentage}<br>"
+                        + f"Iterations: {result.iterations}<br>"
+                        + f"Investment: {result.investment}<extra></extra>"
+                    ),
+                )
+            )
+        fig.update_layout(
+            height=800,
+            showlegend=True,
+            margin={"t": 60, "b": 40},
+        )
+
+        return fig
+
+
+class BackTestConfig(BaseBacktestResult):
+    exit_strategy: ReturnPercentage = Field(default=ReturnPercentage)
+
+    def to_base_backtest_result(self) -> BaseBacktestResult:
+        return BaseBacktestResult(
+            start=self.start,
+            end=self.end,
+            investment=self.investment,
+            holding_period=self.holding_period,
+            extend_days=self.extend_days,
+            percentage=self.percentage,
+            iterations=self.iterations,
+        )
+
+
+class Equity(BaseModel):
+    symbol: str
+    start: date
+    end: date
+    buy: float
+    sell: float
+    investment_in: float
+    investment_out: Optional[float] = None
+
+    def profit(self) -> float:
+        return (self.sell - self.buy) * (self.investment_in / self.buy)
+
+    def current_value(self) -> float:
+        return self.investment_in + self.profit()
+
+    def set_investment_out(self) -> None:
+        self.investment_out = self.current_value()
+
+
+class BackTest(BaseModel):
+    equities: list[Equity] = Field(
+        default_factory=list, description="List of equities bought during the backtest"
+    )
+    end: date = Field(default=date.today(), description="End date of the backtest")
+
+    def valid(self) -> bool:
+        return bool(self.equities)
+
+    def total_profit(self) -> float:
+        return sum(equity.profit() for equity in self.equities)
+
+    def symbols(self) -> list[str]:
+        return [equity.symbol for equity in self.equities]
+
+    def show(self) -> None:
+        for eq in self.equities:
+            print(
+                f"\n{eq.symbol} ({eq.type}): {eq.start}:{eq.investment_in} ({eq.buy}) - "
+                f"{eq.end}:{eq.investment_out} ({eq.sell})"
+            )
+
+    def to_dataframe(self) -> pd.DataFrame:
+        prices = [
+            self.equities[0].investment_in,
+            *[e.investment_out for e in self.equities],
+        ]
+        symbols = [self.equities[0].symbol, *[e.symbol for e in self.equities]]
+        index = [self.equities[0].start, *[e.end for e in self.equities]]
+        buy = [self.equities[0].buy, *[e.buy for e in self.equities]]
+        sell = [self.equities[0].sell, *[e.sell for e in self.equities]]
+        data = pd.DataFrame(
+            np.array([prices, symbols, buy, sell]).T,
+            index=index,
+            columns=["prices", "symbols", "buy", "sell"],
+        )
+        data = data[~data.index.duplicated(keep="first")]
+        return data
+
+    def __hash__(self) -> int:
+        return hash(tuple(sorted(equity.symbol for equity in self.equities)))
+
+
+class BackTests(BaseModel):
+    tests: list[BackTest] = Field(default_factory=list, description="List of backtests")
+    config: BackTestConfig
+    name: str
+
+    @model_validator(mode="after")
+    def _validate(self) -> "BackTests":
+        self.tests = list(set(self.tests))  # Remove duplicates
+        return self
+
+    def to_dataframe(self) -> pd.DataFrame:
+
+        data = (
+            pd.concat([t.to_dataframe() for t in self.tests if t.valid()], axis=1)
+            .sort_index()
+            .fillna(method="ffill")
+        )
+        data = data[~data.index.duplicated(keep="first")]
+        return data
+
+    def to_error(self) -> pd.DataFrame:
+        data_ = self.to_dataframe()
+        mean = data_.prices.astype(float).mean(axis=1).rename("mean")
+        std = data_.prices.astype(float).std(axis=1)
+        median = data_.prices.astype(float).median(axis=1).rename("median")
+        upper = (mean + std).rename("upper")
+        lower = (mean - std).rename("lower")
+        return pd.concat([mean, upper, lower, median], axis=1).sort_index()
+
+    def to_backtest_result(self) -> BacktestResult:
+
+        return BacktestResult.model_validate(
+            self.config.to_base_backtest_result().model_dump()
+            | {"data": json.loads(self.to_error().to_json()), "name": self.name}
+        )
+
+    def to_figure(self) -> go.Figure:
+
+        data_ = self.to_dataframe()
+        self.to_error()
+        column_chunks = [data_.iloc[:, i : i + 4] for i in range(0, data_.shape[1], 4)]
+        fig = go.Figure()
+        for data in column_chunks:
+            fig.add_trace(
+                go.Scatter(
+                    x=data.index,
+                    y=data.prices.astype(float),
+                    mode="lines",
+                    showlegend=False,
+                    customdata=data[
+                        ["symbols", "sell", "buy"]
+                    ],  # Include multiple overlay columns
+                    line={"color": "grey", "width": 0.5},  # normal grey
+                    opacity=0.5,
+                    hovertemplate=(
+                        "Date: %{x}<br>"
+                        + "Price: %{y:.2f}<br>"
+                        + "Symbols: %{customdata[0]}<br>"
+                        + "Sell: %{customdata[1]}<br>"
+                        + "Buy: %{customdata[2]}<extra></extra>"
+                    ),
+                )
+            )
+        for name, column in self.to_error().items():
+            fig.add_trace(
+                go.Scatter(
+                    x=column.index,
+                    y=column,
+                    mode="lines",
+                    line={"color": COLOR[name], "width": 1},
+                    showlegend=True,
+                    name=name,
+                )
+            )
+        fig.update_layout(
+            title="Predefined filter performance",
+            xaxis_title="Date",
+            yaxis_title="Prices [Currency]",
+        )
+        fig.show()
+        return fig
+
+
+def run_backtest(  # noqa: C901, PLR0915
+    bullish_db: "BullishDb", named_filter: "NamedFilterQuery", config: BackTestConfig
+) -> BackTest:
+    equities = []
+    start_date = config.start
+    presence_delta = timedelta(days=config.holding_period)
+    investment = config.investment
+    exclude_symbols = []
+    while True:
+        symbols = []
+        while not symbols:
+            symbols = named_filter.get_backtesting_symbols(bullish_db, start_date)
+            symbols = [b for b in symbols if b not in exclude_symbols]
+            if symbols:
+                break
+            start_date = start_date + timedelta(days=config.extend_days)
+            if start_date > config.end:
+                logger.debug("No symbols found for the given date range.")
+                break
+        if symbols:
+            symbol = random.choice(symbols)  # noqa: S311
+            logger.debug(f"Found symbol: {symbol}, for date: {start_date}")
+            enter_position = start_date
+            end_position = None
+            counter = 0
+            buy_price = None
+            while True:
+
+                data = bullish_db.read_symbol_series(
+                    symbol,
+                    start_date=enter_position + counter * presence_delta,
+                    end_date=enter_position + (counter + 1) * presence_delta,
+                )
+                if data.empty:
+                    logger.debug(f"No data found for symbol: {symbol}")
+                    exclude_symbols.append(symbol)
+                    end_position = start_date
+                    break
+                data.index = data.index.tz_localize(None)
+                if counter == 0:
+                    enter_position_timestamp = data.close.first_valid_index()
+                    enter_position = enter_position_timestamp.date()
+                    buy_price = data.close.loc[enter_position_timestamp]
+
+                mask = data.close >= buy_price * (
+                    1 + config.percentage / (100 * (counter + 1))
+                )
+                mask_ = mask[mask == True]  # noqa: E712
+
+                if mask_.empty:
+                    if enter_position + (counter + 1) * presence_delta > config.end:
+                        end_position = data.close.index[-1].date()
+                        sell_price = data.close.iloc[-1]
+                        equity = Equity(
+                            symbol=symbol,
+                            start=enter_position,
+                            end=end_position,
+                            buy=buy_price,
+                            sell=sell_price,
+                            investment_in=investment,
+                        )
+                        equity.set_investment_out()
+                        equities.append(equity)
+                        investment = equity.current_value()
+                        end_position = config.end
+                        break
+                    counter += 1
+                    continue
+                else:
+                    end_position_timestamp = data[mask].first_valid_index()
+                    end_position = end_position_timestamp.date()
+                    equity = Equity(
+                        symbol=symbol,
+                        start=enter_position,
+                        end=end_position,
+                        buy=buy_price,
+                        sell=data[mask].close.loc[end_position_timestamp],
+                        investment_in=investment,
+                    )
+                    equity.set_investment_out()
+                    equities.append(equity)
+                    investment = equity.current_value()
+                    break
+
+            start_date = end_position
+        if start_date >= config.end:
+            break
+    back_test = BackTest(equities=equities)
+    return back_test
+
+
+def run_tests(
+    bullish_db: "BullishDb", named_filter: "NamedFilterQuery", config: BackTestConfig
+) -> BackTests:
+    return BackTests(
+        config=config,
+        name=named_filter.name,
+        tests=[
+            run_backtest(bullish_db, named_filter, config)
+            for _ in range(config.iterations)
+        ],
+    )
+
+
+def run_many_tests(
+    bullish_db: "BullishDb",
+    named_filters: List["NamedFilterQuery"],
+    config: BackTestConfig,
+) -> None:
+    back_tests = []
+    for named_filter in named_filters:
+        try:
+            back_tests.append(
+                run_tests(bullish_db, named_filter, config).to_backtest_result()
+            )
+        except Exception as e:  # noqa: PERF203
+            logger.error(e)
+            continue
+
+    if back_tests:
+        bullish_db.write_many_backtest_results(back_tests)

{bullishpy-0.14.0 → bullishpy-0.16.0}/bullish/analysis/filter.py

@@ -82,12 +82,15 @@ PROPERTIES_GROUP = list(
         {*INCOME_GROUP, *CASH_FLOW_GROUP, *EPS_GROUP}
     )
 )
-
-GROUP_MAPPING: Dict[str, List[str]] = {
+BOOLEAN_GROUP_MAPPING: Dict[str, List[str]] = {
     "income": INCOME_GROUP,
     "cash_flow": CASH_FLOW_GROUP,
     "eps": EPS_GROUP,
     "properties": PROPERTIES_GROUP,
+}
+GROUP_MAPPING: Dict[str, List[str]] = {
+    **BOOLEAN_GROUP_MAPPING,
+    "properties": PROPERTIES_GROUP,
     "country": list(get_args(Country)),
     "industry": list(get_args(Industry)),
     "industry_group": list(get_args(IndustryGroup)),

{bullishpy-0.14.0 → bullishpy-0.16.0}/bullish/analysis/functions.py

@@ -15,10 +15,17 @@ except Exception:
     logger.warning("Talib is not installed, skipping analysis")
 
 
+def cross_simple(
+    series_a: pd.Series, series_b: pd.Series, above: bool = True
+) -> pd.Series:
+    crossing = ta.cross(series_a=series_a, series_b=series_b, above=above)
+    return crossing  # type: ignore
+
+
 def cross(
     series_a: pd.Series, series_b: pd.Series, above: bool = True
 ) -> Optional[date]:
-    crossing = ta.cross(series_a=series_a, series_b=series_b, above=above)
+    crossing = cross_simple(series_a=series_a, series_b=series_b, above=above)
     if not crossing[crossing == 1].index.empty:
         return crossing[crossing == 1].last_valid_index().date()  # type: ignore
     return None
@@ -31,10 +38,10 @@ def cross_value(series: pd.Series, number: int, above: bool = True) -> Optional[
 def cross_value_series(
     series_a: pd.Series, number: int, above: bool = True
 ) -> pd.Series:
-    crossing = ta.cross(
-        series_a=series_a, series_b=pd.Series(number, index=series_a.index), above=above
+    crossing = cross_simple(
+        series_a, pd.Series(number, index=series_a.index), above=above
     )
-    return crossing  # type: ignore
+    return crossing
 
 
 def compute_adx(data: pd.DataFrame) -> pd.DataFrame:
@@ -302,14 +309,6 @@ def price_above_sma50(data: pd.DataFrame) -> Optional[date]:
     return date_1
 
 
-def momentum(data: pd.DataFrame) -> Optional[date]:
-    date_1 = find_last_true_run_start(data.SMA_50 < data.CLOSE)
-    date_2 = find_last_true_run_start(data.SMA_200 < data.SMA_50)
-    if date_1 is None or date_2 is None:
-        return None
-    return max(date_1, date_2)
-
-
 class IndicatorFunction(BaseModel):
     expected_columns: list[str]
     functions: list[Callable[[pd.DataFrame], pd.DataFrame]]
@@ -323,7 +322,9 @@ class IndicatorFunction(BaseModel):
             except Exception as e:
                 logger.error(f"Fail to compute function {function.__name__}: {e}")
         if data_ is None:
-            raise ValueError("No data returned from indicator functions.")
+            raise ValueError(
+                f"No data returned from indicator functions with expected columns {self.expected_columns}."
+            )
         if not set(self.expected_columns).issubset(set(data_.columns)):
             raise ValueError(
                 f"Expected columns {self.expected_columns} not found in data columns {data_.columns.tolist()}"