class CurveFit(param.Parameterized): dataset = param.FileSelector(path='./*.csv*', label="Choose a file") fit_curve = param.Boolean(False, label="Fit Curve") @param.depends('dataset', 'fit_curve', watch=True) def view(self): data = pd.read_csv(self.dataset) fig, ax = plt.subplots() if self.fit_curve: slope, intercept, _, _, _ = stats.linregress(data['x'], data['y']) ax = sns.regplot(x="x", y="y", data=data, color='blue', line_kws={ 'label': "y={0:.1f}x+{1:.1f}".format(slope, intercept) }) ax.legend() else: data.plot.scatter(x="x", y="y", c="blue", ax=ax) plt.close(fig) return fig
class Dashboard(param.Parameterized): file_selector = param.FileSelector() progress = pn.widgets.Progress(active=False) @param.depends("file_selector", watch=True) def activate_upload_status(self): self.progress.active = True
class GriddedRoughness(RoughnessSpecification): """Roughness specified as a land-use grid file.""" __abstract = True land_use_grid = param.FileSelector(default=None, doc=""" Path to land use grid to use for roughness.""") def get_args(self): raise NotImplementedError
class CreateGSSHAModel(CreateModel): """Create a new GSSHA model.""" mask_shapefile = param.FileSelector( default='./vicksburg_watershed/watershed_boundary.shp', path='./*/*.shp', doc=""" Path to watershed boundary shapefile. Required for new model. Typically a *.shp file.""", precedence=0.1) grid_cell_size = param.Number(default=None, precedence=0.2) # TODO: specify acceptable file extensions? elevation_grid_path = param.FileSelector(doc=""" Path to elevation raster used for GSSHA grid. Required for new model. Typically a *.ele file.""", precedence=0.3) # TODO: paramnb ClassSelector should cache instances that get # created or else editing parameters on non-default options is # confusing. roughness = param.ClassSelector(RoughnessSpecification, default=UniformRoughness(), doc=""" Method for specifying roughness""", precedence=-1) out_hydrograph_write_frequency = param.Number(default=10, bounds=(1, 60), doc=""" Frequency of writing to hydrograph (minutes). Sets HYD_FREQ card. Required for new model.""", precedence=0.8) def _map_kw(self, p): kw = super(CreateGSSHAModel, self)._map_kw(p) kw['mask_shapefile'] = p.mask_shapefile kw['grid_cell_size'] = p.grid_cell_size kw['elevation_grid_path'] = os.path.abspath(p.elevation_grid_path) kw['out_hydrograph_write_frequency'] = p.out_hydrograph_write_frequency kw.update(p.roughness.get_args()) return kw def __call__(self, **params): p = param.ParamOverrides(self, params) return GSSHAModel(**self._map_kw(p))
class GriddedRoughnessTable(GriddedRoughness): """Roughness specified as a land-use grid file and roughness table.""" land_use_to_roughness_table = param.FileSelector(default=None, doc=""" Path to land use to roughness table.""") def get_args(self): return { 'roughness': None, 'land_use_grid': self.land_use_grid, 'land_use_to_roughness_table': self.land_use_to_roughness_table, 'land_use_grid_id': None }
class _BigDumbParams(param.Parameterized): action = param.Action(default_action, allow_None=True) array = param.Array(np.array([1.0, 2.0])) boolean = param.Boolean(True, allow_None=True) callable = param.Callable(default_action, allow_None=True) class_selector = param.ClassSelector(int, is_instance=False, allow_None=True) color = param.Color("#FFFFFF", allow_None=True) composite = param.Composite(["action", "array"], allow_None=True) try: data_frame = param.DataFrame( pd.DataFrame({"A": 1.0, "B": np.arange(5)}), allow_None=True ) except TypeError: data_frame = param.DataFrame(pd.DataFrame({"A": 1.0, "B": np.arange(5)})) date = param.Date(datetime.now(), allow_None=True) date_range = param.DateRange((datetime.min, datetime.max), allow_None=True) dict_ = param.Dict({"foo": "bar"}, allow_None=True, doc="dict means dictionary") dynamic = param.Dynamic(default=default_action, allow_None=True) file_selector = param.FileSelector( os.path.join(FILE_DIR_DIR, "LICENSE"), path=os.path.join(FILE_DIR_DIR, "*"), allow_None=True, ) filename = param.Filename( os.path.join(FILE_DIR_DIR, "LICENSE"), allow_None=True ) foldername = param.Foldername(os.path.join(FILE_DIR_DIR), allow_None=True) hook_list = param.HookList( [CallableObject(), CallableObject()], class_=CallableObject, allow_None=True ) integer = param.Integer(10, allow_None=True) list_ = param.List([1, 2, 3], allow_None=True, class_=int) list_selector = param.ListSelector([2, 2], objects=[1, 2, 3], allow_None=True) magnitude = param.Magnitude(0.5, allow_None=True) multi_file_selector = param.MultiFileSelector( [], path=os.path.join(FILE_DIR_DIR, "*"), allow_None=True, check_on_set=True, ) number = param.Number(-10.0, allow_None=True, doc="here is a number") numeric_tuple = param.NumericTuple((5.0, 10.0), allow_None=True) object_selector = param.ObjectSelector( False, objects={"False": False, "True": 1}, allow_None=True ) path = param.Path(os.path.join(FILE_DIR_DIR, "LICENSE"), allow_None=True) range_ = param.Range((-1.0, 2.0), allow_None=True) series = param.Series(pd.Series(range(5)), allow_None=True) string = param.String("foo", allow_None=True, doc="this is a string") tuple_ = param.Tuple((3, 4, "fi"), allow_None=True) x_y_coordinates = param.XYCoordinates((1.0, 2.0), allow_None=True)
class Activity(param.Parameterized): """A model of an Activity Currently the Activity is based on data from a .fitfile """ file = param.FileSelector( doc="A bytes object. Current only .fit files are supported") data = param.DataFrame(doc="The records of the file") @param.depends( "file", watch=True, ) @progress.report(message="Parsing Activity File") def parse_file(self, ): """Converts the file to the training_data""" if self.file: self.data = fit_file_services.parse_fit_file(self.file) @param.depends("data") @progress.report(message="Creating Activity Plots") def activity_plots(self, ): """A layout of plots of the activity data. For example timestamp vs power. Returns: HoloViews: A layout of plots """ return activity_plot.activity_plots(self.data) @param.depends("data") @progress.report(message="Creating Map") def map_plot(self, ): """The route on a map Returns: HoloViews: A plot of the route on a map. """ return activity_plot.map_plot(self.data) def view(self, ) -> pn.viewable.Viewable: """A view of the Activity Returns: pn.viewable.Viewable: A view of the Activity """ return activity_view.ActivityView( self.param, self.map_plot, self.activity_plots, )
class Inputs(param.Parameterized): input_file = param.FileSelector(path=r".\sample_data\\*.csv", doc="A .csv file selector for input data") x_field = param.Selector(doc="A field selector for longitude") y_field = param.Selector(doc="A field selector for latitude") id_field = param.Selector(doc="A field selector for the identifier") data = None def __init__(self, **params): super().__init__(**params) if self.param.input_file.default: self.input_file = self.param.input_file.default self._update_inputs() @param.depends("input_file", watch=True) def _update_inputs(self): if self.input_file in FILE_STORE: df = FILE_STORE[self.input_file].copy(deep=True) else: df = pd.read_csv(self.input_file) FILE_STORE[self.input_file] = df.copy(deep=True) numeric_cols = list(df.select_dtypes(include=["float64"]).columns) columns = [x for i, x in enumerate(df.columns) if x != "Unnamed: 0"] self.param.x_field.objects = numeric_cols if "lng" in numeric_cols: self.x_field = "lng" elif numeric_cols: self.x_field = numeric_cols[0] self.param.y_field.objects = numeric_cols if "lat" in numeric_cols: self.y_field = "lat" elif numeric_cols: self.y_field = numeric_cols[0] self.param.id_field.objects = columns if "comName" in columns: self.id_field = "comName" elif columns: self.id_field = columns[0] self.data = df
class Example(BaseClass): """An example Parameterized class""" timestamps = [] boolean = param.Boolean(True, doc="A sample Boolean parameter") color = param.Color(default="#FFFFFF") date = param.Date(dt.date(2017, 1, 1), bounds=wired.DATE_BOUNDS) dataframe = param.DataFrame(pd.util.testing.makeDataFrame().iloc[:3]) select_string = param.ObjectSelector(default="yellow", objects=["red", "yellow", "green"]) select_fn = param.ObjectSelector(default=list, objects=[list, set, dict]) int_list = param.ListSelector(default=[3, 5], objects=[1, 3, 5, 7, 9], precedence=0.5) single_file = param.FileSelector(path="../../*/*.py*", precedence=0.5) multiple_files = param.MultiFileSelector(path="../../*/*.py?", precedence=0.5) record_timestamp = param.Action( lambda x: x.timestamps.append(dt.datetime.utcnow()), doc="""Record timestamp.""", precedence=0.7, )
class Inputs(param.Parameterized): input_file = param.FileSelector( path=".\sample_data\*.csv", doc="A .csv file selector for input data" ) x_field = param.Selector(doc="A field selector for longitude") y_field = param.Selector(doc="A field selector for latitude") id_field = param.Selector(doc="A field selector for the identifier") data = None @param.depends("input_file", watch=True) def update_inputs(self): df = pd.read_csv(self.input_file) numeric_cols = list(df.select_dtypes(include=["float64"]).columns) columns = [x for i, x in enumerate(df.columns) if x != "Unnamed: 0"] self.param.x_field.objects = numeric_cols self.x_field = numeric_cols[0] self.param.y_field.objects = numeric_cols self.x_field = numeric_cols[0] self.param.id_field.objects = columns self.id_field = columns[0] self.data = df
class MyParameterized(param.Parameterized): enable = param.Boolean(True, doc="A sample Boolean parameter", allow_None=True) what_proportion = param.Magnitude(default=0.9) age = param.Number(49, bounds=(0, 100), doc="Any Number between 0 to 100") how_many = param.Integer() favorite_quote = param.String(default="Hello, world!") choose_file_or_folder = param.Path(search_paths='./') choose_folder = param.Foldername(search_paths="./") choose_file = param.Filename(search_paths="./") select_a_file = param.FileSelector(path='./*') select_multiple_files = param.MultiFileSelector(path='./*') favorite_color = param.ObjectSelector( default="green", objects=["red", "yellow", "green"]) favorite_fruit = param.Selector(default="Apple", objects=["Orange", "Apple", "Mango"]) select_multiple = param.ListSelector(default=[3, 5], objects=[1, 2, 3, 4, 5]) birthday = param.CalendarDate(dt.date(2017, 1, 1), bounds=(dt.date(2017, 1, 1), dt.date(2017, 2, 1))) appointment = param.Date(dt.datetime(2017, 1, 1), bounds=(dt.datetime(2017, 1, 1), dt.datetime(2017, 2, 1))) least_favorite_color = param.Color(default='#FF0000') dataset = param.DataFrame(pd.util.testing.makeDataFrame().iloc[:3]) this_strange_thing = param.Tuple(default=(False, ), allow_None=True) some_numbers = param.NumericTuple(default=(1, 2, 3.0, 4.0)) home_city = param.XYCoordinates(default=(-111.65, 40.23)) bounds = param.Range(default=(-10, 10))
class ImageClassifierApp(param.Parameterized): """The Image Classifier App We define the parameters, views and depencies of the app """ model = param.ObjectSelector() image_file = param.FileSelector() top_predictions = param.ClassSelector(class_=list) progress_value = param.Integer() progress_message = param.String() def __init__(self, **params): super().__init__(**params) config_keras_applications() self.param.model.default = KERAS_APPLICATIONS[ DEFAULT_KERAS_APPLICATION_INDEX] self.param.model.objects = KERAS_APPLICATIONS self.model = KERAS_APPLICATIONS[DEFAULT_KERAS_APPLICATION_INDEX] @param.depends("model") def resources_view(self, ): """A view of a section with links to resources""" if self.model: return pn.pane.Markdown(get_resources_markdown(self.model)) return pn.pane.HTML() # @param.depends("image_file", watch=True) # def set_image(self): # self.image = Image.open(io.BytesIO(self.image_file)) @param.depends("image_file") def image_view(self, ): """A view of the image_file""" if self.image_file: bytes_io = io.BytesIO(self.image_file) return pn.pane.HTML( ('<img application="data:image/jpg;base64,{0}" ' 'style="height:400px;min-width:600px;"/>').format( b64encode(bytes_io.getvalue()).decode("utf-8"))) return pnx.InfoAlert( "Upload an image in .jpg format", height=400, min_width=600, ) def report_progress( self, message: str = "", value: int = 0, ): """Update the progress message and value Args: message (str, optional): A message to convery to the user. Defaults to "". value (int, optional): A progress value between 0 and 100. Defaults to 0. """ self.progress_message = message self.progress_value = value @param.depends( "image_file", "model", watch=True, ) def set_top_predictions(self, ): """Updates the top_predictions""" self.top_predictions = None if self.image_file and self.model: self.report_progress( "Prediction Started", 1, ) bytes_io = io.BytesIO(self.image_file) pil_image = Image.open(bytes_io) # pylint: disable=no-member self.top_predictions = self.model.get_top_predictions( image=pil_image, report_progress_func=self.report_progress, ) # pylint: enable=no-member @param.depends("top_predictions") def main_prediction_view(self, ): """A pretty string of the main prediction to output to the user""" if self.model and self.top_predictions: # pylint: disable=no-member main_prediction_string = self.model.to_main_prediction_string( self.top_predictions) # pylint: enable=no-member return pn.pane.Markdown(main_prediction_string) return pn.pane.Str("Not Available") @param.depends("top_predictions") def predictions_chart_view(self, ): """A view of a chart showing the top predictions and their probabilities""" if self.model and self.top_predictions: # pylint: disable=no-member chart = self.model.to_predictions_chart(self.top_predictions) # pylint: enable=no-member chart = chart.properties( height=200, width=400, ) return pn.pane.Vega(chart) return pn.pane.Str("Not Available") @param.depends( "progress_value", "top_predictions", ) def predictions_view(self, ): """A view showing the predictions or the progress of the predictions""" if self.progress_value: return pn.Column( pnx.SubHeader("Prediction"), pn.widgets.Progress( value=self.progress_value, width=200, ), pn.pane.Str(self.progress_message), sizing_mode="stretch_width", ) if self.top_predictions: return pn.Column( pnx.SubHeader("Prediction"), self.main_prediction_view, pnx.SubHeader("Alternative Predictions"), self.predictions_chart_view, sizing_mode="stretch_width", ) return pn.pane.HTML()
class ActivityMock(param.Parameterized): """Mock of Activity Class""" file = param.FileSelector()
class MyParamFileSelector(param.Parameterized): single_file = param.FileSelector(path='*', precedence=0.5)
class ChartStudio(param.Parameterized): # create param objects for all possible widgets in the app # import tab data_file = param.FileSelector(path='*.csv') use_layout_file = param.Boolean(default=False) layout_file = param.FileSelector(path='*.cslayout') # chart editor tab # type tab widgets chart_type = param.ObjectSelector(default="Scatter", objects=["Scatter", "Bar"]) bar_mode = param.ObjectSelector( default="group", objects=["group", "stack", "relative", "overlay"]) scatter_mode = param.ObjectSelector( default="lines+markers", objects=["lines+markers", "lines", "markers"]) # trace tab widgets trace_to_edit = param.ObjectSelector(default=None, objects=None) # style tab widgets # general tab widgets chart_background_colour = param.Color(default='#ffffff') chart_background_opacity = param.Number(0.5, bounds=(0.0, 1.0)) chart_text_font = param.ObjectSelector( default="Arial", objects=[ "Arial", "Balto", "Courier New", "Droid Sans", "Droid Serif", "Droid Sans Mono", "Gravitas One", "Old Standard TT", "Open Sans", "Overpass", "PT Sans Narrow", "Raleway", "Times New Roman" ]) chart_text_size = param.Integer(default=12) chart_text_colour = param.Color(default='#000000') chart_title = param.String(default='') plot_width = param.Integer(default=650) plot_height = param.Integer(default=450) top_margin = param.Integer(default=20) bottom_margin = param.Integer(default=80) left_margin = param.Integer(default=80) right_margin = param.Integer(default=80) # axes tab widgets axes_colour = param.Color(default='#000000') axes_thickness = param.Integer(default=1) x_title = param.String(default='x_title') y_title = param.String(default='y_title') y_autorange = param.Boolean(default=True) y_min = param.Number(default=0) y_max = param.Number(default=0) x_autorange = param.Boolean(default=True) x_min = param.Number(default=0) x_max = param.Number(default=0) y_grid_lines = param.Boolean(default=False) y_zeroline = param.Boolean(default=False) auto_x_tick_angle = param.Boolean(default=True) x_tick_angle = param.Number(default=0) # legend tab widgets auto_position_legend = param.Boolean(default=True) legend_x = param.Number(default=1) legend_y = param.Number(default=1) # annotate tab widgets # text annotations widgets show_footnote = param.Boolean(default=False) footnote_text = param.String(default='<i>Footnote:</i>') y_footnote = param.Number(default=-0.1) show_annotation_1 = param.Boolean(default=False) text_1 = param.String(default='Annotation 1') x_1 = param.Number(default=0) y_1 = param.Number(default=0) show_annotation_2 = param.Boolean(default=False) text_2 = param.String(default='Annotation 2') x_2 = param.Number(default=0) y_2 = param.Number(default=0) show_annotation_3 = param.Boolean(default=False) text_3 = param.String(default='Annotation 3') x_3 = param.Number(default=0) y_3 = param.Number(default=0) # shape annotation widgets show_shape_1 = param.Boolean(default=False) shape_1_type = param.ObjectSelector(default="rect", objects=["rect", "circle", "line"]) shape_1_colour = param.Color(default='#0000ff') shape_1_opacity = param.Number(0.5, bounds=(0.0, 1.0)) shape_1_line_style = param.ObjectSelector( default="solid", objects=["solid", "dot", "dash", "longdash", "dashdot", "longdashdot"]) shape_1_line_width = param.Integer(default=0) x_min_1 = param.Number(default=0) x_max_1 = param.Number(default=0) y_min_1 = param.Number(default=0) y_max_1 = param.Number(default=0) show_shape_2 = param.Boolean(default=False) shape_2_type = param.ObjectSelector(default="rect", objects=["rect", "circle", "line"]) shape_2_colour = param.Color(default='#00ff00') shape_2_opacity = param.Number(0.5, bounds=(0.0, 1.0)) shape_2_line_style = param.ObjectSelector( default="solid", objects=["solid", "dot", "dash", "longdash", "dashdot", "longdashdot"]) shape_2_line_width = param.Integer(default=0) x_min_2 = param.Number(default=0) x_max_2 = param.Number(default=0) y_min_2 = param.Number(default=0) y_max_2 = param.Number(default=0) show_shape_3 = param.Boolean(default=False) shape_3_type = param.ObjectSelector(default="rect", objects=["rect", "circle", "line"]) shape_3_colour = param.Color(default='#ff0000') shape_3_opacity = param.Number(0.5, bounds=(0.0, 1.0)) shape_3_line_style = param.ObjectSelector( default="solid", objects=["solid", "dot", "dash", "longdash", "dashdot", "longdashdot"]) shape_3_line_width = param.Integer(default=0) x_min_3 = param.Number(default=0) x_max_3 = param.Number(default=0) y_min_3 = param.Number(default=0) y_max_3 = param.Number(default=0) # export chart tab export_to_file = param.String(default=r"Figure_1", doc="Declare name for exported plot file") png = param.Boolean(default=False) svg = param.Boolean(default=False) pdf = param.Boolean(default=False) html = param.Boolean(default=False) json = param.Boolean(default=False) cslayout = param.Boolean(default=False) export = param.Action(lambda x: x.param.trigger('export')) data = None figure = None update_plot = True #dataframe = param.DataFrame(pd.util.testing.makeDataFrame().iloc[:3]) @param.depends('data_file', watch=True) def process_file(self): self.data = pd.read_csv(self.data_file) self.data_cols = list(self.data.columns) self.xdata = self.data_cols[0] self.x_title = self.xdata self.trace_names = self.data_cols[1:] # method for reading in data if using the customised filebrowser panel widget #@param.depends('data_file', watch=True) #def process_file(self): # data = StringIO(str(self.data_file,'utf-8')) # self.data = pd.read_csv(data) # self.data_cols = list(self.data.columns) # self.xdata = self.data_cols[0] # self.x_title = self.xdata # self.trace_names = self.data_cols[1:] def show_data(self): return self.data @param.depends('layout_file', 'use_layout_file', watch=True) def import_cslayout(self): if self.use_layout_file == True: self.update_plot = False read_layout = pd.read_csv(self.layout_file) for attribute in read_layout.Attribute.unique(): if attribute == read_layout.Attribute.unique()[-1]: self.update_plot = True dtype = read_layout[read_layout.Attribute == attribute].Type.values[0].replace( "<class '", '').replace("'>", '') value = read_layout[read_layout.Attribute == attribute].Value.values[0] if dtype == 'int': setattr(self, attribute, int(value)) elif dtype == 'float': setattr(self, attribute, float(value)) elif dtype == 'bool': if value == 'True': setattr(self, attribute, True) elif value == 'False': setattr(self, attribute, False) elif dtype == 'str': if str(value) == 'nan': setattr(self, attribute, '') else: setattr(self, attribute, value) # function to export .cslayout file which contains param object names and values at time of export def export_cslayout(self): params = list(self.param.objects().keys()) params_df = [] # ignore name and export_plot params i.e. start at 1 and end at peniltimate param for i in range(len(params)): if params[i] not in [ 'name', 'data_file', 'use_layout_file', 'layout_file', 'export_to_file', 'png', 'svg', 'pdf', 'html', 'json', 'cslayout', 'export', 'trace_to_edit' ]: params_df.append([ params[i], getattr(self, list(self.param.objects().keys())[i]), type(getattr(self, list(self.param.objects().keys())[i])) ]) # create dataframe and write out csv containing test layout parameters params_df = pd.DataFrame(params_df, columns=['Attribute', 'Value', 'Type']) params_df.to_csv(f'{self.export_to_file}.cslayout', index=False) @param.depends( 'data_file', 'layout_file', 'use_layout_file', 'chart_type', 'bar_mode', 'scatter_mode', 'chart_background_colour', 'chart_background_opacity', 'chart_text_font', 'chart_text_size', 'chart_text_colour', 'chart_title', 'plot_width', 'plot_height', 'top_margin', 'bottom_margin', 'left_margin', 'right_margin', 'axes_colour', 'axes_thickness', 'x_title', 'y_title', 'y_autorange', 'y_min', 'y_max', 'x_autorange', 'x_min', 'x_max', 'y_grid_lines', 'y_zeroline', 'auto_x_tick_angle', 'x_tick_angle', 'auto_position_legend', 'legend_x', 'legend_y', 'show_footnote', 'footnote_text', 'y_footnote', 'show_annotation_1', 'text_1', 'x_1', 'y_1', 'show_annotation_2', 'text_2', 'x_2', 'y_2', 'show_annotation_3', 'text_3', 'x_3', 'y_3', 'show_shape_1', 'shape_1_type', 'shape_1_colour', 'shape_1_opacity', 'shape_1_line_style', 'shape_1_line_width', 'x_min_1', 'x_max_1', 'y_min_1', 'y_max_1', 'show_shape_2', 'shape_2_type', 'shape_2_colour', 'shape_2_opacity', 'shape_2_line_style', 'shape_2_line_width', 'x_min_2', 'x_max_2', 'y_min_2', 'y_max_2', 'show_shape_3', 'shape_3_type', 'shape_3_colour', 'shape_3_opacity', 'shape_3_line_style', 'shape_3_line_width', 'x_min_3', 'x_max_3', 'y_min_3', 'y_max_3') # all plot widgets I think def plot(self): if self.update_plot == True: colours = cycle(['#3b064d', '#8105d8', '#ed0cef', '#fe59d7']) # create traces data = [] for i in range(0, len(self.trace_names)): colour = next(colours) if self.chart_type == 'Scatter': data.append( go.Scatter(x=self.data[self.xdata], y=self.data[self.trace_names[i]], name=self.trace_names[i], mode=self.scatter_mode, marker=dict(size=12, color=colour, opacity=0.5), line=dict(color=colour, width=2))) elif self.chart_type == 'Bar': data.append( go.Bar(x=self.data[self.xdata], y=self.data[self.trace_names[i]], name=self.trace_names[i], marker=dict(color=colour, opacity=1.0, line=dict(width=0)))) self.param.trace_to_edit.objects = self.trace_names self.trace_to_edit = self.trace_names[0] # set values for items with both tickboxes and value boxes if self.y_autorange == True: ymin = None ymax = None else: ymin = self.y_min ymax = self.y_max if self.x_autorange == True: xmin = None xmax = None else: xmin = self.x_min xmax = self.x_max if self.auto_x_tick_angle == True: xtickangle = None else: xtickangle = self.x_tick_angle if self.auto_position_legend == True: legx = None legy = None else: legx = self.legend_x legy = self.legend_y # set background rgba hex = app.chart_background_colour.lstrip('#') rgb = tuple(int(hex[i:i + 2], 16) for i in (0, 2, 4)) alpha = self.chart_background_opacity bg_rgba = f'rgba({rgb[0]},{rgb[1]},{rgb[2]},{alpha})' # create annotations and shapes annotations = [] if self.show_footnote == True: annotations.append( dict(text=self.footnote_text, font=dict(family=self.chart_text_font, size=self.chart_text_size - 2, color=self.chart_text_colour), xanchor='right', yref='paper', xref='paper', x=1.0, y=self.y_footnote, align='right', showarrow=False)) if self.show_annotation_1 == True: annotations.append( dict(text=self.text_1, font=dict(family=self.chart_text_font, size=self.chart_text_size, color=self.chart_text_colour), x=self.x_1, y=self.y_1, showarrow=False)) if self.show_annotation_2 == True: annotations.append( dict(text=self.text_2, font=dict(family=self.chart_text_font, size=self.chart_text_size, color=self.chart_text_colour), x=self.x_2, y=self.y_2, showarrow=False)) if self.show_annotation_3 == True: annotations.append( dict(text=self.text_3, font=dict(family=self.chart_text_font, size=self.chart_text_size, color=self.chart_text_colour), x=self.x_3, y=self.y_3, showarrow=False)) shapes = [] if self.show_shape_1 == True: shapes.append( dict(type=self.shape_1_type, layer='below', x0=self.x_min_1, x1=self.x_max_1, y0=self.y_min_1, y1=self.y_max_1, opacity=self.shape_1_opacity, fillcolor=self.shape_1_colour, line=dict(color=self.shape_1_colour, width=self.shape_1_line_width, dash=self.shape_1_line_style))) if self.show_shape_2 == True: shapes.append( dict(type=self.shape_2_type, layer='below', x0=self.x_min_2, x1=self.x_max_2, y0=self.y_min_2, y1=self.y_max_2, line=dict(color=self.shape_2_colour, width=self.shape_2_line_width, dash=self.shape_2_line_style))) if self.show_shape_3 == True: shapes.append( dict(type=self.shape_3_type, layer='below', x0=self.x_min_3, x1=self.x_max_3, y0=self.y_min_3, y1=self.y_max_3, opacity=self.shape_3_opacity, fillcolor=self.shape_3_colour, line=dict(color=self.shape_3_colour, width=self.shape_3_line_width, dash=self.shape_3_line_style))) # create layout layout = go.Layout( title=dict(text='<b>' + self.chart_title + '</b>', font=dict(family=self.chart_text_font, size=self.chart_text_size + 4, color=self.chart_text_colour), x=0.5), showlegend=True, hovermode='x', legend=dict(font=dict(family=self.chart_text_font, size=self.chart_text_size, color=self.chart_text_colour), x=legx, y=legy, bgcolor='rgba(0,0,0,0)'), margin=dict(t=self.top_margin, l=self.left_margin, b=self.bottom_margin, r=self.right_margin), width=self.plot_width, height=self.plot_height, font=dict(family=self.chart_text_font, size=self.chart_text_size, color=self.chart_text_colour), paper_bgcolor=bg_rgba, plot_bgcolor='rgba(0,0,0,0)', xaxis=dict( visible=True, color=self.axes_colour, title=dict(text='<b>' + self.x_title + '</b>', font=dict(family=self.chart_text_font, size=self.chart_text_size, color=self.chart_text_colour)), range=[xmin, xmax], ticks='outside', ticklen=5, tickwidth=self.axes_thickness, tickcolor=self.axes_colour, tickfont=dict(family=self.chart_text_font, size=self.chart_text_size, color=self.chart_text_colour), tickangle=xtickangle, showline=True, linecolor=self.axes_colour, linewidth=self.axes_thickness, showgrid=False, zeroline=False, ), yaxis=dict(visible=True, color=self.axes_colour, title=dict(text='<b>' + self.y_title + '</b>', font=dict(family=self.chart_text_font, size=self.chart_text_size, color=self.chart_text_colour)), range=[ymin, ymax], rangemode='tozero', ticks='outside', ticklen=5, tickwidth=self.axes_thickness, tickcolor=self.axes_colour, tickfont=dict(family=self.chart_text_font, size=self.chart_text_size, color=self.chart_text_colour), showline=True, linecolor=self.axes_colour, linewidth=self.axes_thickness, showgrid=self.y_grid_lines, gridcolor='grey', zeroline=self.y_zeroline, zerolinecolor='grey', zerolinewidth=1), barmode=self.bar_mode, annotations=annotations, shapes=shapes) # create figure self.figure = go.Figure(data=data, layout=layout) return self.figure @param.depends('export', watch=True) def export_plots(self): if self.figure != None: if self.png == True: self.figure.write_image(self.export_to_file + ".png", scale=4) if self.svg == True: self.figure.write_image(self.export_to_file + ".svg") if self.pdf == True: self.figure.write_image(self.export_to_file + ".pdf") if self.json == True: self.figure.write_json(self.export_to_file + ".json") if self.html == True: self.figure.write_html(self.export_to_file + ".html") if self.cslayout == True: self.export_cslayout()
class LumenDashboard(param.Parameterized): specfile = param.FileSelector() reloader = pn.widgets.Button(name='=', width=10) config = param.Parameter(precedence=-1) specDoc = param.Parameter(precedence=-1) dashBoard = param.Parameter(precedence=-1) sentinelHackCounter = 0 loading = False indicator = centerContent(pn.indicators.LoadingSpinner(value=True)) @classmethod def getinstancesBySessionId(cls, sessionId): instances = [ inst for inst in instancesList if inst._session == sessionId ] if len(instances) >= 1: return instances return None @classmethod def clearInstancesForSession(cls, sessionId): instances = [ inst for inst in instancesList if inst._session == sessionId ] for i in instances: instancesList.remove(i) @classmethod def clearInstances(cls): instancesList.clear() def __init__(self, **kwargs): super(LumenDashboard, self).__init__(**kwargs) boardId = kwargs['board'] self.board = BoardEntity.objects.get(id=boardId) self._session = kwargs.get('sessionId') + str(boardId) self.josso_session_cookies = { 'JOSSO_SESSIONID': kwargs.get('JOSSO_SESSIONID') } self.specDoc = self.createSpecFromData() instancesList.append(self) def initializerCallback(self): print(f"call initializerCallback; dashboard {self.dashBoard}") if not self.dashBoard and not self.loading: self.sentinelHackCounter += 1 print(f"sentinel UP : {self.sentinelHackCounter}") # premier lancement avec affichage d'un spinner car le server renvoi le document d'un seul tenant, # du coup le panel ne s'affiche pas tant que le Dashboard n'est pas totalement chargé! self.loading = True pn.state.add_periodic_callback(self.update, 700, count=1) def update(self): print( f"call update; dashboard {self.dashBoard}; sentinel {self.sentinelHackCounter}" ) tic = time.clock() if not self.dashBoard: try: self.dashBoard = Dashboard(specification=self.specDoc.name) toc = time.clock() print( f"Time to create the dashboard {self.dashBoard.name} : {toc - tic}" ) except (Exception) as e: self.dashBoard = pn.pane.HTML( object= f"<p>Erreur dans la préparation du dashboard : {e}</p>") print(e) else: self.dashBoard._yaml_file = self.specDoc.name self.dashBoard._load_specification(from_file=True) try: self.dashBoard._reload() except (Exception) as e: self.dashBoard = pn.pane.HTML( object= f"<p>Erreur dans la préparation du dashboard : {e}</p>") self.loading = False def createSpecFromData(self): if self.board.config: tic = time.clock() specification = self.board.config with open( r'specYamlFile/temp/dashboard_{}.yml'.format( self._session), 'w') as file: yaml.dump(specification, file) toc = time.clock() print(f"Time to create yaml {file.name} : {toc - tic}") return file else: specification = self.createFakeYaml() with open( r'specYamlFile/dashboard_fake_{}.yml'.format( self._session), 'w') as file: yaml.dump(specification.__dict__, file) return file def createFakeYaml(self): path = BASE_DIR + '/vizApps/services/intake/' config = { 'title': "Nouveau DashBoard", 'layout': "grid", 'ncols': 2, 'template': 'material', 'theme': 'dark' } targets = [ { 'title': 'Nouvelle Source', "source": { 'type': 'intake', 'filename': os.path.join(path, 'catalog.yml') }, 'views': [], 'filters': [] }, ] specObj = SpecYamlCreator(config=config, targets=targets) return specObj @param.depends('specfile', watch=True) def uploadSpecFile(self): if self.specfile: with open( r'specYamlFile/upload/dashboard_{}.yml'.format( self._session), 'w') as file: spec = yaml.load(self.specfile) for i in [ v for source, v in spec.get('sources').items() if v.get('type') == 'json' ]: i['kwargs']['cookies'] = self.josso_session_cookies break # no need to iterate further yaml.dump(spec, file) self.specDoc = file self.dashBoard = None def updateConfig(self): print(f"call updateConfig; dashboard {self.dashBoard}") if self.specDoc.name is not None: with open(self.specDoc.name, 'r') as f: _yaml = yaml.load(f.read()) _yaml['config'] = self.configMapping() with open( r'specYamlFile/temp/new_dashboard_{}.yml'.format( self._session), 'w') as f: yaml.dump(_yaml, f) self.specDoc = f def configMapping(self): config = { 'title': self.config.title, 'layout': self.config.layout.name, 'ncols': self.config.ncols, 'template': self.config.template.name, 'theme': self.config.theme.name } return config @param.depends('config') def panel(self): layout = pn.Card(sizing_mode='stretch_width', title="Parametres", collapsed=True) layout.append( pn.Param( self.param, widgets={ # 'logo': pn.widgets.FileInput(accept='.jpg,.png,.ico,.gif',name="Logo"), 'specfile': pn.widgets.FileInput(accept='.yaml,.yml', name="Specification File") }, show_name=False, expand_button=False, expand=False, sizing_mode="stretch_width"), ) if self.config: layout.append( pn.Param( self.config.param, show_name=False, expand_button=False, expand=False, sizing_mode="stretch_width", )) return layout @param.depends('dashBoard') def main(self): print( f"call main; dashboard {self.dashBoard}, sentinel {self.sentinelHackCounter}" ) if isinstance(self.dashBoard, Dashboard): self.config = self.dashBoard.config layout = pn.Column(self.dashBoard._main, sizing_mode='stretch_both', margin=10, width_policy='max', height_policy='max') return layout elif self.dashBoard: return self.dashBoard else: return self.indicator @param.depends('dashBoard') def header(self): if isinstance(self.dashBoard, Dashboard): header = self.dashBoard._header return header @param.depends('dashBoard') def sidebar(self): if isinstance(self.dashBoard, Dashboard): sidebar = self.dashBoard._sidebar return sidebar @param.depends('dashBoard') def modal(self): if isinstance(self.dashBoard, Dashboard): modal = self.dashBoard._modal return modal @param.depends('dashBoard') def busyIndicator(self): spinner = pn.indicators.LoadingSpinner(width=40, height=40) pn.state.sync_busy(spinner) bi = pn.Row(spinner) return bi