Merge pull request #210 from quantopian/round-trip2

ENH Round trip tearheet and supporting functions

Author: a-campbell

pyfolio/examples/round_trip_example.ipynb

@@ -16,11 +16,13 @@
 
 import pandas as pd
 import numpy as np
+import scipy as sp
 
 import seaborn as sns
 import matplotlib
 import matplotlib.pyplot as plt
 from matplotlib.ticker import FuncFormatter
+import matplotlib.lines as mlines
 
 from sklearn import preprocessing
 
@@ -1402,3 +1404,114 @@ def cumulate_returns(x):
     ax.set_xticklabels(xticks_label)
 
     return ax
+
+
+def plot_round_trip_life_times(round_trips, ax=None):
+    """
+    Plots timespans and directions of round trip trades.
+
+    Parameters
+    ----------
+    round_trips : pd.DataFrame
+        DataFrame with one row per round trip trade.
+        - See full explanation in round_trips.extract_round_trips
+    ax : matplotlib.Axes, optional
+        Axes upon which to plot.
+
+    Returns
+    -------
+    ax : matplotlib.Axes
+        The axes that were plotted on.
+    """
+    if ax is None:
+        ax = plt.subplot()
+
+    symbols = round_trips.symbol.unique()
+    symbol_idx = pd.Series(np.arange(len(symbols)), index=symbols)
+
+    for symbol, sym_round_trips in round_trips.groupby('symbol'):
+        for _, row in sym_round_trips.iterrows():
+            c = 'b' if row.long else 'r'
+            y_ix = symbol_idx[symbol]
+            ax.plot([row['open_dt'], row['close_dt']],
+                    [y_ix, y_ix], color=c)
+
+    ax.set_yticklabels(symbols)
+
+    red_line = mlines.Line2D([], [], color='r', label='Short')
+    blue_line = mlines.Line2D([], [], color='b', label='Long')
+    ax.legend(handles=[red_line, blue_line], loc=0)
+
+    return ax
+
+
+def show_profit_attribution(round_trips):
+    """
+    Prints the share of total PnL contributed by each
+    traded name.
+
+    Parameters
+    ----------
+    round_trips : pd.DataFrame
+        DataFrame with one row per round trip trade.
+        - See full explanation in round_trips.extract_round_trips
+    ax : matplotlib.Axes, optional
+        Axes upon which to plot.
+
+    Returns
+    -------
+    ax : matplotlib.Axes
+        The axes that were plotted on.
+    """
+
+    total_pnl = round_trips['pnl'].sum()
+    pct_profit_attribution = round_trips.groupby(
+        'symbol')['pnl'].sum() / total_pnl
+
+    print('\nProfitability (PnL / PnL total) per name:')
+    print(pct_profit_attribution.sort(inplace=False, ascending=False))
+
+
+def plot_prob_profit_trade(round_trips, ax=None):
+    """
+    Plots a probability distribution for the event of making
+    a profitable trade.
+
+    Parameters
+    ----------
+    round_trips : pd.DataFrame
+        DataFrame with one row per round trip trade.
+        - See full explanation in round_trips.extract_round_trips
+    ax : matplotlib.Axes, optional
+        Axes upon which to plot.
+
+    Returns
+    -------
+    ax : matplotlib.Axes
+        The axes that were plotted on.
+    """
+
+    x = np.linspace(0, 1., 500)
+
+    round_trips['profitable'] = round_trips.pnl > 0
+
+    dist = sp.stats.beta(round_trips.profitable.sum(),
+                         (~round_trips.profitable).sum())
+    y = dist.pdf(x)
+    lower_perc = dist.ppf(.025)
+    upper_perc = dist.ppf(.975)
+
+    lower_plot = dist.ppf(.001)
+    upper_plot = dist.ppf(.999)
+
+    if ax is None:
+        ax = plt.subplot()
+
+    ax.plot(x, y)
+    ax.axvline(lower_perc, color='0.5')
+    ax.axvline(upper_perc, color='0.5')
+
+    ax.set(xlabel='Probability making a profitable decision', ylabel='Belief',
+           xlim=(lower_plot, upper_plot), ylim=(0, y.max() + 1.))
+
+    return ax

pyfolio/plotting.py

