lint fixes

Author: kylewidmann

pytradebacktest/backtest.py

@@ -13,23 +13,23 @@
 
 
 class Backtest:
-
     def __init__(
         self,
         data: MarketData,
         kstrategy: Type[FxStrategy],
         cash: float,
-        comission: float = 0.0,
+        commission: float = 0.0,
         margin: float = 1.0,
+        spread: float = 0.0,
     ):
         self.data = data
         self._strategy = kstrategy
         self.cash = cash
-        self.comission = comission
+        self.commission = commission
         self.margin = margin
+        self.spread = spread
 
     async def run(self, **kwargs):
-
         # Monkey patch indicators so their update does not
         # need to recalculate after each increment, instead
         # store their initial values from the full data context
@@ -41,14 +41,13 @@ def increment_indicator(self):
 
         Indicator._update = increment_indicator
 
-        self.broker = BacktestBroker(self.data, self.cash, self.comission, self.margin)
+        self.broker = BacktestBroker(self.data, self.cash, self.commission, self.margin, spread=self.spread)
 
         strategy = self._strategy(self.broker, self.data, **kwargs)
         strategy.init()
 
         with ProgressBar(max_value=len(self.data), redirect_stdout=True) as bar:
             while self.data.next():
-
                 self.broker.next()
                 strategy.next()
 
