BackcastPro 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

BackcastPro/backtest.py

@@ -0,0 +1,293 @@
+"""
+バックテスト管理モジュール。
+"""
+
+import warnings
+from functools import partial
+from numbers import Number
+from typing import Optional, Tuple, Type, Union
+
+import numpy as np
+import pandas as pd
+from tqdm import tqdm # プログレスバー
+
+from ._broker import _Broker
+from ._stats import compute_stats
+
+
+class Backtest:
+    """
+    特定のデータに対して特定の（パラメータ化された）戦略をバックテストします。
+
+    バックテストを初期化します。テストするデータと戦略が必要です。
+    初期化後、バックテストインスタンスを実行するために
+    `Backtest.run`メソッドを呼び出す。
+
+    `data`は以下の列を持つ`pd.DataFrame`です：
+    `Open`, `High`, `Low`, `Close`, および（オプションで）`Volume`。
+    列が不足している場合は、利用可能なものに設定してください。
+    例：
+
+        df['Open'] = df['High'] = df['Low'] = df['Close']
+
+    渡されたデータフレームには、戦略で使用できる追加の列
+    （例：センチメント情報）を含めることができます。
+    DataFrameのインデックスは、datetimeインデックス（タイムスタンプ）または
+    単調増加の範囲インデックス（期間のシーケンス）のいずれかです。
+
+    `strategy`は`Strategy`の
+    _サブクラス_（インスタンスではありません）です。
+
+    `cash`は開始時の初期現金です。
+
+    `spread`は一定のビッドアスクスプレッド率（価格に対する相対値）です。
+    例：平均スプレッドがアスク価格の約0.2‰である手数料なしの
+    外国為替取引では`0.0002`に設定してください。
+
+    `commission`は手数料率です。例：ブローカーの手数料が
+    注文価値の1%の場合、commissionを`0.01`に設定してください。
+    手数料は2回適用されます：取引開始時と取引終了時です。
+    単一の浮動小数点値に加えて、`commission`は浮動小数点値の
+    タプル`(fixed, relative)`にすることもできます。例：ブローカーが
+    最低$100 + 1%を請求する場合は`(100, .01)`に設定してください。
+    さらに、`commission`は呼び出し可能な
+    `func(order_size: int, price: float) -> float`
+    （注：ショート注文では注文サイズは負の値）にすることもでき、
+    より複雑な手数料構造をモデル化するために使用できます。
+    負の手数料値はマーケットメーカーのリベートとして解釈されます。
+
+    `margin`はレバレッジアカウントの必要証拠金（比率）です。
+    初期証拠金と維持証拠金の区別はありません。
+    ブローカーが許可する50:1レバレッジなどでバックテストを実行するには、
+    marginを`0.02`（1 / レバレッジ）に設定してください。
+
+    `trade_on_close`が`True`の場合、成行注文は
+    次のバーの始値ではなく、現在のバーの終値で約定されます。
+
+    `hedging`が`True`の場合、両方向の取引を同時に許可します。
+    `False`の場合、反対方向の注文は既存の取引を
+    [FIFO]方式で最初にクローズします。
+
+    `exclusive_orders`が`True`の場合、各新しい注文は前の
+    取引/ポジションを自動クローズし、各時点で最大1つの取引
+    （ロングまたはショート）のみが有効になります。
+
+    `finalize_trades`が`True`の場合、バックテスト終了時に
+    まだ[アクティブで継続中]の取引は最後のバーでクローズされ、
+    計算されたバックテスト統計に貢献します。
+    """  
+    def __init__(self,
+                 data: pd.DataFrame,
+                 strategy: Type,
+                 *,
+                 cash: float = 10_000,
+                 spread: float = .0,
+                 commission: Union[float, Tuple[float, float]] = .0,
+                 margin: float = 1.,
+                 trade_on_close=False,
+                 hedging=False,
+                 exclusive_orders=False,
+                 finalize_trades=False,
+                 ):
+        # 循環インポートを避けるためにここでインポート
+        from .strategy import Strategy
+        
+        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')
+        if not isinstance(commission, (Number, tuple)) and not callable(commission):
+            raise TypeError('`commission` must be a float percent of order value, '
+                            'a tuple of `(fixed, relative)` commission, '
+                            '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
+
+        # partialとは、関数の一部の引数を事前に固定して、新しい関数を作成します。
+        # これにより、後で残りの引数だけを渡せば関数を実行できるようになります。
+        # 1. _Brokerクラスのコンストラクタの引数の一部（cash, spread, commissionなど）を事前に固定
+        # 2. 新しい関数（実際には呼び出し可能オブジェクト）を作成
+        # 3. 後で残りの引数（おそらくdataなど）を渡すだけで_Brokerのインスタンスを作成できるようにする
+        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,
+        )
+
+        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:
+        """
+        バックテストを実行します。結果と統計を含む `pd.Series` を返します。
+
+        キーワード引数は戦略パラメータとして解釈されます。
+
+            >>> Backtest(GOOG, SmaCross).run()
+            Start                     2004-08-19 00:00:00
+            End                       2013-03-01 00:00:00
+            Duration                   3116 days 00:00:00
+            Exposure Time [%]                    96.74115
+            Equity Final [$]                     51422.99
+            Equity Peak [$]                      75787.44
+            Return [%]                           414.2299
+            Buy & Hold Return [%]               703.45824
+            Return (Ann.) [%]                    21.18026
+            Volatility (Ann.) [%]                36.49391
+            CAGR [%]                             14.15984
+            Sharpe Ratio                          0.58038
+            Sortino Ratio                         1.08479
+            Calmar Ratio                          0.44144
+            Alpha [%]                           394.37391
+            Beta                                  0.03803
+            Max. Drawdown [%]                   -47.98013
+            Avg. Drawdown [%]                    -5.92585
+            Max. Drawdown Duration      584 days 00:00:00
+            Avg. Drawdown Duration       41 days 00:00:00
+            # Trades                                   66
+            Win Rate [%]                          46.9697
+            Best Trade [%]                       53.59595
+            Worst Trade [%]                     -18.39887
+            Avg. Trade [%]                        2.53172
+            Max. Trade Duration         183 days 00:00:00
+            Avg. Trade Duration          46 days 00:00:00
+            Profit Factor                         2.16795
+            Expectancy [%]                        3.27481
+            SQN                                   1.07662
+            Kelly Criterion                       0.15187
+            _strategy                            SmaCross
+            _equity_curve                           Eq...
+            _trades                       Size  EntryB...
+            dtype: object
+
+        .. warning::
+            異なる戦略パラメータに対して異なる結果が得られる場合があります。
+            例：50本と200本のSMAを使用する場合、取引シミュレーションは
+            201本目から開始されます。実際の遅延の長さは、最も遅延する
+            `Strategy.I`インジケーターのルックバック期間に等しくなります。
+            明らかに、これは結果に影響を与える可能性があります。
+        """
+        # 循環インポートを避けるためにここでインポート
+        from .strategy import Strategy
+        
+        data = self._data.copy(deep=False)
+        broker: _Broker = self._broker(data=data)
+        strategy: Strategy = self._strategy(broker, data)
+
+        strategy.init()
+
+        # strategy.init()で加工されたdataを再登録
+        self._data = data
+        
+        # インジケーターがまだ「ウォームアップ」中の最初の数本のキャンドルをスキップ
+        # 少なくとも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)), 
+                              desc="バックテスト実行中", 
+                              unit="step",
+                              ncols=120,
+                              leave=True,
+                              dynamic_ncols=True)
+            
+            for i in progress_bar:
+                # 注文処理とブローカー関連の処理
+                data = self._data.iloc[:i]
+                try:
+                    broker._data = data
+                    broker.next()
+                except:
+                    break
+
+                # 次のティック、バークローズ直前
+                strategy._data = data
+                strategy.next()
+                
+                # プログレスバーの説明を更新（現在の日付を表示）
+                if hasattr(self._data.index, 'strftime') and i > 0:
+                    try:
+                        current_date = self._data.index[i-1].strftime('%Y-%m-%d')
+                        progress_bar.set_postfix({"日付": current_date})
+                    except:
+                        pass
+            else:
+                if self._finalize_trades is True:
+                    # 統計を生成するために残っているオープン取引をクローズ
+                    for trade in reversed(broker.trades):
+                        trade.close()
+
+                    # HACK: 最後の戦略イテレーションで配置されたクローズ注文を処理するために
+                    #  ブローカーを最後にもう一度実行。最後のブローカーイテレーションと同じOHLC値を使用。
+                    if start < len(self._data):
+                        broker.next()
+                elif len(broker.trades):
+                    warnings.warn(
+                        'バックテスト終了時に一部の取引がオープンのままです。'
+                        '`Backtest(..., finalize_trades=True)`を使用してクローズし、'
+                        '統計に含めてください。', stacklevel=2)
+
+            equity = pd.Series(broker._equity).bfill().fillna(broker._cash).values
+            self._results = compute_stats(
+                trades=broker.closed_trades,
+                equity=equity,
+                ohlc_data=self._data,
+                strategy_instance=strategy,
+                risk_free_rate=0.0,
+            )
+
+        return self._results
+

