def make_tooltip():
"""Create the tooltip. The function uses local variables from
the enclosing scope."""
# pylint: disable=undefined-loop-variable
def _oper(attr, txt):
if self.data.domain[attr.name] == ddomain[attr.name]:
return " = "
return " " if txt[0] in "<≥" else " in "
xt, yt = [
"<b>{attr}{eq}{val_name}</b>: {obs}/{n} ({p:.0f} %)".format(
attr=to_html(attr.name),
eq=_oper(attr, val_name),
val_name=to_html(val_name),
obs=fmt(prob * n),
n=int(n),
p=100 * prob) for attr, val_name, prob in [(
attr_x, xval_name,
chi.probs_x[x]), (attr_y, yval_name, chi.probs_y[y])]
]
ct = """<b>combination of values: </b><br/>
expected {exp} ({p_exp:.0f} %)<br/>
observed {obs} ({p_obs:.0f} %)""".format(
exp=fmt(chi.expected[y, x]),
p_exp=100 * chi.expected[y, x] / n,
obs=fmt(chi.observed[y, x]),
p_obs=100 * chi.observed[y, x] / n)
return f"{xt}<br/>{yt}<hr/>{ct}"
def make_tooltip():
"""Create the tooltip. The function uses local variables from
the enclosing scope."""
# pylint: disable=undefined-loop-variable
def _oper(attr, txt):
if self.data.domain[attr.name] == ddomain[attr.name]:
return " = "
return " " if txt[0] in "<≥" else " in "
xt, yt = ["<b>{attr}{eq}{val_name}</b>: {obs}/{n} ({p:.0f} %)".format(
attr=to_html(attr.name),
eq=_oper(attr, val_name),
val_name=to_html(val_name),
obs=fmt(prob * n),
n=int(n),
p=100 * prob)
for attr, val_name, prob in [(attr_x, xval_name, chi.probs_x[x]),
(attr_y, yval_name, chi.probs_y[y])]]
ct = """<b>combination of values: </b><br/>
expected {exp} ({p_exp:.0f} %)<br/>
observed {obs} ({p_obs:.0f} %)""".format(
exp=fmt(chi.expected[y, x]),
p_exp=100 * chi.expected[y, x] / n,
obs=fmt(chi.observed[y, x]),
p_obs=100 * chi.observed[y, x] / n)
return f"{xt}<br/>{yt}<hr/>{ct}"
def make_tooltip():
"""Create the tooltip. The function uses local variables from
the enclosing scope."""
# pylint: disable=undefined-loop-variable
def _oper(attr, txt):
if self.data.domain[attr.name] is ddomain[attr.name]:
return "="
return " " if txt[0] in "<≥" else " in "
return (
"<b>{attr_x}{xeq}{xval_name}</b>: {obs_x}/{n} ({p_x:.0f} %)".
format(attr_x=to_html(attr_x.name),
xeq=_oper(attr_x, xval_name),
xval_name=to_html(xval_name),
obs_x=fmt(chi.probs_x[x] * n),
n=int(n),
p_x=100 * chi.probs_x[x]) +
"<br/>" +
"<b>{attr_y}{yeq}{yval_name}</b>: {obs_y}/{n} ({p_y:.0f} %)".
format(attr_y=to_html(attr_y.name),
yeq=_oper(attr_y, yval_name),
yval_name=to_html(yval_name),
obs_y=fmt(chi.probs_y[y] * n),
n=int(n),
p_y=100 * chi.probs_y[y]) +
"<hr/>" +
"""<b>combination of values: </b><br/>
expected {exp} ({p_exp:.0f} %)<br/>
observed {obs} ({p_obs:.0f} %)""".
format(exp=fmt(chi.expected[y, x]),
p_exp=100 * chi.expected[y, x] / n,
obs=fmt(chi.observed[y, x]),
p_obs=100 * chi.observed[y, x] / n))
def make_tooltip():
"""Create the tooltip. The function uses local variables from
the enclosing scope."""
# pylint: disable=undefined-loop-variable
def _oper(attr, txt):
if self.data.domain[attr.name] is ddomain[attr.name]:
return "="
return " " if txt[0] in "<≥" else " in "
return (
"<b>{attr_x}{xeq}{xval_name}</b>: {obs_x}/{n} ({p_x:.0f} %)".
format(attr_x=to_html(attr_x.name),
xeq=_oper(attr_x, xval_name),
xval_name=to_html(xval_name),
obs_x=fmt(chi.probs_x[x] * n),
n=int(n),
p_x=100 * chi.probs_x[x]) +
"<br/>" +
"<b>{attr_y}{yeq}{yval_name}</b>: {obs_y}/{n} ({p_y:.0f} %)".
format(attr_y=to_html(attr_y.name),
yeq=_oper(attr_y, yval_name),
yval_name=to_html(yval_name),
obs_y=fmt(chi.probs_y[y] * n),
n=int(n),
p_y=100 * chi.probs_y[y]) +
"<hr/>" +
"""<b>combination of values: </b><br/>
expected {exp} ({p_exp:.0f} %)<br/>
observed {obs} ({p_obs:.0f} %)""".
format(exp=fmt(chi.expected[y, x]),
p_exp=100 * chi.expected[y, x] / n,
obs=fmt(chi.observed[y, x]),
p_obs=100 * chi.observed[y, x] / n))
def text(txt, *args, **kwargs):
text = html_text = None
if "max_width" in kwargs:
text = txt
else:
html_text = to_html(txt)
return CanvasText(self.canvas, text, html_text=html_text,
*args, **kwargs)
def _rules_str(self):
rules = self.tree.rules(self.label)
if rules:
if isinstance(rules[0], Rule):
sorted_rules = sorted(rules[:-1], key=lambda rule: rule.attr_name)
return '<br>'.join(str(rule) for rule in sorted_rules) + \
'<br><b>%s</b>' % rules[-1]
else:
return '<br>'.join(to_html(rule) for rule in rules)
else:
return ''
def _rules_str(self):
rules = self.tree.rules(self.label)
if rules:
if isinstance(rules[0], Rule):
sorted_rules = sorted(rules[:-1], key=lambda rule: rule.attr_name)
return '<br>'.join(str(rule) for rule in sorted_rules) + \
'<br><b>%s</b>' % rules[-1]
else:
return '<br>'.join(to_html(rule) for rule in rules)
else:
return ''
def _rules_for_tooltip(self, node):
rules = self.tree_adapter.rules(node.label)
if len(rules):
if isinstance(rules[0], Rule):
sorted_rules = sorted(rules[:-1], key=lambda rule: rule.attr_name)
return '<br>'.join(str(rule) for rule in sorted_rules) + \
'<br><b>%s</b>' % rules[-1]
else:
return '<br>'.join(to_html(rule) for rule in rules)
else:
return ''
def _rules_for_tooltip(self, node):
rules = self.tree_adapter.rules(node.label)
if len(rules):
if isinstance(rules[0], Rule):
sorted_rules = sorted(rules[:-1],
key=lambda rule: rule.attr_name)
return '<br>'.join(str(rule) for rule in sorted_rules) + \
'<br><b>%s</b>' % rules[-1]
else:
return '<br>'.join(to_html(rule) for rule in rules)
else:
return ''
def draw_data(attr_list, x0_x1, y0_y1, side, condition,
total_attrs, used_attrs, used_vals, attr_vals=""):
x0, x1 = x0_x1
y0, y1 = y0_y1
if conditionaldict[attr_vals] == 0:
add_rect(x0, x1, y0, y1, "",
used_attrs, used_vals, attr_vals=attr_vals)
# store coordinates for later drawing of labels
draw_text(side, attr_list[0], (x0, x1), (y0, y1), total_attrs,
used_attrs, used_vals, attr_vals)
return
attr = attr_list[0]
# how much smaller rectangles do we draw
edge = len(attr_list) * spacing
values = get_variable_values_sorted(attr)
if side % 2:
values = values[::-1] # reverse names if necessary
if side % 2 == 0: # we are drawing on the x axis
# remove the space needed for separating different attr. values
whole = max(0, (x1 - x0) - edge * (len(values) - 1))
if whole == 0:
edge = (x1 - x0) / float(len(values) - 1)
else: # we are drawing on the y axis
whole = max(0, (y1 - y0) - edge * (len(values) - 1))
if whole == 0:
edge = (y1 - y0) / float(len(values) - 1)
total, counts = get_counts(attr_vals, values)
# when visualizing the third attribute and the first attribute has
# the last value, reverse the order in which the boxes are drawn;
# otherwise, if the last cell, nearest to the labels of the fourth
# attribute, is empty, we wouldn't be able to position the labels
valrange = list(range(len(values)))
if len(attr_list + used_attrs) == 4 and len(used_attrs) == 2:
attr1values = get_variable_values_sorted(used_attrs[0])
if used_vals[0] == attr1values[-1]:
valrange = valrange[::-1]
for i in valrange:
start = i * edge + whole * float(sum(counts[:i]) / total)
end = i * edge + whole * float(sum(counts[:i + 1]) / total)
val = values[i]
htmlval = to_html(val)
newattrvals = attr_vals + "-" + val if attr_vals else val
tooltip = "{} {}: <b>{}</b><br/>".format(
condition, attr.name, htmlval)
attrs = used_attrs + [attr]
vals = used_vals + [val]
args = attrs, vals, newattrvals
if side % 2 == 0: # if we are moving horizontally
if len(attr_list) == 1:
add_rect(x0 + start, x0 + end, y0, y1, tooltip, *args)
else:
draw_data(
attr_list[1:], (x0 + start, x0 + end), (y0, y1),
side + 1, tooltip, total_attrs, *args)
else:
if len(attr_list) == 1:
add_rect(x0, x1, y0 + start, y0 + end, tooltip, *args)
else:
draw_data(
attr_list[1:], (x0, x1), (y0 + start, y0 + end),
side + 1, tooltip, total_attrs, *args)
draw_text(side, attr_list[0], (x0, x1), (y0, y1),
total_attrs, used_attrs, used_vals, attr_vals)
def draw_data(attr_list, x0_x1, y0_y1, side, condition,
total_attrs, used_attrs=[], used_vals=[],
attr_vals=""):
x0, x1 = x0_x1
y0, y1 = y0_y1
if conditionaldict[attr_vals] == 0:
add_rect(x0, x1, y0, y1, "",
used_attrs, used_vals, attr_vals=attr_vals)
# store coordinates for later drawing of labels
draw_text(side, attr_list[0], (x0, x1), (y0, y1), total_attrs,
used_attrs, used_vals, attr_vals)
return
attr = attr_list[0]
# how much smaller rectangles do we draw
edge = len(attr_list) * spacing
values = get_variable_values_sorted(data.domain[attr])
if side % 2:
values = values[::-1] # reverse names if necessary
if side % 2 == 0: # we are drawing on the x axis
# remove the space needed for separating different attr. values
whole = max(0, (x1 - x0) - edge * (
len(values) - 1))
if whole == 0:
edge = (x1 - x0) / float(len(values) - 1)
else: # we are drawing on the y axis
whole = max(0, (y1 - y0) - edge * (len(values) - 1))
if whole == 0:
edge = (y1 - y0) / float(len(values) - 1)
if attr_vals == "":
counts = [conditionaldict[val] for val in values]
else:
counts = [conditionaldict[attr_vals + "-" + val]
for val in values]
total = sum(counts)
# if we are visualizing the third attribute and the first attribute
# has the last value, we have to reverse the order in which the
# boxes will be drawn otherwise, if the last cell, nearest to the
# labels of the fourth attribute, is empty, we wouldn't be able to
# position the labels
valrange = list(range(len(values)))
if len(attr_list + used_attrs) == 4 and len(used_attrs) == 2:
attr1values = get_variable_values_sorted(
data.domain[used_attrs[0]])
if used_vals[0] == attr1values[-1]:
valrange = valrange[::-1]
for i in valrange:
start = i * edge + whole * float(sum(counts[:i]) / total)
end = i * edge + whole * float(sum(counts[:i + 1]) / total)
val = values[i]
htmlval = to_html(val)
if attr_vals != "":
newattrvals = attr_vals + "-" + val
else:
newattrvals = val
tooltip = condition + 4 * " " + attr + \
": <b>" + htmlval + "</b><br>"
attrs = used_attrs + [attr]
vals = used_vals + [val]
common_args = attrs, vals, newattrvals
if side % 2 == 0: # if we are moving horizontally
if len(attr_list) == 1:
add_rect(x0 + start, x0 + end, y0, y1,
tooltip, *common_args)
else:
draw_data(attr_list[1:], (x0 + start, x0 + end),
(y0, y1), side + 1,
tooltip, total_attrs, *common_args)
else:
if len(attr_list) == 1:
add_rect(x0, x1, y0 + start, y0 + end,
tooltip, *common_args)
else:
draw_data(attr_list[1:], (x0, x1),
(y0 + start, y0 + end), side + 1,
tooltip, total_attrs, *common_args)
draw_text(side, attr_list[0], (x0, x1), (y0, y1),
total_attrs, used_attrs, used_vals, attr_vals)
def node_tooltip(self, node):
return "<br>".join(
to_html(rule) for rule in self.model.rule(node.node_inst))
def text(txt, *args, **kwargs):
return CanvasText(self.canvas, "", html_text=to_html(txt),
*args, **kwargs)
def draw_data(attr_list,
x0_x1,
y0_y1,
side,
condition,
total_attrs,
used_attrs,
used_vals,
attr_vals=""):
x0, x1 = x0_x1
y0, y1 = y0_y1
if conditionaldict[attr_vals] == 0:
add_rect(x0,
x1,
y0,
y1,
"",
used_attrs,
used_vals,
attr_vals=attr_vals)
# store coordinates for later drawing of labels
draw_text(side, attr_list[0], (x0, x1), (y0, y1), total_attrs,
used_attrs, used_vals, attr_vals)
return
attr = attr_list[0]
# how much smaller rectangles do we draw
edge = len(attr_list) * spacing
values = get_variable_values_sorted(attr)
if side % 2:
values = values[::-1] # reverse names if necessary
if side % 2 == 0: # we are drawing on the x axis
# remove the space needed for separating different attr. values
whole = max(0, (x1 - x0) - edge * (len(values) - 1))
if whole == 0:
edge = (x1 - x0) / float(len(values) - 1)
else: # we are drawing on the y axis
whole = max(0, (y1 - y0) - edge * (len(values) - 1))
if whole == 0:
edge = (y1 - y0) / float(len(values) - 1)
total, counts = get_counts(attr_vals, values)
# when visualizing the third attribute and the first attribute has
# the last value, reverse the order in which the boxes are drawn;
# otherwise, if the last cell, nearest to the labels of the fourth
# attribute, is empty, we wouldn't be able to position the labels
valrange = list(range(len(values)))
if len(attr_list + used_attrs) == 4 and len(used_attrs) == 2:
attr1values = get_variable_values_sorted(used_attrs[0])
if used_vals[0] == attr1values[-1]:
valrange = valrange[::-1]
for i in valrange:
start = i * edge + whole * float(sum(counts[:i]) / total)
end = i * edge + whole * float(sum(counts[:i + 1]) / total)
val = values[i]
htmlval = to_html(val)
newattrvals = attr_vals + "-" + val if attr_vals else val
tooltip = "{} {}: <b>{}</b><br/>".format(
condition, attr.name, htmlval)
attrs = used_attrs + [attr]
vals = used_vals + [val]
args = attrs, vals, newattrvals
if side % 2 == 0: # if we are moving horizontally
if len(attr_list) == 1:
add_rect(x0 + start, x0 + end, y0, y1, tooltip, *args)
else:
draw_data(attr_list[1:], (x0 + start, x0 + end),
(y0, y1), side + 1, tooltip, total_attrs,
*args)
else:
if len(attr_list) == 1:
add_rect(x0, x1, y0 + start, y0 + end, tooltip, *args)
else:
draw_data(attr_list[1:], (x0, x1),
(y0 + start, y0 + end), side + 1, tooltip,
total_attrs, *args)
draw_text(side, attr_list[0], (x0, x1), (y0, y1), total_attrs,
used_attrs, used_vals, attr_vals)
def node_tooltip(self, node):
return "<br>".join(to_html(rule)
for rule in self.model.rule(node.node_inst))
def node_tooltip(self, node):
return "<br>".join(to_html(str(rule))
for rule in self.tree_adapter.rules(node.node_inst))
def draw_data(attr_list,
x0_x1,
y0_y1,
side,
condition,
total_attrs,
used_attrs=[],
used_vals=[],
attr_vals=""):
x0, x1 = x0_x1
y0, y1 = y0_y1
if conditionaldict[attr_vals] == 0:
add_rect(x0,
x1,
y0,
y1,
"",
used_attrs,
used_vals,
attr_vals=attr_vals)
# store coordinates for later drawing of labels
draw_text(side, attr_list[0], (x0, x1), (y0, y1), total_attrs,
used_attrs, used_vals, attr_vals)
return
attr = attr_list[0]
# how much smaller rectangles do we draw
edge = len(attr_list) * spacing
values = get_variable_values_sorted(data.domain[attr])
if side % 2:
values = values[::-1] # reverse names if necessary
if side % 2 == 0: # we are drawing on the x axis
# remove the space needed for separating different attr. values
whole = max(0, (x1 - x0) - edge * (len(values) - 1))
if whole == 0:
edge = (x1 - x0) / float(len(values) - 1)
else: # we are drawing on the y axis
whole = max(0, (y1 - y0) - edge * (len(values) - 1))
if whole == 0:
edge = (y1 - y0) / float(len(values) - 1)
if attr_vals == "":
counts = [conditionaldict[val] for val in values]
else:
counts = [
conditionaldict[attr_vals + "-" + val] for val in values
]
total = sum(counts)
# if we are visualizing the third attribute and the first attribute
# has the last value, we have to reverse the order in which the
# boxes will be drawn otherwise, if the last cell, nearest to the
# labels of the fourth attribute, is empty, we wouldn't be able to
# position the labels
valrange = list(range(len(values)))
if len(attr_list + used_attrs) == 4 and len(used_attrs) == 2:
attr1values = get_variable_values_sorted(
data.domain[used_attrs[0]])
if used_vals[0] == attr1values[-1]:
valrange = valrange[::-1]
for i in valrange:
start = i * edge + whole * float(sum(counts[:i]) / total)
end = i * edge + whole * float(sum(counts[:i + 1]) / total)
val = values[i]
htmlval = to_html(val)
if attr_vals != "":
newattrvals = attr_vals + "-" + val
else:
newattrvals = val
tooltip = condition + 4 * " " + attr + \
": <b>" + htmlval + "</b><br>"
attrs = used_attrs + [attr]
vals = used_vals + [val]
common_args = attrs, vals, newattrvals
if side % 2 == 0: # if we are moving horizontally
if len(attr_list) == 1:
add_rect(x0 + start, x0 + end, y0, y1, tooltip,
*common_args)
else:
draw_data(attr_list[1:], (x0 + start, x0 + end),
(y0, y1), side + 1, tooltip, total_attrs,
*common_args)
else:
if len(attr_list) == 1:
add_rect(x0, x1, y0 + start, y0 + end, tooltip,
*common_args)
else:
draw_data(attr_list[1:], (x0, x1),
(y0 + start, y0 + end), side + 1, tooltip,
total_attrs, *common_args)
draw_text(side, attr_list[0], (x0, x1), (y0, y1), total_attrs,
used_attrs, used_vals, attr_vals)
def node_tooltip(self, node):
return "<br>".join(to_html(str(rule))
for rule in self.tree_adapter.rules(node.node_inst))
def text(txt, *args, **kwargs):
return CanvasText(self.canvas, "", html_text=to_html(txt),
*args, **kwargs)