BackcastPro 0.3.4__py3-none-any.whl

BackcastPro/__init__.py

@@ -0,0 +1,28 @@
+"""
+BackcastPro をご利用いただきありがとうございます。
+
+インストール後のご案内（インストール済みユーザー向け）
+
+- ドキュメント総合トップ: [index.md](https://github.com/botterYosuke/BackcastPro/blob/main/docs/index.md)
+- クイックスタート/チュートリアル: [tutorial.md](https://github.com/botterYosuke/BackcastPro/blob/main/docs/tutorial.md)
+- APIリファレンス: [BackcastPro - APIリファレンス](https://botteryosuke.github.io/BackcastPro/namespacesrc_1_1BackcastPro.html)
+- トラブルシューティング: [troubleshooting.md](https://github.com/botterYosuke/BackcastPro/blob/main/docs/troubleshooting.md)
+
+※ 使い始めはチュートリアル → 詳細はAPIリファレンスをご参照ください。
+"""
+from .backtest import Backtest
+
+from .api.stocks_price import get_stock_daily
+from .api.stocks_board import get_stock_board
+from .api.stocks_info import get_stock_info
+from .api.chart import chart
+from .api.board import board
+
+__all__ = [
+    'Backtest',
+    'get_stock_daily', 
+    'get_stock_board', 
+    'get_stock_info',
+    'chart',
+    'board'
+]

BackcastPro/_broker.py

