bullishpy 0.15.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

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:

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)

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)),

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

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:

bullish/analysis/predefined_filters.py

@@ -1,9 +1,19 @@
 import datetime
-from typing import Dict, Any, Optional
+from datetime import timedelta
+from typing import Dict, Any, Optional, List, Union
 
-from bullish.analysis.filter import FilterQuery
+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),
@@ -23,6 +33,74 @@ class NamedFilterQuery(FilterQuery):
             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",
@@ -100,7 +178,15 @@ RSI_CROSSOVER_30_GROWTH_STOCK = NamedFilterQuery(
     rsi_bullish_crossover_30=DATE_THRESHOLD,
     market_capitalization=[5e8, 1e12],
     order_by_desc="market_capitalization",
-    country=["Germany", "United states", "France", "United kingdom", "Canada", "Japan"],
+    country=[
+        "Germany",
+        "United states",
+        "France",
+        "United kingdom",
+        "Canada",
+        "Japan",
+        "Belgium",
+    ],
 )
 RSI_CROSSOVER_40_GROWTH_STOCK = NamedFilterQuery(
     name="RSI cross-over 40 growth stock",
@@ -108,7 +194,15 @@ RSI_CROSSOVER_40_GROWTH_STOCK = NamedFilterQuery(
     rsi_bullish_crossover_40=DATE_THRESHOLD,
     market_capitalization=[5e8, 1e12],
     order_by_desc="market_capitalization",
-    country=["Germany", "United states", "France", "United kingdom", "Canada", "Japan"],
+    country=[
+        "Germany",
+        "United states",
+        "France",
+        "United kingdom",
+        "Canada",
+        "Japan",
+        "Belgium",
+    ],
 )
 
 
@@ -131,7 +225,15 @@ MOMENTUM_GROWTH_GOOD_FUNDAMENTALS = NamedFilterQuery(
     ],
     market_capitalization=[5e8, 1e12],
     order_by_desc="momentum",
-    country=["Germany", "United states", "France", "United kingdom", "Canada", "Japan"],
+    country=[
+        "Germany",
+        "United states",
+        "France",
+        "United kingdom",
+        "Canada",
+        "Japan",
+        "Belgium",
+    ],
 )
 
 MOMENTUM_GROWTH_STRONG_FUNDAMENTALS = NamedFilterQuery(
@@ -159,7 +261,15 @@ MOMENTUM_GROWTH_STRONG_FUNDAMENTALS = NamedFilterQuery(
     ],
     market_capitalization=[5e8, 1e12],
     order_by_desc="momentum",
-    country=["Germany", "United states", "France", "United kingdom", "Canada", "Japan"],
+    country=[
+        "Germany",
+        "United states",
+        "France",
+        "United kingdom",
+        "Canada",
+        "Japan",
+        "Belgium",
+    ],
 )
 MOMENTUM_GROWTH_RSI_30 = NamedFilterQuery(
     name="Momentum Growth Screener (RSI 30)",
@@ -178,7 +288,15 @@ MOMENTUM_GROWTH_RSI_30 = NamedFilterQuery(
     ],
     market_capitalization=[5e8, 1e12],
     order_by_desc="momentum",
-    country=["Germany", "United states", "France", "United kingdom", "Canada", "Japan"],
+    country=[
+        "Germany",
+        "United states",
+        "France",
+        "United kingdom",
+        "Canada",
+        "Japan",
+        "Belgium",
+    ],
 )
 MOMENTUM_GROWTH_RSI_40 = NamedFilterQuery(
     name="Momentum Growth Screener (RSI 40)",
@@ -197,7 +315,15 @@ MOMENTUM_GROWTH_RSI_40 = NamedFilterQuery(
     ],
     market_capitalization=[5e8, 1e12],
     order_by_desc="momentum",
-    country=["Germany", "United states", "France", "United kingdom", "Canada", "Japan"],
+    country=[
+        "Germany",
+        "United states",
+        "France",
+        "United kingdom",
+        "Canada",
+        "Japan",
+        "Belgium",
+    ],
 )
 
 GOLDEN_CROSS_LAST_SEVEN_DAYS = NamedFilterQuery(
@@ -209,7 +335,15 @@ GOLDEN_CROSS_LAST_SEVEN_DAYS = NamedFilterQuery(
         datetime.date.today(),
     ],
     order_by_desc="market_capitalization",
-    country=["Germany", "United states", "France", "United kingdom", "Canada", "Japan"],
+    country=[
+        "Germany",
+        "United states",
+        "France",
+        "United kingdom",
+        "Canada",
+        "Japan",
+        "Belgium",
+    ],
 )
 
 

