Section 1.1: Equity Curve Assessment

A vital aspect of the Portfolio class is the equity_curve property method, which provides an overview of the combined trading strategies' performance. It computes the cumulative equity curve by consolidating the individual equity curves of each strategy and averaging them to reflect the portfolio's overall performance.

@property

def equity_curve(self) -> float:

for idx, strat in enumerate(self.strategies):

if idx == 0:

pf = strat[1].equity_curve

else:

asset = strat[1].equity_curve

size_diff = pf.size - asset.size

if size_diff > 0:

asset = np.concatenate((np.full(size_diff, asset[0]), asset))

elif size_diff < 0:

pf = np.concatenate((np.full(-size_diff, pf[0]), pf))

pf = np.add(pf, asset)

pf = (1./len(self.strategies)) * pf

return pf

This method iterates through each strategy in the portfolio, adjusting for discrepancies in their equity curves' lengths by padding with initial values where necessary, before summing and averaging them to generate the portfolio’s overall equity curve.

Section 1.2: Visualizing the Equity Curve

The plot_equity method offers a visual representation of the portfolio's equity curve using matplotlib, making it easier to assess the portfolio’s performance over time. This visualization provides a clear and intuitive understanding of how well the combined strategies perform in the market.

def plot_equity(self) -> None:

pf = self.equity_curve

plt.figure(figsize=(18, 9))

plt.grid(True)

plt.plot(pf)

plt.title("Portfolio Equity Curve")

plt.xlabel("Time")

plt.ylabel("Equity")

plt.show()

This straightforward method retrieves the calculated equity curve and generates a plot, enhancing the analysis by graphically depicting the portfolio’s growth or decline over time.

Section 1.3: Integrating New Strategies

The add_strategy method enables the dynamic addition of new strategies to the portfolio, which is essential for adjusting the portfolio according to evolving market conditions and incorporating new trading methodologies.

def add_strategy(self, strategy: Strategy) -> None:

self.strategies.append(strategy)

This method simply adds a new Strategy instance to the strategies list, integrating it into the portfolio for future assessment and execution.

Section 2.1: Trade Execution and Initialization

The initialize_trades and live_trades methods are essential for simulating historical trades and executing real-time trades, respectively. These functions ensure that the portfolio's strategies are both tested and applied in practical scenarios, confirming their effectiveness and making necessary adjustments for optimal performance.

def initialize_trades(self) -> None:

for idx, strat in enumerate(tqdm(self.strategies)):

start_time = strat[0].start_time

end_time = start_time + timedelta(days=40)

while start_time < datetime.now():

df = self._dh.fetch_historical_data(self._ec, strat[0].market_name, strat[1].timeframe, start_time, end_time)

if self._live:

for index, row in df.iterrows():

strat[1].next_candle_init(row)

else:

for index, row in df.iterrows():

strat[1].next_candle_live(row)

start_time = end_time

end_time = end_time + timedelta(days=40)

def live_trades(self) -> None:

for idx, strat in enumerate(tqdm(self.strategies)):

market_name = strat[0].market_name

df = self._dh.fetch_current_data(self._ec, market_name, strat[1].timeframe.value)

strat[1].next_candle_live(df.iloc[-1])

These methods utilize the DataHandler class to fetch pertinent market data, applying each strategy’s logic to either historical or real-time data, thus enabling the practical execution of the portfolio’s trading strategies.