bullishpy 0.15.0__tar.gz → 0.17.0__tar.gz

{bullishpy-0.15.0 → bullishpy-0.17.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: bullishpy
-Version: 0.15.0
+Version: 0.17.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)

{bullishpy-0.15.0 → bullishpy-0.17.0}/bullish/analysis/analysis.py

@@ -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,
@@ -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
 
@@ -502,7 +530,9 @@ def compute_signal_series(database_path: Path, ticker: Ticker) -> List[SignalSer
     indicators = Indicators()
     prices = Prices.from_ticker(bullish_db, ticker)
     signal_series = indicators.compute_series(prices.to_dataframe(), ticker.symbol)
-    return signal_series
+    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:
@@ -511,17 +541,16 @@ def run_signal_series_analysis(bullish_db: "BullishDb") -> None:
     tickers = list(price_trackers.intersection(finance_trackers))
     parallel = Parallel(n_jobs=-1)
 
-    for batch_ticker in batched(tickers, 100):
-        start = time.perf_counter()
+    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
         )
-        bullish_db.write_signal_series(list(chain.from_iterable(many_signal_series)))
-        elapsed_time = time.perf_counter() - start
-        print(
-            f"Computed signal series for {len(batch_ticker)} tickers in {elapsed_time:.2f} seconds."
-        )
+        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:

bullishpy-0.17.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.15.0 → bullishpy-0.17.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.15.0 → bullishpy-0.17.0}/bullish/analysis/functions.py

@@ -322,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()}"

{bullishpy-0.15.0 → bullishpy-0.17.0}/bullish/analysis/indicators.py

@@ -58,6 +58,7 @@ class Signal(BaseModel):
     description: str
     date: Optional[date] = None
     value: Optional[float] = None
+    in_use_backtest: bool = False
 
     def is_date(self) -> bool:
         if self.type == Optional[date]:
@@ -113,28 +114,40 @@ class Indicator(BaseModel):
 
     def compute_series(self, data: pd.DataFrame, symbol: str) -> pd.DataFrame:
         series = []
-        results = self.function(data)
+        try:
+            results = self.function(data)
+        except Exception as e:
+            logger.error(
+                f"Failed to compute indicator {self.name} for symbol {symbol}: {e}"
+            )
+            return pd.DataFrame()
         if not set(self.expected_columns).issubset(results.columns):
             raise ValueError(
                 f"Expected columns {self.expected_columns}, but got {results.columns.tolist()}"
             )
         for signal in self.signals:
+            if not signal.in_use_backtest:
+                continue
             try:
                 series_ = signal.compute_series(results)
                 if signal.type == Optional[date]:
                     series__ = pd.DataFrame(series_[series_ == 1].rename("value"))
                 else:
-                    series__ = pd.DataFrame(series_.rename("value"))
+                    series__ = pd.DataFrame(
+                        series_[series_ != None].rename("value")  # noqa: E711
+                    )
 
                 series__["name"] = signal.name
                 series__["date"] = series__.index.date  # type: ignore
                 series__["symbol"] = symbol
                 series__ = series__.reset_index(drop=True)
                 series.append(series__)
-            except Exception as e:  # noqa: PERF203
+            except Exception as e:
                 logger.error(
                     f"Fail to compute signal {signal.name} for indicator {self.name}: {e}"
                 )
+        if not series:
+            return pd.DataFrame()
         data = pd.concat(series).reset_index(drop=True)
         return data
 
@@ -181,6 +194,7 @@ def indicators_factory() -> List[Indicator]:
                     function=lambda d: cross_simple(
                         d.MACD_12_26_9, d.MACD_12_26_9_SIGNAL
                     ),
+                    in_use_backtest=True,
                 ),
                 Signal(
                     name="MACD_12_26_9_BEARISH_CROSSOVER",
@@ -221,6 +235,7 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Long",
                     type=Optional[date],
                     function=lambda d: cross_value_series(d.RSI, 30),
+                    in_use_backtest=True,
                 ),
                 Signal(
                     name="RSI_BULLISH_CROSSOVER_40",
@@ -228,6 +243,7 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Long",
                     type=Optional[date],
                     function=lambda d: cross_value_series(d.RSI, 40),
+                    in_use_backtest=True,
                 ),
                 Signal(
                     name="RSI_BULLISH_CROSSOVER_45",
@@ -235,6 +251,7 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Long",
                     type=Optional[date],
                     function=lambda d: cross_value_series(d.RSI, 45),
+                    in_use_backtest=True,
                 ),
                 Signal(
                     name="RSI_BEARISH_CROSSOVER",
@@ -249,6 +266,7 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Oversold",
                     type=Optional[date],
                     function=lambda d: (d.RSI < 30) & (d.RSI > 0),
+                    in_use_backtest=True,
                 ),
                 Signal(
                     name="RSI_OVERBOUGHT",
@@ -322,6 +340,7 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Oversold",
                     type=Optional[date],
                     function=lambda d: cross_simple(d.SMA_50, d.SMA_200),
+                    in_use_backtest=True,
                 ),
                 Signal(
                     name="DEATH_CROSS",
@@ -336,6 +355,7 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Overbought",
                     type=Optional[date],
                     function=lambda d: d.SMA_50 > d.SMA_200,
+                    in_use_backtest=True,
                     processing=ProcessingFunction(date=find_last_true_run_start),
                 ),
                 Signal(
@@ -344,6 +364,7 @@ def indicators_factory() -> List[Indicator]:
                     type_info="Overbought",
                     type=Optional[date],
                     function=lambda d: d.SMA_50 < d.CLOSE,
+                    in_use_backtest=True,
                     processing=ProcessingFunction(date=find_last_true_run_start),
                 ),
             ],
@@ -562,6 +583,14 @@ def indicators_factory() -> List[Indicator]:
 class Indicators(BaseModel):
     indicators: List[Indicator] = Field(default_factory=indicators_factory)
 
+    def in_use_backtest(self) -> List[str]:
+        return [
+            signal.name.lower()
+            for indicator in self.indicators
+            for signal in indicator.signals
+            if signal.in_use_backtest
+        ]
+
     def _compute(self, data: pd.DataFrame) -> None:
         for indicator in self.indicators:
             try: