text: import sys
  import json
  import datetime
  import inspect
  from .util import Switch
  
  
  class Style(Switch):
      """The base :class:`Style` type."""
  
      def __call__(self, log):
          """Return a formated log.
  
          Parameters
          ----------
          log : dict
              A log created by
          """
          log = self._pre(log)
          if log:
              lines = self._switch(log)
              if lines and isinstance(lines, str):
                  lines = [lines]
              if lines:
                  return self._post("\n".join(lines) + "\n")
  
      def _pre(self, log):
          return log
  
      def _post(self, log):
          return log
  
  
  class Raw(Style):
      """Creates a string representation of the log object."""
  
      class Encoder(json.JSONEncoder):
  
          def default(self, o):
              try:
                  return super(json.JSONEncoder, self).default(o)
              except:
                  return str(o)
  
      def _default(self, log):
          return self.Encoder().encode(log)
  
  
  class Log(Style):
      """A basic formater that only creates successes, and failures."""
  
      def _pre(self, log):
          if isinstance(log["metadata"]["title"], str):
              return log
  
      def _completed(self, log):
          metadata = log["metadata"]
          status = metadata["status"]
          duration = metadata["timestamps"][-1] - metadata["timestamps"][0]
          timestamp = datetime.datetime.fromtimestamp(metadata["timestamps"][-1])
          info = ", ".join(map(lambda i: "%s: %s" % i, log["content"].items()))
          message = "{time} {status} {title} after {duration:.3f} seconds"
          if len(info) > 50:
              info = info[:47] + "..."
          if info:
              message += " - {info}"
          yield message.format(time=timestamp, status=status.upper(),
              title=metadata["title"], info=info, duration=duration)
  
      _success = _completed
      _failure = _completed
  
  
  class Tree(Style):
      """An ascii tree representation for logs."""
  
      def __init__(self):
          self._depths = {}
  
      def _pre(self, log):
          tag = log["metadata"]["tag"]
          parent = log["metadata"]["parent"]
          depth = self._depths.get(parent, -1) + 1
          log["metadata"]["depth"] = self._depths[tag] = depth
          return log
  
      def _started(self, log):
          content, metadata = log["content"], log["metadata"]
          indent = "|   " * metadata["depth"]
          timestamp = datetime.datetime.fromtimestamp(metadata["timestamps"][-1])
          yield indent + "|-- {status}: {title}".format(**metadata)
          yield indent + "|   @ {0}".format(timestamp)
          if "reason" in content:
              yield indent + "|   | reason: {0}".format(content.pop("reason"))
          for k, v in content.items():
              yield indent + "|   | {0}: {1}".format(k, v)
  
      def _working(self, log):
          content, metadata = log["content"], log["metadata"]
          indent = "|   " * (metadata["depth"] + 1)
          timestamp = datetime.datetime.fromtimestamp(metadata["timestamps"][-1])
          yield indent + "|-- {status}: {title}".format(**metadata)
          yield indent + "|   @ {0}".format(timestamp)
          if "reason" in content:
              yield indent + "|   | reason: {0}".format(content.pop("reason"))
          for k, v in content.items():
              yield indent + "|   | {0}: {1}".format(k, v)
  
      def _default(self, log):
          content, metadata = log["content"], log["metadata"]
          indent = "|   " * (metadata["depth"] + 1)
          timestamp = datetime.datetime.fromtimestamp(metadata["timestamps"][-1])
          yield indent + "`-- {status}: {title}".format(**metadata)
          yield indent + "    @ {0}".format(timestamp)
          diff = metadata["timestamps"][-1] - metadata["timestamps"][0]
          content["duration"] = "{:.3f}".format(diff) + " seconds"
          if "reason" in content:
              yield indent + "|   | reason: {0}".format(content.pop("reason"))
          for k, v in content.items():
              yield indent + "    | {0}: {1}".format(k, v)
  