@@ -0,0 +1,248 @@
+#
+# Copyright 2015 Quantopian, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import division
+from collections import defaultdict
+
+import pandas as pd
+import numpy as np
+
+
+def extract_round_trips(transactions):
+    """
+    Group transactions into "round trips." A round trip is started when a new
+    long or short position is opened and is only completed when the number
+    of shares in that position returns to or crosses zero.
+    Computes pnl for each round trip.
+
+    For example, the following transactions would constitute one round trip:
+    index                  amount   price    symbol
+    2004-01-09 12:18:01    186      324.12   'AAPL'
+    2004-01-09 15:12:53    -10      344.54   'AAPL'
+    2004-01-13 14:41:23    24       320.21   'AAPL'
+    2004-01-30 10:23:34    -200     340.43   'AAPL'
+
+    Parameters
+    ----------
+    transactions : pd.DataFrame
+        Prices and amounts of executed trades. One row per trade.
+        - See full explanation in tears.create_full_tear_sheet
+
+    Returns
+    -------
+    round_trips : pd.DataFrame
+        DataFrame with one row per round trip.
+    """
+    # Transactions that cross zero must be split into separate
+    # long and short transactions that end/start on zero.
+    transactions_split = split_trades(transactions)
+
+    transactions_split['txn_dollars'] =  \
+        -transactions_split['amount'] * transactions_split['price']
+
+    round_trips = defaultdict(list)
+
+    for sym, trans_sym in transactions_split.groupby('symbol'):
+        trans_sym = trans_sym.sort_index()
+        amount_cumsum = trans_sym.amount.cumsum()
+        # Find indicies where the position amount returns to zero.
+        closed_idx = np.where(amount_cumsum == 0)[0] + 1
+        # Identify the first trade as the beginning of a round trip.
+        closed_idx = np.insert(closed_idx, 0, 0)
+
+        for trade_start, trade_end in zip(closed_idx, closed_idx[1:]):
+            txn = trans_sym.iloc[trade_start:trade_end]
+
+            if len(txn) == 0:
+                continue
+
+            assert txn.amount.sum() == 0
+            long_trade = txn.amount.iloc[0] > 0
+            pnl = txn.txn_dollars.sum()
+            round_trips['symbol'].append(sym)
+            round_trips['pnl'].append(pnl)
+            round_trips['duration'].append(txn.index[-1] - txn.index[0])
+            round_trips['long'].append(long_trade)
+            round_trips['open_dt'].append(txn.index[0])
+            round_trips['close_dt'].append(txn.index[-1])
+
+            # Investing txns push the position amount farther from zero.
+            # invested is always a positive value. Returned - Invested = PnL.
+            if long_trade:
+                invested = -txn.query('txn_dollars < 0').txn_dollars.sum()
+            else:
+                invested = txn.query('txn_dollars > 0').txn_dollars.sum()
+
+            if invested == 0:
+                round_trips['returns'].append(0)
+            else:
+                round_trips['returns'].append(pnl / invested)
+
+    if len(round_trips) == 0:
+        return pd.DataFrame([])
+
+    round_trips = pd.DataFrame(round_trips)
+    round_trips = round_trips[['open_dt', 'close_dt', 'duration',
+                               'pnl', 'returns', 'long', 'symbol']]
+
+    return round_trips
+
+
+def split_trades(transactions):
+    """
+    Splits transactions that cause total position amount to cross zero.
+    In other words, separates of the closing of one short/long position
+    with the opening of a new long/short position.
+
+    For example, the second transaction in this transactions DataFrame
+    would be divided as shown in the second DataFrame:
+    index                  amount   price    symbol
+    2004-01-09 12:18:01    180      324.12   'AAPL'
+    2004-01-09 15:12:53    -200     344.54   'AAPL'
+
+    index                  amount   price    symbol
+    2004-01-09 12:18:01    180      324.12   'AAPL'
+    2004-01-09 15:12:53    -180     344.54   'AAPL'
+    2004-01-09 15:12:54    -20      344.54   'AAPL'
+
+    Parameters
+    ----------
+    transactions : pd.DataFrame
+        Prices and amounts of executed trades. One row per trade.
+        - See full explanation in tears.create_full_tear_sheet
+
+    Returns
+    -------
+    transactions_split : pd.DataFrame
+        Prices and amounts of executed trades. Trades that cause
+        total position amount to cross zero are divided.
+    """
+
+    trans_split = []
+
+    for sym, trans_sym in transactions.groupby('symbol'):
+        trans_sym = trans_sym.sort_index()
+
+        while True:
+            cum_amount = trans_sym.amount.cumsum()
+            # find the indicies where position amount crosses zero
+            sign_flip = np.where(np.abs(np.diff(np.sign(cum_amount))) == 2)[0]
+
+            if len(sign_flip) == 0:
+                break  # all sign flips are converted
+
+            sign_flip = sign_flip[0] + 2
+
+            txn = trans_sym.iloc[:sign_flip]
+
+            left_over_txn_amount = txn.amount.sum()
+            assert left_over_txn_amount != 0
+
+            split_txn_1 = txn.iloc[[-1]].copy()
+            split_txn_2 = txn.iloc[[-1]].copy()
+
+            split_txn_1['amount'] -= left_over_txn_amount
+            split_txn_2['amount'] = left_over_txn_amount
+
+            # Delay 2nd trade by a second to avoid overlapping indices
+            split_txn_2.index += pd.Timedelta(seconds=1)
+
+            assert split_txn_1.amount.iloc[0] + \
+                split_txn_2.amount.iloc[0] == txn.iloc[-1].amount
+            assert trans_sym.iloc[:sign_flip - 1].amount.sum() + \
+                split_txn_1.amount.iloc[0] == 0
+
+            # Recreate transactions so far with split transaction
+            trans_sym = pd.concat([trans_sym.iloc[:sign_flip - 1],
+                                   split_txn_1,
+                                   split_txn_2,
+                                   trans_sym.iloc[sign_flip:]])
+
+        assert np.all(np.abs(np.diff(np.sign(trans_sym.amount.cumsum()))) != 2)
+        trans_split.append(trans_sym)
+
+    transactions_split = pd.concat(trans_split)
+
+    return transactions_split
+
+
+def add_closing_transactions(positions, transactions):
+    """
+    Appends transactions that close out all positions at the end of
+    the timespan covered by positions data. Utilizes pricing information
+    in the positions DataFrame to determine closing price.
+
+    Parameters
+    ----------
+    positions : pd.DataFrame
+        The positions that the strategy takes over time.
+    transactions : pd.DataFrame
+        Prices and amounts of executed trades. One row per trade.
+        - See full explanation in tears.create_full_tear_sheet
+
+    Returns
+    -------
+    closed_txns : pd.DataFrame
+        Transactions with closing transactions appended.
+    """
+
+    closed_txns = transactions.copy()
+
+    pos_at_end = positions.drop('cash', axis=1).iloc[-1]
+    open_pos = pos_at_end.replace(0, np.nan).dropna()
+    # Add closing trades one second after the close to be sure
+    # they don't conflict with other trades executed at that time.
+    end_dt = open_pos.name + pd.Timedelta(seconds=1)
+
+    for sym, ending_val in open_pos.iteritems():
+        txn_sym = transactions[transactions.symbol == sym]
+
+        ending_amount = txn_sym.amount.sum()
+
+        ending_price = ending_val / ending_amount
+        closing_txn = {'symbol': sym,
+                       'amount': -ending_amount,
+                       'price': ending_price}
+
+        closing_txn = pd.DataFrame(closing_txn, index=[end_dt])
+        closed_txns = closed_txns.append(closing_txn)
+
+    return closed_txns
+
+
+def apply_sector_mappings_to_round_trips(round_trips, sector_mappings):
+    """
+    Translates round trip symbols to sectors.
+
+    Parameters
+    ----------
+    round_trips : pd.DataFrame
+        DataFrame with one row per round trip trade.
+        - See full explanation in round_trips.extract_round_trips
+    sector_mappings : dict or pd.Series, optional
+        Security identifier to sector mapping.
+        Security ids as keys, sectors as values.
+
+    Returns
+    -------
+    sector_round_trips : pd.DataFrame
+        Round trips with symbol names replaced by sector names.
+    """
+
+    sector_round_trips = round_trips.copy()
+    sector_round_trips.symbol = sector_round_trips.symbol.apply(
+        lambda x: sector_mappings.get(x, 'No Sector Mapping'))
+    sector_round_trips = sector_round_trips.dropna(axis=0)
+
+    return sector_round_trips