@@ -68,9 +67,7 @@ def plot(self):
         for instrument in instruments:
             goog_data = self.data.get(instrument, Granularity.M1)
             trades = [
-                trade
-                for trade in self.broker.closed_trades
-                if trade.instrument == instrument
+                trade for trade in self.broker.closed_trades if trade.instrument == instrument
             ]
             equity_df = pd.DataFrame(
                 self.broker._equity, index=self.data._market_index, columns=["Equity"]

pytradebacktest/broker.py

@@ -14,7 +14,6 @@
 
 
 class BacktestBroker(IBroker):
-
     def __init__(
         self,
         data: MarketData,
@@ -24,6 +23,7 @@ def __init__(
         trade_on_close=False,
         hedging=False,
         exclusive_orders=False,
+        spread=0.0,
     ):
         self._data = data
         self._cash = cash
@@ -32,6 +32,7 @@ def __init__(
         self._trade_on_close = trade_on_close
         self._hedging = hedging
         self._exclusive_orders = exclusive_orders
+        self._spread = spread
 
         self._equity = np.tile(np.nan, len(self._data))
         self.orders: list[Order] = []
@@ -53,7 +54,6 @@ def leverage(self) -> float:
         return self._leverage
 
     def order(self, order: Order):
-
         # If exclusive orders (each new order auto-closes previous orders/position),
         # cancel all non-contingent orders and close all open trades beforehand
         if self._exclusive_orders:
@@ -65,14 +65,10 @@ def order(self, order: Order):
 
         self.orders.append(order)
 
-    def load_instrument_candles(
-        self, instrument: Instrument, granularity: Granularity, count: int
-    ):
+    def load_instrument_candles(self, instrument: Instrument, granularity: Granularity, count: int):
         self._data.load_instrument_candles(instrument, granularity, count)
 
-    def subscribe(
-        self, instrument: Instrument, granularity: Granularity
-    ) -> IInstrumentData:
+    def subscribe(self, instrument: Instrument, granularity: Granularity) -> IInstrumentData:
         return self._data.get(instrument, granularity)
 
     def get_position(self, instrument: Instrument) -> Position:
@@ -81,9 +77,7 @@ def get_position(self, instrument: Instrument) -> Position:
     def close_position(self, instrument: Instrument):
         position = self.get_position(instrument)
         for trade in position.trades:
-            self.orders.insert(
-                0, Order(trade.instrument, -trade.size, parent_trade=trade)
-            )
+            self.orders.insert(0, Order(trade.instrument, -trade.size, parent_trade=trade))
 
     def next(self):
         self._process_orders()
@@ -107,7 +101,6 @@ def _update_equity(self):
             raise OutOfMoneyError
 
     def _process_orders(self):
-
         reprocess_orders = False
         for order in list(self.orders):
             _data = self._get_instrument_data(order.instrument)
@@ -119,6 +112,7 @@ def _process_orders(self):
                 self._commission,
                 self._leverage,
                 self.margin_available,
+                self._spread,
             )
             # Related SL/TP order already removed
             if order not in self.orders:
@@ -172,9 +166,7 @@ def _process_contingent_order(self, ctx: OrderContext):
         _order_size = ctx.adjusted_size
 
         if trade in self.trades:
-            closed = self._reduce_trade(
-                trade, _order_size, ctx.entry_price, ctx.entry_time
-            )
+            closed = self._reduce_trade(trade, _order_size, ctx.entry_price, ctx.entry_time)
             # If this is a SL/TP closing the trade already removed it.
             if closed and order in self.orders:
                 self.orders.remove(order)
@@ -230,9 +222,7 @@ def _update_position(self, ctx: OrderContext):
     def _open_trade(self, ctx: OrderContext, tag: Optional[str] = None):
         order = ctx.order
         size = ctx.adjusted_size
-        trade = Trade(
-            order.instrument, size, ctx.entry_price, ctx.entry_time, ctx.data, tag
-        )
+        trade = Trade(order.instrument, size, ctx.entry_price, ctx.entry_time, ctx.data, tag)
         self.trades.append(trade)
 
         if order.take_profit_on_fill:
@@ -255,9 +245,7 @@ def _open_trade(self, ctx: OrderContext, tag: Optional[str] = None):
             trade.sl = sl_order
             self.orders.insert(0, sl_order)
 
-    def _reduce_trade(
-        self, trade: Trade, size: int, price: float, timestamp: Timestamp
-    ):
+    def _reduce_trade(self, trade: Trade, size: int, price: float, timestamp: Timestamp):
         size_left = trade.size + size
         closed = False
 
@@ -281,9 +269,7 @@ def _reduce_trade(
 
     def close_trades(self):
         for trade in self.trades:
-            self.orders.insert(
-                0, Order(trade.instrument, -trade.size, parent_trade=trade)
-            )
+            self.orders.insert(0, Order(trade.instrument, -trade.size, parent_trade=trade))
 
     def _close_trade(self, trade: Trade, price: float, timestamp: Timestamp):
         self.trades.remove(trade)

pytradebacktest/data.py

@@ -6,17 +6,14 @@
 import pandas as pd
 from pandas import DatetimeIndex, Timestamp
 from pytrade.events.event import Event
-from pytrade.instruments import Granularity, Instrument
+from pytrade.instruments import Granularity, Instrument, UPDATE_MAP
 from pytrade.interfaces.data import IDataContext, IInstrumentData
 
 from pytradebacktest.utils import load_csv
 
 
 class InstrumentData(IInstrumentData):
-
-    def __init__(
-        self, instrument: Instrument, granularity: Granularity, df: pd.DataFrame
-    ):
+    def __init__(self, instrument: Instrument, granularity: Granularity, df: pd.DataFrame):
         self.__df = df
         self.__i = len(df) - 1
         self.__pip: Optional[float] = None
@@ -37,9 +34,7 @@ def granularity(self) -> Granularity:
 
     @property
     def df(self) -> pd.DataFrame:
-        return (
-            self.__df.iloc[: self.__i + 1] if self.__i < len(self.__df) else self.__df
-        )
+        return self.__df.iloc[: self.__i + 1] if self.__i < len(self.__df) else self.__df
 
     @property
     def on_update(self) -> Event:
@@ -74,28 +69,24 @@ def index(self, value: Timestamp):
 
 
 class DataSource:
-
     def __init__(self, instrument: Instrument, granularity: Granularity):
         self.instrument = instrument
         self.granularity = granularity
 
 
 class CsvDataSource(DataSource):
-
     def __init__(self, path: str, instrument: Instrument, granularity: Granularity):
         super().__init__(instrument, granularity)
         self.path = path
 
 
 class MarketDataLoader:
-
     @abstractmethod
     def load(self) -> list[InstrumentData]:
         raise NotImplementedError
 
 
 class CsvMarketDataLoader(MarketDataLoader):
-
     def __init__(self, sources: list[CsvDataSource]):
         self.sources = sources
 
@@ -116,7 +107,6 @@ def load(self) -> list[InstrumentData]:
 
 
 class MarketData(IDataContext):
-
     _index: pd.Timestamp
 
     def __init__(self, loader: MarketDataLoader):
@@ -137,9 +127,7 @@ def universe(self):
     def index(self) -> pd.Timestamp:
         return self._index
 
-    def load_instrument_candles(
-        self, instrument: Instrument, granularity: Granularity, count: int
-    ):
+    def load_instrument_candles(self, instrument: Instrument, granularity: Granularity, count: int):
         _data = self.get(instrument, granularity)
         _instrument_timestamp: pd.Timestamp = _data.df.index[count]
         if _instrument_timestamp > self._index:
@@ -172,7 +160,6 @@ def next(self):
         return result
 
     def __next(self):
-
         # Slice index incase some candles were loaded prior to starting
         # the test run
         _index = self._market_index[self.i :]
@@ -185,8 +172,24 @@ def __next(self):
         yield False
 
     def get(self, instrument: Instrument, granularity: Granularity) -> IInstrumentData:
-        return next(
+        _data: IInstrumentData = next(
             src
             for src in self._sources
-            if src.instrument == instrument and src.granularity == granularity
+            if src.instrument == instrument and src.granularity == Granularity.M1
         )
+
+        if not _data:
+            raise RuntimeError(f"Data not loaded for {instrument}")
+
+        if granularity != Granularity.M1:
+            _df = _data.df.resample(UPDATE_MAP[granularity]).agg(
+                {
+                    "open": "first",  # First value in each 15-min period
+                    "high": "max",  # Maximum value in each 15-min period
+                    "low": "min",  # Minimum value in each 15-min period
+                    "close": "last",  # Last value in each 15-min period
+                }
+            )
+            _data = InstrumentData(instrument=instrument, granularity=granularity, df=_df)
+
+        return _data

pytradebacktest/order.py

@@ -7,7 +7,6 @@
 
 
 class OrderContext:
-
     def __init__(
         self,
         order: Order,
@@ -16,13 +15,15 @@ def __init__(
         commission: float,
         leverage: float,
         margin_available: float,
+        spread: float = 0.0,
     ):
         self._order = order
         self._data = data
         self._trade_on_close = trade_on_close
         self._commission = commission
         self._leverage = leverage
         self._margin_availalbe = margin_available
+        self._spread = spread
 
     @property
     def order(self):
@@ -82,9 +83,12 @@ def entry_price(self):
 
     @property
     def adjusted_entry_price(self):
-        # Need to update to account for currency pairs and base vs counter currency
-        # as well as spread
-        return self.entry_price * (1 + copysign(self._commission, self.order.size))
+        # Apply commission and spread
+        # For longs (buy): pay ask price (mid + spread/2)
+        # For shorts (sell): receive bid price (mid - spread/2)
+        spread_adjustment = copysign(self._spread / 2, self.order.size)
+        commission_adjustment = copysign(self._commission, self.order.size)
+        return self.entry_price * (1 + commission_adjustment) + spread_adjustment
 
     @property
     def adjusted_size(self):

pytradebacktest/plot.py

@@ -8,10 +8,7 @@
 
 
 def plot(data: IInstrumentData, equity: pd.DataFrame, trades: list[Trade]):
-
-    fig = make_subplots(
-        rows=2, cols=1, row_heights=[0.2, 0.8], subplot_titles=("Equity", "Trades")
-    )
+    fig = make_subplots(rows=2, cols=1, row_heights=[0.2, 0.8], subplot_titles=("Equity", "Trades"))
 
     _plot_equity(fig, equity)
     _plot_ohlc(fig, data)

pytradebacktest/position.py

@@ -24,9 +24,7 @@ def __bool__(self):
 
     @property
     def trades(self):
-        return [
-            trade for trade in self.__trades if trade.instrument == self.__instrument
-        ]
+        return [trade for trade in self.__trades if trade.instrument == self.__instrument]
 
     @property
     def size(self) -> float:
@@ -57,6 +55,4 @@ def is_short(self) -> bool:
         return self.size < 0
 
     def __repr__(self):
-        return (
-            f"<Position[{self.__instrument}]: {self.size} ({len(self.trades)} trades)>"
-        )
+        return f"<Position[{self.__instrument}]: {self.size} ({len(self.trades)} trades)>"