bullish/app/app.py

@@ -12,6 +12,7 @@ from bearish.models.price.prices import Prices  # type: ignore
 from bearish.models.query.query import AssetQuery, Symbols  # type: ignore
 from streamlit_file_browser import st_file_browser  # type: ignore
 
+from bullish.analysis.backtest import BacktestResults
 from bullish.analysis.industry_views import get_industry_comparison_data
 from bullish.analysis.predefined_filters import PredefinedFilters
 from bullish.database.crud import BullishDb
@@ -26,7 +27,7 @@ from bullish.analysis.filter import (
     GeneralFilter,
     TechnicalAnalysisFilters,
 )
-from bullish.jobs.tasks import update, news, analysis
+from bullish.jobs.tasks import update, news, analysis, backtest_signals
 from pydantic import BaseModel
 
 from bullish.utils.checks import (
@@ -212,6 +213,12 @@ def jobs() -> None:
             analysis(st.session_state.database_path, job_type="Update analysis")
             st.success("Data update job has been enqueued.")
             st.rerun()
+    with st.expander("Compute backtest signals"):
+        if st.button("Compute backtest signals"):
+            backtest_signals(
+                st.session_state.database_path, job_type="backtest signals"
+            )
+            st.rerun()
 
 
 @st.dialog("📥  Load", width="large")
@@ -336,7 +343,7 @@ def main() -> None:
     if st.session_state.database_path is None:
         dialog_pick_database()
     bearish_db_ = bearish_db(st.session_state.database_path)
-    charts_tab, jobs_tab = st.tabs(["Charts", "Jobs"])
+    charts_tab, jobs_tab, backtests = st.tabs(["Charts", "Jobs", "Backtests"])
     if "data" not in st.session_state:
         st.session_state.data = load_analysis_data(bearish_db_)
 
@@ -387,6 +394,12 @@ def main() -> None:
             use_container_width=True,
             hide_index=True,
         )
+    with backtests:
+        results = bearish_db_.read_many_backtest_results()
+        backtest_results = BacktestResults(results=results)
+        with st.container():
+            figure = backtest_results.figure()
+            st.plotly_chart(figure)
 
 
 if __name__ == "__main__":

bullish/database/alembic/versions/{3e1a14c41916_.py → 12889a2cbd7d_.py}

@@ -1,8 +1,8 @@
 """
 
-Revision ID: 3e1a14c41916
+Revision ID: 12889a2cbd7d
 Revises: 040b15fba458
-Create Date: 2025-07-17 15:07:44.125783
+Create Date: 2025-07-17 17:50:35.004785
 
 """
 
@@ -14,7 +14,7 @@ from sqlalchemy.dialects import sqlite
 import sqlmodel
 
 # revision identifiers, used by Alembic.
-revision: str = "3e1a14c41916"
+revision: str = "12889a2cbd7d"
 down_revision: Union[str, None] = "040b15fba458"
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
@@ -25,11 +25,12 @@ def upgrade() -> None:
     op.create_table(
         "signalseries",
         sa.Column("date", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
-        sa.Column("value", sa.Float(), nullable=False),
         sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
         sa.Column("symbol", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("value", sa.Float(), nullable=True),
         sa.PrimaryKeyConstraint("date", "name", "symbol"),
     )
+
     with op.batch_alter_table("analysis", schema=None) as batch_op:
         batch_op.drop_index(batch_op.f("ix_analysis_momentum_time_span"))
         batch_op.drop_column("momentum_time_span")

bullish/database/alembic/versions/6d252e23f543_.py

@@ -0,0 +1,48 @@
+"""
+
+Revision ID: 6d252e23f543
+Revises: 12889a2cbd7d
+Create Date: 2025-07-27 16:46:41.885125
+
+"""
+
+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 = "6d252e23f543"
+down_revision: Union[str, None] = "12889a2cbd7d"
+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(
+        "backtestresult",
+        sa.Column("end", sa.Date(), nullable=False),
+        sa.Column("investment", sa.Float(), nullable=False),
+        sa.Column("start", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("holding_period", sa.Integer(), nullable=False),
+        sa.Column("extend_days", sa.Integer(), nullable=False),
+        sa.Column("percentage", sa.Integer(), nullable=False),
+        sa.Column("iterations", sa.Integer(), nullable=False),
+        sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("data", sa.JSON(), nullable=True),
+        sa.PrimaryKeyConstraint(
+            "start", "holding_period", "extend_days", "percentage", "iterations", "name"
+        ),
+    )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+
+    op.drop_table("backtestresult")
+    # ### end Alembic commands ###

bullish/database/crud.py

@@ -8,13 +8,16 @@ from typing import TYPE_CHECKING, Any, List, Optional
 import pandas as pd
 from bearish.database.crud import BearishDb  # type: ignore
 from bearish.models.base import Ticker  # type: ignore
-from bearish.database.schemas import EarningsDateORM, EquityORM  # type: ignore
+from bearish.database.schemas import EarningsDateORM, EquityORM, PriceORM  # type: ignore
 from bearish.types import Sources  # type: ignore
+from bearish.models.price.price import Price  # type: ignore
+from bearish.models.price.prices import Prices  # type: ignore
 from pydantic import ConfigDict
 from sqlalchemy import Engine, create_engine, insert, delete, update
 from sqlmodel import Session, select
 
 from bullish.analysis.analysis import Analysis
+
 from bullish.analysis.constants import Industry, IndustryGroup, Sector, Country
 from bullish.analysis.indicators import SignalSeries
 from bullish.analysis.industry_views import Type, IndustryView
@@ -25,6 +28,7 @@ from bullish.database.schemas import (
     FilteredResultsORM,
     IndustryViewORM,
     SignalSeriesORM,
+    BacktestResultORM,
 )
 from bullish.database.scripts.upgrade import upgrade
 from bullish.exceptions import DatabaseFileNotFoundError
@@ -33,7 +37,7 @@ from bullish.interface.interface import BullishDbBase
 from bullish.jobs.models import JobTracker, JobTrackerStatus
 
 if TYPE_CHECKING:
-    pass
+    from bullish.analysis.backtest import BacktestResult, BacktestResultQuery
 
 logger = logging.getLogger(__name__)
 
@@ -284,3 +288,45 @@ class BullishDb(BearishDb, BullishDbBase):  # type: ignore
                 SignalSeriesORM.date <= end_date,  # type: ignore
             )
             return list(set(session.exec(stmt).all()))
+
+    def read_symbol_series(
+        self, symbol: str, start_date: date, end_date: Optional[date] = None
+    ) -> pd.DataFrame:
+
+        with Session(self._engine) as session:
+            query_ = select(PriceORM)
+            query_ = query_.where(PriceORM.symbol == symbol)
+            if end_date:
+                query_ = query_.where(
+                    PriceORM.date >= start_date, PriceORM.date <= end_date
+                )
+            else:
+                query_ = query_.where(PriceORM.date >= start_date)
+            series = session.exec(query_).all()
+            prices = [Price.model_validate(serie) for serie in series]
+            return Prices(prices=prices).to_dataframe()  # type: ignore
+
+    def write_many_backtest_results(
+        self, backtest_results: List["BacktestResult"]
+    ) -> None:
+        with Session(self._engine) as session:
+            stmt = (
+                insert(BacktestResultORM)
+                .prefix_with("OR REPLACE")
+                .values([a.model_dump() for a in backtest_results])
+            )
+            session.exec(stmt)  # type: ignore
+            session.commit()
+
+    def read_many_backtest_results(
+        self, query: Optional["BacktestResultQuery"] = None
+    ) -> List["BacktestResult"]:
+        from bullish.analysis.backtest import BacktestResult
+
+        with Session(self._engine) as session:
+            stmt = select(BacktestResultORM)
+            results = session.exec(stmt).all()
+            if results:
+                return [BacktestResult.model_validate(r) for r in results]
+            else:
+                return []

bullish/database/schemas.py

@@ -3,6 +3,7 @@ from typing import Dict, Any
 from sqlmodel import Field, SQLModel
 from sqlalchemy import Column, JSON
 from bullish.analysis.analysis import Analysis
+from bullish.analysis.backtest import BacktestResult
 from bullish.analysis.filter import FilteredResults
 from bullish.analysis.indicators import SignalSeries
 from bullish.analysis.industry_views import IndustryView
@@ -55,6 +56,7 @@ class SignalSeriesORM(SQLModel, SignalSeries, table=True):
     date: str = Field(primary_key=True)  # type: ignore
     name: str = Field(primary_key=True)
     symbol: str = Field(primary_key=True)
+    value: float | None = Field(default=None, nullable=True)  # type: ignore
 
 
 class IndustryViewORM(SQLModel, IndustryView, table=True):
@@ -70,3 +72,15 @@ class IndustryViewORM(SQLModel, IndustryView, table=True):
     industry_group: str | None = Field(default=None, nullable=True)  # type: ignore
     sector: str | None = Field(default=None, nullable=True)  # type: ignore
     type: str = Field(primary_key=True)  # type: ignore
+
+
+class BacktestResultORM(SQLModel, BacktestResult, table=True):
+    __tablename__ = "backtestresult"
+    __table_args__ = {"extend_existing": True}  # noqa:RUF012
+    name: str = Field(primary_key=True)
+    start: str = Field(primary_key=True)  # type: ignore
+    holding_period: int = Field(primary_key=True)
+    extend_days: int = Field(primary_key=True)
+    percentage: int = Field(primary_key=True)
+    iterations: int = Field(primary_key=True)
+    data: Dict[str, Any] = Field(sa_column=Column(JSON))

bullish/interface/interface.py

@@ -10,6 +10,7 @@ from bearish.types import Sources  # type: ignore
 
 
 from bullish.analysis.analysis import Analysis, AnalysisView
+from bullish.analysis.backtest import BacktestResult, BacktestResultQuery
 from bullish.analysis.constants import Industry, Sector, IndustryGroup, Country
 from bullish.analysis.filter import FilterQuery, FilteredResults
 from bullish.analysis.indicators import SignalSeries
@@ -134,3 +135,17 @@ class BullishDbBase(BearishDbBase):  # type: ignore
     def read_signal_series(
         self, name: str, start_date: date, end_date: date
     ) -> List[str]: ...
+
+    @abc.abstractmethod
+    def read_symbol_series(
+        self, symbol: str, start_date: date, end_date: Optional[date] = None
+    ) -> pd.DataFrame: ...
+    @abc.abstractmethod
+    def write_many_backtest_results(
+        self, backtest_results: List[BacktestResult]
+    ) -> None: ...
+
+    @abc.abstractmethod
+    def read_many_backtest_results(
+        self, query: Optional[BacktestResultQuery] = None
+    ) -> List[BacktestResult]: ...

bullish/jobs/models.py

@@ -4,7 +4,7 @@ from typing import Literal, get_args
 import pandas as pd
 from pydantic import BaseModel, Field
 
-JobType = Literal["Update data", "Update analysis", "Fetching news"]
+JobType = Literal["Update data", "Update analysis", "Fetching news", "backtest signals"]
 JobStatus = Literal["Completed", "Failed", "Running", "Started"]
 StatusIcon = ["✅ Completed", "❌ Failed", "🔄 Running", "🚀 Started"]
 

bullish/jobs/tasks.py

@@ -11,7 +11,10 @@ from pathlib import Path
 from huey.api import Task  # type: ignore
 
 from .models import JobTrackerStatus, JobTracker, JobType
-from ..analysis.analysis import run_analysis
+from ..analysis.analysis import run_analysis, run_signal_series_analysis
+from ..analysis.backtest import run_many_tests, BackTestConfig
+from ..analysis.industry_views import compute_industry_view
+from ..analysis.predefined_filters import predefined_filters
 from ..database.crud import BullishDb
 from bullish.analysis.filter import FilterUpdate
 
@@ -54,11 +57,13 @@ def job_tracker(func: Callable[..., Any]) -> Callable[..., Any]:
 def update(
     database_path: Path,
     job_type: JobType,
-    symbols: List[str],
+    symbols: Optional[List[str]],
     update_query: FilterUpdate,
     task: Optional[Task] = None,
 ) -> None:
-    logger.debug(f"Running update task for {len(symbols)} tickers.")
+    logger.debug(
+        f"Running update task for {len(symbols) if symbols else 'ALL'} tickers."
+    )
     if not update_query.update_analysis_only:
         bearish = Bearish(path=database_path, auto_migration=False)
         bearish.update_prices(
@@ -81,6 +86,19 @@ def analysis(
 ) -> None:
     bullish_db = BullishDb(database_path=database_path)
     run_analysis(bullish_db)
+    compute_industry_view(bullish_db)
+
+
+@huey.task(context=True)  # type: ignore
+@job_tracker
+def backtest_signals(
+    database_path: Path,
+    job_type: JobType,
+    task: Optional[Task] = None,
+) -> None:
+    bullish_db = BullishDb(database_path=database_path)
+    run_signal_series_analysis(bullish_db)
+    run_many_tests(bullish_db, predefined_filters(), BackTestConfig())
 
 
 @huey.task(context=True)  # type: ignore

{bullishpy-0.15.0.dist-info → bullishpy-0.17.0.dist-info}/METADATA

@@ -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.dist-info → bullishpy-0.17.0.dist-info}/RECORD

@@ -1,14 +1,15 @@
 bullish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bullish/analysis/analysis.py,sha256=ag1wAfNDKWmPxJz7sd1mNhuh4CZfEleTp2_a3DIkEL4,20524
+bullish/analysis/analysis.py,sha256=SqlLrbhMzm2dvK89Ip5KCyTOoLS41vNf1WJolevLKfc,21638
+bullish/analysis/backtest.py,sha256=u3zzdP0IzpcxSzoI_wWT-YkmBulwVCFfhusttquTjSQ,14291
 bullish/analysis/constants.py,sha256=tVDPQEufH8lytMj4DdUdvXt79b7cvWaDwSUOpeqMWts,9851
-bullish/analysis/filter.py,sha256=kSG6fXZrnwqE1HvKQW6O3yVNV49qhVleer9M_7BIDpg,8381
-bullish/analysis/functions.py,sha256=ebCXxYeKlWhvcRRFMbX8E63bL7OquxyoWsYIy0o0SCA,14277
-bullish/analysis/indicators.py,sha256=S3pUsWn4MC_BKPhY1iFQDNNuHcqulez8jOsfWJdht_8,23470
+bullish/analysis/filter.py,sha256=wBVkHhQPfG8wJ0TR3KLo_Bb7cRZFPyHlF4UK2mpG6S0,8495
+bullish/analysis/functions.py,sha256=JSxYCuua_sMGLosN83j0GcY0Ls_gsE4OZLLGInxG9RA,14354
+bullish/analysis/indicators.py,sha256=Dpps-v4bfQ3KF-C8zjMlArw1DJgZo-_EedYwihIiFJ0,24462
 bullish/analysis/industry_views.py,sha256=1B5V39Fm9rNQEsun1xrwELfOiKlGdTie0ZolS2UBh2w,6247
-bullish/analysis/predefined_filters.py,sha256=28e42hGaH7Qb6SPNeH7EK9YIhjERj-qpbY-7xLahvDM,8361
+bullish/analysis/predefined_filters.py,sha256=5G75u4uDLHJR-iEtGZ2s-gkAqNIRUYu5msK8G-LWmD0,12074
 bullish/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bullish/app/app.py,sha256=3xSO4x3T7BnD60M-AQM6-xkRVFLCWqGJ6DWqLmKxbzw,13663
+bullish/app/app.py,sha256=rIvz4A0aJu7wGXBSCqO3EBA4QGhV8GPYVOYLOd9WjnY,14253
 bullish/cli.py,sha256=uYLZmGDAolZKWzduZ58bP-xul1adg0oKfeUQtZMXTvA,1958
 bullish/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/database/alembic/README,sha256=heMzebYwlGhnE8_4CWJ4LS74WoEZjBy-S-mIJRxAEKI,39
@@ -19,11 +20,12 @@ bullish/database/alembic/versions/037dbd721317_.py,sha256=U7EA4odH3t9w0-J4FmvBUt
 bullish/database/alembic/versions/040b15fba458_.py,sha256=scSauB4wZe0sMFHOAMHkx-rNSF06Pn3D52QJ10PvERg,2314
 bullish/database/alembic/versions/08ac1116e055_.py,sha256=zMEiCbraMEAZItT4ibc3evAH7-7mkXpdgnZy4tPVYeg,27263
 bullish/database/alembic/versions/11d35a452b40_.py,sha256=j2PaU1RssLQ20OevGmBC7S9E9ocWiXpBue9SOS4AQoY,11521
+bullish/database/alembic/versions/12889a2cbd7d_.py,sha256=LT_-dM-UstatA1xloCAQnvVgFXMyIAR_LpHPbQnWyVo,1668
 bullish/database/alembic/versions/17e51420e7ad_.py,sha256=xeiVIm1YUZb08opE9rocHZP1__9WQWXsKsXgeFV9cvs,2960
-bullish/database/alembic/versions/3e1a14c41916_.py,sha256=TmpfLl4dBw-CqHsnxwnnBc00nlUtHb0Hh8cc3yLBRME,1668
 bullish/database/alembic/versions/49c83f9eb5ac_.py,sha256=kCBItp7KmqpJ03roy5ikQjhefZia1oKgfZwournQDq8,3890
 bullish/database/alembic/versions/4b0a2f40b7d3_.py,sha256=G0K7w7pOPYjPZkXTB8LWhxoxuWBPcPwOfnubTBtdeEY,1827
 bullish/database/alembic/versions/5b10ee7604c1_.py,sha256=YlqaagPasR3RKASv7acME1jPS8p26VoTE2BvpOwdCpY,1463
+bullish/database/alembic/versions/6d252e23f543_.py,sha256=izF-ejdXk733INkAokGqjA2U_M0_c1f_ruihZ-cgP7s,1525
 bullish/database/alembic/versions/73564b60fe24_.py,sha256=MTlDRDNHj3E9gK7IMeAzv2UxxxYtWiu3gI_9xTLE-wg,1008
 bullish/database/alembic/versions/b76079e9845f_.py,sha256=W8eeTABjI9tT1dp3hlK7g7tiKqDhmA8AoUX9Sw-ykLI,1165
 bullish/database/alembic/versions/bf6b86dd5463_.py,sha256=fKB8knCprGmiL6AEyFdhybVmB7QX_W4MPFF9sPzUrSM,1094
@@ -31,8 +33,8 @@ bullish/database/alembic/versions/d663166c531d_.py,sha256=U92l6QXqPniAYrPeu2Bt77
 bullish/database/alembic/versions/ec25c8fa449f_.py,sha256=8Yts74KEjK4jg20zIo90_0atw-sOBuE3hgCKl-rfS5E,2271
 bullish/database/alembic/versions/ee5baabb35f8_.py,sha256=nBMEY-_C8AsSXVPyaDdUkwrFFo2gxShzJhmrjejDwtc,1632
 bullish/database/alembic/versions/fc191121f522_.py,sha256=0sstF6TpAJ09-Mt-Vek9SdSWksvi4C58a5D92rBtuY8,1894
-bullish/database/crud.py,sha256=EIXCnhvPAxwldicUG4fwsdiXiq08TjXoZ8wSt27ph0g,10808
-bullish/database/schemas.py,sha256=ySTaw77X9rvLg-4PAKaOH6fPe8Bgi8kTtPc8DvsR6F8,2791
+bullish/database/crud.py,sha256=Fv-nI4cmhQnSaa4NxEtf1LvweCJZw9ue_rLA7nxNNB0,12637
+bullish/database/schemas.py,sha256=3uRcNKuobqWC3mCfInzo-4KhrZp3DH6yx_0TEbLoHME,3428
 bullish/database/scripts/create_revision.py,sha256=rggIf-3koPqJNth8FIg89EOfnIM7a9QrvL8X7UJsP0g,628
 bullish/database/scripts/stamp.py,sha256=PWgVUEBumjNUMjTnGw46qmU3p221LeN-KspnW_gFuu4,839
 bullish/database/scripts/upgrade.py,sha256=-Gz7aFNPEt9y9e1kltqXE76-j_8QeNtet_VlwY5AWjo,806
@@ -41,14 +43,14 @@ bullish/exceptions.py,sha256=4z_i-dD-CDz1bkGmZH9DOf1L_awlCPCgdUDPF7dhWAI,106
 bullish/figures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/figures/figures.py,sha256=imrvIIcL9L-z-3vzWK5hDEsNttZs60QxlFI-PLw0hJQ,4829
 bullish/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bullish/interface/interface.py,sha256=QbjC_tWLbhvQr8vaiQl8ymrb6f_vR_KCxEmzJ5lA1Zg,4528
+bullish/interface/interface.py,sha256=9bhXOKlYtoCbbbDBzmwlVK2HuAzfO-1kE8mk_MMG0MM,5046
 bullish/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/jobs/app.py,sha256=5MJ5KXUo7JSNAvOPgkpIMasD11VTrjQvGzM7vmCY65E,77
-bullish/jobs/models.py,sha256=ndrGTMP08S57yGLGEG9TQt8Uw2slc4HvbG-TZtEEuN0,744
-bullish/jobs/tasks.py,sha256=V_b0c8_GQC0-KIxaHDlLFhtkclQJOsck0gXaW6OlC_w,3055
+bullish/jobs/models.py,sha256=S2yvBf69lmt4U-5OU5CjXCMSw0s9Ubh9xkrB3k2qOZo,764
+bullish/jobs/tasks.py,sha256=vXPbISYFUZlrYkMVUb7y-g-z0BBi91wQLm8RbYqR4I0,3691
 bullish/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bullish/utils/checks.py,sha256=Va10_xDVVnxYkOD2hafvyQ-TFV8FQpOkr4huJ7XgpDM,2188
-bullishpy-0.15.0.dist-info/METADATA,sha256=j-VPiqIl7LJyJ56b4oolBx4ZAsJljbxw-NA6wKzmir8,828
-bullishpy-0.15.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-bullishpy-0.15.0.dist-info/entry_points.txt,sha256=eaPpmL6vmSBFo0FBtwibCXGqAW4LFJ83whJzT1VjD-0,43
-bullishpy-0.15.0.dist-info/RECORD,,
+bullishpy-0.17.0.dist-info/METADATA,sha256=eKWsEZTrxHOWMj6v4ZaGuHW3mqThCZecKmWeeZ_yD5E,828
+bullishpy-0.17.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+bullishpy-0.17.0.dist-info/entry_points.txt,sha256=eaPpmL6vmSBFo0FBtwibCXGqAW4LFJ83whJzT1VjD-0,43
+bullishpy-0.17.0.dist-info/RECORD,,