@@ -0,0 +1,430 @@
+"""
+ブローカー管理モジュール。
+"""
+
+import warnings
+from math import copysign
+from typing import List, Optional, TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+
+from .order import Order
+from .position import Position
+from .trade import Trade
+
+if TYPE_CHECKING:
+    pass
+
+
+class _Broker:
+    """
+    バックテストにおける証券取引の実行、注文管理、ポジション管理、損益計算を担当します。
+    実際の証券会社のブローカー機能をシミュレートし、リアルな取引環境を提供します。
+    
+    Parameters
+    ----------
+    data : pd.DataFrame
+        取引対象の価格データ。Open, High, Low, Closeの列を持つ必要があります。
+    cash : float
+        初期現金残高。正の値である必要があります。
+    spread : float
+        ビッドアスクスプレッド（買値と売値の差）。取引コストとして使用されます。
+    commission : float or tuple or callable
+        手数料の設定方法：
+        - float: 相対手数料（例: 0.001 = 0.1%）
+        - tuple: (固定手数料, 相対手数料) の組み合わせ
+        - callable: カスタム手数料計算関数 (size, price) -> 手数料
+    margin : float
+        必要証拠金率（0 < margin <= 1）。レバレッジ = 1/margin として計算されます。
+    trade_on_close : bool
+        取引を終値で実行するかどうか。Trueの場合、次の始値ではなく現在の終値で取引します。
+    hedging : bool
+        ヘッジングモードの有効化。Trueの場合、反対方向のポジションを同時に保有できます。
+    exclusive_orders : bool
+        排他的注文モード。Trueの場合、新しい注文が前のポジションを自動的にクローズします。
+    """
+
+    # ヒント:
+    # 関数定義における`*`の意味
+    # - `*`以降の引数は、必ずキーワード引数として渡す必要がある
+    # - 位置引数として渡すことはできない
+    # なぜキーワード専用引数を使うのか？
+    # 1. APIの明確性: 引数の意味が明確になる
+    # 2. 保守性: 引数の順序を変更しても既存のコードが壊れない
+    # 3. 可読性: 関数呼び出し時に何を渡しているかが分かりやすい
+    def __init__(self, *, data, cash, spread, commission, margin,
+                 trade_on_close, hedging, exclusive_orders):
+        assert cash > 0, f"cash should be > 0, is {cash}"
+        assert 0 < margin <= 1, f"margin should be between 0 and 1, is {margin}"
+        self._data: dict[str, pd.DataFrame] = data
+        self._cash = cash
+
+        # 手数料の登録
+        if callable(commission):
+            # 関数`commission`が呼び出し可能な場合
+            self._commission = commission
+        else:
+            try:
+                self._commission_fixed, self._commission_relative = commission
+            except TypeError:
+                self._commission_fixed, self._commission_relative = 0, commission
+            assert self._commission_fixed >= 0, 'Need fixed cash commission in $ >= 0'
+            assert -.1 <= self._commission_relative < .1, \
+                ("commission should be between -10% "
+                 f"(e.g. market-maker's rebates) and 10% (fees), is {self._commission_relative}")
+            self._commission = self._commission_func
+
+
+        self._spread = spread
+        self._leverage = 1 / margin
+        self._trade_on_close = trade_on_close
+        self._hedging = hedging
+        self._exclusive_orders = exclusive_orders
+
+        self._equity = []
+        self._current_time = None
+        self.orders: List[Order] = []
+        self.trades: List[Trade] = []
+        self.position = Position(self)
+        self.closed_trades: List[Trade] = []
+
+    def _commission_func(self, order_size, price):
+        return self._commission_fixed + abs(order_size) * price * self._commission_relative
+
+    def new_order(self,
+                  code: str,
+                  size: float,
+                  limit: Optional[float] = None,
+                  stop: Optional[float] = None,
+                  sl: Optional[float] = None,
+                  tp: Optional[float] = None,
+                  tag: object = None,
+                  *,
+                  trade: Optional[Trade] = None) -> Order:
+        """
+        Argument size indicates whether the order is long or short
+        """
+        size = float(size)
+        stop = stop and float(stop)
+        limit = limit and float(limit)
+        sl = sl and float(sl)
+        tp = tp and float(tp)
+
+        is_long = size > 0
+        assert size != 0, size
+        adjusted_price = self._adjusted_price(code, size)
+
+        if is_long:
+            if not (sl or -np.inf) < (limit or stop or adjusted_price) < (tp or np.inf):
+                raise ValueError(
+                    "Long orders require: "
+                    f"SL ({sl}) < LIMIT ({limit or stop or adjusted_price}) < TP ({tp})")
+        else:
+            if not (tp or -np.inf) < (limit or stop or adjusted_price) < (sl or np.inf):
+                raise ValueError(
+                    "Short orders require: "
+                    f"TP ({tp}) < LIMIT ({limit or stop or adjusted_price}) < SL ({sl})")
+
+        order = Order(self, code, size, limit, stop, sl, tp, trade, tag)
+
+        if not trade:
+            # 排他的注文（各新しい注文が前の注文/ポジションを自動クローズ）の場合、
+            # 事前にすべての非条件付き注文をキャンセルし、すべてのオープン取引をクローズ
+            if self._exclusive_orders:
+                for o in self.orders:
+                    if not o.is_contingent:
+                        o.cancel()
+                for t in self.trades:
+                    t.close()
+
+        # 新しい注文を注文キューに配置、SL注文が最初に処理されるようにする
+        self.orders.insert(0 if trade and stop else len(self.orders), order)
+
+        return order
+
+    def last_price(self, code: str) -> float:
+        """ Price at the last (current) close. """
+        return self._data[code].Close.iloc[-1]
+
+    def _adjusted_price(self, code: str, size=None, price=None) -> float:
+        """
+        Long/short `price`, adjusted for spread.
+        In long positions, the adjusted price is a fraction higher, and vice versa.
+        """
+        return (price or self.last_price(code)) * (1 + copysign(self._spread, size))
+
+    @property
+    def equity(self) -> float:
+        return self._cash + sum(trade.pl for trade in self.trades)
+
+    @property
+    def margin_available(self) -> float:
+        # https://github.com/QuantConnect/Lean/pull/3768 から
+        margin_used = sum(trade.value / self._leverage for trade in self.trades)
+        return max(0, self.equity - margin_used)
+
+    @property
+    def cash(self):
+        return self._cash
+
+    @property
+    def commission(self):
+        return self._commission
+
+    def next(self, current_time: pd.Timestamp):
+        self._current_time = current_time
+        self._process_orders()
+
+        # エクイティカーブ用にアカウントエクイティを記録
+        equity = self.equity
+        self._equity.append(equity)
+
+        # エクイティが負の場合、すべてを0に設定してシミュレーションを停止
+        if equity <= 0:
+            assert self.margin_available <= 0
+            for trade in self.trades:
+                price = self._data[trade.code].Close.iloc[-1]
+                self._close_trade(trade, price, self._current_time)
+            self._cash = 0
+            raise Exception
+
+    def _process_orders(self):
+        data = self._data
+        reprocess_orders = False
+
+        # 注文を処理
+        for order in list(self.orders):  # 型: Order
+
+            # 関連するSL/TP注文は既に削除されている
+            if order not in self.orders:
+                continue
+
+            # 注文の銘柄データを取得
+            if order.code not in data:
+                continue
+            df = data[order.code]
+            
+            # データの存在確認
+            if len(df) == 0 or df.index[-1] != self._current_time:
+                continue
+                
+            open, high, low = df.Open.iloc[-1], df.High.iloc[-1], df.Low.iloc[-1]
+
+            # ストップ条件が満たされたかチェック
+            stop_price = order.stop
+            if stop_price:
+                is_stop_hit = ((high >= stop_price) if order.is_long else (low <= stop_price))
+                if not is_stop_hit:
+                    continue
+
+                # ストップ価格に達すると、ストップ注文は成行/指値注文になる
+                # https://www.sec.gov/fast-answers/answersstopordhtm.html
+                order._replace(stop_price=None)
+
+            # 購入価格を決定
+            # 指値注文が約定可能かチェック
+            if order.limit:
+                is_limit_hit = low <= order.limit if order.is_long else high >= order.limit
+                # ストップとリミットが同じバー内で満たされた場合、悲観的に
+                # リミットがストップより先に満たされたと仮定する（つまり「カウントされる前に」）
+                is_limit_hit_before_stop = (is_limit_hit and
+                                            (order.limit <= (stop_price or -np.inf)
+                                            if order.is_long
+                                            else order.limit >= (stop_price or np.inf)))
+                if not is_limit_hit or is_limit_hit_before_stop:
+                    continue
+
+                # stop_priceが設定されている場合、このバー内で満たされた
+                price = (min(stop_price or open, order.limit)
+                        if order.is_long else
+                        max(stop_price or open, order.limit))
+            else:
+                # 成行注文（Market-if-touched / market order）
+                # 条件付き注文は常に次の始値で
+                prev_close = df.Close.iloc[-2]
+                price = prev_close if self._trade_on_close and not order.is_contingent else open
+                if stop_price:
+                    price = max(price, stop_price) if order.is_long else min(price, stop_price)
+
+                # エントリー/エグジットバーのインデックスを決定
+                is_market_order = not order.limit and not stop_price
+
+                # 注文がSL/TP注文の場合、それが依存していた既存の取引をクローズする必要がある
+                if order.parent_trade:
+                    trade = order.parent_trade
+                    _prev_size = trade.size
+                    # order.sizeがtrade.sizeより「大きい」場合、この注文はtrade.close()注文で
+                    # 取引の一部は事前にクローズされている
+                    size = copysign(min(abs(_prev_size), abs(order.size)), order.size)
+                    # この取引がまだクローズされていない場合（例：複数の`trade.close(.5)`呼び出し）
+                    if trade in self.trades:
+                        self._reduce_trade(trade, price, size, self._current_time)
+                        assert order.size != -_prev_size or trade not in self.trades
+                        if price == stop_price:
+                            # 統計用にSLを注文に戻す
+                            trade._sl_order._replace(stop_price=stop_price)
+                    if order in (trade._sl_order,
+                                trade._tp_order):
+                        assert order.size == -trade.size
+                        assert order not in self.orders  # 取引がクローズされたときに削除される
+                    else:
+                        # trade.close()注文で、完了
+                        assert abs(_prev_size) >= abs(size) >= 1
+                        self.orders.remove(order)
+                    continue
+
+                # そうでなければ、これは独立した取引
+
+                # 手数料（またはビッドアスクスプレッド）を含むように価格を調整
+                # ロングポジションでは調整価格が少し高くなり、その逆も同様
+                adjusted_price = self._adjusted_price(code=order.code, size=order.size, price=price)
+                
+                # 調整済み価格がゼロまたは負の場合、注文をスキップ
+                if adjusted_price <= 0:
+                    warnings.warn(
+                        f'{self._current_time}: {order.code} の調整済み価格が無効です（{adjusted_price}）。注文をキャンセルしました。'
+                        f'価格データが正常か確認してください。', 
+                        category=UserWarning)
+                    self.orders.remove(order)
+                    continue
+                
+                adjusted_price_plus_commission = \
+                    adjusted_price + self._commission(order.size, price) / abs(order.size)
+                
+ 
+                # 注文サイズが比例的に指定された場合、
+                # マージンとスプレッド/手数料を考慮して、単位での真のサイズを事前計算
+                size = order.size
+                if -1 < size < 1:
+                    size = copysign(int((self.margin_available * self._leverage * abs(size))
+                                        // adjusted_price_plus_commission), size)
+                    # 単一ユニットでも十分な現金/マージンがない
+                    if not size:
+                        warnings.warn(
+                            f'{self._current_time}: ブローカーは相対サイズの注文を'
+                            f'不十分なマージンのためキャンセルしました。', category=UserWarning)
+                        # XXX: 注文はブローカーによってキャンセルされる？
+                        self.orders.remove(order)
+                        continue
+                assert size == round(size)
+                need_size = int(size)
+
+                if not self._hedging:
+                    # 既存の反対方向の取引をFIFOでクローズ/削減してポジションを埋める
+                    # 既存の取引は調整価格でクローズされる（調整は購入時に既に行われているため）
+                    for trade in list(self.trades):
+                        if trade.is_long == order.is_long:
+                            continue
+                        assert trade.size * order.size < 0
+
+                        # 注文サイズがこの反対方向の既存取引より大きい場合、
+                        # 完全にクローズされる
+                        if abs(need_size) >= abs(trade.size):
+                            self._close_trade(trade, price, self._current_time)
+                            need_size += trade.size
+                        else:
+                            # 既存の取引が新しい注文より大きい場合、
+                            # 部分的にのみクローズされる
+                            self._reduce_trade(trade, price, need_size, self._current_time)
+                            need_size = 0
+
+                        if not need_size:
+                            break
+
+                # 注文をカバーするのに十分な流動性がない場合、ブローカーはそれをキャンセルする
+                if abs(need_size) * adjusted_price_plus_commission > \
+                        self.margin_available * self._leverage:
+                    self.orders.remove(order)
+                    continue
+
+                # 新しい取引を開始
+                if need_size:
+                    self._open_trade(order.code,
+                                    adjusted_price,
+                                    need_size,
+                                    order.sl,
+                                    order.tp,
+                                    self._current_time,
+                                    order.tag)
+
+                    # 新しくキューに追加されたSL/TP注文を再処理する必要がある
+                    # これにより、注文が開かれた同じバーでSLがヒットすることを可能にする
+                    # https://github.com/kernc/backtesting.py/issues/119 を参照
+                    if order.sl or order.tp:
+                        if is_market_order:
+                            reprocess_orders = True
+                        # Order.stopとTPが同じバー内でヒットしたが、SLはヒットしなかった。この場合
+                        # ストップとTPが同じ価格方向に進むため、曖昧ではない
+                        elif stop_price and not order.limit and order.tp and (
+                                (order.is_long and order.tp <= high and (order.sl or -np.inf) < low) or
+                                (order.is_short and order.tp >= low and (order.sl or np.inf) > high)):
+                            reprocess_orders = True
+                        elif (low <= (order.sl or -np.inf) <= high or
+                            low <= (order.tp or -np.inf) <= high):
+                            warnings.warn(
+                                f"({df.index[-1]}) 条件付きSL/TP注文が、その親ストップ/リミット注文が取引に"
+                                "変換された同じバーで実行されることになります。"
+                                "正確なローソク足内価格変動を断言できないため、"
+                                "影響を受けるSL/TP注文は代わりに次の（マッチングする）価格/バーで"
+                                "実行され、結果（この取引の）が幾分疑わしいものになります。"
+                                "https://github.com/kernc/backtesting.py/issues/119 を参照",
+                                UserWarning)
+
+                # 注文処理完了
+                self.orders.remove(order)
+
+        if reprocess_orders:
+            self._process_orders()
+
+    def _reduce_trade(self, trade: Trade, price: float, size: float, current_time: pd.Timestamp):
+        assert trade.size * size < 0
+        assert abs(trade.size) >= abs(size)
+
+        size_left = trade.size + size
+        assert size_left * trade.size >= 0
+        if not size_left:
+            close_trade = trade
+        else:
+            # 既存の取引を削減...
+            trade._replace(size=size_left)
+            if trade._sl_order:
+                trade._sl_order._replace(size=-trade.size)
+            if trade._tp_order:
+                trade._tp_order._replace(size=-trade.size)
+
+            # ... その削減コピーをクローズすることによって
+            close_trade = trade._copy(size=-size, sl_order=None, tp_order=None)
+            self.trades.append(close_trade)
+
+        self._close_trade(close_trade, price, current_time)
+
+    def _close_trade(self, trade: Trade, price: float, current_time: pd.Timestamp):
+        self.trades.remove(trade)
+        if trade._sl_order:
+            self.orders.remove(trade._sl_order)
+        if trade._tp_order:
+            self.orders.remove(trade._tp_order)
+
+        closed_trade = trade._replace(exit_price=price, exit_time=current_time)
+        self.closed_trades.append(closed_trade)
+        # 取引終了時に手数料を再度適用
+        commission = self._commission(trade.size, price)
+        self._cash += trade.pl - commission
+        # 統計用にTradeインスタンスに手数料を保存
+        trade_open_commission = self._commission(closed_trade.size, closed_trade.entry_price)
+        # サイズが_reduce_trade()によって変更された可能性があるため、
+        # Trade開始時ではなくここで適用
+        closed_trade._commissions = commission + trade_open_commission
+
+    def _open_trade(self, code: str, price: float, size: int,
+                    sl: Optional[float], tp: Optional[float], current_time: pd.Timestamp, tag):
+        trade = Trade(self, code, size, price, current_time, tag)
+        self.trades.append(trade)
+        # 取引開始時にブローカー手数料を適用
+        self._cash -= self._commission(size, price)
+        # SL/TP（ブラケット）注文を作成。
+        if tp:
+            trade.tp = tp
+        if sl:
+            trade.sl = sl

BackcastPro/_stats.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import datetime
+from numbers import Number
+from typing import TYPE_CHECKING, List, Union, cast
+
+import numpy as np
+import pandas as pd
+
+if TYPE_CHECKING:
+   from .strategy import Strategy
+   from .trade import Trade
+
+def compute_drawdown_duration_peaks(dd: pd.Series):
+    iloc = np.unique(np.r_[(dd == 0).values.nonzero()[0], len(dd) - 1])
+    iloc = pd.Series(iloc, index=dd.index[iloc])
+    df = iloc.to_frame('iloc').assign(prev=iloc.shift())
+    df = df[df['iloc'] > df['prev'] + 1].astype(np.int64)
+
+    # 取引がないためドローダウンがない場合、pandasの都合上以下を避けてnanシリーズを返す
+    if not len(df):
+        return (dd.replace(0, np.nan),) * 2
+
+    df['duration'] = df['iloc'].map(dd.index.__getitem__) - df['prev'].map(dd.index.__getitem__)
+    df['peak_dd'] = df.apply(lambda row: dd.iloc[row['prev']:row['iloc'] + 1].max(), axis=1)
+    df = df.reindex(dd.index)
+    return df['duration'], df['peak_dd']
+
+def geometric_mean(returns: pd.Series) -> float:
+    returns = returns.fillna(0) + 1
+    if np.any(returns <= 0):
+        return 0
+    return np.exp(np.log(returns).sum() / (len(returns) or np.nan)) - 1
+
+def _data_period(index) -> Union[pd.Timedelta, Number]:
+    """データインデックスの期間をpd.Timedeltaとして返す"""
+    values = pd.Series(index[-100:])
+    return values.diff().dropna().median()
+
+def compute_stats(
+        trades: Union[List['Trade'], pd.DataFrame],
+        equity: np.ndarray,
+        index: pd.DatetimeIndex,
+        strategy_instance: Strategy | None,
+        risk_free_rate: float = 0,
+) -> pd.Series:
+    assert -1 < risk_free_rate < 1
+
+   
+    # エクイティカーブとインデックスの長さを一致させる
+    if len(equity) > len(index):
+        equity = equity[:len(index)]
+    elif len(equity) < len(index):
+        # エクイティカーブが短い場合は、0で埋める
+        equity = np.concatenate([equity, np.full(len(index) - len(equity), 0)])
+    
+    dd = 1 - equity / np.maximum.accumulate(equity)
+    dd_dur, dd_peaks = compute_drawdown_duration_peaks(pd.Series(dd, index=index))
+
+    equity_df = pd.DataFrame({
+        'Equity': equity,
+        'DrawdownPct': dd,
+        'DrawdownDuration': dd_dur},
+        index=index)
+
+    if isinstance(trades, pd.DataFrame):
+        trades_df: pd.DataFrame = trades
+        commissions = None  # Not shown
+    else:
+        # Backtest.run()から直接来たデータ
+        trades_df = pd.DataFrame({
+            'Code': [t.code for t in trades],
+            'Size': [t.size for t in trades],
+            'EntryBar': [t.entry_bar for t in trades],
+            'ExitBar': [t.exit_bar for t in trades],
+            'EntryPrice': [t.entry_price for t in trades],
+            'ExitPrice': [t.exit_price for t in trades],
+            'SL': [t.sl for t in trades],
+            'TP': [t.tp for t in trades],
+            'PnL': [t.pl for t in trades],
+            'Commission': [t._commissions for t in trades],
+            'ReturnPct': [t.pl_pct for t in trades],
+            'EntryTime': [t.entry_time for t in trades],
+            'ExitTime': [t.exit_time for t in trades],
+        })
+        trades_df['Duration'] = trades_df['ExitTime'] - trades_df['EntryTime']
+        trades_df['Tag'] = [t.tag for t in trades]
+
+        commissions = sum(t._commissions for t in trades)
+    del trades
+
+    pl = trades_df['PnL']
+    returns = trades_df['ReturnPct']
+    durations = trades_df['Duration']
+
+    def _round_timedelta(value, _period=_data_period(index)):
+        if not isinstance(value, pd.Timedelta):
+            return value
+        resolution = getattr(_period, 'resolution_string', None) or _period.resolution
+        return value.ceil(resolution)
+
+    s = pd.Series(dtype=object)
+    s.loc['Start'] = index[0]
+    s.loc['End'] = index[-1]
+    s.loc['Duration'] = s.End - s.Start
+
+    have_position = np.repeat(0, len(index))
+    for t in trades_df.itertuples(index=False):
+        have_position[t.EntryBar:t.ExitBar + 1] = 1
+
+    s.loc['Exposure Time [%]'] = have_position.mean() * 100  # "n bars"時間単位、インデックス時間ではない
+    s.loc['Equity Final [$]'] = equity[-1]
+    s.loc['Equity Peak [$]'] = equity.max()
+    if commissions:
+        s.loc['Commissions [$]'] = commissions
+    s.loc['Return [%]'] = (equity[-1] - equity[0]) / equity[0] * 100
+
+    gmean_day_return: float = 0
+    day_returns = np.array(np.nan)
+    annual_trading_days = np.nan
+    is_datetime_index = isinstance(index, pd.DatetimeIndex)
+    if is_datetime_index:
+        freq_days = cast(pd.Timedelta, _data_period(index)).days
+        have_weekends = index.dayofweek.to_series().between(5, 6).mean() > 2 / 7 * .6
+        annual_trading_days = (
+            52 if freq_days == 7 else
+            12 if freq_days == 31 else
+            1 if freq_days == 365 else
+            (365 if have_weekends else 252))
+        freq = {7: 'W', 31: 'ME', 365: 'YE'}.get(freq_days, 'D')
+        day_returns = equity_df['Equity'].resample(freq).last().dropna().pct_change()
+        gmean_day_return = geometric_mean(day_returns)
+
+    # 年率化リターンとリスク指標は、リターンが複利計算されるという（ほぼ正確な）
+    # 仮定に基づいて計算される。参照: https://dx.doi.org/10.2139/ssrn.3054517
+    # 我々の年率化リターンは`empyrical.annual_return(day_returns)`と一致するが、
+    # リスクは一致しない。彼らは以下のより単純なアプローチを使用している。
+    annualized_return = (1 + gmean_day_return)**annual_trading_days - 1
+    s.loc['Return (Ann.) [%]'] = annualized_return * 100
+    s.loc['Volatility (Ann.) [%]'] = np.sqrt((day_returns.var(ddof=int(bool(day_returns.shape))) + (1 + gmean_day_return)**2)**annual_trading_days - (1 + gmean_day_return)**(2 * annual_trading_days)) * 100  # noqa: E501
+    # s.loc['Return (Ann.) [%]'] = gmean_day_return * annual_trading_days * 100
+    # s.loc['Risk (Ann.) [%]'] = day_returns.std(ddof=1) * np.sqrt(annual_trading_days) * 100
+    if is_datetime_index:
+        time_in_years = (s.loc['Duration'].days + s.loc['Duration'].seconds / 86400) / annual_trading_days
+        s.loc['CAGR [%]'] = ((s.loc['Equity Final [$]'] / equity[0])**(1 / time_in_years) - 1) * 100 if time_in_years else np.nan  # noqa: E501
+
+    # 我々のSharpeは`empyrical.sharpe_ratio()`と一致しない。彼らは算術平均リターン
+    # と単純な標準偏差を使用するため
+    s.loc['Sharpe Ratio'] = (s.loc['Return (Ann.) [%]'] - risk_free_rate * 100) / (s.loc['Volatility (Ann.) [%]'] or np.nan)  # noqa: E501
+    # 我々のSortinoは`empyrical.sortino_ratio()`と一致しない。彼らは算術平均リターンを使用するため
+    with np.errstate(divide='ignore'):
+        s.loc['Sortino Ratio'] = (annualized_return - risk_free_rate) / (np.sqrt(np.mean(day_returns.clip(-np.inf, 0)**2)) * np.sqrt(annual_trading_days))  # noqa: E501
+    max_dd = -np.nan_to_num(dd.max())
+    s.loc['Calmar Ratio'] = annualized_return / (-max_dd or np.nan)
+    s.loc['Max. Drawdown [%]'] = max_dd * 100
+    s.loc['Avg. Drawdown [%]'] = -dd_peaks.mean() * 100
+    s.loc['Max. Drawdown Duration'] = _round_timedelta(dd_dur.max())
+    s.loc['Avg. Drawdown Duration'] = _round_timedelta(dd_dur.mean())
+    s.loc['# Trades'] = n_trades = len(trades_df)
+    win_rate = np.nan if not n_trades else (pl > 0).mean()
+    s.loc['Win Rate [%]'] = win_rate * 100
+    s.loc['Best Trade [%]'] = returns.max() * 100
+    s.loc['Worst Trade [%]'] = returns.min() * 100
+    mean_return = geometric_mean(returns)
+    s.loc['Avg. Trade [%]'] = mean_return * 100
+    s.loc['Max. Trade Duration'] = _round_timedelta(durations.max())
+    s.loc['Avg. Trade Duration'] = _round_timedelta(durations.mean())
+    s.loc['Profit Factor'] = returns[returns > 0].sum() / (abs(returns[returns < 0].sum()) or np.nan) 
+    s.loc['Expectancy [%]'] = returns.mean() * 100
+    s.loc['SQN'] = np.sqrt(n_trades) * pl.mean() / (pl.std() or np.nan)
+    s.loc['Kelly Criterion'] = win_rate - (1 - win_rate) / (pl[pl > 0].mean() / -pl[pl < 0].mean())
+
+    s.loc['_strategy'] = strategy_instance
+    s.loc['_equity_curve'] = equity_df
+    s.loc['_trades'] = trades_df
+
+    return s

BackcastPro/api/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+BackcastPro Startup Module
+"""