new_contents: import datetime
  import tensorflow as tf
  
  
  class TensorBoard(object):
      """
      TensorBoard is a visualization tool provided with TensorFlow.
      This class can be used to record attributes from a running
      Zipline algorithm.
  
      If you have installed TensorFlow with pip, you should be able
      to launch TensorBoard from the command line:
  
          tensorboard --logdir=/full_path_to_your_logs
  
      Args:
          log_dir: the path of the directory where to save the log
              files to be parsed by tensorboard
          max_queue: Maximum number of summaries or events pending to be
                     written to disk before one of the 'add' calls block.
                     [default 10]
          flush_secs: How often, in seconds, to flush the added summaries
              and events to disk. [default 120]
      """
      def __init__(self, log_dir='./logs', max_queue=10, flush_secs=120):
          self.log_dir = log_dir
          self.merged = tf.merge_all_summaries()
          self.writer = tf.train.SummaryWriter(self.log_dir,
                                               max_queue=max_queue,
                                               flush_secs=flush_secs,
                                               graph_def=None)
  
      def log_dict(self, epoch, logs):
          """
          Writes a dictionary of simple named values to TensorBoard.
  
          Args:
              epoch: An integer representing time.
              logs: A dict containing what we want to log to TensorBoard.
          """
          for name, value in logs.items():
              summary = tf.Summary()
              summary_value = summary.value.add()
              summary_value.simple_value = value
              summary_value.tag = name
              self.writer.add_summary(summary, global_step=epoch)
          self.writer.flush()
  
      def log_algo(self, algo, epoch=None, other_logs={}):
          """
          Logs info about a Zipline algorithm as it's running.
  
          Args:
              epoch: An integer representing algorithm time.
                     If None, then the algorithm's current
                     date is converted to an ordinal so that
                     these integers are monotonically increasing
                     with time. The same integer convention should
                     be used across different runs so that their charts
                     line up correctly.
             algo: An instance of a zipline.algorithm.TradingAlgorithm
             other_logs: A dictionary containing other things we want to log.
          """
          if epoch is None:
              epoch = datetime.date.toordinal(algo.get_datetime())
  
          logs = {}
  
          # add portfolio related things
          logs['portfolio value'] = algo.portfolio.portfolio_value
          logs['portfolio pnl'] = algo.portfolio.pnl
          logs['portfolio return'] = algo.portfolio.returns
          logs['portfolio cash'] = algo.portfolio.cash
          logs['portfolio capital used'] = algo.portfolio.capital_used
          logs['portfolio positions exposure'] = algo.portfolio.positions_exposure
          logs['portfolio positions value'] = algo.portfolio.positions_value
          logs['number of orders'] = len(algo.blotter.orders)
          logs['number of open orders'] = len(algo.blotter.open_orders)
          logs['number of open positions'] = len(algo.portfolio.positions)
  
          # add recorded variables from `zipline.algorithm.record` method
          for name, value in algo.recorded_vars.items():
              logs[name] = value
  
          # add any extras passed in through `other_logs` dictionary
          for name, value in other_logs.items():
              logs[name] = value
  
          self.log_dict(epoch, logs)
  
subject: Create tensorboard.py