BackcastPro/data/JapanStock.py

@@ -0,0 +1,171 @@
+"""Data reader for fetching stock price data from API."""
+
+import os
+import requests
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Union
+from dotenv import load_dotenv
+
+# Load environment variables from .env file in project root
+load_dotenv()
+
+BACKCASTPRO_API_URL= 'http://backcastpro.i234.me'
+
+def DataReader(code: str, 
+        start_date: Union[str, datetime, None] = None, 
+        end_date: Union[str, datetime, None] = None) -> pd.DataFrame:
+    """
+    Fetch stock price data from API.
+    
+    Args:
+        code (str): Stock code (e.g., '7203' for Toyota)
+        start_date (Union[str, datetime, None], optional): Start date for data retrieval. 
+                                                          If None, defaults to 1 year ago.
+        end_date (Union[str, datetime, None], optional): End date for data retrieval. 
+                                                        If None, defaults to today.
+        
+    Returns:
+        pd.DataFrame: Stock price data with columns like 'Open', 'High', 'Low', 'Close', 'Volume'
+        
+    Raises:
+        requests.RequestException: If API request fails
+        ValueError: If dates are invalid or API returns error
+    """
+    # Set default dates if not provided
+    if end_date is None:
+        end_date = datetime.now()
+    if start_date is None:
+        start_date = end_date - timedelta(days=365)
+    
+    # Convert datetime objects to string format if needed
+    if isinstance(start_date, datetime):
+        start_date_str = start_date.strftime('%Y-%m-%d')
+    else:
+        start_date_str = str(start_date)
+        
+    if isinstance(end_date, datetime):
+        end_date_str = end_date.strftime('%Y-%m-%d')
+    else:
+        end_date_str = str(end_date)
+    
+    # Construct API URL
+    base_url = os.getenv('BACKCASTPRO_API_URL')
+    if not base_url:
+        base_url = BACKCASTPRO_API_URL
+        
+    # Ensure base_url doesn't end with slash and path starts with slash
+    base_url = base_url.rstrip('/')
+    url = f"{base_url}/api/stocks/price?code={code}&start_date={start_date_str}&end_date={end_date_str}"
+    
+    try:
+        # Make API request
+        response = requests.get(url, timeout=30)
+        response.raise_for_status()
+        
+        # Parse JSON response
+        data = response.json()
+        
+        # Convert to DataFrame
+        if isinstance(data, dict):
+            if 'price_data' in data:
+                df = pd.DataFrame(data['price_data'])
+            elif 'data' in data:
+                df = pd.DataFrame(data['data'])
+            elif 'prices' in data:
+                df = pd.DataFrame(data['prices'])
+            elif 'results' in data:
+                df = pd.DataFrame(data['results'])
+            else:
+                # If it's a single dict, wrap it in a list
+                df = pd.DataFrame([data])
+        elif isinstance(data, list):
+            # If response is directly a list
+            df = pd.DataFrame(data)
+        else:
+            raise ValueError(f"Unexpected response format: {type(data)}")
+        
+        # Ensure proper datetime index
+        if 'Date' in df.columns:
+            df['Date'] = pd.to_datetime(df['Date'])
+            df.set_index('Date', inplace=True)
+        elif 'date' in df.columns:
+            df['Date'] = pd.to_datetime(df['date'])
+            df.set_index('Date', inplace=True)
+        elif df.index.name is None or df.index.name == 'index':
+            # If no date column, try to parse index as datetime
+            try:
+                df.index = pd.to_datetime(df.index)
+            except:
+                pass
+        
+        # Ensure numeric columns are properly typed
+        numeric_columns = ['Open', 'High', 'Low', 'Close', 'Volume']
+        for col in numeric_columns:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors='coerce')
+        
+        # Add code column to the DataFrame
+        df['code'] = code
+        
+        return df
+        
+    except requests.exceptions.RequestException as e:
+        raise requests.RequestException(f"Failed to fetch data from API: {e}")
+    except Exception as e:
+        raise ValueError(f"Error processing API response: {e}")
+
+def JapanStocks() -> pd.DataFrame:
+    """
+    日本株の銘柄リストを取得
+    
+    Returns:
+        pd.DataFrame: 日本株の銘柄リスト（コード、名前、市場、セクター等）
+        
+    Raises:
+        requests.RequestException: If API request fails
+        ValueError: If API returns error
+    """
+    # Construct API URL
+    base_url = os.getenv('BACKCASTPRO_API_URL')
+    if not base_url:
+        base_url = BACKCASTPRO_API_URL
+        
+    # Ensure base_url doesn't end with slash and path starts with slash
+    base_url = base_url.rstrip('/')
+    url = f"{base_url}/api/stocks"
+    
+    try:
+        # Make API request
+        response = requests.get(url, timeout=30)
+        response.raise_for_status()
+        
+        # Parse JSON response
+        data = response.json()
+        
+        # Convert to DataFrame
+        if isinstance(data, dict) and 'data' in data:
+            df = pd.DataFrame(data['data'])
+        elif isinstance(data, list):
+            df = pd.DataFrame(data)
+        else:
+            raise ValueError(f"Unexpected response format: {type(data)}")
+        
+        # Ensure proper column names and types
+        if 'code' in df.columns:
+            df['code'] = df['code'].astype(str)
+        if 'name' in df.columns:
+            df['name'] = df['name'].astype(str)
+        if 'market' in df.columns:
+            df['market'] = df['market'].astype(str)
+        if 'sector' in df.columns:
+            df['sector'] = df['sector'].astype(str)
+        if 'currency' in df.columns:
+            df['currency'] = df['currency'].astype(str)
+        
+        return df
+        
+    except requests.exceptions.RequestException as e:
+        raise requests.RequestException(f"Failed to fetch data from API: {e}")
+    except Exception as e:
+        raise ValueError(f"Error processing API response: {e}")

