def property_info(): df_group_tax = pd.read_csv('data/tax_df.csv') if request.method == 'GET': tax_asr_name = request.args.get("tax_asr_name") if tax_asr_name is None: tax_asr_name = tax_assessor_list[0] # select = Select(title='property assessment attribute', value='assessed_value_total', options=tax_assessor_list, width =500) div = Div(text="<iframe src=" r'html/itax_map.html' " style='min-width:calc(100vw - 26px); height: 500px'><iframe>", width=500) plot_variable = tax_asr_name tax_attr_m = create_hex_map(df_group_tax, plot_variable) div.text = tax_attr_m._repr_html_() tax_asr_script, tax_asr_div = components(div) return render_template('tax_asr.html', script=tax_asr_script, div=tax_asr_div, tax_asr_name=tax_asr_name, tax_asr_attributes=tax_assessor_list)
def _get_title_div(self, key, default_fontsize='15pt', width=450): title_div = None title = self._format_title(key) if self.show_title else '' if not title: return title_div title_json = theme_attr_json(self.renderer.theme, 'Title') color = title_json.get('text_color', None) font = title_json.get('text_font', 'Arial') fontstyle = title_json.get('text_font_style', 'bold') fontsize = self._fontsize('title').get('fontsize', default_fontsize) if fontsize == default_fontsize: # if default fontsize = title_json.get('text_font_size', default_fontsize) if 'em' in fontsize: # it's smaller than it shosuld be so add 0.25 fontsize = str(float(fontsize[:-2]) + 0.25) + 'em' title_tags = self._title_template.format(color=color, font=font, fontstyle=fontstyle, fontsize=fontsize, title=title) if 'title' in self.handles: title_div = self.handles['title'] else: title_div = Div(width=width) # so it won't wrap long titles easily title_div.text = title_tags return title_div
def _get_title_div(self, key, default_fontsize='15pt', width=450): title_div = None title = self._format_title(key) if self.show_title else '' if not title: return title_div title_json = theme_attr_json(self.renderer.theme, 'Title') color = title_json.get('text_color', None) font = title_json.get('text_font', 'Arial') fontstyle = title_json.get('text_font_style', 'bold') fontsize = self._fontsize('title').get('fontsize', default_fontsize) if fontsize == default_fontsize: # if default fontsize = title_json.get('text_font_size', default_fontsize) if 'em' in fontsize: # it's smaller than it shosuld be so add 0.25 fontsize = str(float(fontsize[:-2]) + 0.25) + 'em' title_tags = self._title_template.format( color=color, font=font, fontstyle=fontstyle, fontsize=fontsize, title=title) if 'title' in self.handles: title_div = self.handles['title'] else: title_div = Div(width=width, style={"white-space": "nowrap"}) # so it won't wrap long titles easily title_div.text = title_tags return title_div
def demographics(): df_demo_join_cherre = pd.read_csv('data/demo_data.csv') df_demo_join_cherre['zip'] = df_demo_join_cherre['zip'].astype(str) if request.method == 'GET': demo_name = request.args.get("demo_name") if demo_name is None: demo_name = demo_menu_list[0] # select = Select(title='Demographic attribute', value='median_employee_salary', options=menu_list, width =500) div = Div(text="<iframe src=" r'html/imap.html' " style='min-width:calc(100vw - 26px); height: 500px'><iframe>", width=500) attribute = demo_name demog_m = create_map(df_demo_join_cherre, 'zip', attribute, 'per Zipcode') div.text = demog_m._repr_html_() demo_script, demo_div = components(div) return render_template('demographics.html', script=demo_script, div=demo_div, demo_name=demo_name, demo_attributes=demo_menu_list)
def main(images_folder: str, data_json_file: str, img_ref: Optional[str], out: str): """Project data point into interactive scatter plot Arguments: images_folder {str} -- Path of the images directory data_json_file {str} -- Path of the corresponding json file img_ref {Optional[str]} -- Path of the image version of the projection (see create_image_projection.py script) out {str} -- Output html file """ print( colored(figlet_format("Scatter plot projection", font="standard"), "cyan")) assert out[-5:] == ".html", "Please give a html output file" images_folder = str(Path(images_folder).resolve()) with open(data_json_file, "r") as json_file: points_projection = json.load(json_file) points = np.zeros((len(points_projection), 2)) for i, point_properties in enumerate(points_projection): points[i] = [ float(point_properties["x"]), float(point_properties["y"]) ] domain_min, domain_max = np.min(points[:, 1]), np.max(points[:, 1]) domain = domain_max - domain_min s1 = ColumnDataSource( data=dict(x=points[:, 0], y=abs(points[:, 1] - domain))) p1 = figure(tools=TOOLS, plot_width=1280) p1.circle("x", "y", source=s1, size=10) div = Div(width=400, height=p1.plot_height) layout = row(p1, div) ### callback = display_event( div, root_image=images_folder, source=points_projection, block_height=p1.plot_height, ) s1.selected.js_on_change("indices", callback) ### if img_ref: div_img_ref = Div(width=1280) div_img_ref.text = f"<img style='width:1280px' src='{img_ref}' / >" layout = column(layout, div_img_ref) output_file(out, title="scatter projection") show(layout)
def _get_title(self, key): title_div = None title = self._format_title(key) if self.show_title else '' if title: fontsize = self._fontsize('title') title_tags = self._title_template.format(title=title, **fontsize) if 'title' in self.handles: title_div = self.handles['title'] else: title_div = Div() title_div.text = title_tags return title_div
def places_of_interest(): df = pd.read_csv('data/poi_data_NY.csv') if request.method == 'GET': place_type_name = request.args.get("poi_type_name", 'RETAIL') if request.args.get("poi_rad") == None: place_radius = 2.0 else: place_radius = float(request.args.get("poi_rad").strip()) if request.args.get("center_lat") == None: center_latitude = 40.753912 else: center_latitude = float( request.args.get("center_lat", 40.753912).strip()) if request.args.get("center_long") == None: center_longitude = -73.981205 else: center_longitude = float( request.args.get("center_long", -73.981205).strip()) # select = Select(title="Type of rental space", value="RETAIL", options=poi_options_list) # radius = TextInput(title="Radius of places to check in km", value="5.0") # center_latitude = TextInput(title="Enter the latitude as float", value="40.753912") # center_longitude = TextInput(title="Enter the longitude as float", value="-73.981205") div = Div(text="<iframe src=" r'html/i_poi_map.html' " style='min-width:calc(100vw - 26px); height: 500px'><iframe>", width=500) # place_type = select.value # place_radius=float(radius.value) # c_lat=float(center_latitude.value) # c_long=float(center_longitude.value) poi_map = select_df_and_map(df, place_type_name, place_radius, center_latitude, center_longitude) div.text = poi_map._repr_html_() poi_script, poi_div = components(div) return render_template('poi.html', script=poi_script, div=poi_div, poi_type_name=place_type_name, poi_rad=place_radius, center_lat=center_latitude, center_long=center_longitude, place_type_list=poi_list)
def generate_color_description_component() -> column: """ 色の説明書きのコンポーネントを作成する :return: """ div = Div(width=200, height=8, style={'color': '#545454'}) left_div = Div(width=120, height=55, style={'color': '#545454'}) right_div = Div(width=120, height=55, style={'color': '#545454'}) div.text = 'Color means the status of PEPs.' left_div.text = """<img src="image/draft_icon.png"> Draft<br> <img src="image/provisional_icon.png"> Provisional<br> <img src="image/accepted_icon.png"> Accepted<br> <img src="image/final_icon.png"> Final<br> <img src="image/active_icon.png"> Active<br><br> """ right_div.text = """<img src="image/deffered_icon.png"> Deferred<br> <img src="image/withdrawned_icon.png"> Withdrawn<br> <img src="image/rejected_icon.png"> Rejected<br> <img src="image/superseded_icon.png"> Superseded<br><br> """ component = column(div, row(left_div, right_div)) return component
# Unicode options for Anaconda python conn.setencoding("utf-8") conn.setdecoding(pyodbc.SQL_CHAR, encoding='utf-32le') conn.setdecoding(pyodbc.SQL_WMETADATA, encoding='utf-32le') # Unicode options for python (not anaconda) #conn.setdecoding(pyodbc.SQL_CHAR, encoding='utf-32le', to=str) #conn.setdecoding(pyodbc.SQL_WMETADATA, encoding='utf-32le', to=str) cursor = conn.cursor() sql = "SELECT _id, name, address, email, phone_number, latitude, longitude, first_visit, churn_risk, sentiment " \ "FROM `dfs.default`.`./apps/crm` limit 10000" logger.debug("executing SQL: " + sql) customer_directory_df = pd.read_sql(sql, conn) logger.debug("records returned: " + str(len(customer_directory_df.index))) query_performance.text = "<div class=\"small\">" + str( len(customer_directory_df.index)) + " rows selected</div>" text_input = TextInput(title="Search String:", value='') filter_options = ['name', 'phone_number', 'email'] filterby = Select(title="Search Field:", width=100, value="name", options=filter_options) sort_options = ['name', 'phone_number', 'email', 'first_visit'] sortby = Select(title="Order By:", width=100, value="name", options=sort_options) controls = [text_input, filterby, sortby] for control in controls:
def stream_news(): plot_symbol = '^GSPC' database = CassandraStorage(plot_symbol) database.session.row_factory = pandas_factory database.session.default_fetch_size = None def make_dataset(date='2019-08-01'): query = "SELECT * FROM NEWS WHERE DATE>='{}' ALLOW FILTERING;".format( date) rslt = database.session.execute(query, timeout=None) df = rslt._current_rows df.publishedat = pd.DatetimeIndex( pd.to_datetime(df.publishedat, unit='ms')).tz_localize( 'GMT').tz_convert('US/Pacific').to_pydatetime() df = df.sort_values('publishedat').tail(4) df.description = df.description.str.replace('@@', "'") df.title = df.title.str.replace('@@', "'") return df def make_text(source): text="""<b><p style="color:blue;">News: </p></b> <b>{}</b><br> {}<br> <i>Source: {} Published At: {} </i><br> <br> <br> <b>{}</b><br> {}<br> <i>Source: {} Published At: {} </i><br> <br> <br> <b>{}</b><br> {}<br> <i>Source: {} Published At: {} </i><br> <br> <br> <b>{}</b><br> {}<br> <i>Source: {} Published At: {} </i><br> <br> <br> """.format(source.data['title'][-1], \ source.data['description'][-1], \ source.data['source'][-1], \ str(pd.to_datetime(source.data['publishedat'][-1])), \ source.data['title'][-2], \ source.data['description'][-2], \ source.data['source'][-2], \ str(pd.to_datetime(source.data['publishedat'][-2])), source.data['title'][-3], \ source.data['description'][-3], \ source.data['source'][3], \ str(pd.to_datetime(source.data['publishedat'][-3])), source.data['title'][-4], \ source.data['description'][-4], \ source.data['source'][-4], \ str(pd.to_datetime(source.data['publishedat'][-4]))) return text df = make_dataset(date='2019-08-01') source = ColumnDataSource(data=df.to_dict('list')) div = Div(text="", width=600) div.text = make_text(source) def update(): df = make_dataset(date='2019-08-01') source.stream(df.to_dict('list')) #print(str(source.data['title'])) #print() return div, update
def make_figures(scan): ub_matrix = ft.UBMatrix(scan['latparam'], scan['hkl1'], scan['hkl2'], scan['plot_x'], scan['plot_y']) A3_starts, A3_ends, A4_starts, A4_ends = (scan['A3_starts'], scan['A3_ends'], scan['A4_starts'], scan['A4_ends']) NPs = [int(x) for x in scan['NPs']] kis = [ft.e_to_k(e) for e in scan['eis']] kfs = [ft.e_to_k(e) for e in ft.EF_LIST] hm = scan['hm'] hm_hkl = scan['hm_hkl'] hm_ssr = scan['hm_ssr'] unique_kis = sorted(list(set(kis))) indexes_of_ki = [[ind for ind in range(len(kis)) if kis[ind] == ki] for ki in unique_kis] locus_palette = ['#FFCE98', '#F6FF8D', '#94FFD5', '#909CFF', '#FF8AD8'] locuses_dict = {} scatters_dict = {} colors_dict = {} senses_dict = {} for nth_ki, ki in enumerate(unique_kis): clippers = [Pyclipper() for _ in range(ft.EF_CHANNELS)] scatter_arrays = [[] for _ in range(ft.EF_CHANNELS)] color_arrays = [[] for _ in range(ft.EF_CHANNELS)] for scan_no in indexes_of_ki[nth_ki]: angles = (A3_starts[scan_no], A3_ends[scan_no], A4_starts[scan_no], A4_ends[scan_no], ub_matrix) locuses = [ ft.calculate_locus(ki, kf, *angles, no_points=NPs[scan_no]) for kf in kfs ] scatter_coords = [ ft.scatter_coords(ki, kf, *angles, no_points=NPs[scan_no]) for kf in kfs ] scatter_colors = [ ft.scatter_color(ki, kf, *angles, name=hm, ssr=hm_ssr, north=hm_hkl, no_points=NPs[scan_no]) for kf in kfs ] if A4_starts[scan_no] > 0: senses_dict[ki] = 1 else: senses_dict[ki] = -1 for i in range(ft.EF_CHANNELS): clippers[i].AddPath(scale_to_clipper(locuses[i]), PT_SUBJECT) scatter_arrays[i] += scatter_coords[i] color_arrays[i] += scatter_colors[i] locuses_ki = [ scale_from_clipper(clippers[i].Execute(CT_UNION, PFT_NONZERO)) for i in range(ft.EF_CHANNELS) ] locuses_ki_x, locuses_ki_y = split_locus_lists(locuses_ki) scatters_ki_x, scatters_ki_y = split_scatter_lists(scatter_arrays) common_locus_x, common_locus_y = find_common_coverage(locuses_ki) locuses_dict[ki] = [ locuses_ki_x, locuses_ki_y, common_locus_x, common_locus_y ] scatters_dict[ki] = [scatters_ki_x, scatters_ki_y, color_arrays] p_col = [] plots = [] x_axis = np.array(scan['plot_x']) y_axis = np.array(scan['plot_y']) for ki in unique_kis: TOOLS = "pan,wheel_zoom,reset,save" main_plot = figure(plot_width=700, plot_height=600, title='Ei = %s meV' % fmt2(ft.k_to_e(ki)), tools=TOOLS) main_plot.xaxis.axis_label = 'x * %s' % bracketed_vector(x_axis) main_plot.yaxis.axis_label = 'y * %s' % bracketed_vector(y_axis) ticker = SingleIntervalTicker(interval=0.5, num_minor_ticks=1) main_plot.axis.ticker = ticker main_plot.grid.ticker = ticker locus = locuses_dict[ki] efs_str = [fmt1(ft.k_to_e(ki) - ft.k_to_e(kf)) for kf in kfs] sources = [] source_handle = ColumnDataSource(dict(x=[], y=[], colors=[])) scatter_off = ColumnDataSource(dict(x=[], y=[], colors=[])) for i in reversed(range(ft.EF_CHANNELS)): color = locus_palette[i] x_list = locus[0][i] y_list = locus[1][i] main_plot.patches(x_list, y_list, alpha=0.35, fill_color=color, muted_fill_color='black', muted_fill_alpha=0.01, muted_line_alpha=0.1, line_width=1, legend='dE=' + efs_str[i]) set_aspect(main_plot, x_list[0], y_list[0], aspect=ub_matrix.figure_aspect) for i in range(ft.EF_CHANNELS): sources.append( ColumnDataSource( dict(x=scatters_dict[ki][0][i], y=scatters_dict[ki][1][i], colors=scatters_dict[ki][2][i]))) main_plot.circle(x='x', y='y', size=4.5, fill_alpha=1, visible=True, fill_color='colors', line_alpha=0.2, source=source_handle) main_plot.patches(locus[2][0], locus[3][0], fill_alpha=0.0, line_width=1.2, legend='Common', line_color='red', muted_line_alpha=0.0, muted_fill_alpha=0.0) glyph_dots = plot_lattice_points(main_plot, x_axis, y_axis) main_plot.legend.click_policy = 'mute' plot_brillouin_zones(main_plot, x_axis, y_axis) cs = sources callback = CustomJS(args=dict(s0=cs[0], s1=cs[1], s2=cs[2], s3=cs[3], s4=cs[4], s5=scatter_off, source=source_handle), code=""" var f = cb_obj.active; switch (f) { case 0: source.data = s0.data; break; case 1: source.data = s1.data; break; case 2: source.data = s2.data; break; case 3: source.data = s3.data; break; case 4: source.data = s4.data; break; case 5: source.data = s5.data; break; } source.change.emit(); """) en_buttons = RadioButtonGroup( labels=['2.5', '3.0', '3.5', '4.0', '4.5', 'Off'], active=5, callback=callback) en_button_caption = Div() en_button_caption.text = """<span style="font-weight: bold;">Active channel:</span>""" hover = HoverTool(renderers=[glyph_dots], tooltips=[('Q', '@coord')]) main_plot.add_tools(hover) message_div = Div(width=600, height=200) if hm != 'no': plot_radar = draw_radar(main_plot, message_div, en_buttons, hm, ki, scan['hkl1'], hm_hkl, hm_ssr, ub_matrix, senses_dict[ki]) plot_radar.axis.visible = False ctrl_col = column( [en_button_caption, en_buttons, plot_radar, message_div]) else: plot_radar = draw_radar(main_plot, message_div, en_buttons, hm, ki, scan['hkl1'], scan['hkl1'], 0, ub_matrix, senses_dict[ki]) plot_radar.axis.visible = False ctrl_col = column( [en_button_caption, en_buttons, plot_radar, message_div]) # ctrl_col = column([en_button_caption, en_buttons, message_div]) plots.append(main_plot) p_col.append([main_plot, ctrl_col]) for each in plots: each.x_range = plots[0].x_range each.y_range = plots[0].y_range grid = layout(p_col) script, div = components(grid) return script, div
p0 = [5.0, 22., 0.08, 0.15, 6.15, 7., 0.08, 0.15, 6.9, 12., 0.08, 0.15] lower_bounds = [ 4.85, 1, 0.001, 0.0001, 6.0, 1., 0.001, 0.0001, 6.75, 1., 0.001, 0.0001 ] upper_bounds = [5.15, 30, 0.3, 0.6, 6.3, 20, 0.3, 0.6, 7.0, 20, 0.3, 0.6] bounds = (lower_bounds, upper_bounds) y = exp_gauss_3(x, *p0) lnlike_val = lnlike(p0, x, y_data) lnlikebox = Div(text="", width=800) lnliketext = open(os.path.join(os.path.dirname(__file__), "lnlike.html")).read() lnlikebox.text = lnliketext + "<h1> lnlikelihood:</p>%.3f </h1>" % lnlike_val # Set up data source = ColumnDataSource(data=dict(x=x, y=y, res=(y - y_data))) # Set up plot plot = figure(plot_height=500, plot_width=700, title="FRB181017", tools="crosshair,pan,reset,save,wheel_zoom", x_range=[0, np.max(x)], y_range=[-3, 1.2 * np.max(y_data)]) plot_residual = figure(plot_height=200, plot_width=700, title="Residuals",
height_dropdown.on_change('value', redraw_pixels) width_dropdown.on_change('value', redraw_pixels) colour_depth_selector.on_change('value', redraw_pixels) ## Content sections intro_div = Div(width=600, height=300, style={ 'font-size': '1.2em', 'font-family': 'Helvetica' }) intro_div.text = f""" <h3>The Curse of Dimensionality and Density in the Structure of Nature</h3> <p>This interactive application was inspired by Richard Hamming's<a href="https://en.wikipedia.org/wiki/Richard_Hamming"><em>"Art of Doing Science and Engineering"</em>, and the compressibility and compressed sensing video lecture series by <a href="https://www.youtube.com/watch?v=Dt2WYkqZfbs&list=PLMrJAkhIeNNQV7wi9r7Kut8liLFMWQOXn&index=89">Steve Brunton</a></a> </p> <p>The <a href="https://blogs.scientificamerican.com/observations/ada-lovelace-day-honors-the-first-computer-programmer/">iconic image</a> below at left is {original_dims[0]} pixels wide by {original_dims[1]} pixels high in the original file. Since the image is in greyscale, the colour of each pixel is represented by an integer value in the range [0, 255].</p> <p>Thinking more generally about images as systems, there are ({original_dims[0]}x{original_dims[1]})<sup>256</sup> possible configurations (states), making this image unimaginably unique.</p> <p>In other words, if each pixel can take one of 256 values, and there are {original_dims[0]} x {original_dims[1]} = {n_pixels:,} pixels, the number of possible <em>unique</em> images is {n_pixels:,}<sup>256</sup>, or roughly <strong>10<sup>262</sup></strong>. It's not really possible to imagine such large numbers, but as a basis of comparison, the <a href="https://physics.stackexchange.com/questions/47941/dumbed-down-explanation-how-scientists-know-the-number-of-atoms-in-the-universe">cosmological estimate of the number of <strong>atoms in the universe is about 10<sup>80</sup></strong></a>. The set of all {original_dims[0]} x {original_dims[1]} images that humans can recognize is <strong>effectively zero</strong> against such an unimaginable proportion of possibilities. If every human that ever lived spent their entire lifetime looking at {original_dims[0]} x {original_dims[1]} images with randomly assigned pixel values, virtually all images drawn would be like <a href="https://www.youtube.com/watch?v=Un8yRBC84Yk">static on an old CRT TV</a>.</p> <p>So what is it about natural systems that makes pattern recognition not just possible, but common?</p> """ system_description_div = Div(width=350, height=400,
def make_timeline_html(input_dir_path: str, output_path: str) -> None: # Load Data path = Path(input_dir_path) / 'pep_graph.gpickle' pep_graph = nx.read_gpickle(path) path = Path(input_dir_path) / 'python_release_info.csv' release_df = pd.read_csv(path, encoding='utf-8', parse_dates=['release_date']) release_df = release_df[release_df.micro == 0] release_df['color'] = release_df.major.apply(lambda x: PYTHON_YELLOW_COLOR_CODE if x == 2 else PYTHON_BLUE_COLOR_CODE) # 2, 3以外が出てきたら再考すること node_dict = dict(pep_graph.nodes(data=True)) date_list = [value['Created_dt'] for key, value in node_dict.items()] min_date = datetime.datetime(min(date_list).year, 1, 1) py2_release_label_data_source = tl_compo.generate_release_label_source(release_df, major_version=2, pos_x=min_date) py3_release_label_data_source = tl_compo.generate_release_label_source(release_df, major_version=3, pos_x=min_date) py2_release_line_data_source = tl_compo.generate_release_line_data_source(release_df, major_version=2) py3_release_line_data_source = tl_compo.generate_release_line_data_source(release_df, major_version=3) release_source_dict = {'py2_release_label_source': py2_release_label_data_source, 'py3_release_label_source': py3_release_label_data_source, 'py2_release_line_source': py2_release_line_data_source, 'py3_release_line_source': py3_release_line_data_source } all_pep_data_source = compo.generate_node_data_source(pep_graph) # DataTable用のデータソースを用意する linked_from_table_source = table_compo.generate_data_table_data_source(pep_graph) link_to_table_source = table_compo.generate_data_table_data_source(pep_graph) linked_from_data_table = table_compo.generate_data_table(linked_from_table_source) link_to_data_table = table_compo.generate_data_table(link_to_table_source) linked_from_table_title_div = Div(text='<strong>PEP N is linked from ...</strong>', style={'color': BASE_FONT_COLOR}) link_to_table_title_div = Div(text='<strong>PEP N links to ...</strong>', style={'color': BASE_FONT_COLOR}) # Timeline用のデータソースを用意する timeline_display_circle_source = tl_compo.generate_timeline_data_source(pep_graph) timeline_label_source = tl_compo.generate_timeline_label_data_source(pep_graph) desc_start_date, _ = tl_compo.get_timeline_plot_range(pep_graph) desc_start_date = desc_start_date + datetime.timedelta(days=30) timeline_desc_label_source = tl_compo.generate_timeline_desc_data_source(xs=[desc_start_date, desc_start_date], ys=[1.7, 0.1], font_size=15) # 入力ボックス用のデータソース生成 error_message_div = Div(width=300, height=8, style={'color': 'red'}, text='') title_div = Div(width=700, style={'font-size': 'large', 'line-height': '1.5', 'color': BASE_FONT_COLOR}) title_div.text = """ Let's enter the PEP number in the left text box.<br> Then you can see the following information. <li>Which PEPs do link that PEP?</li> <li>Which PEPs are linked from that PEP?</li> """ checkbox_group = CheckboxGroup(labels=["Show Python 2 release dates", "Show Python 3 release dates"], active=[0, 1]) def callback_input_pep_number(all_pep_data_source=all_pep_data_source, link_to_table_source=link_to_table_source, linked_from_table_source=linked_from_table_source, link_to_table_title_div=link_to_table_title_div, linked_from_table_title_div=linked_from_table_title_div, timeline_display_circle_source=timeline_display_circle_source, timeline_label_source=timeline_label_source, timeline_desc_source=timeline_desc_label_source, title_div=title_div, error_message_div=error_message_div) -> None: """ テキストボックスに文字入力されたときに実行される関数。 PyScriptを使ってJavaScriptに変換される。 参考: https://bokeh.pydata.org/en/latest/docs/user_guide/interaction/callbacks.html#customjs-with-a-python-function * このパラメータの設定の仕方以外にもあるかもしれない :param all_pep_data_source: :param link_to_table_source: :param linked_from_table_source: :param link_to_table_title_div: :param linked_from_table_title_div: :param timeline_display_circle_source: :param timeline_label_source: :param timeline_desc_source: :param title_div: :param error_message_div: :param debug_div: :return: """ inputed_text = cb_obj['value'] # PyScriptで変換するときに自分の外側の関数の呼び方がわからないので、 # 暫定で関数内関数で定義する。 def create_header_text(pep_dict: dict) -> str: if not pep_dict: return 'Not Found.' # .formatを使うとJavaScript変換後に実行時エラーになるので、 # +演算子で連結している description_text = "<span>Created: " \ + pep_dict['Created_str'] \ + " Type: " \ + pep_dict['Type'] \ + "<br>" link_text = "<a href='https://www.python.org/dev/peps/pep-" \ + pep_dict['index'] \ + "/' target='_blank'>PEP " \ + pep_dict['PEP'] \ + "</a>" title_text = "<span style='font-size : xx-large;'>" \ + link_text \ + "<br>" \ + pep_dict['Title'] \ + " (" + pep_dict['Status'] + ")" \ + "</span>" return description_text + title_text def search_index_by_pep_number(text: str) -> int: index = 0 for pep_number in all_pep_data_source['data']['PEP']: if text == str(pep_number): return index index += 1 return -1 # Not Found def get_inputed_pep_dict(text: int) -> dict: selected_index = search_index_by_pep_number(text) if selected_index == -1: return {} pep_dict = {} for key, value in all_pep_data_source.data.items(): pep_dict[key] = value[selected_index] return pep_dict def get_pep_info(list_index: int) -> dict: pep_dict = {} for key, value in all_pep_data_source['data'].items(): pep_dict[key] = value[list_index] return pep_dict def get_neighbor_node_info(pep_dict: dict, neighbor_type: str) -> dict: neighbors = dict() for key, value in all_pep_data_source.data.items(): neighbors[key] = [] for pep_id in pep_dict[neighbor_type]: index = search_index_by_pep_number(int(pep_id)) work_pep_dict = get_pep_info(index) for key in neighbors.keys(): neighbors[key].append(work_pep_dict[key]) return neighbors def generate_timeline_source_dict(pep_dict: dict) -> dict: in_edge_nodes_dict = get_neighbor_node_info(pep_dict, 'in_edge_nodes') out_edge_nodes_dict = get_neighbor_node_info(pep_dict, 'out_edge_nodes') in_edge_nodes_dict['y'] = [1.5] * len(in_edge_nodes_dict['PEP']) out_edge_nodes_dict['y'] = [0.5] * len(out_edge_nodes_dict['PEP']) timeline_source_dict = in_edge_nodes_dict del timeline_source_dict['in_degree'] del timeline_source_dict['in_edge_nodes'] del timeline_source_dict['out_degree'] del timeline_source_dict['out_edge_nodes'] for key, value in timeline_source_dict.items(): timeline_source_dict[key] += out_edge_nodes_dict[key] if key == 'y': timeline_source_dict[key].append(1) else: timeline_source_dict[key].append(pep_dict[key]) return timeline_source_dict def update_data_table(pep_dict: dict) -> None: linked_from_table_title_div.text = '<strong>PEP ' \ + pep_dict['PEP'] \ + ' is linked from ...</strong>' link_to_table_title_div.text = '<strong>PEP ' \ + pep_dict['PEP'] \ + ' links to ...</strong>' in_edge_nodes_dict = get_neighbor_node_info(pep_dict, 'in_edge_nodes') linked_from_table_source.data = in_edge_nodes_dict linked_from_table_source.change.emit() out_edge_nodes_dict = get_neighbor_node_info(pep_dict, 'out_edge_nodes') link_to_table_source.data = out_edge_nodes_dict link_to_table_source.change.emit() def update_timeline(pep_dict: dict) -> None: timeline_circle_dict = generate_timeline_source_dict(pep_dict) timeline_display_circle_source.data = timeline_circle_dict timeline_display_circle_source.change.emit() timeline_label_dict = generate_timeline_source_dict(pep_dict) timeline_label_dict['displayed_text'] = timeline_label_dict['PEP'] timeline_label_source.data = timeline_label_dict timeline_label_source.change.emit() texts = ['PEP ' + pep_dict['PEP'] + ' is linked from...', 'PEP ' + pep_dict['PEP'] + ' links to...', ] timeline_desc_dict = dict(x=timeline_desc_source.data['x'], y=timeline_desc_source.data['y'], text=texts, size=timeline_desc_source.data['size'], ) timeline_desc_source.data = timeline_desc_dict timeline_desc_source.change.emit() # 正規表現でタグを除去したいけど、JS変換後にreを呼べないので、暫定で<と>を外す inputed_text = inputed_text.replace('<', '') inputed_text = inputed_text.replace('>', '') inputed_text = inputed_text.strip() # 入力文字のチェック if not inputed_text: error_message_div.text = 'Please enter the number of PEP' + inputed_text return inputed_text = inputed_text.lstrip('0') # 表示の更新 selected_pep_dict = get_inputed_pep_dict(inputed_text) if selected_pep_dict: title_div.text = create_header_text(selected_pep_dict) update_data_table(selected_pep_dict) update_timeline(selected_pep_dict) error_message_div.text = "" else: error_message_div.text = "Not Found: PEP " + inputed_text def callback_change_checkbox(py2_label_source=py2_release_label_data_source, py2_line_source=py2_release_line_data_source, py3_label_source=py3_release_label_data_source, py3_line_source=py3_release_line_data_source): def switch_show_or_hide(label_source, line_source, major_version): label_data = label_source.data line_data = line_source.data check_box_index_map = {2: 0, 3: 1} if check_box_index_map[major_version] in cb_obj.active: label_data['alpha'] = [1] * len(label_data['alpha']) line_data['alpha'] = [1] * len(line_data['alpha']) else: label_data['alpha'] = [0] * len(label_data['alpha']) line_data['alpha'] = [0] * len(line_data['alpha']) label_source.data = label_data label_source.change.emit() line_source.data = line_data line_source.change.emit() switch_show_or_hide(py2_label_source, py2_line_source, 2) switch_show_or_hide(py3_label_source, py3_line_source, 3) # Header Component pep_textinput = TextInput(title='PEP:', placeholder='Please enter the PEP number.', callback=CustomJS.from_py_func(callback_input_pep_number), width=190) info_div = Div(width=200, height=20, style={'background-color': '#175A89', 'padding': '5px', 'color': '#FFFFFF'}) info_div.text = "<li>" \ "<a href='https://github.com/komo-fr/pep_map_site'><font color='#FFFFFF'>repository</font></a>" \ "</li>" inputbox_component = column(pep_textinput, error_message_div) color_desc_component = compo.generate_color_description_component() header_component = row(column(inputbox_component, color_desc_component), title_div, info_div) # Timeline Component checkbox_group.callback = CustomJS.from_py_func(callback_change_checkbox) timeline_plot = tl_compo.generate_timeline_plot(pep_graph, timeline_display_circle_source, timeline_label_source, timeline_desc_label_source, release_source_dict) as_of_date_div = Div(width=200, height=8, style={'color': 'red'}) # TODO: fetch_start_datetimeを持っていないときの対応について決める fetch_datetime = pep_graph.graph['fetch_start_datetime'].strftime('%Y/%m/%d') \ if 'fetch_start_datetime' in pep_graph.graph else 'Unknown' as_of_date_div.text = '* Data as of {}'.format(fetch_datetime) # データ取得日 timeline_component = column(timeline_plot, as_of_date_div) # Table Component margin_div = Div(width=50) link_to_table_component = column(link_to_table_title_div, link_to_data_table) linked_from_table_component = column(linked_from_table_title_div, linked_from_data_table) table_component = row(linked_from_table_component, margin_div, link_to_table_component) # TODO: ここでshowしなくても出力できる方法はないか? output_file(output_path, 'PEP Map | Timeline') show(column(header_component, checkbox_group, timeline_component, table_component))
tools=PLOT_TOOLS, x_range=[0, DAYS], ) plot9.line('x', 'y', source=source_pr, line_width=PLOT_LINE_WIDTH, line_alpha=PLOT_LINE_ALPHA, line_color=PLOT_LINE_NEW_COLOR, legend_label='% Prevalence') set_plot_details(plot9, hover9, PLOT_Y_LABEL2) # misc text intro.text = TEXT_INTRO summary.text = TEXT_SUMMARY summary.style = {'font-weight': 'bold'} beta = round(h1.value * p1.value / 100, 4) R0 = round(beta * period.value, 4) im_threshold = max(round((1 - 1 / R0) * 100, 2), 0) # could go negative for R0 < 1 pre_str = 'β: ' + str(beta) + '<br/>R<sub>0</sub>: ' + str( R0) + '<br/>Immunity threshold: ' + str(im_threshold) + '%' extra_str = '' stats_str = pre_str + '<br/>Transmissions: ' + str(ar_stats[0]) + ' / ' + str( ar_stats[3]) + '%' '<br/>Recoveries: ' + str( ar_stats[1]) + '<br/>Deaths: ' + str(ar_stats[2]) + extra_str stats.text = stats_str notes.text = TEXT_NOTES
def get_attributes(source, df, radius_source, radius_slider, point_info, point_probabilities): try: idx = source.selected._property_values['indices'][0] except KeyError: radius_source.data = {'x': [], 'y': [], 'rad': []} return dpoint = df.iloc[source.data['index'][idx]] # check if selection didn't change when doing ColumnDataSource.stream(...) global source_idx global real_idx if source_idx == idx: # if index in the source didn't change, we assume the selection wasn't changed by the user dpoint = df.iloc[real_idx] else: source_idx = idx real_idx = dpoint.name # draw radius circle radius_source.data = { 'x': [dpoint.x_cats_ae], 'y': [dpoint.y_cats_ae], 'rad': [radius_slider.value] } # update table with point info bin_class = {0: 'Normal', 1: 'Attack'} visual_pred = visual_classifier.predict(np.array( [dpoint.x_cats_ae, dpoint.y_cats_ae]), eps=radius_slider.value) visual_pred_str = ('✅ ' if visual_pred == dpoint.category else '❌ ') + \ categories_short[visual_pred] if visual_pred != -1 else 'Unknown' cats_pred = ('✅ ' if dpoint.cats_ae_pred == (dpoint.category != 9) else '❌ ') + bin_class[dpoint.cats_ae_pred] orig_pred = ('✅ ' if dpoint.original_pred == (dpoint.category != 9) else '❌ ') + bin_class[dpoint.original_pred] point_info.text = '<div class="attrs">' + tabulate( [ ['index', real_idx], ['category', categories_short[dpoint.category]], ['cats_ae_pred', cats_pred], ['original_pred', orig_pred], ['x', '{:.4f}'.format(dpoint.x_cats_ae)], ['y', '{:.4f}'.format(dpoint.y_cats_ae)], ['visual_pred', visual_pred_str], ], tablefmt='html') + '</div>' probs, counts = visual_classifier.predict_proba(np.array( [dpoint.x_cats_ae, dpoint.y_cats_ae]), eps=radius_slider.value, return_counts=True) source = ColumnDataSource(data={ 'category': categories_short, 'probability': probs }) barplot = figure( x_range=(0, 1), y_range=categories_short, plot_height=200, toolbar_location=None, title='Visual classifier\'s categories probability distribution') barplot.hbar(y='category', right='probability', source=source, height=0.95, fill_color=factor_cmap('category', palette=cmap, factors=categories_short), line_color='white') outlierness_score = Div() outlierness_score.text = "<p>#(samples within eps) = %d</p>" \ "<p>eps / #(samples within eps) = %s</p>" % \ (counts, counts / radius_slider.value) point_probabilities.children = [barplot, outlierness_score]