text: from catalyst.finance.slippage import VolumeShareSlippage
  
  from catalyst.api import (
      order_target_value,
      symbol,
      record,
      cancel_order,
      get_open_orders,
  )
  
  def initialize(context):
      context.ASSET_NAME = 'USDT_ETH'
      context.TARGET_HODL_RATIO = 0.3
      context.TARGET_STOP_RATIO = 0.1
      context.RESERVE_RATIO = 1.0 - context.TARGET_HODL_RATIO
  
      # For all trading pairs in the poloniex bundle, the default denomination
      # currently supported by Catalyst is 1/1000th of a full coin. Use this
      # constant to scale the price of up to that of a full coin if desired.
      context.TICK_SIZE = 1000.0
  
      context.is_buying = True
      context.asset = symbol(context.ASSET_NAME)
  
      context.i = 0
  
  def handle_data(context, data):
      context.i += 1
  
      starting_cash = context.portfolio.starting_cash
      target_hodl_value = context.TARGET_HODL_RATIO * starting_cash
      target_stop_value = context.TARGET_STOP_RATIO * starting_cash
      reserve_value = context.RESERVE_RATIO * starting_cash
  
      # Cancel any outstanding orders
      orders = get_open_orders(context.asset) or []
      for order in orders:
          cancel_order(order)
  
      # Stop buying after passing the reserve threshold
      cash = context.portfolio.cash
      if cash <= reserve_value:
          context.is_buying = False
  
      # Retrieve current asset price from pricing data
      price = data[context.asset].price
  
      # Check if still buying and could (approximately) afford another purchase
      if context.is_buying and cash > price:
          # Place order to make position in asset equal to target_hodl_value
          order_target_value(
              context.asset,
              target_hodl_value,
              limit_price=price*1.1,
              stop_price=price*0.9,
          )
  
      record(
          price=price,
          volume=data[context.asset].volume,
          cash=cash,
          starting_cash=context.portfolio.starting_cash,
          leverage=context.account.leverage,
      )
  
  def analyze(context=None, results=None):
      import matplotlib.pyplot as plt
  
      # Plot the portfolio and asset data.
      ax1 = plt.subplot(611)
      results[['portfolio_value']].plot(ax=ax1)
      ax1.set_ylabel('Portfolio Value (USD)')
  
      ax2 = plt.subplot(612, sharex=ax1)
      ax2.set_ylabel('{asset} (USD)'.format(asset=context.ASSET_NAME))
      (context.TICK_SIZE * results[['price']]).plot(ax=ax2)
  
      trans = results.ix[[t != [] for t in results.transactions]]
      buys = trans.ix[
          [t[0]['amount'] > 0 for t in trans.transactions]
      ]
      ax2.plot(
          buys.index,
          context.TICK_SIZE * results.price[buys.index],
          '^',
          markersize=10,
          color='g',
      )
  
      ax3 = plt.subplot(613, sharex=ax1)
      results[['leverage', 'alpha', 'beta']].plot(ax=ax3)
      ax3.set_ylabel('Leverage ')
  
      ax4 = plt.subplot(614, sharex=ax1)
      results[['starting_cash', 'cash']].plot(ax=ax4)
      ax4.set_ylabel('Cash (USD)')
  
      results[[
          'treasury',
          'algorithm',
          'benchmark',
      ]] = results[[
          'treasury_period_return',
          'algorithm_period_return',
          'benchmark_period_return',
      ]]
  
      ax5 = plt.subplot(615, sharex=ax1)
      results[[
          'treasury',
          'algorithm',
          'benchmark',
      ]].plot(ax=ax5)
      ax5.set_ylabel('Percent Change')
  
      ax6 = plt.subplot(616, sharex=ax1)
      results[['volume']].plot(ax=ax6)
      ax6.set_ylabel('Volume (mCoins/5min)')
  
      plt.legend(loc=3)
  
      # Show the plot.
      plt.gcf().set_size_inches(18, 8)
      plt.show()
  