Refactor f-string formating.

Author: Alex-CodeLab

backtesting/_plotting.py

@@ -101,8 +101,8 @@ def _maybe_resample_data(resample_rule, df, indicators, equity_data, trades):
         FREQS = ('1T', '5T', '10T', '15T', '30T', '1H', '2H', '4H', '8H', '1D', '1W', '1M')
         freq = next((f for f in FREQS[from_index:]
                      if len(df.resample(f)) <= _MAX_CANDLES), FREQS[-1])
-        warnings.warn("Data contains too many candlesticks to plot; downsampling to {!r}. "
-                      "See `Backtest.plot(resample=...)`".format(freq))
+        warnings.warn(f"Data contains too many candlesticks to plot; downsampling to {freq!r}. "
+                      "See `Backtest.plot(resample=...)`")
 
     from .lib import OHLCV_AGG, TRADES_AGG, _EQUITY_AGG
     df = df.resample(freq, label='right').agg(OHLCV_AGG).dropna()
@@ -354,7 +354,7 @@ def _plot_equity_section():
         dd_timedelta_label = df['datetime'].iloc[int(round(dd_end))] - df['datetime'].iloc[dd_start]
         fig.line([dd_start, dd_end], equity.iloc[dd_start],
                  line_color='red', line_width=2,
-                 legend_label='Max Dd Dur. ({})'.format(dd_timedelta_label)
+                 legend_label=f'Max Dd Dur. ({dd_timedelta_label})'
                  .replace(' 00:00:00', '')
                  .replace('(0 days ', '('))
 
@@ -424,8 +424,8 @@ def _plot_superimposed_ohlc():
                               millisecond='S').get(time_resolution))
         if not resample_rule:
             warnings.warn(
-                "'Can't superimpose OHLC data with rule '{}' (index datetime resolution: '{}'). "
-                "Skipping.".format(resample_rule, time_resolution),
+                f"'Can't superimpose OHLC data with rule '{resample_rule}' (index datetime resolution: '{time_resolution}'). "
+                "Skipping.",
                 stacklevel=4)
             return
 
@@ -469,7 +469,7 @@ def _plot_ohlc_trades():
         trade_source.add(trades[['EntryPrice', 'ExitPrice']].values.tolist(), 'position_lines_ys')
         fig_ohlc.multi_line(xs='position_lines_xs', ys='position_lines_ys',
                             source=trade_source, line_color=trades_cmap,
-                            legend_label='Trades ({})'.format(len(trades)),
+                            legend_label=f'Trades ({len(trades)})',
                             line_width=8, line_alpha=1, line_dash='dotted')
 
     def _plot_indicators():
@@ -478,7 +478,7 @@ def _plot_indicators():
         def _too_many_dims(value):
             assert value.ndim >= 2
             if value.ndim > 2:
-                warnings.warn("Can't plot indicators with >2D ('{}')".format(value.name),
+                warnings.warn(f"Can't plot indicators with >2D ('{value.name}')",
                               stacklevel=5)
                 return True
             return False
@@ -517,7 +517,7 @@ def __eq__(self, other):
             legend_label = LegendStr(value.name)
             for j, arr in enumerate(value, 1):
                 color = next(colors)
-                source_name = '{}_{}_{}'.format(legend_label, i, j)
+                source_name = f'{legend_label}_{i}_{j}'
                 if arr.dtype == bool:
                     arr = arr.astype(int)
                 source.add(arr, source_name)

backtesting/backtesting.py

@@ -66,15 +66,15 @@ def __str__(self):
                                                           map(_as_str, self._params.values())))
         if params:
             params = '(' + params + ')'
-        return '{}{}'.format(self.__class__.__name__, params)
+        return f'{self.__class__.__name__}{params}'
 
     def _check_params(self, params):
         for k, v in params.items():
             if not hasattr(self, k):
                 raise AttributeError(
-                    "Strategy '{}' is missing parameter '{}'. Strategy class "
+                    f"Strategy '{self.__class__.__name__}' is missing parameter '{k}'. Strategy class "
                     "should define parameters as class variables before they "
-                    "can be optimized or run with.".format(self.__class__.__name__, k))
+                    "can be optimized or run with.")
             setattr(self, k, v)
         return params
 
@@ -121,15 +121,15 @@ def init():
         if name is None:
             params = ','.join(filter(None, map(_as_str, chain(args, kwargs.values()))))
             func_name = _as_str(func)
-            name = ('{}({})' if params else '{}').format(func_name, params)
+            name = (f'{func_name}({params})' if params else f'{func_name}')
         else:
             name = name.format(*map(_as_str, args),
                                **dict(zip(kwargs.keys(), map(_as_str, kwargs.values()))))
 
         try:
             value = func(*args, **kwargs)
         except Exception as e:
-            raise RuntimeError('Indicator "{}" errored with exception: {}'.format(name, e))
+            raise RuntimeError(f'Indicator "{name}" errored with exception: {e}')
 
         if isinstance(value, pd.DataFrame):
             value = value.values.T
@@ -145,8 +145,7 @@ def init():
         if not is_arraylike or not 1 <= value.ndim <= 2 or value.shape[-1] != len(self._data.Close):
             raise ValueError(
                 'Indicators must return (optionally a tuple of) numpy.arrays of same '
-                'length as `data` (data shape: {}; indicator "{}" shape: {}, returned value: {})'
-                .format(self._data.Close.shape, name, getattr(value, 'shape', ''), value))
+                f'length as `data` (data shape: {self._data.Close.shape}; indicator "{name}" shape: {getattr(value, 'shape', '')}, returned value: {value})')
 
         if plot and overlay is None and np.issubdtype(value.dtype, np.number):
             x = value / self._data.Close