BackcastPro/data/__init__.py

@@ -0,0 +1,7 @@
+"""Data and utilities for testing."""
+
+from .JapanStock import DataReader, JapanStocks
+
+
+TOYOTA = DataReader('72030')
+

BackcastPro/order.py

@@ -0,0 +1,151 @@
+"""
+注文管理モジュール。
+"""
+
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from ._broker import _Broker
+    from .trade import Trade
+
+
+class Order:
+    """
+    `Strategy.buy()`と`Strategy.sell()`を通じて新しい注文を出します。
+    `Strategy.orders`を通じて既存の注文を照会します。
+
+    注文が実行または[約定]されると、`Trade`が発生します。
+
+    出されたがまだ約定されていない注文の側面を変更したい場合は、
+    キャンセルして新しい注文を出してください。
+
+    すべての出された注文は[取消注文まで有効]です。
+    """
+    def __init__(self, broker: '_Broker',
+                 size: float,
+                 limit_price: Optional[float] = None,
+                 stop_price: Optional[float] = None,
+                 sl_price: Optional[float] = None,
+                 tp_price: Optional[float] = None,
+                 parent_trade: Optional['Trade'] = None,
+                 tag: object = None):
+        self.__broker = broker
+        assert size != 0
+        self.__size = size
+        self.__limit_price = limit_price
+        self.__stop_price = stop_price
+        self.__sl_price = sl_price
+        self.__tp_price = tp_price
+        self.__parent_trade = parent_trade
+        self.__tag = tag
+
+    def _replace(self, **kwargs):
+        for k, v in kwargs.items():
+            setattr(self, f'_{self.__class__.__qualname__}__{k}', v)
+        return self
+
+
+    def cancel(self):
+        """注文をキャンセルします。"""
+        self.__broker.orders.remove(self)
+        trade = self.__parent_trade
+        if trade:
+            if self is trade._sl_order:
+                trade._replace(sl_order=None)
+            elif self is trade._tp_order:
+                trade._replace(tp_order=None)
+            else:
+                pass  # Order placed by Trade.close()
+
+    # Fields getters
+
+    @property
+    def size(self) -> float:
+        """
+        注文サイズ（ショート注文の場合は負の値）。
+
+        サイズが0と1の間の値の場合、現在利用可能な流動性（現金 + `Position.pl` - 使用済みマージン）の
+        割合として解釈されます。
+        1以上の値は絶対的なユニット数を示します。
+        """
+        return self.__size
+
+    @property
+    def limit(self) -> Optional[float]:
+        """
+        [指値注文]の注文指値価格、または[成行注文]の場合はNone（次に利用可能な価格で約定）。
+
+        [limit orders]: https://www.investopedia.com/terms/l/limitorder.asp
+        [market orders]: https://www.investopedia.com/terms/m/marketorder.asp
+        """
+        return self.__limit_price
+
+    @property
+    def stop(self) -> Optional[float]:
+        """
+        [ストップリミット/ストップ成行]注文の注文ストップ価格。
+        ストップが設定されていない場合、またはストップ価格が既にヒットした場合はNone。
+
+        [_]: https://www.investopedia.com/terms/s/stoporder.asp
+        """
+        return self.__stop_price
+
+    @property
+    def sl(self) -> Optional[float]:
+        """
+        ストップロス価格。設定されている場合、この注文の実行後に`Trade`に対して
+        新しい条件付きストップ成行注文が配置されます。
+        `Trade.sl`も参照してください。
+        """
+        return self.__sl_price
+
+    @property
+    def tp(self) -> Optional[float]:
+        """
+        テイクプロフィット価格。設定されている場合、この注文の実行後に`Trade`に対して
+        新しい条件付き指値注文が配置されます。
+        `Trade.tp`も参照してください。
+        """
+        return self.__tp_price
+
+    @property
+    def parent_trade(self):
+        return self.__parent_trade
+
+    @property
+    def tag(self):
+        """
+        任意の値（文字列など）。設定されている場合、この注文と関連する`Trade`の
+        追跡が可能になります（`Trade.tag`を参照）。
+        """
+        return self.__tag
+
+    __pdoc__ = {'Order.parent_trade': False}
+
+    # Extra properties
+
+    @property
+    def is_long(self):
+        """注文がロングの場合（注文サイズが正）にTrueを返します。"""
+        return self.__size > 0
+
+    @property
+    def is_short(self):
+        """注文がショートの場合（注文サイズが負）にTrueを返します。"""
+        return self.__size < 0
+
+    @property
+    def is_contingent(self):
+        """
+        [条件付き]注文、つまりアクティブな取引に配置された[OCO]ストップロスおよび
+        テイクプロフィットブラケット注文の場合にTrueを返します。
+        親`Trade`がクローズされると、残りの条件付き注文はキャンセルされます。
+
+        `Trade.sl`と`Trade.tp`を通じて条件付き注文を変更できます。
+
+        [contingent]: https://www.investopedia.com/terms/c/contingentorder.asp
+        [OCO]: https://www.investopedia.com/terms/o/oco.asp
+        """
+        return bool((parent := self.__parent_trade) and
+                    (self is parent._sl_order or
+                     self is parent._tp_order))

