def _doc_modifier(doc: Document) -> None:
plot, source = _create_plot(stats, aspects)
events_table = _create_events_table()
events_type = RadioButtonGroup(labels=['All Events', 'In-Domain Events'], active=0)
# pylint: disable=unused-argument
def _events_handler(attr, old, new):
_update_events(stats, aspects, events_table, source, events_type.active)
events_type.on_change('active', _events_handler)
source.selected.on_change('indices', _events_handler) # pylint: disable=no-member
doc.add_root(column(_create_header(), plot, events_type, events_table,
sizing_mode="scale_width"))
def setupControls(self):
repeatResolutionSlider = Slider(
start=1, end=10, value=1, step=1, title="Repeat resolution"
) #,width = self.figureWidth,height = self.buttonHeight)
repeatResolutionSlider.on_change("value",
self.repeatResolutionCallback)
chunkModeButtons = RadioButtonGroup(
labels=["Time", "Sample"], active=0, button_type="warning"
) #,width=self.buttonWidth,height = self.buttonHeight)
chunkModeButtons.on_change("active", self.chunkModeCallback)
yAxisModeButtons = RadioButtonGroup(labels=["Linear", "Log"],
active=0,
button_type="warning")
yAxisModeButtons.on_change("active", self.yAxisModeCallback)
self.controls = row(repeatResolutionSlider, chunkModeButtons,
yAxisModeButtons)
def use_server_with_radio_buttons(self):
# crate columndatasource
source = ColumnDataSource(
dict(average_grades=["B+", "A", "D-"],
exam_grades=["A+", "C", "D"],
student_names=["Stephan", "Helder", "Riazudidn"]))
# create the figure
f = figure(x_range=[
"F", "D-", "D", "D+", "C-", "C", "C+", "B-", "B", "B+", "A-", "A",
"A+"
],
y_range=[
"F", "D-", "D", "D+", "C-", "C", "C+", "B-", "B", "B+",
"A-", "A", "A+"
])
# add labels for glyphs
labels = LabelSet(x="average_grades",
y="exam_grades",
text="student_names",
x_offset=5,
y_offset=5,
source=source)
f.add_layout(labels)
# create glyphs
f.circle(x="average_grades", y="exam_grades", source=source, size=8)
# create function
def update_labels(attr, old, new):
labels.text = options[radio_button_group.active]
# create select widget
options = ["average_grades", "exam_grades", "student_names"]
radio_button_group = RadioButtonGroup(labels=options)
radio_button_group.on_change("active", update_labels)
# create layout and add to curdoc
lay_out = layout([[radio_button_group]])
curdoc().add_root(f)
curdoc().add_root(lay_out)
def source_filters(sources):
def _handle_state_filter():
for fullname in sources['dataframes']:
df = sources['dataframes'][fullname]
df = df[(df.index >= _state['date_range'][0]) & (df.index <= _state['date_range'][1])]
units = UNIT_CONVERSION_MAP[_state['units']]
df = df * UNIT_CONVERSION[units]
sources['sources'][fullname].data = ColumnDataSource(df).data
for callback in ELEMENT_CALLBACKS:
callback(sources=sources, **_state)
def _date_slider_handler(attr, old, new):
start_time, end_time = new
start_date = dt.datetime.fromtimestamp(start_time / 1000)
end_date = dt.datetime.fromtimestamp(end_time / 1000)
_state['date_range'] = (start_date, end_date)
_handle_state_filter()
start_date = dt.datetime(year=2018, month=12, day=1)
end_date = dt.datetime(year=2018, month=12, day=1)
date_slider = DateRangeSlider(start=_state['date_range'][0], end=_state['date_range'][1], value=_state['date_range'], step=1, title="Date Range", height=100)
date_slider.on_change('value', _date_slider_handler)
def _radio_button_group_handler(attr, old, new):
_state['units'] = int(new)
_handle_state_filter()
radio_button_group = RadioButtonGroup(labels=UNIT_CONVERSION_MAP, active=0, width=700, height=100)
radio_button_group.on_change('active', _radio_button_group_handler)
div_button_group_selection = Div(text=f'<img src="/visualization/static/images/{UNIT_CONVERSION_MAP[_state["units"]]}.svg" height="100px"/>', height=100)
def _update_div_button_group(**kwargs):
units = UNIT_CONVERSION_MAP[kwargs['units']]
div_button_group_selection.text = f'<img src="/visualization/static/images/{units}.svg" height="100px"/>'
ELEMENT_CALLBACKS.append(_update_div_button_group)
return [date_slider, radio_button_group, div_button_group_selection]
def show_analysis() -> None:
global stats, aspects, plot, source, tabs
plot, source = _create_plot()
events_table = _create_events_table()
# pylint: disable=unused-argument
def _events_handler(attr, old, new):
_update_events(events_table, events_type.active)
# Toggle display of in-domain / All aspect mentions
events_type = RadioButtonGroup(labels=["All Events", "In-Domain Events"], active=0)
analysis_layout = layout([[plot], [events_table]])
# events_type display toggle disabled
# analysis_layout = layout([[plot],[events_type],[events_table]])
analysis_tab = Panel(child=analysis_layout, title="Analysis")
tabs.tabs.insert(2, analysis_tab)
tabs.active = 2
events_type.on_change("active", _events_handler)
source.selected.on_change("indices", _events_handler) # pylint: disable=no-member
def setupControls(self):
boardModeButtons = RadioButtonGroup(labels=self.boardModes,
active=0,
width=400,
button_type="primary")
boardModeButtons.on_change("active", self.boardModeCallback)
self.brightnessSlider = Slider(title="Brightness",
show_value=False,
height=self.figureSize,
value=.5,
start=0,
end=1,
step=.1,
orientation="vertical")
self.brightnessSlider.on_change("value", self.brightnessCallback)
#create an empty row to store the active controls in
activeControlsBox = column(name="activeControls")
#setup the image handler controls to control the board
cIS.iconFileSource.on_change('data', self.iconFileCallback)
self.controls = column(boardModeButtons, activeControlsBox)
labels.text = ["chosen file is : " + tkFileDialog.askopenfilename()]
print labels.text
def open_local_file_long(attr, old, new):
import wx
import os
app = wx.PySimpleApp()
wildcard = "Python source (*.py)|*.py|" \
"Compiled Python (*.pyc)|*.pyc|" \
"All files (*.*)|*.*"
dialog = wx.FileDialog(None, "Choose a file", os.getcwd(), "", wildcard,
wx.OPEN)
if dialog.ShowModal() == wx.ID_OK:
print dialog.GetPath()
dialog.Destroy()
#create select widget
options = ["average_grades", "exam_grades", "student_names"]
radio_button_group = RadioButtonGroup(labels=options)
# radio_button_group.on_change("active",update_labels)
radio_button_group.on_change("active", open_local_file)
#create layout and add to curdoc
lay_out = layout([[radio_button_group]])
curdoc().add_root(f)
curdoc().add_root(lay_out)
plot_height=450,
plot_width=600,
tools="save,reset",
toolbar_location="below")
plot_figure.scatter('x', 'y', color='label', source=source, size=10)
radio_button_group = RadioButtonGroup(labels=["Red", "Orange"])
def radiogroup_click(attr, old, new):
active_radio = radio_button_group.active ##Getting radio button value
# filter the dataframe with value in radio-button
if active_radio == 0:
selected_df = df[df['label'] == 'Red']
elif active_radio == 1:
selected_df = df[df['label'] == "Orange"]
source.data = dict(x=selected_df.x,
y=selected_df.y,
label=selected_df.label)
radio_button_group.on_change('active', radiogroup_click)
layout = row(radio_button_group, plot_figure)
curdoc().add_root(layout)
curdoc().title = "Radio Button Group Bokeh Server"
######################
# Callback behaviour #
######################
sample_fun_input_f.on_change('value', sample_fun_input_modified)
Wavelet_fun_input.on_change('value', Wavelet_fun_modified)
Wavelet_fun_input.on_change('label', update)
T0_input.on_change('value', update)
T1_input.on_change('value', update)
Amp_input.on_change('value', update)
User_Func.on_change('value', update)
Resolution.on_change('value', update)
a_param.on_change('value', param_change)
b_param.on_change('value', param_change)
Trigonometric_radio.on_change('active', Trig_fun_modified)
Frequency_Slider.on_change('value', Trig_fun_modified)
Calc_button.on_change('clicks', update)
############################
# Description and warnings #
############################
description_filename = join(dirname(__file__), "description.html")
loading_spinner_filename = join(dirname(__file__), "loading_spinner.html")
choose_WaveLet_error_filename = join(dirname(__file__),
"choose_WaveLet_error.html")
choose_SampleFunc_error_filename = join(dirname(__file__),
"choose_SampleFunc_error.html")
user_function_error_filename = join(dirname(__file__),
"user_function_error.html")
class ProfilePlot:
"""
A profile plot displays the height distribution of an atmospheric quantity
with respect to either altitude or pressure.
"""
def __init__(self, z, p, title, name, width=500):
def update_y_variable(attrname, old, new):
if self.y_axis_quantity.active == 0:
self.y = self.z
self.y_range = Range1d(start=self.z[0], end=self.z[-1])
if self.y_axis_quantity.active == 1:
self.y = self.p
self.y_range = Range1d(start=self.p[-1], end=self.p[0])
for s in self.sources:
s.data["y"] = self.y
fig = curdoc().get_model_by_name(self.name).children[0]
fig.y_range = self.y_range
def update_x_scale(attrname, old, new):
if self.x_axis_scale.active == 1:
for s in self.sources:
s.data["x"] = np.log10(s.data["x_"])
else:
for s in self.sources:
s.data["x"] = s.data["x_"]
def update_y_scale(attrname, old, new):
if self.y_axis_scale.active == 1:
for s in self.sources:
s.data["y"] = np.log10(self.y)
else:
for s in self.sources:
s.data["y"] = self.y
self.z = np.copy(z)
self.p = np.copy(p)
self.y = z
self.quantities = []
self.name = name
self.x_axis_scale = RadioButtonGroup(labels=["linear", "log"],
active=0)
self.x_axis_scale.on_change("active", update_x_scale)
self.y_axis_scale = RadioButtonGroup(labels=["linear", "log"],
active=0)
self.y_axis_scale.on_change("active", update_y_scale)
self.y_axis_quantity = RadioButtonGroup(
labels=["altitude", "pressure"], active=0)
self.y_axis_quantity.on_change("active", update_y_variable)
self.sources = []
self.fig = figure(title=title, width=width, height=500)
def add_quantity(self, x, line_kwargs={}):
self.sources += [ColumnDataSource(data=dict(x=x, x_=x, y=self.y))]
self.fig.line("x", "y", source=self.sources[-1], **line_kwargs)
@property
def doc(self):
d1 = Div(text="y-axis variable:", width=200)
d2 = Div(text="x-axis scale:", width=200)
d3 = Div(text="y-axis scale:", width=200)
return column(self.fig,
row(d1, self.y_axis_quantity),
row(d2, self.x_axis_scale),
row(d3, self.y_axis_scale),
name=self.name)
class Interface:
def __init__(self):
self.grepolis = Grepolis()
imgRessource = []
for v in ["Bois", "Pierre", "Argent"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgRessource.append(Image(d))
colRess = column(*[img.figure for img in imgRessource])
self.inputRess = [
TextInput(value="", title=el + " :", width=150)
for el in ["Bois", "Pierre", "Argent"]
]
colinputRess = column(*self.inputRess)
imgDieu = []
for v in ["Athena", "Artemis", "Hades", "Zeus", "Poseidon", "Hera"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgDieu.append(Image(d, multiplier=3))
rowDieu = [HFill(5)]
for img in imgDieu:
rowDieu.append(HFill(5))
rowDieu.append(img.figure)
rowDieu = row(*rowDieu)
imgAtt = []
for v in ["Att_hack", "Att_sharp", "Att_distance"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgAtt.append(Image(d))
colAtt = column(*[img.figure for img in imgAtt])
self.inputAtt = [
TextInput(value="", title=el + " :", width=150)
for el in ["Contondantes", "Blanches", "De Jet"]
]
colinputAtt = column(*self.inputAtt)
imgDef = []
for v in ["Def_hack", "Def_sharp", "Def_distance"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgDef.append(Image(d))
colDef = column(*[img.figure for img in imgDef])
self.inputDef = [
TextInput(value="", title=el + " :", width=150)
for el in ["Contondantes", "Blanches", "De Jet"]
]
rowinputDef = column(*self.inputDef)
imgOther = []
for v in ["Vitesse", "Butin", "Faveur"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgOther.append(Image(d))
colOther = column(*[img.figure for img in imgOther])
self.inputFavBut = [
TextInput(value="", title=el + " :", width=150)
for el in ["Vitesse", "Butin", "Faveur"]
]
self.inputOther = column(*self.inputFavBut)
self.imgUnit = []
for v in [
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier",
"Char", "Envoye", "Centaure", "Pegase"
]:
r = "static/" + v + ".jpg"
d = dict(url=[r])
self.imgUnit.append(Image(d, multiplier=2))
rowUnit = row(HFill(10), *[img.figure for img in self.imgUnit])
imgDefAtt = []
for v in ["Pop", "Attaque", "Defense"]:
r = "static/" + v + ".png"
d = dict(url=[r])
imgDefAtt.append(Image(d))
rowInputUnit = [HFill(10)]
self.unitInput = [
TextInput(value="", title=el + " :", width=80) for el in [
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier",
"Char", "Envoye", "Centaure", "Pegase"
]
]
for inp in self.unitInput:
rowInputUnit.append(inp)
rowInputUnit.append(HFill(30))
rowInputUnit = row(HFill(10), *rowInputUnit)
self.selectUnit = CheckboxButtonGroup(labels=[
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier", "Char",
"Envoye", "Centaure", "Pegase"
],
active=[i for i in range(9)])
self.selectUnit.on_change("active", self.updateSelectUnit)
self.Dieu = RadioButtonGroup(
labels=["Athena", "Artemis", "Hades", "Zeus", "Poseidon", "Hera"],
active=0,
width=1110)
self.Dieu.on_change('active', self.updateUnit)
self.attdef = RadioButtonGroup(labels=["Attaque", "Defense"],
active=0,
width=200)
self.attdef.on_change('active', self.switchAttDef)
self.typeAtt = RadioGroup(
labels=["Armes Contondantes", "Armes Blanches", "Armes de Jet"],
active=0,
width=150)
self.typeAtt.on_change('active', self.process2)
self.imgFaveur = Image(dict(url=["static/" + "Faveur" + ".png"]))
self.launch = Button(label="Lancer")
self.launch.on_click(self.process)
self.inputPop = TextInput(value="1500",
title="Population : ",
width=120)
self.inputPop.on_change("value", self.process2)
self.inputFav = TextInput(value="1500",
title="Faveur Max : ",
width=120)
self.inputFav.on_change("value", self.process2)
rowPop = row(HFill(10), self.typeAtt, imgDefAtt[1].figure, self.attdef,
HFill(30), imgDefAtt[2].figure, HFill(50),
imgDefAtt[0].figure, self.inputPop, HFill(50),
self.imgFaveur.figure, self.inputFav, HFill(50))
self.doc = column(
rowDieu, self.Dieu, VFill(20), rowPop, VFill(20), self.selectUnit,
rowUnit, rowInputUnit, VFill(20),
row(HFill(50), colRess, colinputRess,
HFill(40), colAtt, colinputAtt, HFill(40), colDef, rowinputDef,
HFill(40), colOther, self.inputOther))
#curdoc().add_root(column(rowDieu,self.Dieu,VFill(20),rowPop,VFill(20),self.selectUnit,rowUnit,rowInputUnit,VFill(20),row(HFill(50),colRess,colinputRess,HFill(40),colAtt,colinputAtt,HFill(40),colDef,rowinputDef,HFill(40),colOther,self.inputOther)))
self.process(None)
#curdoc().title = "Grepolis"
def updateUnit(self, attrname, old, new):
L = ["Athena", "Artemis", "Hades", "Zeus", "Poseidon", "Hera"]
print(self.selectUnit.active)
if L[new] == "Poseidon":
self.imgUnit[-1].figure.visible = False
self.unitInput[-1].visible = False
self.selectUnit.active = [1, 2, 3, 4, 5, 6, 7]
else:
self.imgUnit[-1].figure.visible = True
self.unitInput[-1].visible = True
self.selectUnit.active = [1, 2, 3, 4, 5, 6, 7, 8]
self.grepolis.setDieu(L[new])
unit = Add(L[new])
self.selectUnit.labels = [
"Combattant", "Frondeur", "Archer", "Hoplite", "Cavalier", "Char",
"Envoye"
] + unit
for i, v in enumerate(unit):
r = "static/" + v + ".jpg"
d = dict(url=[r])
self.imgUnit[-2 + i].update(d)
self.unitInput[-2 + i].title = v + " : "
self.process(None)
def process2(self, attrname, old, new):
self.process(None)
def switchAttDef(self, attrname, old, new):
if self.attdef.active == 0:
self.typeAtt.disabled = False
else:
self.typeAtt.disabled = True
self.process(None)
def updateSelectUnit(self, attrname, old, new):
N = len(self.selectUnit.labels)
active = self.selectUnit.active
zeros = [i for i in range(N) if i not in active]
for inp in [self.unitInput[i] for i in zeros]:
inp.value = str(0)
self.process(None)
def process(self, attrname):
try:
pop = int(self.inputPop.value)
favmax = int(self.inputFav.value)
active = self.selectUnit.active
type = self.typeAtt.active
if self.attdef.active == 0:
X, Att, Def, Prix, Speed, Pops, butin = self.grepolis.optimAttaque(
pop=pop, favmax=favmax, active=active, type=type)
else:
X, Att, Def, Prix, Speed, Pops, butin = self.grepolis.optimDefense(
pop=pop, favmax=favmax, active=active)
for v, inp in zip(X, [self.unitInput[i] for i in active]):
inp.value = str(v)
for v, inp in zip(Att, self.inputAtt):
inp.value = str(v) + " /u - " + str(int(v * pop))
for v, inp in zip(Def, self.inputDef):
inp.value = str(v) + " /u - " + str(int(v * pop))
for v, inp in zip(Prix, self.inputRess):
inp.value = str(v) + " /u - " + str(int(v * pop))
for i, (v, inp) in enumerate(
zip([Speed, butin, Prix[3]], self.inputFavBut)):
#add = ""
#if i > 0:
# add = + " /u - " +str(int(v*pop))
#print(v,add)
inp.value = str(v) + " /u - " + str(int(
v * pop)) if i != 0 else str(v)
except:
pass
df=pd.DataFrame({'x':x,'y':y,'label':label})
source = ColumnDataSource(data=dict(x=df.x, y=df.y,label=df.label))
plot_figure = figure(title='Radio Button Group',plot_height=450, plot_width=600,
tools="save,reset", toolbar_location="below")
plot_figure.scatter('x', 'y',color='label', source=source, size=10)
radio_button_group = RadioButtonGroup(labels=["Red", "Orange"])
def radiogroup_click(attr,old,new):
active_radio=radio_button_group.active ##Getting radio button value
# filter the dataframe with value in radio-button
if active_radio==0:
selected_df = df[df['label'] == 'Red']
elif active_radio==1:
selected_df = df[df['label'] == "Orange"]
source.data=dict(x=selected_df.x, y=selected_df.y,label=selected_df.label)
radio_button_group.on_change('active',radiogroup_click)
layout=row(radio_button_group, plot_figure)
curdoc().add_root(layout)
curdoc().title = "Radio Button Group Bokeh Server"
def main():
df = pd.read_csv("nlp_entities.csv")
s_per_df = pd.read_csv("data/entity_sentiment_avgValues/PersonSentiment.csv")
s_pla_df = pd.read_csv("data/entity_sentiment_avgValues/PlaceSentiment.csv")
s_org_df = pd.read_csv("data/entity_sentiment_avgValues/OrganizationSentiment.csv")
r = 300
margin = 80
sentiment = ["all", "Negative", "Positive", "Neutral"]
with open("Radviz_files.json") as json_file:
sources = json.load(json_file)
json_file.close()
for s in sentiment:
dstr = sources[s]["views"]["dstr"]
dates = []
for d in dstr:
dates.append(datetime.strptime(d, "%m/%d/%Y"))
sources[s]["views"]["s_x"] = dates
############# Radviz for headlines #############
print("ploting Radviz ...")
a_source = ColumnDataSource(data=sources["all"]["anchors"])
v_source = ColumnDataSource(data=sources["all"]["views"])
radviz = figure(plot_width=400, plot_height=450, title="Headlines (anchors: words), Centroid Measure",
x_axis_type=None, y_axis_type=None,
output_backend="webgl",tools="pan,box_zoom,box_select,reset,save")
radviz.circle(r, r, radius=r, line_color="black", fill_color=None)
c1 = radviz.circle('a_x', 'a_y', size=7, color="#af8dc3", source=a_source)
c2 = radviz.circle('v_x', 'v_y', size=7, color='c', alpha=0.8, source=v_source,legend= 'senti')
radviz.x_range = Range1d(-margin, 2 * r + margin)
radviz.y_range = Range1d(-margin, 2 * r + margin)
c2.selection_glyph = Circle(fill_color="c", line_color=None)
c2.nonselection_glyph = Circle(fill_color=None, line_color="c")
hover1 = HoverTool(tooltips=[("words: ", "@anchors")], renderers=[c1])
hover2 = HoverTool(tooltips=[("file: ", "@views"),
("headlines: ", "@h"),
("sentiment: ", "@senti"),
("sentiment score: ", "@score")
], renderers=[c2])
radviz.add_tools(hover1)
radviz.add_tools(hover2)
radviz.legend.location = (0,380)
radviz.legend.orientation = "horizontal"
radviz.legend.label_text_font_size = "8pt"
############# Timeline for each file #############
print("ploting scatter ...")
scatter = figure(plot_width=750, plot_height=450, title="Timeline for Files",
x_axis_type='datetime', x_axis_label='Time',y_axis_label='Sentiment Score',
output_backend="webgl",tools="pan,box_zoom,box_select,reset,save")
c3 = scatter.circle('s_x', 'score', source=v_source, size=7, color='c', alpha=0.8, legend= 'senti')
hover3 = HoverTool(
tooltips=[
("file: ", "@views"),
("date: ", "@dstr"),
("headline: ", "@e_h")
]
)
scatter.add_tools(hover3)
scatter.x_range = Range1d(datetime.strptime('01/01/2002', "%m/%d/%Y"), datetime.strptime('12/31/2004', "%m/%d/%Y"))
scatter.legend.location = "top_left"
c3.selection_glyph = Circle(fill_color="c", line_color="#d73027")
c3.nonselection_glyph = Circle(fill_color=None, line_color="c")
#create a button group to select different sentiment headlines
button_group = RadioButtonGroup(labels=sentiment, active=0)
def button_group_update(attr, old, new):
b = button_group.active
s = sentiment[b]
a_source.data = sources[s]["anchors"]
v_source.data = sources[s]["views"]
return
button_group.on_change("active", button_group_update)
# create interactive network graph
print("ploting network 1 ...")
s1 = ColumnDataSource(data=dict(xs=[], ys=[]))
s2 = ColumnDataSource(data=dict(vx=[], vy=[], labels=[], color=[],h=[], senti=[]))
n1 = figure(plot_width=600, plot_height=600, x_axis_type=None, y_axis_type=None,
outline_line_color=None, tools="pan,box_select,box_zoom,reset,save",
title="Neighbors of Selected Files",output_backend="webgl")
n1.multi_line('xs', 'ys', line_color="black", source=s1, alpha=0.3)
c4 = n1.circle('vx', 'vy', size=20, line_color="black", fill_color='color', source=s2, alpha=0.5,legend='senti')
n1.text('vx', 'vy', text='labels', text_color="black", text_font_size="10px", text_align="center",
text_baseline="middle", source=s2)
hover4 = HoverTool(
tooltips=[
("file: ", "@labels"),
("headline: ", "@h")
], renderers= [c4]
)
n1.add_tools(hover4)
n1.legend.location = "top_left"
def update_network1(attr,old,new):
inds = new['1d']['indices']
nodes = []
edges = []
selected = []
if inds == []:
s1.data = dict(xs=[], ys=[])
s2.data = dict(vx=[], vy=[], labels=[], color=[],h=[], senti=[])
n1.title.text = "Neighbors of Selected Files"
return
for i in inds:
f = v_source.data["views"][i]
selected.append(f)
v = df.loc[df["filename"] == f]["file_neighbors"].values
n = ast.literal_eval(v[0])
if f not in n:
n.append(f)
nodes = list(set(nodes).union(n))
e_v = df.loc[df["filename"] == f]["file_neighbors_edge"].values
e = ast.literal_eval(e_v[0])
edges = list(set(edges).union(e))
new_dict = create_file_graph(nodes,edges,df)
s1.data = new_dict["s1"]
s2.data = new_dict["s2"]
n1.title.text = "Neighbors of Selected Files - " +", ".join(selected)
return
c2.data_source.on_change("selected",update_network1)
print("ploting network 2 ...")
s3 = ColumnDataSource(data=dict(xs=[], ys=[]))
s4 = ColumnDataSource(data=dict(vx=[], vy=[], labels=[], color=[],s=[]))
n2 = figure(plot_width=600, plot_height=600, x_axis_type=None, y_axis_type=None,
outline_line_color=None, tools="pan,box_zoom,reset,save", title="Entities Involved in Selected Files",
output_backend="webgl")
n2.multi_line('xs', 'ys', line_color="black", source=s3, alpha=0.3)
n2.circle('vx', 'vy', size=20, line_color="black", fill_color='color', source=s4, alpha=0.5,legend='s')
n2.text('vx', 'vy', text='labels', text_color="black", text_font_size="10px", text_align="center",
text_baseline="middle", source=s4)
n2.legend.location = (0,580)
n2.legend.orientation = "horizontal"
n2.legend.label_text_font_size = "8pt"
def update_network2(attr, old, new):
inds = new['1d']['indices']
s3.data = dict(xs=[], ys=[])
s4.data = dict(vx=[], vy=[], labels=[], color=[], s=[])
n2.title.text = "Entities Involved in Selected Files"
if inds == []:
return
selected = []
nodes = []
edges = []
r_per = []
r_pla = []
r_org = []
t_t_edges = []
senti = {}
s_color = {}
for i in inds:
f = s2.data["labels"][i]
selected.append(f)
v = df.loc[df["filename"] == f]["all_nodes"].values
n = ast.literal_eval(v[0])
nodes = list(set(nodes).union(n))
e = ast.literal_eval(df.loc[df["filename"] == f]["all_edges"].values[0])
edges = list(set(edges).union(e))
t_t_e = ast.literal_eval(df.loc[df["filename"] == f]["file_neighbors_edge"].values[0])
t_t_edges = list(set(t_t_edges).union(t_t_e))
r_person = df.loc[df["filename"] == f]["Person"].values[0]
if r_person == "None":
r_person = []
else:
r_person = ast.literal_eval(r_person)
r_place = df.loc[df["filename"] == f]["Place"].values[0]
if r_place == "None":
r_place = []
else:
r_place = ast.literal_eval(r_place)
r_organization = df.loc[df["filename"] == f]["Org"].values[0]
if r_organization == "None":
r_organization = []
else:
r_organization = ast.literal_eval(r_organization)
r_per = list(set(r_per).union(r_person))
r_pla = list(set(r_pla).union(r_place))
r_org = list(set(r_org).union(r_organization))
t_t = list(itertools.combinations(selected, 2))
for t in t_t:
if (t in t_t_edges) or ((t[1], t[0]) in t_t_edges):
edges.append(t)
for node in nodes:
if node in r_per:
s_color[node] = s_per_df.loc[s_per_df["Entity"] == node]["Sentiment Color"].values[0]
senti[node] = s_per_df.loc[s_per_df["Entity"] == node]["Sentiment"].values[0]
elif node in r_pla:
s_color[node] = s_pla_df.loc[s_pla_df["Entity"] == node]["Sentiment Color"].values[0]
senti[node] = s_pla_df.loc[s_pla_df["Entity"] == node]["Sentiment"].values[0]
elif node in r_org:
s_color[node] = s_org_df.loc[s_org_df["Entity"] == node]["Sentiment Color"].values[0]
senti[node] = s_org_df.loc[s_org_df["Entity"] == node]["Sentiment"].values[0]
elif node in selected:
s_color[node] = df.loc[df["filename"] == node]["sentiment_color"].values[0]
senti[node] = df.loc[df["filename"] == node]["sentiment"].values[0]
elif "-Person" in node:
s_color[node] = "#f441e8"
senti[node] = "Person Parent Node"
elif "-Place" in node:
s_color[node] = "#e2f441"
senti[node] = "Place Parent Node"
elif "-Org" in node:
s_color[node] = "#f49141"
senti[node] = "Org Parent Node"
new_dict = create_graph(nodes, edges, s_color, senti)
s3.data = new_dict["s1"]
s4.data = new_dict["s2"]
n2.title.text = "Entities Involved in Selected Files - " + ", ".join(selected)
return
c4.data_source.on_change("selected", update_network2)
def update_network3(attr, old, new):
inds = new['1d']['indices']
s3.data = dict(xs=[], ys=[])
s4.data = dict(vx=[], vy=[], labels=[], color=[], s=[])
n2.title.text = "Entities Involved in Selected Files"
if inds == []:
return
selected = []
nodes = []
edges = []
r_per = []
r_pla = []
r_org = []
t_t_edges = []
senti = {}
s_color = {}
for i in inds:
f = v_source.data["views"][i]
selected.append(f)
v = df.loc[df["filename"] == f]["all_nodes"].values
n = ast.literal_eval(v[0])
nodes = list(set(nodes).union(n))
e = ast.literal_eval(df.loc[df["filename"] == f]["all_edges"].values[0])
edges = list(set(edges).union(e))
t_t_e = ast.literal_eval(df.loc[df["filename"] == f]["file_neighbors_edge"].values[0])
t_t_edges = list(set(t_t_edges).union(t_t_e))
r_person = df.loc[df["filename"] == f]["Person"].values[0]
if r_person == "None":
r_person = []
else:
r_person = ast.literal_eval(r_person)
r_place = df.loc[df["filename"] == f]["Place"].values[0]
if r_place == "None":
r_place = []
else:
r_place = ast.literal_eval(r_place)
r_organization = df.loc[df["filename"] == f]["Org"].values[0]
if r_organization == "None":
r_organization = []
else:
r_organization = ast.literal_eval(r_organization)
r_per = list(set(r_per).union(r_person))
r_pla = list(set(r_pla).union(r_place))
r_org = list(set(r_org).union(r_organization))
t_t = list(itertools.combinations(selected, 2))
for t in t_t:
if (t in t_t_edges) or ((t[1], t[0]) in t_t_edges):
edges.append(t)
for node in nodes:
if node in r_per:
s_color[node] = s_per_df.loc[s_per_df["Entity"] == node]["Sentiment Color"].values[0]
senti[node] = s_per_df.loc[s_per_df["Entity"] == node]["Sentiment"].values[0]
elif node in r_pla:
s_color[node] = s_pla_df.loc[s_pla_df["Entity"] == node]["Sentiment Color"].values[0]
senti[node] = s_pla_df.loc[s_pla_df["Entity"] == node]["Sentiment"].values[0]
elif node in r_org:
s_color[node] = s_org_df.loc[s_org_df["Entity"] == node]["Sentiment Color"].values[0]
senti[node] = s_org_df.loc[s_org_df["Entity"] == node]["Sentiment"].values[0]
elif node in selected:
s_color[node] = df.loc[df["filename"] == node]["sentiment_color"].values[0]
senti[node] = df.loc[df["filename"] == node]["sentiment"].values[0]
elif "-Person" in node:
s_color[node] = "#f441e8"
senti[node] = "Person Parent Node"
elif "-Place" in node:
s_color[node] = "#e2f441"
senti[node] = "Place Parent Node"
elif "-Org" in node:
s_color[node] = "#f49141"
senti[node] = "Org Parent Node"
new_dict = create_graph(nodes, edges, s_color, senti)
s3.data = new_dict["s1"]
s4.data = new_dict["s2"]
n2.title.text = "Entities Involved in Selected Files - " + ", ".join(selected)
return
c2.data_source.on_change("selected", update_network3)
print("Done")
l = column(button_group,row(radviz,scatter),row(n1,n2))
show(l)
curdoc().add_root(l)
ticker=BasicTicker(desired_num_ticks=len(colors)),
formatter=PrintfTickFormatter(format="%d%%"),
label_standoff=6,
border_line_color=None,
location=(0, 0))
p.add_layout(color_bar, 'right')
# page layout
desc = Div(text=open(join(dirname(__file__), "description.html")).read(),
width=1000)
footer = Div(text=open(join(dirname(__file__), "footer.html"),
encoding="utf8").read(),
width=1200)
sizing_mode = 'fixed'
l = layout([[desc], [row(property, radio_button_group)],
[row(p, data_table)], [footer]],
sizing_mode=sizing_mode)
curdoc().add_root(l)
# callbacks
property.on_change('value', select_property)
radio_button_group.on_change('active', select_property)
curdoc().title = 'Commercial Fragment Libraries'
update()
s3ysd = s3yqresult.iloc[:, (rbg2 + 3)]
s3ysdplus = [bar + sd / (2 * sd_factor) for bar, sd in zip(s3y, s3ysd)]
s3ysdminus = [bar - sd / (2 * sd_factor) for bar, sd in zip(s3y, s3ysd)]
s1.data = dict(x = x, y = s1y, sdplus = s1sdplus, sdminus = s1sdminus,
color = color)
p1.title.text = rbg1labels[rbg1]
s2.data = dict(x = x, y = s2y, sdplus = s2sdplus, sdminus = s2sdminus,
color = color)
p2.title.text = qName + ' ' + rbg2labels[rbg2]
s3.data = dict(x = s3x, xsdplus = s3xsdplus, xsdminus = s3xsdminus,
y = s3y, ysdplus = s3ysdplus, ysdminus = s3ysdminus,
color = color)
p3.title.text = 'Plot of ' + y3name + ' vs. ' + x3name + ' ' + rbg2labels[rbg2]
p3.xaxis.axis_label = x3name
p3.yaxis.axis_label = y3name
kneighb.on_change('value', update_data)
radio_button_group1.on_change('active', update_data)
radio_button_group2.on_change('active', update_data)
dropdown.on_change('value', update_data)
x3drop.on_change('value', update_data)
y3drop.on_change('value', update_data)
#add to document
curdoc().add_root(layout([[w, p1], [p3, p2]], sizing_mode = 'scale_width'))
curdoc().title = "NN Explorer"
# here one can choose arbitrary input function
default_function_input = TextInput(value=fs.function_input_init)
default_function_period_start = TextInput(title='period start', value=fs.timeinterval_start_init)
default_function_period_end = TextInput(title='period end', value=fs.timeinterval_end_init)
# slider controlling degree of the fourier series
degree = Slider(title="degree", name='degree', value=fs.degree_init, start=fs.degree_min,
end=fs.degree_max, step=fs.degree_step)
# initialize callback behaviour
degree.on_change('value', degree_change)
default_function_input.on_change('value',
type_input_change) # todo write default functions for any callback, like above
default_function_period_start.on_change('value', type_input_change)
default_function_period_end.on_change('value', type_input_change)
sample_function_type.on_change('active', type_input_change)
# initialize plot
toolset = "crosshair,pan,reset,resize,save,wheel_zoom"
# Generate a figure container
plot = Figure(plot_height=fs.resolution,
plot_width=fs.resolution,
tools=toolset,
title="Fourier Series Approximation",
x_range=[fs.x_min, fs.x_max],
y_range=[fs.y_min, fs.y_max]
)
# Plot the line by the x,y values in the source property
plot.line('t', 'x_orig', source=source_orig,
line_width=3,
line_alpha=0.6,
item.value = 'best_mt_score'
except AttributeError:
continue
if presets.labels[presets.active] == "Tumor Clonality and Expression":
for item in widgets:
try:
if item.title == 'X-Axis Value':
item.value = 'tumor_dna_vaf'
elif item.title == 'Y-Axis Value':
item.value = 'tumor_rna_vaf'
except AttributeError:
continue
#Add callbacks to the 3 widgets manually created back at the start
x_field.on_change('value', lambda a,r,g: update())
y_field.on_change('value', lambda a,r,g: update())
presets.on_change('active', lambda a,r,g: change_preset())
hide_null.on_click(lambda arg: update())
#Add all models and widgets to the document
box = widgetbox(*widgets, sizing_mode='stretch_both')
fig = column(
row(box, p),
table,
sizing_mode='scale_width'
)
update() #initial update
curdoc().add_root(fig)
curdoc().title = sample
else:
if button_group2.active == 1:
print (slider.value)
plotToRemove = curdoc().get_model_by_name('plot')
listOfSubLayouts.remove(plotToRemove)
team = map_classes.Team(search_bar.value)
nextyear = str(slider.value+1)
years = str(slider.value)+'-'+nextyear[2:4]
p2 = team.hex_freq(season=years)
plotToAdd = p2
listOfSubLayouts.append(plotToAdd)
else:
print (slider.value)
plotToRemove = curdoc().get_model_by_name('plot')
listOfSubLayouts.remove(plotToRemove)
team = map_classes.Team(search_bar.value)
nextyear = str(slider.value+1)
years = str(slider.value)+'-'+nextyear[2:4]
p2 = team.hex_accuracy(years)
plotToAdd = p2
listOfSubLayouts.append(plotToAdd)
#Set up callback event behavior
""" These define the attribute of each widget that is continiously checked and defines the callback functions to be run when the atribute is changed by the user."""
search.on_change('clicks', update_search_term, update_year)
button_group2.on_change('active', update_plot_type)
slider.on_change('value',update_year)
#Name the html document
curdoc().title = "GUI"
def fit_tab(agg, df_all, df_goal, candidates_data, train_dates, test_dates,
old_to_new_sources, new_to_old_sources, old_to_new_regions):
## Get region names
region_names_new = list(old_to_new_regions.values())
region_names_new.sort()
## Pick gold standard and data source
gs_name = 'AMAZONAS-VE'
source_set = 'Best'
if source_set == 'Best':
agg_source_best = agg.loc[(
agg.Region == old_to_new_regions[gs_name[:-3]]),
'BestSource'].values[0]
source_set = new_to_old_sources[agg_source_best]
dates_train, dates_test, gs_ts,in_sample_forecast_ts,OOS_forecast_ts,\
r_squared_in_sample, r_squared_OOS = get_graph_data(\
df_all,agg,df_goal,candidates_data,gs_name,source_set,
train_dates,test_dates,old_to_new_regions,old_to_new_sources)
### Create Bokeh graph
all_dates = pd.to_datetime(gs_ts.index.tolist())
dates_train_plot = pd.to_datetime(dates_train)
dates_test_plot = pd.to_datetime(dates_test)
#xs = [dates_train,dates_test,dates_train,dates_test]
xs = [all_dates, dates_train_plot, dates_test_plot]
ys = [np.array(gs_ts), in_sample_forecast_ts, OOS_forecast_ts]
source = ColumnDataSource(data=dict(
x=xs,
y=ys,
color=(Category10[3])[0:len(xs)],
group=['Gold Standard', 'Forecast In Sample', 'Forecast OOS']))
TOOLS = "pan,wheel_zoom,box_zoom,reset,hover,save"
p_ts = figure(
plot_width=800,
plot_height=500,
x_axis_type='datetime',
title='',
tools=TOOLS,
)
p_ts.multi_line(xs='x',
ys='y',
legend='group',
source=source,
line_color='color')
p_ts.legend.location = (0, 350)
## Radio buttons
# Define buttons
sourceset_display = ['Best'] + list(old_to_new_sources.keys())[1:]
#sourceset_display = ['Best'] + sourceset_names_old[1:]
source_set_button_plot = RadioButtonGroup(labels=sourceset_display,
active=0)
regions_button_plt = RadioButtonGroup(labels=region_names_new, active=0)
# Text above graph
div_text = 'In and Out of Sample fit <br>Gold Standard: ' + \
old_to_new_regions[gs_name[:-3]] + ' - Predictor Set: ' + \
old_to_new_sources[source_set] + '<br>' + \
'In Sample R<sup>2</sup>: ' + np.str(np.round(r_squared_in_sample,2)) + \
' - ' + 'Out of Sample R<sup>2</sup>: ' + np.str(np.round(r_squared_OOS,2))
div = Div(text=div_text, width=700, height=100)
# Update function
def plot_callback(attr, old, new):
# Get new selected value
#new_score = score_types[new.active]
gs_name_selected = region_names_new[regions_button_plt.active]
if gs_name_selected == 'Distrito Federal':
gs_name = 'DTTOMETRO-VE'
else:
gs_name = gs_name_selected.replace(' ', '').upper() + '-VE'
source_set = sourceset_display[source_set_button_plot.active]
if source_set == 'Best':
agg_source_best = agg.loc[(
agg.Region == old_to_new_regions[gs_name[:-3]]),
'BestSource'].values[0]
source_set = new_to_old_sources[agg_source_best]
# Get data to update graph
dates_train, dates_test, gs_ts,in_sample_forecast_ts,OOS_forecast_ts,\
r_squared_in_sample, r_squared_OOS = get_graph_data(\
df_all,agg,df_goal,candidates_data,gs_name,source_set,
train_dates,test_dates,old_to_new_regions,old_to_new_sources)
### Create Bokeh graph
all_dates = pd.to_datetime(gs_ts.index.tolist())
dates_train_plot = pd.to_datetime(dates_train)
dates_test_plot = pd.to_datetime(dates_test)
#xs = [dates_train,dates_test,dates_train,dates_test]
xs = [all_dates, dates_train_plot, dates_test_plot]
ys = [np.array(gs_ts), in_sample_forecast_ts, OOS_forecast_ts]
#new_data = pd.DataFrame({'x':xs,'y':ys,'color':(Category10[3])[0:len(xs)]})
new_source = ColumnDataSource(data=dict(
x=xs,
y=ys,
color=(Category10[3])[0:len(xs)],
group=['Gold Standard', 'Forecast In Sample', 'Forecast OOS']))
source.data = new_source.data
# p_ts.source = new_source
new_text = 'In and Out of Sample fit <br>Gold Standard :' + \
old_to_new_regions[gs_name[:-3]] + ' - Predictor Set: ' + \
old_to_new_sources[source_set] + '<br>' + \
'In Sample R<sup>2</sup>: ' + np.str(np.round(r_squared_in_sample,2)) + \
'<br>Out of Sample R<sup>2</sup>: ' + np.str(np.round(r_squared_OOS,2))
div.text = new_text
source_set_button_plot.on_change('active', plot_callback)
regions_button_plt.on_change('active', plot_callback)
# Put controls in a single element
controls = WidgetBox(regions_button_plt, source_set_button_plot)
# Create a row layout
layout = column(controls, div, p_ts)
# Make a tab with the layout
tab = Panel(child=layout, title='Regression Fit')
return tab
new_source = bats_man_data[
(bats_man_data['Batsman'] == selected_batsman)
& (bats_man_data['Year_bats'] == yr1) &
(bats_man_data['Opposition_bats'] == selected_oppo)].groupby([
'Match_ID', '6s'
])['Runs'].sum().sort_values().reset_index().sort_values(
by=['Match_ID'])
new_source.rename({'6s': 'shots'}, axis='columns', inplace=True)
new_runs_cds = ColumnDataSource(new_source[['Match_ID', 'Runs']])
new_shots_cds = ColumnDataSource(new_source[['Match_ID', 'shots']])
runs_cds.data = new_runs_cds.data
shots_cds.data = new_shots_cds.data
fig.title.text = '%s Performance Across the Seasons in the Year %d' % (
selected_batsman, yr)
fig.x_range.factors = []
fig.x_range.factors = list(np.sort(new_source['Match_ID'].unique()))
run_type.on_change('active', lambda attr, old, new: update(attr, old, new))
slider.on_change('value', update)
radiogroup_batsman.on_change('active', update)
radiogroup_oppo.on_change('active', update)
# Make a row layout of widgetbox(slider) and plot and add it to the current document
layout = row(column(widgetbox(slider), widgetbox(radiogroup_batsman)), fig,
column(widgetbox(run_type), widgetbox(radiogroup_oppo)))
curdoc().add_root(layout)
def map_tab(gdf, gdf_country, agg_all_nfolds, score_types_list, sources_list,
n_folds_list):
# Prepare coordinates data
gdf.sort_values(by=['Region'], inplace=True)
gdf.reset_index(drop=True, inplace=True)
gdf = geopd_prepare(gdf)
# Get lis of coordinates of states limits, and their names
country_xs = gdf.apply(getPolyCoords,
geom='geometry',
coord_type='x',
axis=1)
country_ys = gdf.apply(getPolyCoords,
geom='geometry',
coord_type='y',
axis=1)
states = gdf.Region.tolist()
# Get entire country coordinates and add them to the list
total_country_x, total_country_y = country_adjust(gdf_country)
country_xs = country_xs.append(pd.Series(total_country_x),
ignore_index=True)
country_ys = country_ys.append(pd.Series(total_country_y),
ignore_index=True)
states.extend(['Total'] * len(total_country_x))
# List of n_folds values
n_folds_display = [np.str(x) for x in n_folds_list]
# Filter data we start with
score_type_filter = 'InSample' #'OOS'
source_filter = 'Best'
n_folds_map = n_folds_list[0]
# t = score_types_list[0]
# s = sources_list[0]
df_show = agg_all_nfolds.loc[agg_all_nfolds.NbFolds == n_folds_map, :]
df_show = df_show.loc[df_show.ScoreType == score_type_filter, :]
if source_filter == 'Best':
df_show = df_show.loc[df_show['IsBest'], :]
else:
df_show = df_show.loc[df_show['SourcesSet'] == source_filter, :]
df_show_dict = df_show[['Region', 'Value']].set_index('Region').T.to_dict()
scores = [df_show_dict[x]['Value'] for x in states]
# Create bokeh map source data
col_source = ColumnDataSource(
data=dict(xs=country_xs, ys=country_ys, Region=states, Score=scores))
# geosource = GeoJSONDataSource(geojson = \
# map_all_data[score_type_filter + '|' + source_filter].geojson)
## Map formatting ##################
palette = Viridis256 # brewer["Spectral"][8] # Category20[20] # brewer["PRGn"][11]
color_mapper = LinearColorMapper(palette=palette, low=-1, high=1)
color_bar = ColorBar(color_mapper=color_mapper,
width=650,
height=20,
formatter=NumeralTickFormatter(format=",0.00"),
border_line_color=None,
orientation='horizontal',
location=(0, 0))
hover = HoverTool(tooltips=[('Region', '@Region'), ('Score', '@Score')])
#Create figure object.
width = 750
height = np.int(width * 13 / 15)
p = figure(title='Venezuela Situational Awareness',
plot_height=height,
plot_width=width,
tools=[hover, "pan,wheel_zoom,box_zoom,reset"],
toolbar_location="left")
p.xgrid.grid_line_color = None
p.ygrid.grid_line_color = None
#Add patch renderer to figure.
p.patches('xs',
'ys',
source=col_source,
fill_color={
'field': 'Score',
'transform': color_mapper
},
line_color='white',
line_width=1,
fill_alpha=0.7)
#Specify figure layout.
p.add_layout(color_bar, 'below')
## Radio buttons
# Define buttons
n_folds_button = RadioButtonGroup(labels=n_folds_display, active=0)
score_types = score_types_list.tolist()
score_type_button = RadioButtonGroup(labels=score_types, active=0)
data_sources = sources_list.tolist()
sources_button = RadioButtonGroup(labels=data_sources, active=0)
###########################################################################
# Update function
def score_type_callback(attr, old, new):
# Get new score data to display
# Filter data we start with
n_folds_map_new = np.int(n_folds_display[n_folds_button.active])
new_score = score_types[score_type_button.active]
new_source = data_sources[sources_button.active]
df_show = agg_all_nfolds.loc[agg_all_nfolds.NbFolds ==
n_folds_map_new, :]
df_show = df_show.loc[df_show.ScoreType == new_score, :]
if new_source == 'Best':
df_show = df_show.loc[df_show['IsBest'], :]
else:
df_show = df_show.loc[df_show['SourcesSet'] == new_source, :]
df_show_dict = df_show[['Region',
'Value']].set_index('Region').T.to_dict()
new_scores = [df_show_dict[x]['Value'] for x in states]
# Patch source data with new scores
col_source.patch({'Score': [(slice(len(new_scores)), new_scores)]})
###########################################################################
# Update events
n_folds_button.on_change('active', score_type_callback)
score_type_button.on_change('active', score_type_callback)
sources_button.on_change('active', score_type_callback)
# Figure formatting
set_stype(p)
# Put controls in a single element
controls = WidgetBox(n_folds_button, score_type_button, sources_button)
# Create a row layout
layout = column(controls, p)
# Make a tab with the layout
tab = Panel(child=layout, title='Map of Scores')
return tab
# In Notebook (without callbacks)
#output_notebook()
#show(p)
# In Spyder (without callbacks)
# output_file('foo.html')
# show(column(widgetbox(score_type_button),p),browser="chrome")
# To run from command (in the folder of the file) using the command
# bokeh serve --show situ_map.py
# curdoc().add_root(column(score_type_button,sources_button,p))
# curdoc().title = "Venezuela Situational Awareness"
###############################################################################
PROPERTY_TYPE_HOST = Select(title='Property Type:',
value=c.EMPTY_STRING,
options=[c.EMPTY_STRING] + FILTER_PROPERTIES[c.PT])
N_HOST = Select(title='Neighbourhood:',
value=c.EMPTY_STRING,
options=[c.EMPTY_STRING] + FILTER_PROPERTIES[c.NC])
NG_HOST = Select(title='Neighbourhood Group:',
value=c.EMPTY_STRING,
options=[c.EMPTY_STRING] + NG_LIST)
ROOM_TYPE_HOST = Select(title='Room Type:',
value=c.EMPTY_STRING,
options=[c.EMPTY_STRING] + RT_LIST)
# Radio Button Widget
USER_TYPE = RadioButtonGroup(labels=['Guest', 'Host'], active=0)
USER_TYPE.on_change(c.ACTIVE, update_layout)
# Button Toggle Widget
PREDICT_VALUE = Toggle(label='Submit', button_type='success')
PREDICT_VALUE.on_click(predict_price)
# Text Widget
HOST_PRICE = Paragraph(text="""Select all listing values and press
submit to view your listings valued price.""",
width=500,
height=500)
WIDGETS_BOTH_1 = [USER_TYPE, CITY_INPUT]
WIDGETS_BOTH_2 = [
ACCOMMODATES_SLIDER, BEDROOM_SLIDER, BED_SLIDER, BATHROOM_SLIDER
]
def buildPlot():
#####################Setup
# Grab graph colors, pop undesireable ones
colors = SEABORN_PALETTES['bright']
#Grab and sort the FQs
quals = fruit_df.reset_index()
quals = quals['FruitQuality'].unique().tolist()
for idx, i in enumerate(list(quals)):
if type(i) == type(0.5):
quals.pop(idx)
unique_FQs = quals
#a little math to get the epoch time to set the initial x range
minDate = ts_to_epoch(fruit_df['Date'].min())
maxDate = ts_to_epoch(fruit_df['Date'].max())
###########Create and format the plot
plot = figure(
x_axis_type="datetime",
plot_width=600,
plot_height=400,
tools=[PanTool(),
WheelZoomTool(),
SaveTool(),
BoxZoomTool()],
x_range=DataRange1d(
start=minDate, end=maxDate
), #sets the initial date range to the limits of the data
y_range=DataRange1d(start=0, end=1),
name='the_plot',
toolbar_location='above')
#some styling
plot.title.text = "Historical Volatility"
plot.xaxis.axis_label = "Trade Date"
plot.yaxis.axis_label = "Vol"
plot.background_fill_color = '#EAEBF0'
plot.xgrid.grid_line_color = 'white'
plot.ygrid.grid_line_color = 'white'
plot.xaxis.axis_line_color = 'white'
plot.xaxis.major_tick_line_color = 'white'
plot.xaxis.minor_tick_line_color = 'white'
plot.yaxis.axis_line_color = 'white'
plot.yaxis.major_tick_line_color = 'white'
plot.yaxis.minor_tick_line_color = 'white'
plot.toolbar.logo = None
#a list for all of the lines to reside in
lines = []
legends = []
##############Create the widgets
#a console style window to show debug messages TODO: add on/off functionality
debug = PreText(text="", width=1200, height=500)
#echos the debug in a place more visiable for the user
user_message = Paragraph(text='')
#Asset_Class, Product, and From dropdown boxes. Sets dropdown's initial value.
asCls = Select(title="Asset Class",
options=ddOpts['Asset_Class'].unique().tolist())
asCls.value = asCls.options[0]
prod = Select(title="Products",
options=ddOpts[ddOpts['Asset_Class'] == asCls.value]
['Product'].unique().tolist())
prod.value = prod.options[0]
whereFrom = Select(title="From",
options=ddOpts[(ddOpts['Asset_Class'] == asCls.value)
& (ddOpts['Product'] == prod.value)]
['From'].unique().tolist())
whereFrom.value = whereFrom.options[0]
FQslider = Slider(title='Fruit Quality',
start=min(unique_FQs),
end=max(unique_FQs),
step=1)
#the amount of days back to look for the data
days_back = TextInput(title='Days ago', value='365')
days_back_buttons = RadioButtonGroup(
labels=['10', '30', '90', '180', '365', '730'], active=4)
#the date to linear fit to
fixed_date_buttons = RadioButtonGroup(
labels=['30', '60', '90', '120', '180', '365'], active=2)
fixed_date = TextInput(title='Days to Exp', value='90')
#the amount of days with which to calculate the rolling mean
rolling_days_buttons = RadioButtonGroup(labels=['1', '2', '5', '10'],
active=0)
rolling_days = TextInput(title='Rolling Mean Days', value='1')
#a dynamically resizing checkbox group that allows for the changing of the visablity of any line on the plot
line_onOff = CheckboxGroup(width=400, name='line_onOff')
#the associated colors to act as a legend for line_onOff
legendDiv = Div(width=50)
#button to add a line
addLine = Button(label="Add Line")
#an html rendered visualization of the data for each line
descriptions = Div(text='', width=500)
#resizes the plot
rszButton = Button(label='resize')
##########Define functions associated with the widgets
#concats any dubug call to the end of the current debug text, and changes the user message
def updateDebug(inString):
inString = str(inString)
user_message.text = inString
oldText = debug.text
newText = ("*- " + str(datetime.now()) + " : " + inString)
debug.text = oldText + '\n' + newText
#changes the potential products and contract categories to match the user selected asset class
def asClsChange(attrname, old, new):
prod.options = ddOpts[ddOpts['Asset_Class'] ==
asCls.value]['Product'].unique().tolist()
prod.value = prod.options[0]
#changes the potential contract categories to match the user selected product
def prodChange(attrname, old, new):
whereFrom.options = ddOpts[(ddOpts['Asset_Class'] == asCls.value) & (
ddOpts['Product'] == prod.value)]['From'].unique().tolist()
whereFrom.value = whereFrom.options[0]
#links the days back button and text box
def days_back_buttonChange(attrname, old, new):
days_back.value = days_back_buttons.labels[days_back_buttons.active]
#checks that the users input is an int
def days_backChange(attrname, old, new):
try:
days_back.value = str(int(days_back.value))
except ValueError:
days_back.value = '0'
updateDebug('please type an integer')
#links the fixed date button and text box
def fixed_date_buttonChange(attrname, old, new):
fixed_date.value = fixed_date_buttons.labels[fixed_date_buttons.active]
#checks that the users input is an int
def fixed_dateChange(attrname, old, new):
try:
fixed_date.value = str(int(fixed_date.value))
except ValueError:
fixed_date.value = '0'
updateDebug('please type an integer')
#links the rolling days button and text box
def rolling_days_buttonsChange(attrname, old, new):
rolling_days.value = rolling_days_buttons.labels[
rolling_days_buttons.active]
#checks that the users input is an int
def rolling_daysChange(attrname, old, new):
try:
rolling_days.value = str(int(rolling_days.value))
except ValueError:
rolling_days.value = '0'
updateDebug('please type an integer')
#fits the plot to the currently visiable lines
def resize():
if len(line_onOff.active) == 0 or len(line_onOff.labels) == 0:
plot.x_range.start = ts_to_epoch(fruit_df['Date'].min())
plot.x_range.end = ts_to_epoch(fruit_df['Date'].max())
plot.y_range.start = 0
plot.y_range.end = 100
else:
xmin, xmax, ymin, ymax = calc_range(lines)
plot.x_range.start = xmin
plot.x_range.end = xmax
plot.y_range.start = ymin
plot.y_range.end = ymax
#turn lines on or off
def line_onOffChange(attrname, old, new):
for i in range(len(line_onOff.labels)):
if i in line_onOff.active:
lines[i].glyph.visible = True
else:
lines[i].glyph.visible = False
legendDiv.text = '<div>'
for line in lines:
legendDiv.text += '<br><div style="background-color: %s; float:up; padding: 4px 4px 4px 4px"></div><br>' % line.glyph.line_color
legendDiv.text += '</div>'
resize()
#adds a line to the graph
def grphUpdt():
#adds some debug messages, grabs the current time as to later show the total time taken to calculate
updateDebug("Starting")
updateDebug("total dataframe size: " + str(fruit_df.shape))
stTime = datetime.now()
#the value to linear fit to
fit_to = int(fixed_date.value)
#instiantiate an empty dataframe that will eventually contain the graphs data
graphData = pd.DataFrame({
'Date': [],
'PriceVolatility': [],
'Days_to_Exp': []
})
#grab the appropriate subset of the whole dataframe based on the users input into the widgets
updateDebug("querying the data..")
try:
workingDf = fruit_df.loc[asCls.value, prod.value, whereFrom.value]
except KeyError:
updateDebug(
'no data with that combination of Asset Class, Product, From')
return
try:
workingDf = workingDf[[
'Date', 'PriceVolatility', 'Days_to_Exp'
]][(workingDf['Date'] >
(date.today() - timedelta(days=int(days_back.value))))]
except KeyError:
updateDebug(
'no data with that combination of Asset Class, Product, From, and days back'
)
return
updateDebug("done breaking down df")
#a hook in the case that the users inputs resulted in an empty dataframe
if (workingDf.empty):
updateDebug(
'no data with that combination of Asset Class, Product, From, and days back'
)
return
#widdle down the database to only contain the user specified FQ
try:
graphData = workingDf.loc[int(FQslider.value)].copy()
except KeyError:
updateDebug('no data with that FQ')
#another empty graph hook
if (graphData.empty):
updateDebug(
'no data with that combination of Asset Class, Product, Contract Category, FQ, and days back'
)
return
updateDebug('grabed correct FQs')
#calculate linear fit on the current subset
updateDebug('calculating linear fit...')
graphData = mu.linearFit(fit_to=fit_to,
group_on_column='Date',
df=graphData,
fit_column='Days_to_Exp',
on_columns=['PriceVolatility'])
updateDebug('finished with linear fit')
# a few more debug messages
updateDebug(
"working df qry: Asset_Class = %s and Product = %s and From = %s and Date > %s "
% (asCls.value, prod.value, whereFrom.value,
str(date.today() - timedelta(days=int(days_back.value)))))
updateDebug("graph data shape: " + str(workingDf.shape))
#makes sure graph data has at least 5 rows, so that rolling mean can be calculated
if graphData.shape[0] > int(rolling_days.value):
#make the graph legend, based on if there's a denominator specified or not
this_legend = '%s - %s FQ: %s Days to Exp: %s From: %s Rolling Days: %s' % (
prod.value, whereFrom.value, int(
FQslider.value), fixed_date.value,
str(date.today() - timedelta(days=int(days_back.value))),
rolling_days.value)
#add a new line to the graph, and add the accosiated GlyphRenderer created by adding the line to the lines list.
#Set the legend to the previously calculated legend, and set the color to the next color in the current theme (if there are more lines than colors, there will be multiple lines with the same color)
#Calculates a 5 day rolling mean on the y values. Maybe add a slider/text box/other widget so the user can set the rolling mean themselves
updateDebug('adding line to plot')
lines.append(
plot.line(graphData.index.values[int(rolling_days.value) - 1:],
graphData['PriceVolatility'].rolling(
window=int(rolling_days.value)).mean()
[int(rolling_days.value) - 1:],
line_width=3,
color=colors[len(lines) % len(colors)]))
legends.append(this_legend)
updateDebug("updated graph")
global descDf
#either creates, or adds to, a dataframe containing statistics about the data. stats come from pandas DataFrame.describe.
if descDf is None:
graphData[this_legend] = graphData['PriceVolatility']
descDf = graphData[[
this_legend
]].rolling(window=int(rolling_days.value)).mean(
)[int(rolling_days.value) -
1:].describe(percentiles=[]).transpose().copy()
else:
graphData[this_legend] = graphData['PriceVolatility']
descDf = pd.concat([
descDf, graphData[[
this_legend
]].rolling(window=int(rolling_days.value)).mean()
[int(rolling_days.value) -
1:].describe(percentiles=[]).transpose().copy()
])
descDf = descDf.round(1)
descriptions.text = descDf.to_html().replace('\\n', '')
graphData.drop(this_legend, 1, inplace=True)
#add the name of the line to the checkbox so that it can be turned off and o
line_onOff.labels.append(this_legend)
line_onOff.active.append(len(line_onOff.labels) - 1)
legendDiv.text = '<div>'
for line in lines:
legendDiv.text += '<br><div style="background-color: %s; float:up; padding: 4px 4px 4px 4px"></div><br>' % line.glyph.line_color
legendDiv.text += '</div>'
##leaving this in case we get around to figuring out the hover tool
##formats the date values for the hover tool, currently commented out until we, or bokeh, fix the hover tool for multiple lines
#formDates= pd.to_datetime(graphData['Date'] ,format="%m-%d-%Y")
#lines[-1].data_source.data['formDates'] = formDates.apply(lambda x: x.strftime('%m-%d-%Y'))
##Displays the amout of time it took to draw the line, as well as the number of points in the graph
updateDebug("updated y vals, with rolling mean calculated")
updateDebug(
str(datetime.now() - stTime) + " FOR " +
str(len(lines[-1].data_source.data['x'])) + " points")
else:
updateDebug("There's no data to display")
del graphData
del workingDf
#######Link widgets to their associated functions
asCls.on_change('value', asClsChange)
prod.on_change('value', prodChange)
days_back_buttons.on_change('active', days_back_buttonChange)
days_back.on_change('value', days_backChange)
fixed_date_buttons.on_change('active', fixed_date_buttonChange)
fixed_date.on_change('value', fixed_dateChange)
rolling_days_buttons.on_change('active', rolling_days_buttonsChange)
rolling_days.on_change('value', rolling_daysChange)
line_onOff.on_change('active', line_onOffChange)
addLine.on_click(grphUpdt)
rszButton.on_click(resize)
#Formatting
fixed_date_box = WidgetBox(fixed_date, fixed_date_buttons)
days_back_box = WidgetBox(days_back, days_back_buttons)
rolling_days_box = WidgetBox(rolling_days, rolling_days_buttons)
widgets = [
asCls, prod, whereFrom, FQslider, days_back_box, fixed_date_box,
rolling_days_box, addLine, rszButton, user_message
]
plot_w_description = VBox(plot, descriptions, width=700)
pwd_w_leg = HBox(plot_w_description,
VBox(legendDiv),
VBox(line_onOff),
width=plot_w_description.width + line_onOff.width + 100,
name='div_to_save')
input_box = VBox(*widgets, width=400, height=1200)
total_box = HBox(VBox(input_box),
VBox(pwd_w_leg),
width=input_box.width + pwd_w_leg.width + 100,
height=1200)
tot_w_debug = VBox(total_box, VBox(HBox(debug)))
resize()
return tot_w_debug
Voltage_WE2.visible = True
"""Callback Assignments"""
callback_update_plot = None
callback_acquire_data_fake = None
Connect.on_click(callback_Connect_eLoaD_BLE)
Save.js_on_click(callback_Save)
Start.on_click(callback_Start)
Random_test.on_click(callback_Random_4)
Gain.on_change('value', update_gain)
Scan_rate.on_change('value', update_scan_rate)
Segments.on_change('value', update_segments)
Voltage_Start.on_change('value', update_v1_start)
Voltage_WE2.on_change('value', update_v2)
Voltage_Window.on_change('value', update_v1_window)
Sweep_direction.on_change('active', update_sweep)
Voltammetry_Mode.on_change('active', update_voltammetry_mode)
#---------------------------#
# Callbacks (Threads) #
#---------------------------#
#Plotting has no priority, also slower
@gen.coroutine
#It seems that we cannot make streaming unlocked
def stream():
global acquiredData
source.stream(
{'time': acquiredData['timestamp'], 'raw_data': acquiredData['raw_data']})
clear_dict(acquiredData)
def get_radio():
"""
chooses which of the returned data columns is plotted
"""
options_dict = {0: 'f', 1: 'a0', 2: 'a1', 3: 'a2'}
return options_dict[data_radios.active]
def radio_callback(attr, old, new):
update_plot_data()
data_radios = RadioButtonGroup(labels=["f", "a0", "a1", "a2"], active=0)
data_radios.on_change('active', radio_callback)
#######
## GENERATE MANIPLUABLE LINE PLOTS
#######
p = figure(width=600, height=600)
manny_on_the_map = Manipulator([0], [0], "empty", p)
def update_plot_data():
selectionIndex = data_grabber.file_source.selected.indices[0]
df = H5Scan(data_grabber.file_source.data['address'][selectionIndex]).df(
'analysis')
data_option = get_radio()
manny_on_the_map.update_data(
class DVHs:
def __init__(self, sources, time_series, correlation, regression,
custom_title, data_tables):
self.sources = sources
self.time_series = time_series
self.correlation = correlation
self.regression = regression
self.dvh_review_rois = []
self.query = None
self.temp_dvh_info = Temp_DICOM_FileSet()
self.dvh_review_mrns = self.temp_dvh_info.mrn
if self.dvh_review_mrns[0] != '':
self.dvh_review_rois = self.temp_dvh_info.get_roi_names(
self.dvh_review_mrns[0]).values()
self.dvh_review_mrns.append('')
else:
self.dvh_review_rois = ['']
# Add Current row to source
self.add_endpoint_row_button = Button(label="Add Endpoint",
button_type="primary",
width=200)
self.add_endpoint_row_button.on_click(self.add_endpoint)
self.ep_row = Select(value='', options=[''], width=50, title="Row")
self.ep_options = [
"Dose (Gy)", "Dose (%)", "Volume (cc)", "Volume (%)"
]
self.select_ep_type = Select(value=self.ep_options[0],
options=self.ep_options,
width=180,
title="Output")
self.select_ep_type.on_change('value', self.select_ep_type_ticker)
self.ep_text_input = TextInput(value='',
title="Input Volume (cc):",
width=180)
self.ep_text_input.on_change('value', self.ep_text_input_ticker)
self.ep_units_in = RadioButtonGroup(labels=["cc", "%"],
active=0,
width=100)
self.ep_units_in.on_change('active', self.ep_units_in_ticker)
self.delete_ep_row_button = Button(label="Delete",
button_type="warning",
width=100)
self.delete_ep_row_button.on_click(self.delete_ep_row)
tools = "pan,wheel_zoom,box_zoom,reset,crosshair,save"
self.plot = figure(plot_width=1050,
plot_height=500,
tools=tools,
logo=None,
active_drag="box_zoom")
self.plot.min_border_left = options.MIN_BORDER
self.plot.min_border_bottom = options.MIN_BORDER
self.plot.add_tools(
HoverTool(show_arrow=False,
line_policy='next',
tooltips=[('Label', '@mrn @roi_name'), ('Dose', '$x'),
('Volume', '$y')]))
self.plot.xaxis.axis_label_text_font_size = options.PLOT_AXIS_LABEL_FONT_SIZE
self.plot.yaxis.axis_label_text_font_size = options.PLOT_AXIS_LABEL_FONT_SIZE
self.plot.xaxis.major_label_text_font_size = options.PLOT_AXIS_MAJOR_LABEL_FONT_SIZE
self.plot.yaxis.major_label_text_font_size = options.PLOT_AXIS_MAJOR_LABEL_FONT_SIZE
self.plot.yaxis.axis_label_text_baseline = "bottom"
self.plot.lod_factor = options.LOD_FACTOR # level of detail during interactive plot events
# Add statistical plots to figure
stats_median_1 = self.plot.line(
'x',
'median',
source=sources.stats_1,
line_width=options.STATS_1_MEDIAN_LINE_WIDTH,
color=options.GROUP_1_COLOR,
line_dash=options.STATS_1_MEDIAN_LINE_DASH,
alpha=options.STATS_1_MEDIAN_ALPHA)
stats_mean_1 = self.plot.line(
'x',
'mean',
source=sources.stats_1,
line_width=options.STATS_1_MEAN_LINE_WIDTH,
color=options.GROUP_1_COLOR,
line_dash=options.STATS_1_MEAN_LINE_DASH,
alpha=options.STATS_1_MEAN_ALPHA)
stats_median_2 = self.plot.line(
'x',
'median',
source=sources.stats_2,
line_width=options.STATS_2_MEDIAN_LINE_WIDTH,
color=options.GROUP_2_COLOR,
line_dash=options.STATS_2_MEDIAN_LINE_DASH,
alpha=options.STATS_2_MEDIAN_ALPHA)
stats_mean_2 = self.plot.line(
'x',
'mean',
source=sources.stats_2,
line_width=options.STATS_2_MEAN_LINE_WIDTH,
color=options.GROUP_2_COLOR,
line_dash=options.STATS_2_MEAN_LINE_DASH,
alpha=options.STATS_2_MEAN_ALPHA)
# Add all DVHs, but hide them until selected
self.plot.multi_line('x',
'y',
source=sources.dvhs,
selection_color='color',
line_width=options.DVH_LINE_WIDTH,
alpha=0,
line_dash=options.DVH_LINE_DASH,
nonselection_alpha=0,
selection_alpha=1)
# Shaded region between Q1 and Q3
iqr_1 = self.plot.patch('x_patch',
'y_patch',
source=sources.patch_1,
alpha=options.IQR_1_ALPHA,
color=options.GROUP_1_COLOR)
iqr_2 = self.plot.patch('x_patch',
'y_patch',
source=sources.patch_2,
alpha=options.IQR_2_ALPHA,
color=options.GROUP_2_COLOR)
# Set x and y axis labels
self.plot.xaxis.axis_label = "Dose (Gy)"
self.plot.yaxis.axis_label = "Normalized Volume"
# Set the legend (for stat dvhs only)
legend_stats = Legend(items=[("Median", [stats_median_1]),
("Mean", [stats_mean_1]),
("IQR", [iqr_1]),
("Median", [stats_median_2]),
("Mean", [stats_mean_2]),
("IQR", [iqr_2])],
location=(25, 0))
# Add the layout outside the plot, clicking legend item hides the line
self.plot.add_layout(legend_stats, 'right')
self.plot.legend.click_policy = "hide"
self.download_endpoints_button = Button(label="Download Endpoints",
button_type="default",
width=150)
self.download_endpoints_button.callback = CustomJS(
args=dict(source=sources.endpoint_calcs),
code=open(join(dirname(__file__), "download_endpoints.js")).read())
# Setup axis normalization radio buttons
self.radio_group_dose = RadioGroup(
labels=["Absolute Dose", "Relative Dose (Rx)"],
active=0,
width=200)
self.radio_group_dose.on_change('active', self.radio_group_ticker)
self.radio_group_volume = RadioGroup(
labels=["Absolute Volume", "Relative Volume"], active=1, width=200)
self.radio_group_volume.on_change('active', self.radio_group_ticker)
# Setup selectors for dvh review
self.select_reviewed_mrn = Select(title='MRN to review',
value='',
options=self.dvh_review_mrns,
width=300)
self.select_reviewed_mrn.on_change('value',
self.update_dvh_review_rois)
self.select_reviewed_dvh = Select(title='ROI to review',
value='',
options=[''],
width=360)
self.select_reviewed_dvh.on_change('value',
self.select_reviewed_dvh_ticker)
self.review_rx = TextInput(value='', title="Rx Dose (Gy):", width=170)
self.review_rx.on_change('value', self.review_rx_ticker)
if options.LITE_VIEW:
self.layout = column(
Div(text="<b>DVH Analytics v%s</b>" % options.VERSION),
row(self.radio_group_dose,
self.radio_group_volume), self.add_endpoint_row_button,
row(self.ep_row, Spacer(width=10), self.select_ep_type,
self.ep_text_input, Spacer(width=20),
self.ep_units_in, self.delete_ep_row_button,
Spacer(width=50), self.download_endpoints_button),
data_tables.ep)
else:
self.layout = column(
Div(text="<b>DVH Analytics v%s</b>" % options.VERSION),
row(custom_title['1']['dvhs'], Spacer(width=50),
custom_title['2']['dvhs']),
row(self.radio_group_dose, self.radio_group_volume),
row(self.select_reviewed_mrn, self.select_reviewed_dvh,
self.review_rx), self.plot,
Div(text="<b>DVHs</b>", width=1200), data_tables.dvhs,
Div(text="<hr>", width=1050),
Div(text="<b>Define Endpoints</b>",
width=1000), self.add_endpoint_row_button,
row(self.ep_row, Spacer(width=10), self.select_ep_type,
self.ep_text_input, Spacer(width=20),
self.ep_units_in, self.delete_ep_row_button,
Spacer(width=50), self.download_endpoints_button),
data_tables.ep, Div(text="<b>DVH Endpoints</b>",
width=1200), data_tables.endpoints)
def add_endpoint(self):
if self.sources.endpoint_defs.data['row']:
temp = self.sources.endpoint_defs.data
for key in list(temp):
temp[key].append('')
temp['row'][-1] = len(temp['row'])
self.sources.endpoint_defs.data = temp
new_options = [str(x + 1) for x in range(len(temp['row']))]
self.ep_row.options = new_options
self.ep_row.value = new_options[-1]
else:
self.ep_row.options = ['1']
self.ep_row.value = '1'
self.sources.endpoint_defs.data = dict(row=['1'],
output_type=[''],
input_type=[''],
input_value=[''],
label=[''],
units_in=[''],
units_out=[''])
if not self.ep_text_input.value:
self.ep_text_input.value = '1'
self.update_ep_source()
clear_source_selection(self.sources, 'endpoint_defs')
def update_ep_source(self):
if self.ep_row.value:
r = int(self.ep_row.value) - 1
if 'Dose' in self.select_ep_type.value:
input_type, output_type = 'Volume', 'Dose'
if '%' in self.select_ep_type.value:
units_out = '%'
else:
units_out = 'Gy'
units_in = ['cc', '%'][self.ep_units_in.active]
label = "D_%s%s" % (self.ep_text_input.value, units_in)
else:
input_type, output_type = 'Dose', 'Volume'
if '%' in self.select_ep_type.value:
units_out = '%'
else:
units_out = 'cc'
units_in = ['Gy', '%'][self.ep_units_in.active]
label = "V_%s%s" % (self.ep_text_input.value, units_in)
try:
input_value = float(self.ep_text_input.value)
except:
input_value = 1
patch = {
'output_type': [(r, output_type)],
'input_type': [(r, input_type)],
'input_value': [(r, input_value)],
'label': [(r, label)],
'units_in': [(r, units_in)],
'units_out': [(r, units_out)]
}
self.sources.endpoint_defs.patch(patch)
self.update_source_endpoint_calcs()
def ep_units_in_ticker(self, attr, old, new):
if self.query.allow_source_update:
self.update_ep_text_input_title()
self.update_ep_source()
def update_ep_text_input_title(self):
if 'Dose' in self.select_ep_type.value:
self.ep_text_input.title = "Input Volume (%s):" % [
'cc', '%'
][self.ep_units_in.active]
else:
self.ep_text_input.title = "Input Dose (%s):" % [
'Gy', '%'
][self.ep_units_in.active]
def select_ep_type_ticker(self, attr, old, new):
if self.query.allow_source_update:
if 'Dose' in new:
self.ep_units_in.labels = ['cc', '%']
else:
self.ep_units_in.labels = ['Gy', '%']
self.update_ep_text_input_title()
self.update_ep_source()
def ep_text_input_ticker(self, attr, old, new):
if self.query.allow_source_update:
self.update_ep_source()
def delete_ep_row(self):
if self.ep_row.value:
new_ep_source = self.sources.endpoint_defs.data
index_to_delete = int(self.ep_row.value) - 1
new_source_length = len(
self.sources.endpoint_defs.data['output_type']) - 1
if new_source_length == 0:
clear_source_data(self.sources, 'endpoint_defs')
self.ep_row.options = ['']
self.ep_row.value = ''
else:
for key in list(new_ep_source):
new_ep_source[key].pop(index_to_delete)
for i in range(index_to_delete, new_source_length):
new_ep_source['row'][i] -= 1
self.ep_row.options = [
str(x + 1) for x in range(new_source_length)
]
if self.ep_row.value not in self.ep_row.options:
self.ep_row.value = self.ep_row.options[-1]
self.sources.endpoint_defs.data = new_ep_source
self.update_source_endpoint_calcs(
) # not efficient, but still relatively quick
clear_source_selection(self.sources, 'endpoint_defs')
def update_ep_row_on_selection(self, attr, old, new):
self.query.allow_source_update = False
if new:
data = self.sources.endpoint_defs.data
r = min(new)
# update row
self.ep_row.value = self.ep_row.options[r]
# update input value
self.ep_text_input.value = str(data['input_value'][r])
# update input units radio button
if '%' in data['units_in'][r]:
self.ep_units_in.active = 1
else:
self.ep_units_in.active = 0
# update output
if 'Dose' in data['output_type'][r]:
if '%' in data['units_in'][r]:
self.select_ep_type.value = self.ep_options[1]
else:
self.select_ep_type.value = self.ep_options[0]
else:
if '%' in data['units_in'][r]:
self.select_ep_type.value = self.ep_options[3]
else:
self.select_ep_type.value = self.ep_options[2]
self.query.allow_source_update = True
def update_source_endpoint_calcs(self):
if self.query.current_dvh:
group_1_constraint_count, group_2_constraint_count = group_constraint_count(
self.sources)
ep = {'mrn': ['']}
ep_group = {'1': {}, '2': {}}
table_columns = []
ep['mrn'] = self.query.current_dvh.mrn
ep['uid'] = self.query.current_dvh.study_instance_uid
ep['group'] = self.sources.dvhs.data['group']
ep['roi_name'] = self.sources.dvhs.data['roi_name']
table_columns.append(TableColumn(field='mrn', title='MRN'))
table_columns.append(TableColumn(field='group', title='Group'))
table_columns.append(
TableColumn(field='roi_name', title='ROI Name'))
data = self.sources.endpoint_defs.data
for r in range(len(data['row'])):
ep_name = str(data['label'][r])
table_columns.append(
TableColumn(field=ep_name,
title=ep_name,
formatter=NumberFormatter(format="0.00")))
x = data['input_value'][r]
if '%' in data['units_in'][r]:
endpoint_input = 'relative'
x /= 100.
else:
endpoint_input = 'absolute'
if '%' in data['units_out'][r]:
endpoint_output = 'relative'
else:
endpoint_output = 'absolute'
if 'Dose' in data['output_type'][r]:
ep[ep_name] = self.query.current_dvh.get_dose_to_volume(
x,
volume_scale=endpoint_input,
dose_scale=endpoint_output)
for g in GROUP_LABELS:
if self.time_series.current_dvh_group[g]:
ep_group[g][
ep_name] = self.time_series.current_dvh_group[
g].get_dose_to_volume(
x,
volume_scale=endpoint_input,
dose_scale=endpoint_output)
else:
ep[ep_name] = self.query.current_dvh.get_volume_of_dose(
x,
dose_scale=endpoint_input,
volume_scale=endpoint_output)
for g in GROUP_LABELS:
if self.time_series.current_dvh_group[g]:
ep_group[g][
ep_name] = self.time_series.current_dvh_group[
g].get_volume_of_dose(
x,
dose_scale=endpoint_input,
volume_scale=endpoint_output)
if group_1_constraint_count and group_2_constraint_count:
ep_1_stats = calc_stats(ep_group['1'][ep_name])
ep_2_stats = calc_stats(ep_group['2'][ep_name])
stats = []
for i in range(len(ep_1_stats)):
stats.append(ep_1_stats[i])
stats.append(ep_2_stats[i])
ep[ep_name].extend(stats)
else:
ep[ep_name].extend(calc_stats(ep[ep_name]))
self.sources.endpoint_calcs.data = ep
# Update endpoint calc from review_dvh, if available
if self.sources.dvhs.data['y'][0] != []:
review_ep = {}
rx = float(self.sources.dvhs.data['rx_dose'][0])
volume = float(self.sources.dvhs.data['volume'][0])
data = self.sources.endpoint_defs.data
for r in range(len(data['row'])):
ep_name = str(data['label'][r])
x = data['input_value'][r]
if '%' in data['units_in'][r]:
endpoint_input = 'relative'
x /= 100.
else:
endpoint_input = 'absolute'
if '%' in data['units_out'][r]:
endpoint_output = 'relative'
else:
endpoint_output = 'absolute'
if 'Dose' in data['output_type'][r]:
if endpoint_input == 'relative':
current_ep = dose_to_volume(y, x)
else:
current_ep = dose_to_volume(y, x / volume)
if endpoint_output == 'relative' and rx != 0:
current_ep = current_ep / rx
else:
if endpoint_input == 'relative':
current_ep = volume_of_dose(y, x * rx)
else:
current_ep = volume_of_dose(y, x)
if endpoint_output == 'absolute' and volume != 0:
current_ep = current_ep * volume
review_ep[ep_name] = [(0, current_ep)]
review_ep['mrn'] = [(0, self.select_reviewed_mrn.value)]
self.sources.endpoint_calcs.patch(review_ep)
self.update_endpoint_view()
if not options.LITE_VIEW:
self.time_series.update_options()
def update_endpoint_view(self):
if self.query.current_dvh:
rows = len(self.sources.endpoint_calcs.data['mrn'])
ep_view = {
'mrn': self.sources.endpoint_calcs.data['mrn'],
'group': self.sources.endpoint_calcs.data['group'],
'roi_name': self.sources.endpoint_calcs.data['roi_name']
}
for i in range(1, options.ENDPOINT_COUNT + 1):
ep_view["ep%s" %
i] = [''] * rows # filling table with empty strings
for r in range(len(self.sources.endpoint_defs.data['row'])):
if r < options.ENDPOINT_COUNT: # limiting UI to ENDPOINT_COUNT for efficiency
key = self.sources.endpoint_defs.data['label'][r]
ep_view["ep%s" %
(r + 1)] = self.sources.endpoint_calcs.data[key]
self.sources.endpoint_view.data = ep_view
if not options.LITE_VIEW:
self.correlation.update_or_add_endpoints_to_correlation()
categories = list(self.correlation.data['1'])
categories.sort()
self.regression.x.options = [''] + categories
self.regression.y.options = [''] + categories
self.correlation.validate_data()
self.correlation.update_correlation_matrix()
self.regression.update_data()
def update_source_endpoint_view_selection(self, attr, old, new):
if new:
self.sources.endpoint_view.selected.indices = new
def update_dvh_table_selection(self, attr, old, new):
if new:
self.sources.dvhs.selected.indices = new
def update_dvh_review_rois(self, attr, old, new):
if self.select_reviewed_mrn.value:
if new != '':
self.dvh_review_rois = self.temp_dvh_info.get_roi_names(
new).values()
self.select_reviewed_dvh.options = self.dvh_review_rois
self.select_reviewed_dvh.value = self.dvh_review_rois[0]
else:
self.select_reviewed_dvh.options = ['']
self.select_reviewed_dvh.value = ['']
else:
self.select_reviewed_dvh.options = ['']
self.select_reviewed_dvh.value = ''
patches = {
'x': [(0, [])],
'y': [(0, [])],
'roi_name': [(0, '')],
'volume': [(0, '')],
'min_dose': [(0, '')],
'mean_dose': [(0, '')],
'max_dose': [(0, '')],
'mrn': [(0, '')],
'rx_dose': [(0, '')]
}
self.sources.dvhs.patch(patches)
def calculate_review_dvh(self):
global x, y
patches = {
'x': [(0, [])],
'y': [(0, [])],
'roi_name': [(0, '')],
'volume': [(0, 1)],
'min_dose': [(0, '')],
'mean_dose': [(0, '')],
'max_dose': [(0, '')],
'mrn': [(0, '')],
'rx_dose': [(0, 1)]
}
try:
if not self.sources.dvhs.data['x']:
self.query.update_data()
else:
file_index = self.temp_dvh_info.mrn.index(
self.select_reviewed_mrn.value)
roi_index = self.dvh_review_rois.index(
self.select_reviewed_dvh.value)
structure_file = self.temp_dvh_info.structure[file_index]
plan_file = self.temp_dvh_info.plan[file_index]
dose_file = self.temp_dvh_info.dose[file_index]
key = list(
self.temp_dvh_info.get_roi_names(
self.select_reviewed_mrn.value))[roi_index]
rt_st = dicomparser.DicomParser(structure_file)
rt_structures = rt_st.GetStructures()
review_dvh = dvhcalc.get_dvh(structure_file, dose_file, key)
dicompyler_plan = dicomparser.DicomParser(plan_file).GetPlan()
roi_name = rt_structures[key]['name']
volume = review_dvh.volume
min_dose = review_dvh.min
mean_dose = review_dvh.mean
max_dose = review_dvh.max
if not self.review_rx.value:
rx_dose = float(dicompyler_plan['rxdose']) / 100.
self.review_rx.value = str(round(rx_dose, 2))
else:
rx_dose = round(float(self.review_rx.value), 2)
x = review_dvh.bincenters
if max(review_dvh.counts):
y = np.divide(review_dvh.counts, max(review_dvh.counts))
else:
y = review_dvh.counts
if self.radio_group_dose.active == 1:
f = 5000
bin_count = len(x)
new_bin_count = int(bin_count * f / (rx_dose * 100.))
x1 = np.linspace(0, bin_count, bin_count)
x2 = np.multiply(
np.linspace(0, new_bin_count, new_bin_count),
rx_dose * 100. / f)
y = np.interp(x2, x1, review_dvh.counts)
y = np.divide(y, np.max(y))
x = np.divide(np.linspace(0, new_bin_count, new_bin_count),
f)
if self.radio_group_volume.active == 0:
y = np.multiply(y, volume)
patches = {
'x': [(0, x)],
'y': [(0, y)],
'roi_name': [(0, roi_name)],
'volume': [(0, volume)],
'min_dose': [(0, min_dose)],
'mean_dose': [(0, mean_dose)],
'max_dose': [(0, max_dose)],
'mrn': [(0, self.select_reviewed_mrn.value)],
'rx_dose': [(0, rx_dose)]
}
except:
pass
self.sources.dvhs.patch(patches)
self.update_source_endpoint_calcs()
def select_reviewed_dvh_ticker(self, attr, old, new):
self.calculate_review_dvh()
def review_rx_ticker(self, attr, old, new):
if self.radio_group_dose.active == 0:
self.sources.dvhs.patch(
{'rx_dose': [(0, round(float(self.review_rx.value), 2))]})
else:
self.calculate_review_dvh()
def radio_group_ticker(self, attr, old, new):
if self.sources.dvhs.data['x'] != '':
self.query.update_data()
self.calculate_review_dvh()
def add_query_link(self, query):
self.query = query
def make_tab():
# Slider to select width of bin
pastdays_select = RangeSlider(start=0,
end=999,
value=(0, 999),
step=1,
title='Past Days',
sizing_mode="stretch_both")
# Slider to select buffer size
bufferdays_select = Slider(start=.01,
end=9,
value=0.01,
step=.1,
title='Buffer Size (days)',
sizing_mode="stretch_both")
# Re-read
refresh_button = Button(label="Time window and buffer are up to date",
button_type="success",
sizing_mode="stretch_both")
refresh_button.disabled = True
# read data
flights, available_carriers = read(pastdays_select, bufferdays_select)
# CheckboxGroup to select carrier to display
locationcodes = np.unique(
['.'.join(seedid.split('.')[:3]) for seedid in available_carriers])
selections = []
for locationcode in locationcodes[:maxnstation]:
matching = [s for s in available_carriers if locationcode in s]
active = [i for i, m in enumerate(matching)] # if "Z" == m[-1]]
selections += [
CheckboxButtonGroup(labels=matching,
active=active,
sizing_mode="stretch_both")
]
#selections += [MultiSelect(#title="Option:",
# value=matching,
# active=active)
# Find the initially selected carrieres
initial_carriers = [s.labels[i] for s in selections for i in s.active]
# Slider to select width of bin
binwidth_select = Slider(start=16,
end=160,
step=16,
value=80,
title='Bin number',
sizing_mode="stretch_both")
# RangeSlider control to select start and end of plotted delays
range_select = RangeSlider(start=-1,
end=999,
value=(-.2, 99),
step=.1,
title='Range (sec)',
sizing_mode="stretch_both")
# Switch from lines to hists
type_switch = RadioButtonGroup(labels=["Histogram", "Cumulated dist."],
active=0,
sizing_mode="stretch_both")
# Find the initially selected carrieres
plottype = type_switch.labels[type_switch.active]
src = {}
for output in ['Latencies', 'Delays', 'PSD']:
src[output] = make_dataset(flights,
initial_carriers,
range_start=range_select.value[0],
range_end=range_select.value[1],
bin_width=binwidth_select.value,
output=output,
plottype=plottype)
callback = partial(update,
output='Delays',
type_switch=type_switch,
flights=flights,
src=src,
selections=selections,
range_select=range_select,
binwidth_select=binwidth_select)
callbacklat = partial(update,
output='Latencies',
type_switch=type_switch,
flights=flights,
src=src,
range_select=range_select,
selections=selections,
binwidth_select=binwidth_select)
callbackpsd = partial(update,
output='PSD',
type_switch=type_switch,
flights=flights,
src=src,
range_select=range_select,
selections=selections,
binwidth_select=binwidth_select)
callbackneedsread = partial(needsreadupdate, refresh_button=refresh_button)
callbackread = partial(readupdate,
src=src,
selections=selections,
range_select=range_select,
type_switch=type_switch,
binwidth_select=binwidth_select,
pastdays_select=pastdays_select,
bufferdays_select=bufferdays_select,
refresh_button=refresh_button)
[
s.on_change('active', callback, callbacklat, callbackpsd)
for s in selections
]
type_switch.on_change('active', callback, callbacklat, callbackpsd)
binwidth_select.on_change('value', callback, callbacklat, callbackpsd)
range_select.on_change('value', callback, callbacklat, callbackpsd)
pastdays_select.on_change('value', callbackneedsread)
bufferdays_select.on_change('value', callbackneedsread)
refresh_button.on_click(callbackread)
p = {}
for output in ['PSD', 'Latencies', 'Delays']:
p[output] = make_plot(src[output], output=output)
# Create a row layout
graphs = [p[k] for k in p]
controls = [
type_switch, binwidth_select, range_select, refresh_button,
pastdays_select, bufferdays_select, *selections[:maxnstation]
]
graphslayout = column(children=graphs, sizing_mode="stretch_both")
controlslayout = column(
children=controls,
sizing_mode='fixed', #stretch_width',
width=400,
)
layout = row(children=[graphslayout, controlslayout],
sizing_mode='stretch_both')
# Make a tab with the layout
return Panel(child=layout, title='Channels')
def basic_teams_stats_tab(teams_stats_df):
"""Tab with teams stats."""
def create_data_source(comparison_stat, aggfunc):
"""Returns a pivoted table by teams and match result (w/d/l).
Values are index of comparison_stat.
:param comparison_stat: str. Statistic to show (goals, passes,
etc.).
:param aggfunc: str. Aggregate function to calculate by ('mean'
or 'sum').
"""
def get_team_indexed_stat(team_row, stat, aggfunc):
"""Returns aggregated team's stat.
:param team_row: pd.Series. A row from teams stat table.
:param stat: str. Statistic to calculate (goal, passes,
etc.)
:param aggfunc: str. Aggregate function to calculate by
('mean' or 'sum')
"""
if aggfunc == 'mean':
df = teams_stats_df.groupby(by='team').mean()
elif aggfunc == 'sum':
df = teams_stats_df.groupby(by='team').sum()
return df.loc[team_row.name, stat]
df = teams_stats_df.pivot_table(index='team',
columns='Match result',
values=comparison_stat,
aggfunc=aggfunc)
df['Total'] = df.apply(get_team_indexed_stat,
args=[comparison_stat, aggfunc],
axis=1)
return df.sort_values(by='Total', ascending=False)
def plot_team_stat(comparison_stat, agg_func):
"""Creates figures with bars plots of teams stats.
:param comparison_stat: str. Statistic to plot.
:param agg_func: str. 'mean' or 'sum'.
:return: bokeh figures.
"""
map_agg_func = ('mean', 'sum')
data = create_data_source(comparison_stat, map_agg_func[agg_func])
source = ColumnDataSource(data=data)
teams = list(source.data['team'])
# Plot avg stat per game
p_1 = figure(x_range=FactorRange(factors=teams),
plot_height=400,
plot_width=700)
hover = HoverTool(tooltips=[('', '@{Total}')])
hover.point_policy = 'follow_mouse'
p_1.add_tools(hover)
p_1.vbar(x='team',
top='Total',
source=source,
width=0.4,
color=Spectral4[0])
p_1.x_range.range_padding = 0.05
p_1.xaxis.major_label_orientation = 1
p_1.xaxis.major_label_text_font_size = "10pt"
p_1.toolbar_location = None
# Plot breakdown by match result
p_2 = figure(x_range=FactorRange(factors=teams),
plot_height=400,
plot_width=700,
tools='hover',
tooltips='@$name',
title='Breakdown by Match Result')
w = p_2.vbar(x=dodge('team', -0.25, range=p_2.x_range),
top='w',
width=0.2,
source=source,
color=Spectral4[1],
name='w')
d = p_2.vbar(x=dodge('team', 0.0, range=p_2.x_range),
top='d',
width=0.2,
source=source,
color=Spectral4[2],
name='d')
l = p_2.vbar(x=dodge('team', 0.25, range=p_2.x_range),
top='l',
width=0.2,
source=source,
color=Spectral4[3],
name='l')
legend_it = [('Won', [w]), ('Drew', [d]), ('Lost', [l])]
legend = Legend(items=legend_it, location=(0, 155))
p_2.add_layout(legend, 'right')
p_2.title.text_font_size = '12pt'
p_2.x_range.range_padding = 0.05
p_2.xgrid.grid_line_color = None
p_2.xaxis.major_label_text_font_size = "10pt"
p_2.xaxis.major_label_orientation = 1
p_2.toolbar_location = None
return p_1, p_2
# Update plots on changes
def update(attrname, old, new):
"""Update plots after widgets changes."""
stat = select_stat.value
agg_func = choose_agg_func.active
p1, p2 = plot_team_stat(stat, agg_func)
layout.children[1:] = [p1, p2]
# Widgets
select_stat = Select(title="Select a Stat for Comparison:",
value="goal",
options=list(teams_stats_df.columns)[1:-3])
select_stat.on_change('value', update)
choose_agg_func = RadioButtonGroup(labels=['Average per Match', 'Total'],
active=0)
choose_agg_func.on_change('active', update)
# Wrap widgets
widgets = widgetbox([select_stat, choose_agg_func])
comparison_stat = select_stat.value
agg_func_state = choose_agg_func.active
# Arrange layout
p1, p2 = plot_team_stat(comparison_stat, agg_func_state)
layout = column(row(widgets), p1, p2)
tab = Panel(child=layout, title='Basic Teams Stats')
return tab
def update(attr, old, new):
init_time = datetime.now()
main_doc.clear()
main_doc.add_root(layout)
#main_doc.theme = 'dark_minimal'
title = ticker0.value
print('-I- selected item is : ', title)
# sentiment = ticker1.value
reviews = reviews_ms1.copy()
reviews = reviews[reviews.title == title]
reviews = reviews.drop_duplicates()
reviews['id'] = range(len(reviews))
## sentence making
full_comments = []
full_title = []
l1 = int(len(reviews) / 2)
c1, t1, id1 = sentence_finder(reviews, 0, l1)
c2, t2, id2 = sentence_finder(reviews, l1, len(reviews))
full_comments = c1 + c2
full_title = t1 + t2
full_id = id1 + id2
reviews_old = reviews[['id', 'comments']]
reviews_old.columns = ['id', 'comments_full']
def stripper(s):
return s.strip()
reviews = pd.DataFrame()
reviews['comments'] = full_comments
reviews['comments'] = reviews['comments'].apply(stripper)
reviews['title'] = full_title
reviews['id'] = full_id
reviews = reviews[reviews.comments != '']
reviews = reviews.drop_duplicates(subset=['comments'])
reviews = reviews.merge(reviews_old, on='id', how='left')
title_words = spacy_tokenizer(reviews.title.iloc[0].replace("'",
"")).split()
def title_word_remover(s):
for t in title_words:
s = s.replace(t, '')
return s
## For finding bigrams
data = reviews.comments.values.tolist()
# Remove Emails
data = [re.sub('\S*@\S*\s?', '', sent) for sent in data]
# Remove new line characters
data = [re.sub('\s+', ' ', sent) for sent in data]
# Remove distracting single quotes
data = [re.sub("\'", "", sent) for sent in data]
data_words = list(sent_to_words(data))
# Build the bigram and trigram models
bigram = gensim.models.Phrases(
data_words, min_count=4,
threshold=50) # higher threshold fewer phrases.
# trigram = gensim.models.Phrases(bigram[data_words], threshold=50)
# Faster way to get a sentence clubbed as a trigram/bigram
bigram_mod = gensim.models.phrases.Phraser(bigram)
# trigram_mod = gensim.models.phrases.Phraser(trigram)
data_words1 = [' '.join(bigram_mod[d]) for d in data_words]
reviews['comments'] = data_words1
## steming lemmetising and stop word removal
reviews['cleaned_comments'] = reviews.comments.apply(spacy_tokenizer)
## sentiment finding
senti = sentimental_analysis.find_sentiment(reviews)
reviews['sentiment_pred'] = senti
## finding all nouns in the full reviews
all_nouns = []
for i in tqdm(range(len(reviews))):
all_nouns = all_nouns + noun_finder(reviews.cleaned_comments.iloc[i])
## Nouns and their count with weight
noun_df = pd.DataFrame(
pd.Series(all_nouns).astype('str').value_counts().reset_index())
noun_df.columns = ['noun', 'count']
noun_df['weight'] = 0
noun_df.head()
print('-I- finding the weight and updating it in df ---------------------')
## finding the weight and updating it in df
for text in tqdm(reviews.cleaned_comments):
doc = nlp(text)
noun_adj_pairs = []
for i, token in enumerate(doc):
bi_words = str(token).split('_')
if ((token.pos_ not in ('ADJ')) & (len(bi_words) == 1)):
continue
if ((len(bi_words) == 2)):
if ((nlp(bi_words[0])[0].pos_ == 'ADJ') &
(nlp(bi_words[1])[0].pos_ in ('NOUN', 'PROPN')) &
(~pd.Series(bi_words[1]).isin(title_words)[0])):
noun_adj_pairs.append((bi_words[0], bi_words[1]))
try:
noun_df.loc[noun_df.noun == str(bi_words[1]),
'weight'] = noun_df.loc[
noun_df.noun == str(bi_words[1]),
'weight'].iloc[0] + 1
except:
noun_df = noun_df.append(
pd.DataFrame(
{
'noun': [bi_words[1]],
'count': [1],
'weight': [1]
},
index=[len(noun_df)]))
elif ((token.pos_ in ('NOUN', 'PROPN')) &
(nlp(bi_words[0])[0].pos_ in ('NOUN', 'PROPN')) &
(nlp(bi_words[1])[0].pos_ in ('NOUN', 'PROPN')) &
(~pd.Series(bi_words[0]).isin(title_words)[0]) &
(~pd.Series(bi_words[1]).isin(title_words)[0])):
# elif((nlp(bi_words[0])[0].pos_ in ('NOUN','PROPN')) & (nlp(bi_words[1])[0].pos_ in ('NOUN','PROPN'))):
noun_df.loc[
noun_df.noun == str(token),
'weight'] = noun_df.loc[noun_df.noun == str(token),
'weight'].iloc[0] + 1
continue
if ((pd.Series([str(token)]).isin(positive)[0]) |
(pd.Series([str(token)]).isin(negative)[0])):
for j in range(i + 1, min(i + 6, len(doc))):
# if (doc[j].pos_ in ('NOUN','PROPN')):
if ((doc[j].pos_ in ('NOUN', 'PROPN')) &
(len(str(doc[j]).split('_')) != 2)):
noun_adj_pairs.append((token, doc[j]))
noun_df.loc[noun_df.noun == str(doc[j]),
'weight'] = noun_df.loc[
noun_df.noun == str(doc[j]),
'weight'].iloc[0] + 1
break
## removing words from noun which is in title to find top topics ( topic nouns )
noun_df = noun_df[~noun_df.noun.isin(
spacy_tokenizer(reviews.title.iloc[0].replace("'", "")).split())]
noun_df = noun_df.sort_values(by='weight', ascending=False)
noun_df = noun_df.iloc[0:20, ]
reviews.to_csv('./CRM_bokeh_app/static/temp.csv', index=False)
topic_df = pd.DataFrame()
topic_df['topics'] = noun_df['noun']
print('-I- topic sentimental distribution finding---')
pos_r = []
neg_r = []
neu_r = []
full_l = []
for t in tqdm(topic_df.topics):
temp = reviews.copy()
temp['item_presence'] = temp.apply(
lambda row: topic_presence(row['cleaned_comments'], t), axis=1)
temp = temp[temp.item_presence != -1]
full_l.append(len(temp))
pos_r.append(len(temp[temp.sentiment_pred == 'positive']))
neg_r.append(len(temp[temp.sentiment_pred == 'negative']))
neu_r.append(len(temp[temp.sentiment_pred == 'neutral']))
# topic_df['length'] = full_l
topic_df['positive'] = pos_r
topic_df['negative'] = neg_r
topic_df['neutral'] = neu_r
final_time = datetime.now()
print('-I- Time taken for update is = ', str(final_time - init_time))
global ticker2
global radio_button_group
global text_input
ticker2 = Select(title='Topic',
value='all',
options=['all'] + list(noun_df.noun))
ticker2.on_change('value', update2)
radio_button_group = RadioButtonGroup(
labels=['all', 'positive', 'negative', 'neutral'], active=0)
radio_button_group.on_change('active', update2)
text_input = TextInput(value="", title="Custom topic search:")
text_input.on_change("value", update2)
t_r = column([row([ticker2, text_input]), radio_button_group])
z = plot_senti(reviews, title)
z1 = plot_topic(noun_df, title)
z2 = column([
row([
plot_senti_stack(topic_df.sort_values(by='positive'), 1),
plot_senti_stack(topic_df.sort_values(by='negative'), 2)
]),
plot_senti_stack(topic_df.sort_values(by='neutral'), 3)
])
z = column([row([z, z1]), z2])
z1 = row([plot_senti(reviews, 'all topics'), summarizer(reviews)])
z2 = plot_rows(reviews)
z2 = column([z1, z2])
z3 = column(column([z, t_r], name='needed1'),
column([z2], name='review1'),
name='needed')
main_doc.add_root(z3)
class Page():
def __init__(self):
self.WIDTH_MATRIX = 1
self.HEIGHT_MATRIX = 1
self.tabs = RadioButtonGroup(labels=['Page1', 'Page2'], active=0)
self.tabs.on_change('active',
lambda attr, old, new: self.change_page())
self.data_directory = 'data'
self.data_files = os.listdir(self.data_directory)
self.select_data_files1 = Select(title="Data files 1:",
value="df1",
options=["df1"] + self.data_files)
self.select_data_files2 = Select(title="Data files 2:",
value="df2",
options=["df2"] + self.data_files)
self.select_data_files1.on_change(
'value', lambda attr, old, new: self.init_dataframes())
self.select_data_files2.on_change(
'value', lambda attr, old, new: self.init_dataframes())
self.refresh_button = Button(label="Refresh",
button_type="success",
width=100)
self.refresh_button.on_click(self.update_directory)
self.layout = column(
self.tabs, row(self.select_data_files1, self.select_data_files2),
self.refresh_button)
curdoc().add_root(self.layout)
# show(self.layout)
def change_page(self):
if (self.select_data_files1.value == "df1"
or self.select_data_files2.value == "df2"):
self.tabs.active = 0
return
if (self.tabs.active == 0):
self.layout.children = [
self.tabs,
row(self.select_data_files1, self.select_data_files2),
self.refresh_button, self.slider_depth, self.plot_matrix
]
elif (self.tabs.active == 1):
self.layout.children = [
self.tabs,
# self.sel_well,self.pred_button,
self.plots_rock,
row(column(self.select_df1_corr, self.checkbox_df1),
column(self.select_df2_corr, self.checkbox_df2)),
self.plot_correlation
]
def init_dataframes(self):
if (self.select_data_files1.value == "df1"
or self.select_data_files2.value == "df2"):
return
if (not self.select_data_files1.value.endswith('.csv')
or not self.select_data_files2.value.endswith('.csv')):
print("incorrect data, expected format csv")
return
self.Y_COL = 'Depth'
self.main_df1, self.main_df2 = self.read_dataframe()
# self.change
self.df1 = self.main_df1.copy()
self.df2 = self.main_df2.copy()
self.slider_depth = RangeSlider(
start=self.min_total_depth(self.main_df1, self.main_df2),
# изменить реализацию мин и мах
end=self.max_total_depth(self.main_df1, self.main_df2),
step=1,
value=(self.min_total_depth(self.main_df1, self.main_df2),
self.max_total_depth(self.main_df1, self.main_df2)))
self.slider_depth.on_change('value', self.change_depth)
self.update_page()
def update_page(self):
print("1")
self.columns_df1 = [
col for col in self.df1.columns if self.is_number(col, self.df1)
]
self.columns_df2 = [
col for col in self.df2.columns if self.is_number(col, self.df2)
]
# self.select_plots = [-1 for i in range(len(self.columns_df1) + len(self.columns_df1))]
self.select_plots = []
print("2")
# wells = self.df1['Well Name'].unique().tolist()
# wells = [well for well in wells if well not in ['Recruit F9']]
# self.sel_well = Select(title="Well name:", value=wells[0], options=wells)
# self.pred_button = Button(label="Predict", button_type="success", width=100)
# self.pred_button.on_click(self.update_predict)
# self.plots_rock = self.init_plots_rock()
self.plots_rock = column()
self.source_correlation_plot = None
self.plot_correlation = self.init_corr()
self.select_df1_corr = Select(title="Data frame 1:",
value=self.columns_df1[0],
options=self.columns_df1)
self.select_df2_corr = Select(title="Data frame 2:",
value=self.columns_df2[1],
options=self.columns_df2)
self.select_df1_corr.on_change(
'value', lambda attr, old, new: self.update_set_data())
self.select_df2_corr.on_change(
'value', lambda attr, old, new: self.update_set_data())
self.checkbox_df1 = CheckboxGroup(labels=["log10"], active=[])
self.checkbox_df2 = CheckboxGroup(labels=["log10"], active=[])
self.checkbox_df1.on_change(
'active', lambda attr, old, new: self.update_set_data())
self.checkbox_df2.on_change(
'active', lambda attr, old, new: self.update_set_data())
print("3")
data_matrix = self.init_data_matrix(self.df1, self.df2)
self.plot_matrix = self.draw_matrix(data_matrix)
self.plot_matrix.on_event(Tap, self.update_plots)
print("4")
self.layout.children = [
self.tabs,
row(self.select_data_files1, self.select_data_files2),
self.refresh_button, self.slider_depth, self.plot_matrix
]
print("5")
def change_depth(self, attr, old, new):
self.df1 = self.df1[
(self.df1[self.Y_COL] >= self.slider_depth.value[0])
& (self.df1[self.Y_COL] <= self.slider_depth.value[1])]
self.df2 = self.df2[
(self.df2[self.Y_COL] >= self.slider_depth.value[0])
& (self.df2[self.Y_COL] <= self.slider_depth.value[1])]
self.update_page()
def min_total_depth(self, df1, df2):
return max(df1[self.Y_COL].min(), df2[self.Y_COL].min())
def max_total_depth(self, df1, df2):
return min(df1[self.Y_COL].max(), df2[self.Y_COL].max())
def change_case_depth(self, df1, df2):
ret_code = self.rename_depth(df1)
# Обработать код возврата
ret_code = self.rename_depth(df2)
# if df1[self.Y_COL][1] - df1[self.Y_COL][0] > df2[self.Y_COL][1] - df2[self.Y_COL][0]:
if (df1[self.Y_COL].size < df2[self.Y_COL].size):
df2.set_index([self.Y_COL], inplace=True)
df2 = df2.reindex(df1[self.Y_COL], method='nearest')
column_values = pd.Series(df2.index, index=df2.index)
df2.insert(loc=0, column=self.Y_COL, value=column_values)
df2.set_index(df1.index, inplace=True)
else:
df1.set_index([self.Y_COL], inplace=True)
df1 = df1.reindex(df2[self.Y_COL], method='nearest')
column_values = pd.Series(df1.index, index=df1.index)
df1.insert(loc=0, column=self.Y_COL, value=column_values)
df1.set_index(df2.index, inplace=True)
return df1, df2
def rename_depth(self, df):
is_renamed_df = False
dept = "Dept"
unnamed = "Unnamed: 0"
exist = 0
not_exist = 1
for col in df.columns:
if (col.lower() == self.Y_COL.lower()
or col.lower() == dept.lower()):
df.rename(columns={col: self.Y_COL}, inplace=True)
is_renamed_df = True
if (not is_renamed_df):
if (df.index.name == None and df.columns[0] == unnamed):
df.rename(columns={unnamed: self.Y_COL}, inplace=True)
return not_exist
elif (df.index.name != None
and df.index.name.lower().find(dept.lower()) != -1):
column_values = pd.Series(df.index, index=df.index)
df.insert(loc=0, column=self.Y_COL, value=column_values)
return not_exist
elif ((df.columns)[0] != unnamed
and df.columns[0].lower().find(dept.lower()) != -1):
df.rename(columns={unnamed: self.Y_COL}, inplace=True)
return not_exist
else:
column_values = pd.Series(df.index, index=df.index)
df.insert(loc=0, column=self.Y_COL, value=column_values)
return not_exist
return exist
''' if(df1)
df_gis = pd.read_csv('gis.csv')
df_gis = df_gis.astype(np.float32)
df_git = pd.read_csv('git.csv')
df_git = df_git.rename(columns={'0':'DEPT'})
df_gis = df_gis.set_index(['DEPT'])
df_gis.reindex(df_git['DEPT'], method='nearest')'''
def is_number(self, col, df):
if type(df[col][df[col].index[0]]).__name__ == "int64" or type(
df[col][df[col].index[0]]).__name__ == "float64":
return True
return False
def update_directory(self):
self.data_directory = 'data'
self.data_files = os.listdir(self.data_directory)
self.select_data_files1 = Select(title="Data files 1:",
value="df1",
options=["df1"] + self.data_files)
self.select_data_files2 = Select(title="Data files 2:",
value="df2",
options=["df2"] + self.data_files)
self.layout.children[1] = row(self.select_data_files1,
self.select_data_files2)
def init_corr(self):
plot_correlation = figure(plot_width=800,
plot_height=500,
title='correlation graph')
data = pd.DataFrame(data={
'x': self.df1[self.columns_df1[0]],
'y': self.df2[self.columns_df2[1]]
})
self.source_correlation_plot = ColumnDataSource(data)
plot_correlation.scatter(x='x',
y='y',
source=self.source_correlation_plot,
line_color='red',
size=2)
return plot_correlation
def toFixed(self, numObj, digits=0):
return f"{numObj:.{digits}f}"
def get_y_range(self, df):
ymin = df[self.Y_COL].min()
ymax = df[self.Y_COL].max()
res = Range1d(ymin, ymax)
return res
def update_plots(self, event):
length_columns_df1 = len(self.columns_df1)
length_columns_df2 = len(self.columns_df2)
x = int((event.x) / self.WIDTH_MATRIX)
y = int((event.y) / self.HEIGHT_MATRIX)
if (self.select_plots.count(
((1, self.columns_df1[x]),
(2, self.columns_df2[length_columns_df2 - y - 1]))) == 1):
self.select_plots.remove(
((1, self.columns_df1[x]),
(2, self.columns_df2[length_columns_df2 - y - 1])))
self.delete_select_cell(
name=self.columns_df1[x] +
self.columns_df2[length_columns_df2 - y - 1])
elif (event.x < 0 or event.x > length_columns_df1 or event.y < 0
or event.y > length_columns_df2):
return
else:
self.draw_select_cell(name=self.columns_df1[x] +
self.columns_df2[length_columns_df2 - y - 1],
x=x + 0.5,
y=y + 0.5,
width=1,
height=1)
self.select_plots.append(
((1, self.columns_df1[x]),
(2, self.columns_df2[length_columns_df2 - y - 1])))
self.plots_rock.children = [
self.draw_plot_rock(self.df1, self.df2, self.select_plots)
]
def draw_select_cell(self, name, x, y, height, width):
self.plot_matrix.rect(x=x,
y=y,
width=width,
height=height,
fill_alpha=0,
line_color="blue",
name=name)
def delete_select_cell(self, name):
self.plot_matrix.select(name=name).visible = False
def update_set_data(self):
r = self.df1[self.select_df1_corr.value]
col = self.df2[self.select_df2_corr.value]
if (self.checkbox_df2.active == [0]):
col = col.apply(numpy.log10)
if (self.checkbox_df1.active == [0]):
r = r.apply(numpy.log10)
data = {'x': r, 'y': col}
self.source_correlation_plot.data = data
def update_predict(self):
return
def draw_plot_rock(self, df1, df2, select_plots):
list_plots = []
source_df1 = ColumnDataSource(data=df1)
source_df2 = ColumnDataSource(data=df2)
yrange = self.get_y_range(df1)
for pair_data in self.select_plots:
list_plots.append(
self.init_plot_rock(pair_data[0][1], pair_data[0][1],
self.Y_COL, source_df1, yrange, '#0000ff'))
list_plots.append(
self.init_plot_rock(pair_data[1][1], pair_data[1][1],
self.Y_COL, source_df2, yrange, '#008000'))
return row(list_plots)
def init_plot_rock(self, title, x, y, source, yrange, color_title):
plot = figure(plot_width=200,
plot_height=400,
title=title,
toolbar_location=None,
tools='ywheel_zoom',
active_scroll='ywheel_zoom')
plot.line(x, y, source=source, line_width=2)
plot.y_range = yrange
plot.title.text_color = color_title
return plot
def init_data_matrix(self, df1, df2):
matrix = {col: [] for col in self.columns_df1}
for r in self.columns_df1:
for col in self.columns_df2:
matrix[r].append(
float(
self.toFixed(
numpy.corrcoef(df1[r], df2[col])[0, 1], 3)))
data = pd.DataFrame(data=matrix)
data.index = list(self.columns_df2)
data.index.name = 'rows'
data.columns.name = 'columns'
return data
def draw_matrix(self, data):
df = pd.DataFrame(data.stack(), columns=['rate']).reset_index()
source = ColumnDataSource(df)
colors = [
"#75968f", "#a5bab7", "#c9d9d3", "#e2e2e2", "#dfccce", "#ddb7b1",
"#cc7878", "#933b41", "#550b1d"
]
mapper = LinearColorMapper(palette=colors,
low=df.rate.min(),
high=df.rate.max())
plot_matrix = figure(plot_width=800,
plot_height=300,
title="",
x_range=list(self.columns_df2),
y_range=list(reversed(self.columns_df1)),
toolbar_location=None,
tools="",
x_axis_location="above")
plot_matrix.rect(x="rows",
y="columns",
width=self.WIDTH_MATRIX,
height=self.HEIGHT_MATRIX,
source=source,
line_color=None,
fill_color=transform('rate', mapper))
plot_matrix.xaxis.major_label_text_color = '#0000ff' # blue
plot_matrix.yaxis.major_label_text_color = '#008000' # green
self.r = plot_matrix.text(x=dodge("rows",
-0.1,
range=plot_matrix.x_range),
y=dodge("columns",
-0.2,
range=plot_matrix.y_range),
text="rate",
**{"source": df})
self.r.glyph.text_font_size = "9pt"
plot_matrix.axis.axis_line_color = None
plot_matrix.axis.major_tick_line_color = None
return plot_matrix
def read_dataframe(self):
df1 = pd.read_csv('data/' + self.select_data_files1.value)
df2 = pd.read_csv('data/' + self.select_data_files2.value)
df1, df2 = self.change_case_depth(df1, df2)
min = self.min_total_depth(df1, df2)
max = self.max_total_depth(df1, df2)
print("@@@")
df1 = df1[(df1[self.Y_COL] >= min) & (df1[self.Y_COL] <= max)]
df2 = df2[(df2[self.Y_COL] >= min) & (df2[self.Y_COL] <= max)]
print("######")
return (df1, df2)
#new_data = pd.DataFrame({'x':xs,'y':ys,'color':(Category10[3])[0:len(xs)]})
new_source = ColumnDataSource(data=dict(
x=xs,
y=ys,
color=(Category10[3])[0:len(xs)],
group=['Gold Standard', 'Forecast In Sample', 'Forecast OOS']))
source.data = new_source.data
# p_ts.source = new_source
new_text = 'In and Out of Sample fit <br>Gold Standard :' + \
old_to_new_regions[gs_name[:-3]] + ' - Predictor Set: ' + \
old_to_new_sources[source_set] + '<br>' + \
'In Sample R<sup>2</sup>: ' + np.str(np.round(r_squared_in_sample,2)) + \
' - ' + 'Out of Sample R<sup>2</sup>: ' + np.str(np.round(r_squared_OOS,2))
div.text = new_text
source_set_button_plot.on_change('active', plot_callback)
regions_button_plt.on_change('active', plot_callback)
# To run from Spyder (radio buttons won't work)
# output_file('foo.html')
# show(column(regions_button_plt,source_set_button_plot,div,p_ts),browser="chrome")
# To run from command (in the folder of the file) using the command
# bokeh serve --show visu_ts.py
curdoc().add_root(column(regions_button_plt, source_set_button_plot, div,
p_ts))
curdoc().title = "Venezuela Situational Awareness"
def load_page(experiment_df, experiment_db):
########## bokeh plots ##########
# general plot tools
plot_tools = 'wheel_zoom, pan, reset, save, hover'
hover = HoverTool(tooltips=[("(x,y)", "($x, $y)")])
# progress curve plots
global raw_source
raw_source = ColumnDataSource(data=dict(x=[], y=[], yr=[], yfit=[]))
global raw
raw = figure(title="Initial Rate Fit",
x_axis_label="Time",
y_axis_label="Signal",
plot_width=350,
plot_height=300,
tools=plot_tools)
raw.circle('x',
'y',
size=2,
source=raw_source,
color='gray',
selection_color="black",
alpha=0.6,
nonselection_alpha=0.2,
selection_alpha=0.6)
raw.line('x', 'yfit', source=raw_source, color='red')
global warning_source
warning_source = ColumnDataSource(data=dict(
x=[0],
y=[0],
t=[
'Please enter transform equation! \nMust convert signal to [substrate] \nin Schnell-Mendoza mode (e.g. via \nx/6.22/0.45/0.001 for sample data). \nNote: this transform may need \nto be inverted through multiplying \nby -1 when analyzing experiments \nthat measure increasing product \nconcentration over time)'
]))
global warning
warning = raw.text(x='x',
y='y',
text='t',
text_font_size='12pt',
angle=0,
source=warning_source)
warning.visible = False
global circles_source
circles_source = ColumnDataSource(
data=dict(x=[-.05, -.05, 1.6, 1.6], y=[0, 0.6, 0, 0.6]))
global circles
circles = raw.circle(x='x', y='y', alpha=0., source=circles_source)
circles.visible = False
global resi
resi = figure(title="Initial Rate Fit Residuals",
x_axis_label="Time",
y_axis_label="Residual",
plot_width=700,
plot_height=200,
tools='wheel_zoom,pan,reset')
resi.yaxis.formatter = BasicTickFormatter(precision=2, use_scientific=True)
resi.circle('x', 'yr', size=5, source=raw_source, color='grey', alpha=0.6)
# model plot for titration experiments
global model_data_source
model_data_source = ColumnDataSource(
data=dict(xt=[], yt=[], n=[], ct=[], et=[]))
global model_plot_source
model_plot_source = ColumnDataSource(
data=dict(xp=[], yp=[], l=[], u=[], cp=[], ep=[]))
global model_fit_source
model_fit_source = ColumnDataSource(data=dict(x=[], y=[]))
global varea_source
varea_source = ColumnDataSource(data=dict(x=[], r1=[], r2=[]))
global model
model = figure(title='Model Fit',
x_axis_label='Concentration',
y_axis_label='Rate',
plot_width=350,
plot_height=300,
tools=plot_tools)
model.circle('xp',
'yp',
size=8,
source=model_plot_source,
color='cp',
alpha=0.6)
model.add_layout(
Whisker(source=model_plot_source, base='xp', upper='u', lower='l'))
model.line('x',
'y',
source=model_fit_source,
line_width=3,
color='black',
alpha=0.8)
model.varea('x', 'r1', 'r2', source=varea_source, color='grey', alpha=0.3)
########## bokeh widgets ##########
# button for selecting progress curve fitting routine
global fit_button
fit_button = RadioButtonGroup(labels=[
'Maximize Slope Magnitude', 'Linear Fit', 'Logarithmic Fit',
'Schnell-Mendoza'
],
active=0,
width=375)
fit_button.on_change('active', widget_callback)
# button for selecting progress curve fitting routine
global scalex_box
scalex_box = CheckboxButtonGroup(
labels=["transform x-axis to Log10 scale"], active=[])
scalex_box.on_change('active', widget_callback)
# dropdown menu for selecting titration experiment model
global model_select
model_select = Select(
title='Choose Model',
value='Michaelis-Menten',
options=['Michaelis-Menten', 'pEC50/pIC50', 'High-Throughput Screen'],
width=350)
model_select.on_change('value', widget_callback)
# dropdown menu for selecting blank sample to subtract from remaining titration samples
global subtract_select
subtract_select = Select(title='Select Blank Sample for Subtraction',
value='',
options=list(experiment_df)[1:] + [''],
width=350)
subtract_select.on_change('value', widget_callback)
# dropdown menu for selecting titration sample to plot in current view
global sample_select
sample_select = Select(title='Y Axis Sample',
value=list(experiment_df)[-1],
options=list(experiment_df)[1:],
width=350)
sample_select.on_change('value', sample_callback)
# text input box for transforming slopes to rates
global transform_input
transform_input = TextInput(value='',
title="Enter Transform Equation",
width=350)
transform_input.on_change('value', widget_callback)
# text input box for setting delay time in logarithmic progress curve fitting
global offset_input
offset_input = TextInput(value='',
title="Enter Time Between Mixing and First Read",
width=350)
offset_input.on_change('value', widget_callback)
# text input boxes for fixing EC/IC50 parameters
global bottom_fix
bottom_fix = TextInput(value='', title="Fix pIC50/pEC50 Bottom")
bottom_fix.on_change('value', widget_callback)
global top_fix
top_fix = TextInput(value='', title="Fix pIC50/pEC50 Top")
top_fix.on_change('value', widget_callback)
global slope_fix
slope_fix = TextInput(value='', title="Fix pIC50/pEC50 Hill Slope")
slope_fix.on_change('value', widget_callback)
# text input boxes for progress curve xrange selection
global start_time
start_time = TextInput(value=str(
experiment_df[list(experiment_df)[0]].values[0]),
title="Enter Start Time")
global end_time
end_time = TextInput(value=str(
experiment_df[list(experiment_df)[0]].values[-1]),
title='Enter End Time')
start_time.on_change('value', xbox_callback)
end_time.on_change('value', xbox_callback)
# range slider to select threshold for hit detection in HTS mode
global threshold_slider
threshold_slider = Slider(start=0,
end=5,
value=2,
step=0.1,
title='HTS Hit Threshold (Standard Deviation)',
width=350)
threshold_slider.on_change('value', threshold_callback)
# range slider to update plots according to progress cuve xrange selection
xmin = experiment_df[experiment_df.columns[0]].values[0]
xmax = experiment_df[experiment_df.columns[0]].values[-1]
global range_slider
range_slider = RangeSlider(
start=xmin,
end=xmax,
value=(xmin, xmax),
step=experiment_df[experiment_df.columns[0]].values[1] - xmin,
title='Fine Tune X-Axis Range',
width=650)
range_slider.on_change('value', slider_callback)
# button to upload local data file
global file_source
file_source = ColumnDataSource(data=dict(file_contents=[], file_name=[]))
file_source.on_change('data', file_callback)
try:
output_filename = file_source.data['file_name'] + '-out.csv'
except:
output_filename = 'output.csv'
global upload_button
upload_button = Button(label="Upload Local File",
button_type="success",
width=350)
upload_button.callback = CustomJS(args=dict(file_source=file_source),
code=open(
join(dirname(__file__),
"upload.js")).read())
# table containing rate fits and errors
template = """
<div style="background:<%=ct%>"; color="white";>
<%= value %></div>
"""
formatter = HTMLTemplateFormatter(template=template)
columns = [
TableColumn(field='n', title='Sample'),
TableColumn(field='yt',
title='Slope (Initial Rate)',
formatter=formatter),
TableColumn(field='et', title='Std. Error')
]
global rate_table
rate_table = DataTable(source=model_data_source,
columns=columns,
width=350,
height=250,
selectable=True,
editable=True)
# tables containing model fits and errors
global mm_source
mm_source = ColumnDataSource(dict(label=[], Km=[], Vmax=[]))
columns = [
TableColumn(field='label', title=''),
TableColumn(field='Vmax', title='Vmax'),
TableColumn(field='Km', title='Km')
]
global mm_table
mm_table = DataTable(source=mm_source,
columns=columns,
width=350,
height=75,
selectable=True,
editable=True)
global ic_source
ic_source = ColumnDataSource(
dict(label=[], Bottom=[], Top=[], Slope=[], p50=[]))
columns = [
TableColumn(field='label', title=''),
TableColumn(field='Bottom', title='Bottom'),
TableColumn(field='Top', title='Top'),
TableColumn(field='Slope', title='Slope'),
TableColumn(field='p50', title='pEC/IC50')
]
global ic_table
ic_table = DataTable(source=ic_source,
columns=columns,
width=350,
height=75,
selectable=True,
editable=True)
# button for copying rate data table to clipboard
global copy_button
copy_button = Button(label="Copy Table to Clipboard",
button_type="primary",
width=350)
copy_button.callback = CustomJS(args=dict(source=model_data_source),
code=open(
join(dirname(__file__),
"copy.js")).read())
# button for downloading rate data table to local csv file
global download_button
download_button = Button(label="Download Table to CSV",
button_type="primary",
width=350)
download_button.callback = CustomJS(args=dict(source=model_data_source,
file_name=output_filename),
code=open(
join(dirname(__file__),
"download.js")).read())
########## document formatting #########
desc = Div(text=open(join(dirname(__file__), "description.html")).read(),
width=1400)
advanced = Div(
text="""<strong>Advanced Settings for \npEC/IC50 Analysis</strong>""")
widgets = widgetbox(model_select, sample_select, subtract_select,
transform_input, offset_input, advanced, scalex_box,
bottom_fix, top_fix, slope_fix)
table = widgetbox(rate_table)
main_row = row(
column(upload_button, widgets),
column(fit_button, row(raw, model), resi, row(start_time, end_time),
range_slider),
column(download_button, copy_button, table, mm_table, ic_table,
threshold_slider))
sizing_mode = 'scale_width'
l = layout([[desc], [main_row]], sizing_mode=sizing_mode)
update()
curdoc().clear()
curdoc().add_root(l)
curdoc().title = "ICEKAT"
# Update function
def score_type_callback(attr, old, new):
# Get new selected value
#new_score = score_types[new.active]
new_score = score_types[score_type_button.active]
new_source = data_sources[sources_button.active]
new_key = new_score + '|' + new_source
geosource_new = all_data[new_key]
geosource.geojson = geosource_new.geojson
#div.text = new_score # For testing only
score_type_button.on_change('active', score_type_callback)
sources_button.on_change('active', score_type_callback)
#Display figure.
set_stype(p)
# In Notebook (without callbacks)
#output_notebook()
#show(p)
# In Spyder (without callbacks)
# output_file('foo.html')
# show(column(widgetbox(score_type_button),p),browser="chrome")
# To run from command (in the folder of the file) using the command
# bokeh serve --show situ_map.py
button_value = radio_button_group.active
print('Button value is : ', button_value)
if button_value == 0:
won_source = new_source[new_source['Result'] == 'won']
new_won_cds = ColumnDataSource(won_source)
total_cds.data = new_won_cds.data
if button_value == 1:
lost_source = new_source[new_source['Result'] == 'lost']
new_lost_cds = ColumnDataSource(lost_source)
total_cds.data = new_lost_cds.data
if button_value == 2:
tied_source = new_source[new_source['Result'] == 'tied']
new_tied_cds = ColumnDataSource(tied_source)
total_cds.data = new_tied_cds.data
fig.title.text = 'Total Matches Played Aganist Opposition for Year %d' % yr
fig.x_range.factors = []
fig.x_range.factors = list(new_source['Opposition'].unique())
radio_button_group.on_change('active',
lambda attr, old, new: update(attr, old, new))
slider.on_change('value', update)
# Make a row layout of widgetbox(slider) and plot and add it to the current document
layout = row(column(widgetbox(slider), widgetbox(radio_button_group)), fig)
curdoc().add_root(layout)
''' ran change from original '''
def open_local_file(attr,old,new):
labels.text = ["chosen file is : " + tkFileDialog.askopenfilename()]
print labels.text
def open_local_file_long(attr,old,new):
import wx
import os
app = wx.PySimpleApp()
wildcard = "Python source (*.py)|*.py|" \
"Compiled Python (*.pyc)|*.pyc|" \
"All files (*.*)|*.*"
dialog = wx.FileDialog(None, "Choose a file", os.getcwd(), "", wildcard, wx.OPEN)
if dialog.ShowModal() == wx.ID_OK:
print dialog.GetPath()
dialog.Destroy()
#create select widget
options=["average_grades","exam_grades","student_names"]
radio_button_group=RadioButtonGroup(labels=options)
# radio_button_group.on_change("active",update_labels)
radio_button_group.on_change("active",open_local_file)
#create layout and add to curdoc
lay_out=layout([[radio_button_group]])
curdoc().add_root(f)
curdoc().add_root(lay_out)
