visualizer/server.py at main · aibasel/visualizer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
import base64 #for encoding the compressed json parameter dict as url
import json #for dumping the parameter dict as json
import logging
import panel as pn
from panel.viewable import Viewer
import param
import traceback
import zlib #for compressing the json parameter dict

from absolute_table import AbsoluteTable
from attribute_table import AttributeReport
from cactus import Cactusplot
from config_string_translator import translate
from diff_table import DiffTable
from experiment_data import ExperimentData
from problem_table import ProblemTable
from scatter import ScatterReport
from user_logger import UserLogger

from custom_golden_template import GoldenTemplate

logger = logging.getLogger("visualizer")
global_user_logger = UserLogger()
pn.config.throttled = True
pn.extension('tabulator')
pn.extension('floatpanel')

def exception_handler(ex):
    global_user_logger.log(logging.ERROR, traceback.format_exc())
    pn.state.notifications.error('Error: %s' % ex)

pn.extension(exception_handler=exception_handler, notifications=True)

class FullViewer(Viewer):

    selected_report = param.Selector(label="Report Type")
    user_logger = param.Parameter(precedence=-1)
    experiment_data = param.Parameter(precedence=-1)
    param_config = param.String(precedence=-1) #encodes all relevant parameter information in a string that is passed to the url
    report_information = param.String(precedence=-1, default="")

    def __init__(self, **params):
        super().__init__(**params)

        self.user_logger = global_user_logger
        self.experiment_data = ExperimentData(user_logger=self.user_logger)
        self.reports = [
            AbsoluteTable(name="Absolute Table", experiment_data=self.experiment_data, user_logger=self.user_logger),
            AttributeReport(name="Attribute Report", experiment_data=self.experiment_data, user_logger=self.user_logger),
            Cactusplot(name="Cactus Plot", experiment_data=self.experiment_data, user_logger=self.user_logger),
            DiffTable(name="Diff Table", experiment_data=self.experiment_data, user_logger=self.user_logger),
            ProblemTable(name="Problem Table", experiment_data=self.experiment_data, user_logger=self.user_logger),
            ScatterReport(name="Scatter Plot", experiment_data=self.experiment_data, user_logger=self.user_logger)
        ]
        self.param.selected_report.objects = self.reports


        # We wrap param and report views into a Column since we need one
        # constant object whose visibility we manipulate when switching
        # report type. (Param and report views might return new objects.)
        self.report_param_views = pn.Column(*[pn.Column(x.param_view) for x in self.reports])
        self.report_data_views = pn.Column(*[pn.Column(report) for report in self.reports])
        self.log_view = pn.Column(pn.Column(scroll=True),scroll=True)

        self.template = GoldenTemplate(
            title='Visualizer',
            sidebar=pn.Column(
                pn.widgets.Select.from_param(
                    self.param.selected_report,
                    options={},
                    margin=(10, 0, 5, 0),
                    min_width=100,
                    sizing_mode="stretch_width"
                ),
                pn.pane.HTML(self.param.report_information),
                pn.pane.Markdown("## Properties", margin=(25,0,0,0)),
                pn.layout.Divider(margin=(-15,0,0,0)),
                self.experiment_data.param_view,
                pn.pane.Markdown("## Report", margin=(25,0,0,0)),
                pn.layout.Divider(margin=(-15,0,0,0)),
                *self.report_param_views,
                sizing_mode="stretch_width",
                scroll=True
            ),
            main=pn.Column(
                *self.report_data_views,
                sizing_mode="stretch_both",
                scroll=True,
            ),
            modal=self.user_logger
        )
        # HACK: if we initialize the Select widget with the right options, we
        # get an expand button (https://github.com/holoviz/panel/issues/3836)
        # Initializing it empty and changing the options afterwards avoids this.
        self.template.sidebar[0].options = {x.name: x for x in self.reports}


    def __panel__(self):
        return self.template


    @param.depends("selected_report", watch=True)
    def report_selected(self):
        logger.debug("setting selected report")
        self.report_information = self.selected_report.report_information
        for i, report in enumerate(self.reports):
            self.report_param_views[i].visible = bool(self.selected_report == report)
            self.report_data_views[i].visible = bool(self.selected_report == report)


    # will load the parameters from the url or set a default if url contains no information
    def load_params(self):
        if not self.param_config:
            self.selected_report = self.reports[5]
            return

        logger.debug("loading parameters from url")

        params = json.loads(zlib.decompress(
            base64.urlsafe_b64decode(self.param_config.encode())))
        if params["version"] != "2.0":
            params = translate(params)
        logger.debug(f"loading param dict: {params}")
        logger.debug("loading selected report")
        self.selected_report = self.reports[params["repn"]]
        logger.debug("loading experiment data params")
        self.experiment_data.set_params_from_param_config_dict(params["data"])
        logger.debug("loading selected report params")
        self.selected_report.set_params_from_param_config_dict(params["rep"])

        logger.debug("done loading parameters from url")


    def setup_param_config_watchers(self):
        self.param.watch(self.set_param_config, ["selected_report"])
        self.experiment_data.param.watch(
            self.set_param_config,
            self.experiment_data.get_watchers_for_param_config()
        )
        for report in self.reports:
            report.param.watch(
                self.set_param_config,
                report.get_watchers_for_param_config()
            )


    # sets a url based on the current parameter values
    def set_param_config(self, *events):
        self.param_config = ""
        logger.debug("setting param config string")
        # we only want to set an url if the properties file was passed by url
        if self.experiment_data.properties_mode == "file":
            self.param_config = ""
            return

        params = {
            "version": "2.0",
            "repn" : self.reports.index(self.selected_report),
            "data": self.experiment_data.get_param_config_dict(),
            "rep" : self.selected_report.get_param_config_dict()
        }
        self.param_config = base64.urlsafe_b64encode(zlib.compress(json.dumps(params).encode())).decode()
        logger.debug(f"set param config string with dictionary {params}")


overall_view = FullViewer()
pn.state.location.sync(overall_view, { "param_config" : "c" })
overall_view.load_params()
overall_view.setup_param_config_watchers()
overall_view.servable()