BackcastPro/position.py

@@ -0,0 +1,61 @@
+"""
+ポジション管理モジュール。
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._broker import _Broker
+
+
+class Position:
+    """
+    現在保有している資産ポジション。
+    `backtesting.backtesting.Strategy.next`内で
+    `backtesting.backtesting.Strategy.position`として利用可能です。
+    ブール値コンテキストで使用できます。例：
+
+        if self.position:
+            ...  # ポジションがあります（ロングまたはショート）
+    """
+    def __init__(self, broker: '_Broker'):
+        self.__broker = broker
+
+    def __bool__(self):
+        return self.size != 0
+
+    @property
+    def size(self) -> float:
+        """資産単位でのポジションサイズ。ショートポジションの場合は負の値。"""
+        return sum(trade.size for trade in self.__broker.trades)
+
+    @property
+    def pl(self) -> float:
+        """現在のポジションの利益（正）または損失（負）を現金単位で。"""
+        return sum(trade.pl for trade in self.__broker.trades)
+
+    @property
+    def pl_pct(self) -> float:
+        """現在のポジションの利益（正）または損失（負）をパーセントで。"""
+        total_invested = sum(trade.entry_price * abs(trade.size) for trade in self.__broker.trades)
+        return (self.pl / total_invested) * 100 if total_invested else 0
+
+    @property
+    def is_long(self) -> bool:
+        """ポジションがロング（ポジションサイズが正）の場合True。"""
+        return self.size > 0
+
+    @property
+    def is_short(self) -> bool:
+        """ポジションがショート（ポジションサイズが負）の場合True。"""
+        return self.size < 0
+
+    def close(self, portion: float = 1.):
+        """
+        各アクティブな取引の「一部」を決済することで、ポジションの一部を決済します。詳細は「Trade.close」を参照してください。
+        """
+        for trade in self.__broker.trades:
+            trade.close(portion)
+
+    def __repr__(self):
+        return f'<Position: {self.size} ({len(self.__broker.trades)} trades)>'