pyfolio/round_trips.py

@@ -20,6 +20,7 @@
 from . import utils
 from . import pos
 from . import txn
+from . import round_trips
 from . import plotting
 from .plotting import plotting_context
 
@@ -167,6 +168,9 @@ def create_full_tear_sheet(returns, positions=None, transactions=None,
                                   unadjusted_returns=unadjusted_returns,
                                   set_context=set_context)
 
+            create_round_trip_tear_sheet(transactions, positions,
+                                         sector_mappings=sector_mappings)
+
     if bayesian:
         create_bayesian_tear_sheet(returns,
                                    live_start_date=live_start_date,
@@ -402,12 +406,12 @@ def create_position_tear_sheet(returns, positions, gross_lev=None,
 
     if sector_mappings is not None:
         sector_exposures = pos.get_sector_exposures(positions, sector_mappings)
-
-        sector_alloc = pos.get_percent_alloc(sector_exposures)
-        sector_alloc = sector_alloc.drop('cash', axis='columns')
-        ax_sector_alloc = plt.subplot(gs[4, :], sharex=ax_gross_leverage)
-        plotting.plot_sector_allocations(returns, sector_alloc,
-                                         ax=ax_sector_alloc)
+        if len(sector_exposures.columns) > 1:
+            sector_alloc = pos.get_percent_alloc(sector_exposures)
+            sector_alloc = sector_alloc.drop('cash', axis='columns')
+            ax_sector_alloc = plt.subplot(gs[4, :], sharex=ax_gross_leverage)
+            plotting.plot_sector_allocations(returns, sector_alloc,
+                                             ax=ax_sector_alloc)
 
     plt.show()
     if return_fig:
@@ -435,8 +439,6 @@ def create_txn_tear_sheet(returns, positions, transactions,
          - See full explanation in create_full_tear_sheet.
     return_fig : boolean, optional
         If True, returns the figure that was plotted on.
-    set_context : boolean, optional
-        If True, set default plotting style context.
     """
     vertical_sections = 5 if unadjusted_returns is not None else 3
 
@@ -479,6 +481,102 @@ def create_txn_tear_sheet(returns, positions, transactions,
         return fig
 
 
+@plotting_context
+def create_round_trip_tear_sheet(transactions, positions,
+                                 sector_mappings=None,
+                                 return_fig=False):
+    """
+    Generate a number of figures and plots describing the duration,
+    frequency, and profitability of trade "round trips."
+    A round trip is started when a new long or short position is
+    opened and is only completed when the number of shares in that
+    position returns to or crosses zero.
+
+    Parameters
+    ----------
+    positions : pd.DataFrame
+        Daily net position values.
+         - See full explanation in create_full_tear_sheet.
+    transactions : pd.DataFrame
+        Prices and amounts of executed trades. One row per trade.
+         - See full explanation in create_full_tear_sheet.
+    sector_mappings : dict or pd.Series, optional
+        Security identifier to sector mapping.
+        Security ids as keys, sectors as values.
+    return_fig : boolean, optional
+        If True, returns the figure that was plotted on.
+    """
+
+    transactions_closed = round_trips.add_closing_transactions(positions,
+                                                               transactions)
+    trades = round_trips.extract_round_trips(transactions_closed)
+
+    if len(trades) < 5:
+        warnings.warn(
+            """Fewer than 5 round-trip trades made.
+               Skipping round trip tearsheet.""", UserWarning)
+        return
+
+    ndays = len(positions)
+
+    print(trades.drop(['open_dt', 'close_dt', 'symbol'],
+                      axis='columns').describe())
+    print('Percent of round trips profitable = {:.4}%'.format(
+          (trades.pnl > 0).mean() * 100))
+
+    winning_round_trips = trades[trades.pnl > 0]
+    losing_round_trips = trades[trades.pnl < 0]
+    print('Mean return per winning round trip = {:.4}'.format(
+        winning_round_trips.returns.mean()))
+    print('Mean return per losing round trip = {:.4}').format(
+        losing_round_trips.returns.mean())
+
+    print('A decision is made every {:.4} days.'.format(ndays / len(trades)))
+    print('{:.4} trading decisions per day.'.format(len(trades) * 1. / ndays))
+    print('{:.4} trading decisions per month.'.format(
+        len(trades) * 1. / (ndays / 21)))
+
+    plotting.show_profit_attribution(trades)
+
+    if sector_mappings is not None:
+        sector_trades = round_trips.apply_sector_mappings_to_round_trips(
+            trades, sector_mappings)
+        plotting.show_profit_attribution(sector_trades)
+
+    fig = plt.figure(figsize=(14, 3 * 6))
+
+    fig = plt.figure(figsize=(14, 3 * 6))
+    gs = gridspec.GridSpec(3, 2, wspace=0.5, hspace=0.5)
+
+    ax_trade_lifetimes = plt.subplot(gs[0, :])
+    ax_prob_profit_trade = plt.subplot(gs[1, 0])
+    ax_holding_time = plt.subplot(gs[1, 1])
+    ax_pnl_per_round_trip_dollars = plt.subplot(gs[2, 0])
+    ax_pnl_per_round_trip_pct = plt.subplot(gs[2, 1])
+
+    plotting.plot_round_trip_life_times(trades, ax=ax_trade_lifetimes)
+
+    plotting.plot_prob_profit_trade(trades, ax=ax_prob_profit_trade)
+
+    trade_holding_times = [x.days for x in trades['duration']]
+    sns.distplot(trade_holding_times, kde=False, ax=ax_holding_time)
+    ax_holding_time.set(xlabel='holding time in days')
+
+    sns.distplot(trades.pnl, kde=False, ax=ax_pnl_per_round_trip_dollars)
+    ax_pnl_per_round_trip_dollars.set(xlabel='PnL per round-trip trade in $')
+
+    pnl_pct = trades.pnl / trades.pnl.sum() * 100
+    sns.distplot(pnl_pct, kde=False, ax=ax_pnl_per_round_trip_pct)
+    ax_pnl_per_round_trip_pct.set(
+        xlabel='PnL per round-trip trade in % of total profit')
+
+    gs.tight_layout(fig)
+
+    plt.show()
+    if return_fig:
+        return fig
+
+
 @plotting_context
 def create_interesting_times_tear_sheet(
         returns, benchmark_rets=None, legend_loc='best', return_fig=False):

pyfolio/tears.py

@@ -0,0 +1,115 @@
+from nose_parameterized import parameterized
+
+from unittest import TestCase
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    date_range,
+    Timedelta,
+    read_csv
+)
+from pandas.util.testing import (assert_frame_equal)
+
+import os
+import gzip
+
+from pyfolio.round_trips import (extract_round_trips,
+                                 add_closing_transactions)
+
+
+class RoundTripTestCase(TestCase):
+    dates = date_range(start='2015-01-01', freq='D', periods=20)
+
+    @parameterized.expand([
+        (DataFrame(data=[[2, 10, 'A'],
+                         [-2, 15, 'A']],
+                   columns=['amount', 'price', 'symbol'],
+                   index=dates[:2]),
+         DataFrame(data=[[dates[0], dates[1],
+                          Timedelta(days=1), 10, .5,
+                          True, 'A']],
+                   columns=['open_dt', 'close_dt',
+                            'duration', 'pnl', 'returns',
+                            'long', 'symbol'],
+                   index=[0])
+         ),
+        (DataFrame(data=[[2, 10, 'A'],
+                         [2, 15, 'A'],
+                         [-9, 10, 'A']],
+                   columns=['amount', 'price', 'symbol'],
+                   index=dates[:3]),
+         DataFrame(data=[[dates[0], dates[2],
+                          Timedelta(days=2), -10, -.2,
+                          True, 'A']],
+                   columns=['open_dt', 'close_dt',
+                            'duration', 'pnl', 'returns',
+                            'long', 'symbol'],
+                   index=[0])
+         ),
+        (DataFrame(data=[[2, 10, 'A'],
+                         [-4, 15, 'A'],
+                         [3, 20, 'A']],
+                   columns=['amount', 'price', 'symbol'],
+                   index=dates[:3]),
+         DataFrame(data=[[dates[0], dates[1],
+                          Timedelta(days=1), 10, .5,
+                          True, 'A'],
+                         [dates[1] + Timedelta(seconds=1), dates[2],
+                          Timedelta(days=1) - Timedelta(seconds=1),
+                          -10, (-1. / 3),
+                          False, 'A']],
+                   columns=['open_dt', 'close_dt',
+                            'duration', 'pnl', 'returns',
+                            'long', 'symbol'],
+                   index=[0, 1])
+         )
+    ])
+    def test_extract_round_trips(self, transactions, expected):
+        round_trips = extract_round_trips(transactions)
+
+        assert_frame_equal(round_trips, expected)
+
+    def test_add_closing_trades(self):
+        dates = date_range(start='2015-01-01', periods=20)
+        transactions = DataFrame(data=[[2, 10, 'A'],
+                                       [-5, 10, 'A'],
+                                       [-1, 10, 'B']],
+                                 columns=['amount', 'price', 'symbol'],
+                                 index=[dates[:3]])
+        positions = DataFrame(data=[[20, 10, 0],
+                                    [-30, 10, 30],
+                                    [-60, 0, 30]],
+                              columns=['A', 'B', 'cash'],
+                              index=[dates[:3]])
+
+        expected_ix = dates[:3].append(DatetimeIndex([dates[2] +
+                                       Timedelta(seconds=1)]))
+        expected = DataFrame(data=[[2, 10, 'A'],
+                                   [-5, 10, 'A'],
+                                   [-1, 10., 'B'],
+                                   [3, 20., 'A']],
+                             columns=['amount', 'price', 'symbol'],
+                             index=expected_ix)
+
+        transactions_closed = add_closing_transactions(positions, transactions)
+        assert_frame_equal(transactions_closed, expected)
+
+    def test_txn_pnl_matches_round_trip_pnl(self):
+        __location__ = os.path.realpath(
+            os.path.join(os.getcwd(), os.path.dirname(__file__)))
+
+        test_txn = read_csv(gzip.open(
+                            __location__ + '/test_data/test_txn.csv.gz'),
+                            index_col=0, parse_dates=0)
+        test_pos = read_csv(gzip.open(
+                            __location__ + '/test_data/test_pos.csv.gz'),
+                            index_col=0, parse_dates=0)
+
+        transactions_closed = add_closing_transactions(test_pos, test_txn)
+        transactions_closed['txn_dollars'] = transactions_closed.amount * \
+            -1. * transactions_closed.price
+        round_trips = extract_round_trips(transactions_closed)
+
+        self.assertAlmostEqual(round_trips.pnl.sum(),
+                               transactions_closed.txn_dollars.sum())

pyfolio/tests/test_data/test_gross_lev.csv.gz

@@ -14,8 +14,6 @@
 # limitations under the License.
 from __future__ import division
 
-from collections import defaultdict
-
 import pandas as pd
 
 
@@ -39,7 +37,7 @@ def map_transaction(txn):
         symbol = txn['sid']['symbol']
     else:
         sid = txn['sid']
-        symbol = None
+        symbol = txn['sid']
 
     return {'sid': sid,
             'symbol': symbol,
@@ -134,47 +132,6 @@ def adjust_returns_for_slippage(returns, turnover, slippage_bps):
     return trim_returns - turnover * slippage
 
 
-def create_txn_profits(transactions):
-    """
-    Compute per-trade profits.
-
-    Generates a new transactions DataFrame with a profits column
-
-    Parameters
-    ----------
-    transactions : pd.DataFrame
-        Daily transaction volume and number of shares.
-         - See full explanation in tears.create_full_tear_sheet.
-
-    Returns
-    -------
-    profits_dts : pd.DataFrame
-        DataFrame containing transactions and their profits, datetimes,
-        amounts, current prices, prior prices, and symbols.
-    """
-
-    txn_descr = defaultdict(list)
-
-    for symbol, transactions_sym in transactions.groupby('symbol'):
-        transactions_sym = transactions_sym.reset_index()
-
-        for i, (amount, price, dt) in transactions_sym.iloc[1:][
-                ['amount', 'price', 'date_time_utc']].iterrows():
-            prev_amount, prev_price, prev_dt = transactions_sym.loc[
-                i - 1, ['amount', 'price', 'date_time_utc']]
-            profit = (price - prev_price) * -amount
-            txn_descr['profits'].append(profit)
-            txn_descr['dts'].append(dt - prev_dt)
-            txn_descr['amounts'].append(amount)
-            txn_descr['prices'].append(price)
-            txn_descr['prev_prices'].append(prev_price)
-            txn_descr['symbols'].append(symbol)
-
-    profits_dts = pd.DataFrame(txn_descr)
-
-    return profits_dts
-
-
 def get_turnover(transactions, positions, period=None, average=True):
     """
     Portfolio Turnover Rate: