monthly_cash, monthly_params

4 years ago · 75e770960b
parent 7585d54eb0
commit 75e770960b
2 changed files with 106 additions and 60 deletions
--- a/compare.py
+++ b/compare.py
@ -18,13 +18,24 @@ def get_data(stocks, start, end):
        cache_name="cache", backend="sqlite", expire_after=expire_after
    )
    session.headers = DEFAULT_HEADERS
-    start = datetime.datetime.fromisoformat("1900-01-01")
-    end = datetime.datetime.now()
-    stockData = pdr.get_data_yahoo(stocks, start, end, session=session)
-    return stockData
+    stockData = pdr.get_data_yahoo(
+        stocks,
+        datetime.datetime.fromisoformat("1900-01-01"),
+        datetime.datetime.now(),
+        session=session,
+    )
+    return stockData.loc[start:end]
+
+
+def human_readable_size(size, decimal_places=3):
+    for unit in ["$", "K$", "M$", "G$", "T$", "P$"]:
+        if size < 1000.0 or unit == "P$":
+            return f"{size:.{decimal_places}f} {unit}"
+            break
+        size /= 1000.0


-def run(strategy, data, fund_mode=False):
+def prepare_simulation(strategy, params, data, fund_mode=False):
    if fund_mode:
        cerebro = bt.Cerebro()
        cerebro.addobserver(bt.observers.FundShares)
@ -34,7 +45,7 @@ def run(strategy, data, fund_mode=False):
        cerebro.addobserver(bt.observers.BuySell)

    cerebro.adddata(data)
-    cerebro.addstrategy(strategy)
+    cerebro.addstrategy(strategy, params)

    # Broker Information
    broker_args = dict(coc=True)
@ -45,68 +56,100 @@ def run(strategy, data, fund_mode=False):
    if fund_mode:
        cerebro.broker.set_fundmode(True)

-    cerebro.broker.set_cash(st.month_sum)
    cerebro.addanalyzer(bt.analyzers.DrawDown, _name="drawdown")
    cerebro.addanalyzer(bt.analyzers.VWR, _name="returns")
    cerebro.addanalyzer(
        bt.analyzers.TimeReturn, timeframe=bt.TimeFrame.NoTimeFrame, _name="tr"
    )
-    thestrats = cerebro.run()
-    thestrat = thestrats[0]
-    # cerebro.plot(iplot=False, style="candlestick")
-    return thestrat
+    return cerebro


-if __name__ == "__main__":
+def simulate(stockData, monthly_params):
+    pd.options.display.float_format = "{:,.2f}".format
    df = pd.DataFrame(
        columns=[
-            "froi",
+            "froi%",
            "cost",
            "total_value",
-            "times",
-            "units",
+            "#deals",
+            "#units",
            "comms",
+            "monthly",
            "annual%",
-            "max_dd_len",
-            "max_dd",
+            "max_dd_days",
+            "max_dd%",
            "max_md",
-            "twr",
+            "vwr",
            "tr",
        ]
    )

+    actualStart: datetime.datetime = stockData.index[0]
+    actualEnd: datetime.datetime = stockData.index[-1]
+    data = bt.feeds.PandasData(dataname=stockData)
+
+    for i, strategy in enumerate((st.DCA, st.QDCA, st.VA, st.QVA)):
+        cerebro = prepare_simulation(strategy, monthly_params, data)
+        cerebro.broker.set_cash(monthly_params["sum"])
+        therun = cerebro.run()[0]
+        # cerebro.plot(iplot=False, style="candlestick")
+        dd = therun.analyzers.drawdown
+        ret = therun.analyzers.returns
+        tr = therun.analyzers.tr
+        # print(next(reversed(tr.get_analysis())))
+        params = therun.calc_params()
+        # omg IM so sorry for this, ironically this is here to get human readable size
+        for i in 1, 2, 5, 6:
+            params[i] = human_readable_size(params[i])
+        annual = 100 * (
+            (1 + params[0] / 100) ** (365 / (actualEnd - actualStart).days) - 1
+        )
+        df.loc[strategy.__name__] = params + [
+            annual,
+            dd.get_analysis().max.len,
+            dd.get_analysis().max.drawdown,
+            human_readable_size(dd.get_analysis().max.moneydown),
+            ret.get_analysis()["vwr"],
+            list(tr.get_analysis().items())[0][1],
+        ]
+    print(
+        "Investing monthly, increasing {:.2f}%, starting from ${}, from {} to {}, {:.1f} years".format(
+            (monthly_params["coef"] * 100) - 100,
+            monthly_params["sum"],
+            actualStart.date(),
+            actualEnd.date(),
+            (actualEnd - actualStart).days / 365,
+        )
+    )
+    # print(df[["annual%", "froi%", "cost", "total_value", "max_dd%", "max_md"]])
+    print(df)
+
+
+if __name__ == "__main__":
    stockList = ["^GSPC"]
