visualization.py

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Button

from os import listdir
from os.path import isfile, join

import json
import seaborn as sns

class LogFile(object):
 def __init__(self, json_content, file_name=None):
 self._file_name = file_name if file_name is not None else "noname"
 self._steps = [Step(s) for s in json_content]
 if len(self._steps) <= 0:
 self._max_length = 0
 self._sender_count = 0
 else:
 self._max_length = max([s._max_length for s in self._steps])
 self._sender_count = self._steps[0]._sender_count

 def __repr__(self):
 s = "LogFile{"
 for step in self._steps:
 s += "%s," % step
 if len(self._steps) > 0:
 s = s[:-1]
 s += "}"
 return s

 def plot(self):
 for step in log_file._steps:
 f, axes = plt.subplots(self._sender_count, sharex=True, sharey=True)
 step.show_plot(self._max_length, axes)
 plt.show()

 def plot_step(self, axes, selected):
 self._steps[selected].show_plot(self._max_length, axes)

 @staticmethod
 def parse_json_file(filename):
 print(filename)
 with open(filename, 'r') as f:
 json_content = json.load(f)
 return LogFile(json_content, filename)

class Step(object):
 def __init__(self, json_content):
 self._sender_count = json_content["sendercount"]
 self._cliques = json_content["clqs"]
 # reversed so that validator 0 is at the bottom
 self._last_messages = [View(j) for j in json_content["lms"]]
 self._max_length = max([v.get_max_length() for v in self._last_messages])

 def __repr__(self):
 s = "Step{sender_count: %d, cliques: %s, last_messages: %s}" % (
 self._sender_count, self._cliques, self._last_messages)
 return s

 def show_plot(self, max_length, axes):
 length = len(self._last_messages)-1
 for i, view in enumerate(self._last_messages):
 view.add_plot(self._sender_count, max_length, axes[length-i])
 axes[length-i].set_ylabel(i)
 plt.setp(axes,
 xticks=range(1, max_length),
 yticks=range(0, self._sender_count),
 )


class View(object):
 def __init__(self, json_content):
 _json_content = json_content[0]
 self._heights = {}
 self._messages = {key: Message(value) for (key, value) in _json_content.items()}
 self.compute_heights()

 def __repr__(self):
 return "View%s" % self._messages

 def add_plot(self, sender_count, max_length, axes):
 for i, key in enumerate(sorted(self._messages.keys())):
 self._messages[key].add_plot(sender_count, self._heights, axes)

 def get_max_length(self):
 return max([len(m._justification) for m in self._messages.values()])

 def compute_heights(self):
 for name, message in self._messages.items():
 for index, block in enumerate(reversed(message._justification)):
 if block is not None:
 self._heights[block[1]] = index
 last_block = block
 else:
 self._heights[None] = -1


class Message(object):
 def __init__(self, json_content):
 # formatting?
 assert len(json_content) == 1
 # get first key
 self._name, justification = json_content.popitem()
 self._justification = [tuple(j) if j != 'None' else None for j in justification]

 def __repr__(self):
 return "Message{name: %s, justification: %s}" % (self._name, self._justification)

 def add_plot(self, sender_count, heights, axes):
 # m is None if its the genesis remove "if m is not None" to show it on the graphs
 x = [heights[m[1]] if m is not None else heights[m] for m in self._justification if m is not None]
 y = [-1 if m is None else int(m[0]) for m in self._justification if m is not None]
 axes.plot(x,y, 'bo', linestyle='solid')


