BackcastPro 0.0.5__py3-none-any.whl → 0.1.1__py3-none-any.whl

BackcastPro/backtest.py

@@ -76,8 +76,9 @@ class Backtest:
     まだ[アクティブで継続中]の取引は最後のバーでクローズされ、
     計算されたバックテスト統計に貢献します。
     """  
+
     def __init__(self,
-                 data: pd.DataFrame,
+                 data: dict[str, pd.DataFrame],
                  strategy: Type,
                  *,
                  cash: float = 10_000,
@@ -94,8 +95,7 @@ class Backtest:
         
         if not (isinstance(strategy, type) and issubclass(strategy, Strategy)):
             raise TypeError('`strategy` must be a Strategy sub-type')
-        if not isinstance(data, pd.DataFrame):
-            raise TypeError("`data` must be a pandas.DataFrame with columns")
+    
         if not isinstance(spread, Number):
             raise TypeError('`spread` must be a float value, percent of '
                             'entry order price')
@@ -105,47 +105,63 @@ class Backtest:
                             'or a function that takes `(order_size, price)`'
                             'and returns commission dollar value')
 
-        data = data.copy(deep=False)
-
-        # インデックスをdatetimeインデックスに変換
-        if (not isinstance(data.index, pd.DatetimeIndex) and
-            not isinstance(data.index, pd.RangeIndex) and
-            # 大部分が大きな数値の数値インデックス
-            (data.index.is_numeric() and
-             (data.index > pd.Timestamp('1975').timestamp()).mean() > .8)):
-            try:
-                data.index = pd.to_datetime(data.index, infer_datetime_format=True)
-            except ValueError:
-                pass
-
-        if 'Volume' not in data:
-            data['Volume'] = np.nan
-
-        if len(data) == 0:
-            raise ValueError('OHLC `data` is empty')
-        if len(data.columns.intersection({'Open', 'High', 'Low', 'Close', 'Volume'})) != 5:
-            raise ValueError("`data` must be a pandas.DataFrame with columns "
-                             "'Open', 'High', 'Low', 'Close', and (optionally) 'Volume'")
-        if data[['Open', 'High', 'Low', 'Close']].isnull().values.any():
-            raise ValueError('Some OHLC values are missing (NaN). '
-                             'Please strip those lines with `df.dropna()` or '
-                             'fill them in with `df.interpolate()` or whatever.')
-        if np.any(data['Close'] > cash):
-            warnings.warn('Some prices are larger than initial cash value. Note that fractional '
-                          'trading is not supported by this class. If you want to trade Bitcoin, '
-                          'increase initial cash, or trade μBTC or satoshis instead (see e.g. class '
-                          '`backtesting.lib.FractionalBacktest`.',
-                          stacklevel=2)
-        if not data.index.is_monotonic_increasing:
-            warnings.warn('Data index is not sorted in ascending order. Sorting.',
-                          stacklevel=2)
-            data = data.sort_index()
-        if not isinstance(data.index, pd.DatetimeIndex):
-            warnings.warn('Data index is not datetime. Assuming simple periods, '
-                          'but `pd.DateTimeIndex` is advised.',
-                          stacklevel=2)
-
-        self._data: pd.DataFrame = data
+        k0, v0 = next(iter(data.items()))
+        len0 = len(v0)
+        for k, v in list(data.items())[1:]:
+            if not len0 == len(v):
+                raise TypeError(f"`data[{k}]` 数が、{k0}と合致していません。")
+
+
+        data = data.copy()
+
+        for code, df in data.items():
+            if not isinstance(df, pd.DataFrame):
+                raise TypeError(f"`data[{code}]` must be a pandas.DataFrame with columns")
+
+            # インデックスをdatetimeインデックスに変換
+            if (not isinstance(df.index, pd.DatetimeIndex) and
+                not isinstance(df.index, pd.RangeIndex) and
+                # 大部分が大きな数値の数値インデックス
+                (df.index.is_numeric() and
+                (df.index > pd.Timestamp('1975').timestamp()).mean() > .8)):
+                try:
+                    df.index = pd.to_datetime(df.index, infer_datetime_format=True)
+                except ValueError:
+                    pass
+
+            if 'Volume' not in df:
+                df['Volume'] = np.nan
+
+            if len(df) == 0:
+                raise ValueError(f'OHLC `data[{code}]` is empty')
+            if len(df.columns.intersection({'Open', 'High', 'Low', 'Close', 'Volume'})) != 5:
+                raise ValueError(f"`data[{code}]` must be a pandas.DataFrame with columns "
+                                "'Open', 'High', 'Low', 'Close', and (optionally) 'Volume'")
+            if df[['Open', 'High', 'Low', 'Close']].isnull().values.any():
+                raise ValueError('Some OHLC values are missing (NaN). '
+                                'Please strip those lines with `df.dropna()` or '
+                                'fill them in with `df.interpolate()` or whatever.')
+            if np.any(df['Close'] > cash):
+                warnings.warn('Some prices are larger than initial cash value. Note that fractional '
+                            'trading is not supported by this class. If you want to trade Bitcoin, '
+                            'increase initial cash, or trade μBTC or satoshis instead (see e.g. class '
+                            '`backtesting.lib.FractionalBacktest`.',
+                            stacklevel=2)
+            if not df.index.is_monotonic_increasing:
+                warnings.warn(f'data[{code}] index is not sorted in ascending order. Sorting.',
+                            stacklevel=2)
+                df = df.sort_index()
+                data[code] = df  # 重要：ソート後のDataFrameを辞書に再代入
+            if not isinstance(df.index, pd.DatetimeIndex):
+                warnings.warn(f'data[{code}] index is not datetime. Assuming simple periods, '
+                            'but `pd.DateTimeIndex` is advised.',
+                            stacklevel=2)
+
+        # 辞書dataに含まれる全てのdf.index一覧を作成
+        # df.indexが不一致の場合のために、どれかに固有値があれば抽出しておくため
+        self.index: pd.DatetimeIndex = pd.DatetimeIndex(sorted({idx for df in data.values() for idx in df.index}))
+
+        self._data: dict[str, pd.DataFrame] = data
 
         # partialとは、関数の一部の引数を事前に固定して、新しい関数を作成します。
         # これにより、後で残りの引数だけを渡せば関数を実行できるようになります。
@@ -155,16 +171,13 @@ class Backtest:
         self._broker = partial(
             _Broker, cash=cash, spread=spread, commission=commission, margin=margin,
             trade_on_close=trade_on_close, hedging=hedging,
-            exclusive_orders=exclusive_orders, index=data.index,
+            exclusive_orders=exclusive_orders
         )
 
         self._strategy = strategy
         self._results: Optional[pd.Series] = None
         self._finalize_trades = bool(finalize_trades)
         
-        # 初期化パラメータを保存（実行後に振り返るため）
-        self._cash = cash
-        self._commission = commission
 
     def run(self) -> pd.Series:
         """