+    monthly_params = dict(sum=1000, coef=1.001)
    # startDate = datetime.datetime.fromisoformat("2000-01-01")
    # endDate = datetime.datetime.fromisoformat("2022-01-01")
    print(stockList[0])
-    for period_years in (20, 50):
-        endDate = datetime.datetime.now()
-        startDate = endDate - datetime.timedelta(days=period_years * 365)
-        stockData = get_data(stockList[0], startDate, endDate)
-        actualStart: datetime.datetime = stockData.index[0]
-        data = bt.feeds.PandasData(dataname=stockData)
-
-        for i, strategy in enumerate(
-            (st.SmaCross, st.DCA, st.QDCA, st.VA, st.QVA, st.SmaVA)
-        ):
-            therun = run(strategy, data)
-            dd = therun.analyzers.drawdown
-            ret = therun.analyzers.returns
-            tr = therun.analyzers.tr
-            # print(next(reversed(tr.get_analysis())))
-            params = therun.calc_params()
-            annual = 100 * (
-                (1 + params[0] / 100) ** (365 / (endDate - actualStart).days) - 1
-            )
-            df.loc[strategy.__name__] = therun.calc_params() + (
-                annual,
-                dd.get_analysis().max.len,
-                dd.get_analysis().max.drawdown,
-                dd.get_analysis().max.moneydown,
-                ret.get_analysis()["vwr"],
-                list(tr.get_analysis().items())[0][1],
-            )
-        print("Starting from:", actualStart)
-        print("Time in Market: {:.1f} years".format((endDate - actualStart).days / 365))
-        # print(df[["annual%", "froi", "cost", "total_value", "max_dd", "max_md"]])
-        print(df)
+    for period_years in (1, 2, 5, 10, 20, 50, 100):
+        end_date = datetime.datetime.now()
+        start_date = end_date - datetime.timedelta(days=period_years * 365)
+        stockData = get_data(stockList[0], start_date, end_date)
+        simulate(stockData, monthly_params)
+    """
+    period_years = 10
+    stockData = get_data(
+        stockList[0],
+        datetime.datetime.fromisoformat("1900-01-01"),
+        datetime.datetime.now(),
+    )
+    start_date = stockData.index[0]
+    end_date = start_date + datetime.timedelta(days=period_years * 365)
+    while start_date < datetime.datetime.today():
+        stockData = get_data(stockList[0], start_date, end_date)
+        simulate(stockData)
+        start_date, end_date = (
+            end_date,
+            end_date + datetime.timedelta(days=period_years * 365),
+        )
+    """
--- a/strategies.py
+++ b/strategies.py
@ -7,8 +7,6 @@ from pandas_datareader import data as pdr
 import backtrader as bt

 reserve = 5  # usd for comms etc cause I cant math
-month_sum = 5000  # usd
-

 """
 class LSI(bt.Strategy):
@ -47,7 +45,8 @@ class PercentageCommisionScheme(bt.CommInfoBase):


 class Investing(bt.Strategy):
-    def __init__(self):
+    def __init__(self, params={"sum": 500, "coef": 1}):
+        self.monthly_params = params
        self.order = None
        self.cost = 0  # no comms
        self.comms = 0
@ -105,21 +104,26 @@ class Investing(bt.Strategy):

        self.order = None

+    @property
+    def monthly_cash(self):
+        return self.monthly_params["sum"] * self.monthly_params["coef"] ** (self.months)
+
    def calc_params(self):
        # calculate actual returns
        self.froi = self.broker.get_fundvalue() - self.val_start
-        return (
+        return [
            self.froi,
            self.cost,
            self.broker.get_value(),
            self.times,
            self.units,
            self.comms,
-        )
+            self.monthly_cash,
+        ]

    def notify_timer(self, timer, when, *args):
        self.months += 1
-        self.broker.add_cash(month_sum * 1.005 ** (self.months))
+        self.broker.add_cash(self.monthly_cash)


 class FormulaInvesting(Investing):
@ -132,7 +136,7 @@ class VA(FormulaInvesting):
    def formula(self):
        target_value = (
            min(
-                self.months * month_sum * 1.005 ** (self.months),
+                self.months * self.monthly_cash,
                self.broker.get_value(),
            )
            - reserve
@ -159,14 +163,13 @@ class QDCA(DCA):


 class SmaCross(Investing):
-    # list of parameters which are configurable for the strategy
    params = dict(
        pfast=50,  # period for the fast moving average
        pslow=200,  # period for the slow moving average
    )
-
-    def __init__(self):
-        super().__init__()
+    # list of parameters which are configurable for the strategy
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
        sma1 = bt.ind.SMA(period=self.p.pfast)  # fast moving average
        sma2 = bt.ind.SMA(period=self.p.pslow)  # slow moving average
        self.crossover = bt.ind.CrossOver(sma1, sma2)  # crossover signal