@@ -293,10 +292,9 @@ def __getattr__(self, item):
         removed_attrs = ('entry', 'set_entry', 'is_long', 'is_short',
                          'sl', 'tp', 'set_sl', 'set_tp')
         if item in removed_attrs:
-            raise AttributeError('Strategy.orders.{} were removed in Backtesting 0.2.0. '
-                                 'Use `Order` API instead. See docs.'
-                                 .format('/.'.join(removed_attrs)))
-        raise AttributeError("'tuple' object has no attribute {!r}".format(item))
+            raise AttributeError(f'Strategy.orders.{"/.".join(removed_attrs)} were removed in Backtesting 0.2.0. '
+                                 'Use `Order` API instead. See docs.')
+        raise AttributeError(f"'tuple' object has no attribute {item!r}")
 
 
 class Position:
@@ -351,7 +349,7 @@ def close(self, portion: float = 1.):
             trade.close(portion)
 
     def __repr__(self):
-        return '<Position: {} ({} trades)>'.format(self.size, len(self.__broker.trades))
+        return f'<Position: {self.size} ({len(self.__broker.trades)} trades)>'
 
 
 class _OutOfMoneyError(Exception):
@@ -518,9 +516,7 @@ def __init__(self, broker: '_Broker', size: int, entry_price: float, entry_bar):
         self.__tp_order = None  # type: Optional[Order]
 
     def __repr__(self):
-        return '<Trade size={} time={}-{} price={}-{} pl={:.0f}>'.format(
-            self.__size, self.__entry_bar, self.__exit_bar or '',
-            self.__entry_price, self.__exit_price or '', self.pl)
+        return f'<Trade size={self.__size} time={self.__entry_bar}-{self.__exit_bar or ""} price={self.__entry_price}-{self.__exit_price or ""} pl={self.pl:.0f}>'
 
     def _replace(self, **kwargs):
         for k, v in kwargs.items():
@@ -665,9 +661,9 @@ def __set_contingent(self, type, price):
 class _Broker:
     def __init__(self, *, data, cash, commission, margin,
                  trade_on_close, hedging, exclusive_orders, index):
-        assert 0 < cash, "cash shosuld be >0, is {}".format(cash)
-        assert 0 <= commission < .1, "commission should be between 0-10%, is {}".format(commission)
-        assert 0 < margin <= 1, "margin should be between 0 and 1, is {}".format(margin)
+        assert 0 < cash, f"cash shosuld be >0, is {cash}"
+        assert 0 <= commission < .1, f"commission should be between 0-10%, is {commission}"
+        assert 0 < margin <= 1, f"margin should be between 0 and 1, is {margin}"
         self._data = data  # type: _Data
         self._cash = cash
         self._commission = commission
@@ -683,8 +679,7 @@ def __init__(self, *, data, cash, commission, margin,
         self.closed_trades = []  # type: List[Trade]
 
     def __repr__(self):
-        return '<Broker: {:.0f}{:+.1f} ({} trades)>'.format(
-            self._cash, self.position.pl, len(self.trades))
+        return f'<Broker: {self._cash:.0f}{self.position.pl:+.1f} ({len(self.trades)} trades)>'
 
     def new_order(self,
                   size: float,
@@ -707,12 +702,10 @@ def new_order(self,
 
         if is_long:
             if not (sl or -np.inf) <= (limit or stop or self.last_price) <= (tp or np.inf):
-                raise ValueError("Long orders require: SL ({}) < LIMIT ({}) < TP ({})".format(
-                    sl, limit or stop or self.last_price, tp))
+                raise ValueError(f"Long orders require: SL ({sl}) < LIMIT ({limit or stop or self.last_price}) < TP ({tp})")
         else:
             if not (tp or -np.inf) <= (limit or stop or self.last_price) <= (sl or np.inf):
-                raise ValueError("Short orders require: TP ({}) < LIMIT ({}) < SL ({})".format(
-                    tp, limit or stop or self.last_price, sl))
+                raise ValueError(f"Short orders require: TP ({tp}) < LIMIT ({limit or stop or self.last_price}) < SL ({sl})")
 
         order = Order(self, size, limit, stop, sl, tp, trade)
         # Put the new order in the order queue,
@@ -1237,8 +1230,8 @@ def _tuple(x):
 
         for k, v in kwargs.items():
             if len(_tuple(v)) == 0:
-                raise ValueError("Optimization variable '{0}' is passed no "
-                                 "optimization values: {0}={1}".format(k, v))
+                raise ValueError(f"Optimization variable '{k}' is passed no "
+                                 f"optimization values: {k}={v}")
 
         class AttrDict(dict):
             def __getattr__(self, item):
@@ -1253,7 +1246,7 @@ def __getattr__(self, item):
             raise ValueError('No admissible parameter combinations to test')
 
         if len(param_combos) > 300:
-            warnings.warn('Searching for best of {} configurations.'.format(len(param_combos)),
+            warnings.warn(f'Searching for best of {len(param_combos)} configurations.',
                           stacklevel=2)
 
         heatmap = pd.Series(np.nan,