class IndexSteps(object):
 _FAST_FORWARD_STEP = 5

 def __init__(self, fig, log_files):
 self._fig = fig
 self._log_files = log_files
 self._selected_log_file = 0
 self._log_file = log_files[self._selected_log_file]
 self._axes = fig.subplots(self._log_file._sender_count, sharex=True, sharey=True)
 self._fix_axes()
 self._selected_step = 0
 self._min = 0
 self._max = len(self._log_file._steps)-1
 self._log_file.plot_step(self._axes, self._selected_step)
 self._print_title()

 def _perform_step(self, step):
 self._selected_step += step
 self._selected_step = self._max if self._selected_step >= self._max else self._selected_step
 self._selected_step = self._min if self._selected_step <= self._min else self._selected_step
 self._plot()

 def _fix_axes(self):
 '''if there is only one validator, there is only one axe and
 matplotlib returns only an object, not a list of objects.
 as everything is based on loops over a list of axes it is easier to fix it here once'''
 if not isinstance(self._axes, np.ndarray):
 self._axes = [self._axes]

 def next(self, event):
 self._perform_step(1)

 def prev(self, event):
 self._perform_step(-1)

 def next_ff(self, event):
 self._perform_step(self._FAST_FORWARD_STEP)

 def prev_ff(self, event):
 self._perform_step(-self._FAST_FORWARD_STEP)

 def _plot(self):
 self._reset_axes()
 self._log_file.plot_step(self._axes, self._selected_step)
 self._print_subtitle()
 self._fig.canvas.draw()

 def prev_log_file(self, event):
 self._perform_log(-1)

 def next_log_file(self, event):
 self._perform_log(1)

 def _reset_axes(self):
 for axe in self._axes:
 axe.cla()

 def _print_title(self):
 self._fig.suptitle(self._log_file._file_name)
 self._print_subtitle()

 def _print_subtitle(self):
 self._axes[0].set_title("Step %d/%d" % (self._selected_step + 1, self._max + 1))


 def _perform_log(self, selected_log_file_step):
 self._selected_log_file += selected_log_file_step
 min_index = 0
 max_index = len(self._log_files)-1

 self._selected_log_file = max_index if self._selected_log_file >= max_index else self._selected_log_file
 self._selected_log_file = min_index if self._selected_log_file <= min_index else self._selected_log_file

 self._log_file = self._log_files[self._selected_log_file]
 self._min = 0
 self._max = len(self._log_file._steps)-1
 self._selected_step = self._min

 self._reset_axes()

 plt.setp(self._axes, xticks=[], yticks=[])
 self._axes = self._fig.subplots(self._log_file._sender_count, sharex=True, sharey=True)
 self._fix_axes()
 self._print_title()
 self._plot()

def main():
 # json files loading
 from os import listdir
 from os.path import isfile, join

 directory = "./generated"

 # all files (no folders) in directory
 onlyfiles = sorted([f for f in listdir(directory) if isfile(join(directory, f))])

 log_files = [LogFile.parse_json_file(directory+'/'+f) for f in onlyfiles]

 # filter out empty files
 log_files = [log_file for log_file in log_files if len(log_file._steps) > 0]

 size_x = 0.075
 size_y = 0.054

 size_x_large = size_x * 1.4
 offset_x = 0.01

 fig = plt.figure(figsize=(5,5), dpi=100)

 callback = IndexSteps(fig, log_files)

 axprev = plt.axes([0.15 + 1 * size_x, offset_x, size_x, size_y])
 axnext = plt.axes([0.15 + 2 * size_x, offset_x, size_x, size_y])

 axprev_ff = plt.axes([0.15 + 0 * size_x, offset_x, size_x, size_y])
 axnext_ff = plt.axes([0.15 + 3 * size_x, offset_x, size_x, size_y])

 axprev_log = plt.axes([0.65, offset_x, size_x_large, size_y])
 axnext_log = plt.axes([0.65 + size_x_large, offset_x, size_x_large, size_y])

 bnext = Button(axnext, '>')
 bnext.on_clicked(callback.next)

 bprev = Button(axprev, '<')
 bprev.on_clicked(callback.prev)

 bnext_ff = Button(axnext_ff, '>>')
 bnext_ff.on_clicked(callback.next_ff)

 bprev_ff = Button(axprev_ff, '<<')
 bprev_ff.on_clicked(callback.prev_ff)

 bnext_log = Button(axnext_log, "Next Log")
 bnext_log.on_clicked(callback.next_log_file)

 bprev_log = Button(axprev_log, "Prev Log")
 bprev_log.on_clicked(callback.prev_log_file)
 plt.show()

if __name__ == '__main__':
 main()