@@ -219,49 +232,50 @@ class Backtest:
         # 循環インポートを避けるためにここでインポート
         from .strategy import Strategy
         
-        data = self._data.copy(deep=False)
-        broker: _Broker = self._broker(data=data)
-        strategy: Strategy = self._strategy(broker, data)
+        broker: _Broker = self._broker(data=self._data)
+        strategy: Strategy = self._strategy(broker, self._data)
 
         strategy.init()
 
-        # strategy.init()で加工されたdataを再登録
-        self._data = data
+        # strategy.init()で加工されたdataを登録
+        data = self._data.copy()
         
-        # インジケーターがまだ「ウォームアップ」中の最初の数本のキャンドルをスキップ
-        # 少なくとも2つのエントリが利用可能になるように+1
-        start = 1
-
         # "invalid value encountered in ..."警告を無効化。比較
         # np.nan >= 3は無効ではない；Falseです。
         with np.errstate(invalid='ignore'):
 
             # プログレスバーを表示
-            progress_bar = tqdm(range(start, len(self._data)), 
+            progress_bar = tqdm(self.index, 
                               desc="バックテスト実行中", 
                               unit="step",
                               ncols=120,
                               leave=True,
                               dynamic_ncols=True)
-            
-            for i in progress_bar:
+            count = 0
+            for current_time in progress_bar:
+
                 # 注文処理とブローカー関連の処理
-                data = self._data.iloc[:i]
+                for k, value in self._data.items():
+                    # time以前のデータをフィルタリング
+                    data[k] = value[value.index <= current_time]
+
+                # brokerに更新したdateを再登録
                 try:
                     broker._data = data
-                    broker.next()
+                    broker.next(current_time)
                 except:
                     break
 
                 # 次のティック、バークローズ直前
                 strategy._data = data
-                strategy.next()
+                strategy.next(current_time)
                 
+                count += 1
+
                 # プログレスバーの説明を更新（現在の日付を表示）
-                if hasattr(self._data.index, 'strftime') and i > 0:
+                if data:
                     try:
-                        current_date = self._data.index[i-1].strftime('%Y-%m-%d')
-                        progress_bar.set_postfix({"日付": current_date})
+                        progress_bar.set_postfix({"日付": current_time.strftime('%Y-%m-%d')})
                     except:
                         pass
             else:
@@ -272,8 +286,7 @@ class Backtest:
 
                     # HACK: 最後の戦略イテレーションで配置されたクローズ注文を処理するために
                     #  ブローカーを最後にもう一度実行。最後のブローカーイテレーションと同じOHLC値を使用。
-                    if start < len(self._data):
-                        broker.next()
+                    broker.next(self.index[count-1])
                 elif len(broker.trades):
                     warnings.warn(
                         'バックテスト終了時に一部の取引がオープンのままです。'
@@ -283,11 +296,22 @@ class Backtest:
             equity = pd.Series(broker._equity).bfill().fillna(broker._cash).values
             self._results = compute_stats(
                 trades=broker.closed_trades,
-                equity=equity,
-                ohlc_data=self._data,
+                equity=np.array(equity),
+                index=self.index,
                 strategy_instance=strategy,
                 risk_free_rate=0.0,
             )
 
         return self._results
 
+
+    @property
+    def cash(self):
+        # partialで初期化されている場合、初期化時のcash値を返す
+        return self._broker.keywords.get('cash', 0)
+
+   
+    @property
+    def commission(self):
+        # partialで初期化されている場合、初期化時のcommission値を返す
+        return self._broker.keywords.get('commission', 0)   

BackcastPro/order.py

@@ -21,7 +21,9 @@ class Order:
 
     すべての出された注文は[取消注文まで有効]です。
     """
+    
     def __init__(self, broker: '_Broker',
+                 code: str,
                  size: float,
                  limit_price: Optional[float] = None,
                  stop_price: Optional[float] = None,
@@ -29,6 +31,7 @@ class Order:
                  tp_price: Optional[float] = None,
                  parent_trade: Optional['Trade'] = None,
                  tag: object = None):
+        self.__code = code
         self.__broker = broker
         assert size != 0
         self.__size = size
@@ -59,6 +62,13 @@ class Order:
 
     # Fields getters
 
+    @property
+    def code(self) -> str:
+        """
+        注文対象の銘柄コード。
+        """
+        return self.__code
+
     @property
     def size(self) -> float:
         """

BackcastPro/position.py

@@ -18,6 +18,7 @@ class Position:
         if self.position:
             ...  # ポジションがあります（ロングまたはショート）
     """
+    
     def __init__(self, broker: '_Broker'):
         self.__broker = broker
 
@@ -57,5 +58,3 @@ class Position:
         for trade in self.__broker.trades:
             trade.close(portion)
 
-    def __repr__(self):
-        return f'<Position: {self.size} ({len(self.__broker.trades)} trades)>'

BackcastPro/strategy.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import sys
 from abc import ABCMeta, abstractmethod
+from tkinter import NO
 from typing import Optional, Tuple
 
 import pandas as pd
@@ -35,12 +36,12 @@ class Strategy(metaclass=ABCMeta):
     オーバーライドして独自の戦略を定義してください。
     """
     
-    def __init__(self, broker: _Broker, data: pd.DataFrame):
+    def __init__(self, broker: _Broker, data: dict[str, pd.DataFrame]):
         """
         これは Backtestクラスで初期化するためユーザーは不要
         """
         self._broker: _Broker = broker
-        self._data: pd.DataFrame = data
+        self._data: dict[str, pd.DataFrame] = data
 
 
     @abstractmethod
@@ -58,7 +59,7 @@ class Strategy(metaclass=ABCMeta):
         """
 
     @abstractmethod
-    def next(self):
+    def next(self, current_time: pd.Timestamp):
         """
         メインのストラテジー実行メソッド。新しい
         `backtesting.backtesting.Strategy.data`
@@ -88,6 +89,7 @@ class Strategy(metaclass=ABCMeta):
     _FULL_EQUITY = __FULL_EQUITY(1 - sys.float_info.epsilon)
 
     def buy(self, *,
+            code: str,
             size: float = _FULL_EQUITY,
             limit: Optional[float] = None,
             stop: Optional[float] = None,
@@ -108,9 +110,11 @@ class Strategy(metaclass=ABCMeta):
         """
         assert 0 < size < 1 or round(size) == size >= 1, \
             "sizeは正の資産割合または正の整数単位である必要があります"
-        return self._broker.new_order(size, limit, stop, sl, tp, tag)
+
+        return self._broker.new_order(code, size, limit, stop, sl, tp, tag)
 
     def sell(self, *,
+             code: str,
              size: float = _FULL_EQUITY,
              limit: Optional[float] = None,
              stop: Optional[float] = None,
@@ -139,7 +143,8 @@ class Strategy(metaclass=ABCMeta):
         """
         assert 0 < size < 1 or round(size) == size >= 1, \
             "sizeは正の資産割合または正の整数単位である必要があります"
-        return self._broker.new_order(-size, limit, stop, sl, tp, tag)
+
+        return self._broker.new_order(code, -size, limit, stop, sl, tp, tag)
 
     @property
     def equity(self) -> float:
@@ -147,7 +152,7 @@ class Strategy(metaclass=ABCMeta):
         return self._broker.equity
 
     @property
-    def data(self) -> pd.DataFrame:
+    def data(self) -> dict[str, pd.DataFrame]:
         """
         価格データは、`Backtest.__init__`に渡されるものと同じ
         """
@@ -172,3 +177,4 @@ class Strategy(metaclass=ABCMeta):
     def closed_trades(self) -> 'Tuple[Trade, ...]':
         """決済済みトレードリスト（`Trade` を参照）。"""
         return tuple(self._broker.closed_trades)
+

BackcastPro/trade.py

@@ -18,23 +18,19 @@ class Trade:
     `Order`が約定されると、アクティブな`Trade`が発生します。
     アクティブな取引は`Strategy.trades`で、クローズされた決済済み取引は`Strategy.closed_trades`で見つけることができます。
     """
-    def __init__(self, broker: '_Broker', size: int, entry_price: float, entry_bar, tag):
+    def __init__(self, broker: '_Broker', code: str, size: int, entry_price: float, entry_time: Union[pd.Timestamp, int], tag):
         self.__broker = broker
+        self.__code = code
         self.__size = size
         self.__entry_price = entry_price
         self.__exit_price: Optional[float] = None
-        self.__entry_bar: int = entry_bar
-        self.__exit_bar: Optional[int] = None
+        self.__entry_time: Union[pd.Timestamp, int] = entry_time
+        self.__exit_time: Optional[Union[pd.Timestamp, int]] = None
         self.__sl_order: Optional[Order] = None
         self.__tp_order: Optional[Order] = None
         self.__tag = tag
         self._commissions = 0
 
-    def __repr__(self):
-        return f'<Trade size={self.__size} time={self.__entry_bar}-{self.__exit_bar or ""} ' \
-               f'price={self.__entry_price}-{self.__exit_price or ""} pl={self.pl:.0f}' \
-               f'{" tag=" + str(self.__tag) if self.__tag is not None else ""}>'
-
     def _replace(self, **kwargs):
         for k, v in kwargs.items():
             setattr(self, f'_{self.__class__.__qualname__}__{k}', v)
@@ -49,11 +45,16 @@ class Trade:
         # Ensure size is an int to avoid rounding errors on 32-bit OS
         size = copysign(max(1, int(round(abs(self.__size) * portion))), -self.__size)
         from .order import Order
-        order = Order(self.__broker, size, parent_trade=self, tag=self.__tag)
+        order = Order(self.__broker, self.__code, size, parent_trade=self, tag=self.__tag)
         self.__broker.orders.insert(0, order)
 
     # Fields getters
 
+    @property
+    def code(self):
+        """取引対象銘柄"""
+        return self.__code
+
     @property
     def size(self):
         """取引サイズ（ボリューム；ショート取引の場合は負の値）。"""
@@ -71,16 +72,59 @@ class Trade:
 
     @property
     def entry_bar(self) -> int:
-        """取引がエントリーされた時のローソク足バーのインデックス。"""
-        return self.__entry_bar
+        """
+        取引がエントリーされた時のローソク足バーのインデックス。
+        
+        .. deprecated:: 0.1.0
+            `entry_time`プロパティを使用してください。
+        """
+        import warnings
+        warnings.warn(
+            "entry_barプロパティは非推奨です。entry_timeプロパティを使用してください。",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        # データからインデックスを逆算
+        try:
+            data_index = self.__broker._data[self.__code].index
+            return data_index.get_loc(self.__entry_time)
+        except (KeyError, TypeError):
+            # インデックスが見つからない場合は0を返す
+            return 0
 
     @property
     def exit_bar(self) -> Optional[int]:
         """
         取引がエグジットされた時のローソク足バーのインデックス
         （取引がまだアクティブな場合はNone）。
+        
+        .. deprecated:: 0.1.0
+            `exit_time`プロパティを使用してください。
         """
-        return self.__exit_bar
+        import warnings
+        warnings.warn(
+            "exit_barプロパティは非推奨です。exit_timeプロパティを使用してください。",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        if self.__exit_time is None:
+            return None
+        try:
+            data_index = self.__broker._data[self.__code].index
+            return data_index.get_loc(self.__exit_time)
+        except (KeyError, TypeError):
+            # インデックスが見つからない場合はNoneを返す
+            return None
+
+    @property
+    def entry_time(self) -> Union[pd.Timestamp, int]:
+        """取引がエントリーされた日時。"""
+        return self.__entry_time
+
+    @property
+    def exit_time(self) -> Optional[Union[pd.Timestamp, int]]:
+        """取引がエグジットされた日時。"""
+        return self.__exit_time
 
     @property
     def tag(self):
@@ -103,18 +147,6 @@ class Trade:
 
     # Extra properties
 
-    @property
-    def entry_time(self) -> Union[pd.Timestamp, int]:
-        """取引がエントリーされた日時。"""
-        return self.__broker._data.index[self.__entry_bar]
-
-    @property
-    def exit_time(self) -> Optional[Union[pd.Timestamp, int]]:
-        """取引がエグジットされた日時。"""
-        if self.__exit_bar is None:
-            return None
-        return self.__broker._data.index[self.__exit_bar]
-
     @property
     def is_long(self):
         """取引がロングの場合True（取引サイズが正の値）。"""
@@ -131,13 +163,13 @@ class Trade:
         取引の利益（正の値）または損失（負の値）を現金単位で表示。
         手数料は取引がクローズされた後にのみ反映されます。
         """
-        price = self.__exit_price or self.__broker.last_price
+        price = self.__exit_price or self.__broker.last_price(self.__code)
         return (self.__size * (price - self.__entry_price)) - self._commissions
 
     @property
     def pl_pct(self):
         """取引の利益（正の値）または損失（負の値）をパーセントで表示。"""
-        price = self.__exit_price or self.__broker.last_price
+        price = self.__exit_price or self.__broker.last_price(self.__code)
         gross_pl_pct = copysign(1, self.__size) * (price / self.__entry_price - 1)
 
         # 取引全体のサイズに対する手数料を個別単位に換算
@@ -147,7 +179,7 @@ class Trade:
     @property
     def value(self):
         """取引の総価値を現金単位で表示（ボリューム × 価格）。"""
-        price = self.__exit_price or self.__broker.last_price
+        price = self.__exit_price or self.__broker.last_price(self.__code)
         return abs(self.__size) * price
 
     # SL/TP management API
@@ -191,5 +223,5 @@ class Trade:
             order.cancel()
         if price:
             kwargs = {'stop': price} if type == 'sl' else {'limit': price}
-            order = self.__broker.new_order(-self.size, trade=self, tag=self.tag, **kwargs)
+            order = self.__broker.new_order(self.code, -self.size, trade=self, tag=self.tag, **kwargs)
             setattr(self, attr, order)

{backcastpro-0.0.5.dist-info → backcastpro-0.1.1.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: BackcastPro
-Version: 0.0.5
+Version: 0.1.1
 Summary: トレーディング戦略のためのPythonバックテストライブラリ
-Author-email: botterYosuke <yosuke.sasazawa@gmail.com>
+Author: botterYosuke
 Project-URL: Homepage, https://github.com/botterYosuke/BackcastPro/
-Project-URL: Issues, https://github.com/BackcastPro/BackcastPro/issues
-Project-URL: Logo, https://raw.githubusercontent.com/BackcastPro/BackcastPro/main/docs/img/logo.drawio.svg
+Project-URL: Issues, https://github.com/botterYosuke/BackcastPro/issues
+Project-URL: Logo, https://raw.githubusercontent.com/botterYosuke/BackcastPro/main/docs/img/logo.drawio.svg
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: MIT License
@@ -45,7 +45,6 @@ py -m pip install -r requirements.txt
 
 ```python
 from BackcastPro import Strategy, Backtest
-from BackcastPro.data import DataReader, JapanStocks
 
 # ここにトレーディング戦略の実装を記述
 ```

backcastpro-0.1.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+BackcastPro/__init__.py,sha256=VS0jRp1UqgrHufWzx_mq_TuULtoX_DSxwEOXp2by4tQ,870
+BackcastPro/_broker.py,sha256=KaZUxCisbB_5RRMSpIGhus3-gTurgZK-ETd7eo3JANo,20562
+BackcastPro/_stats.py,sha256=swVWo2ZEP7Qt_neVuEXBw9GbshLU28oc4EyPedW3XlI,8437
+BackcastPro/backtest.py,sha256=nI-X7DKSIahiJf3PTWjwjvc8qG7pt6FNDCgrhR9nKYY,15952
+BackcastPro/order.py,sha256=S_2j6zjSFNgujJJDcaQw1-cXU9jgwE-PTCMLZvx6EAI,5706
+BackcastPro/position.py,sha256=xm8umqpJDHqLEmQ_qyq_K0VR1rKO6mY2J10c0wlzYCU,2137
+BackcastPro/strategy.py,sha256=zHCYMjfE6RA4Y-ANvGBp7dEpxFsSbSzf4Vtv1vN0jc8,7359
+BackcastPro/trade.py,sha256=fXB2YKdDzgnc895-PGdad2_sh5uH6X6HoEeFpD5CeCc,8340
+backcastpro-0.1.1.dist-info/METADATA,sha256=NnynVoy3YDAEIY8E4rYuLrcom0dmOpNk-xX9wLcL2_Q,2061
+backcastpro-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+backcastpro-0.1.1.dist-info/top_level.txt,sha256=GiP-TX_Bc2jjwHS9cx0VCrW27e9JPbhWWnqGxa5B4Fs,12
+backcastpro-0.1.1.dist-info/RECORD,,