From 23750c6394d19d5b71949b2ba9589c0192e655fa Mon Sep 17 00:00:00 2001 From: Francisco Arrieta Date: Fri, 16 Dec 2016 10:18:12 -0700 Subject: [PATCH 1/7] Data Table shows annotation code Need to optimize and clean --- odmtools/controller/frmDataTable.py | 9 +-- odmtools/controller/olvDataTable.py | 47 ++++++++++++-- odmtools/odmdata/memory_database.py | 34 +++++++++- odmtools/odmservices/series_service.py | 90 ++++++++++++-------------- 4 files changed, 121 insertions(+), 59 deletions(-) diff --git a/odmtools/controller/frmDataTable.py b/odmtools/controller/frmDataTable.py index ce6f008..be6ccbe 100644 --- a/odmtools/controller/frmDataTable.py +++ b/odmtools/controller/frmDataTable.py @@ -13,17 +13,14 @@ def __init__(self, parent, **kwargs): self.memDB = None DataTable.__init__(self, parent, **kwargs) + def init(self, memDB): + self.memDB = memDB + self.olvDataTable.init(self.memDB) - def init_publishers(self): Publisher.subscribe(self.onChangeSelection, "changeTableSelection") Publisher.subscribe(self.onRefresh, "refreshTable") Publisher.subscribe(self.olvDataTable.onDeselectAll, "deselectAllDataTable") - def init(self, memDB): - self.memDB = memDB - self.olvDataTable.init(self.memDB) - self.init_publishers() - def onItemSelected(self, event): pass diff --git a/odmtools/controller/olvDataTable.py b/odmtools/controller/olvDataTable.py index 112f4d7..8007aba 100644 --- a/odmtools/controller/olvDataTable.py +++ b/odmtools/controller/olvDataTable.py @@ -20,6 +20,8 @@ def __init__(self, parent, **kwargs): self.sortedColumnIndex = -1 self.currentItem = None self.dataframe = None + self.annotations = None + self.data = None def init(self, memDB): self.memDB = memDB @@ -28,19 +30,54 @@ def init(self, memDB): self.oddRowsBackColor = wx.Colour(191, 217, 217) self.dataframe = self.memDB.getDataValuesDF() - sort_by_index = list(self.dataframe.columns).index("valuedatetime") - self.dataframe.sort_values(self.dataframe.columns[sort_by_index], inplace=True) - self.dataObjects = self.dataframe.values.tolist() + self.annotations = self.memDB.get_annotations() + # sort_by_index = list(self.dataframe.columns).index("valuedatetime") + # columns = self.memDB.get_columns_with_annotations() + # self.dataframe.sort_values(self.dataframe.columns[sort_by_index], inplace=True) + # self.dataObjects = self.dataframe.values.tolist() + self.dataObjects = self.__merge_dataframe_with_annotations() + col = self.memDB.get_columns_with_annotations() + + # columns = \ + # [ColumnDefn(x.strip(), align="left", valueGetter=i, minimumWidth=125, width=125, + # stringConverter='%Y-%m-%d %H:%M:%S' if "valuedatetime" == x.lower() else '%s') + # for x, i in self.memDB.getEditColumns()] columns = \ [ColumnDefn(x.strip(), align="left", valueGetter=i, minimumWidth=125, width=125, - stringConverter='%Y-%m-%d %H:%M:%S' if "valuedatetime" == x.lower() else '%s') - for x, i in self.memDB.getEditColumns()] + stringConverter='%Y-%m-%d %H:%M:%S' if "valuedatetime" == x.lower() else '%s') + for x, i in col] + self.SetColumns(columns) self.SetObjectGetter(self.ObjectGetter) self.SetItemCount(len(self.dataframe)) + def __merge_dataframe_with_annotations(self): + sort_by_index = self.dataframe.columns.tolist().index("valuedatetime") + self.dataframe.sort_values(self.dataframe.columns[sort_by_index], inplace=True) + + data_list = self.dataframe.values.tolist() + anno_list = self.annotations.values.tolist() + data = data_list + + anno = {} + for i in range(0, len(anno_list)): + value_id = anno_list[i][1] + annotation_code = anno_list[i][-1] + if value_id in anno: + anno[value_id].append(annotation_code) + else: + anno[value_id] = [annotation_code] + + for key, value in anno.iteritems(): + for i in range(0, len(data_list)): + if key in data_list[i]: + data_list[i].append(value) + break + + return data + def EnableSorting(self): self.Bind(wx.EVT_LIST_COL_CLICK, self.onColSelected) if not self.smallImageList: diff --git a/odmtools/odmdata/memory_database.py b/odmtools/odmdata/memory_database.py index 813fbe9..1bdc792 100644 --- a/odmtools/odmdata/memory_database.py +++ b/odmtools/odmdata/memory_database.py @@ -25,6 +25,7 @@ def __init__(self, taskserver=None): self.df = None # Series_Service handles remote database self.series_service = None + self.results_annotations = None # Memory_service handles in memory database sm = ServiceManager() @@ -77,6 +78,16 @@ def getDataValuesDF(self): logging.debug("done updating memory dataframe") return self.df + def get_annotations(self, query_db_again=False): + # self.mem_service._session.commit() + # setSchema(self.mem_service._session_factory.engine) + if self.results_annotations is None or query_db_again: + result_id = self.df.resultid[0] + annotation = self.series_service.get_annotations_by_result(resultid=result_id) + self.results_annotations = annotation + + return self.results_annotations + def getDataValues(self): # TODO: fix me! this commit location is only temoporarily. should be flushing so that we can restore self.mem_service._session.commit() @@ -94,6 +105,27 @@ def getEditColumns(self): return [(x, i) for (i, x) in enumerate(columns)] # return [(x, i) for (i, x) in enumerate(self.df.columns)] + def get_columns_with_annotations(self): + """ + If results_annotations has not been set then + :return: + """ + + if self.results_annotations is None or self.df is None: + print "self.df and self.results_annotations must be a pandas dataframe. Currently they are None" + return [] + + columns = [] + columns.extend(self.df.columns.tolist()) + + annotation_columns = self.results_annotations.columns.tolist() + index = annotation_columns.index("annotationcode") + annotation_code_column = annotation_columns[index] + + columns.append(annotation_code_column) + + return [(x, i) for (i, x) in enumerate(columns)] + def getDataValuesforGraph(self, seriesID, noDataValue, startDate=None, endDate=None): return self.series_service.get_plot_values(seriesID, noDataValue, startDate, endDate) @@ -250,7 +282,7 @@ def initEditValues(self, seriesID): logger.debug("Load series from db") self.series = self.series_service.get_series(seriesID) - self.df = self.series_service.get_values(series_id= seriesID) + self.df = self.series_service.get_values(series_id=seriesID) self.editLoaded = True diff --git a/odmtools/odmservices/series_service.py b/odmtools/odmservices/series_service.py index aec7c69..4a76710 100644 --- a/odmtools/odmservices/series_service.py +++ b/odmtools/odmservices/series_service.py @@ -116,26 +116,6 @@ def get_variables_by_site_code(self, site_code): q = self._session.query(Variables).filter(Variables.VariableID.in_(var_ids)) return q.all() - # Data Value Methods - def get_values(self, series_id=None): - ''' - - :param series_id: Series id - :return: pandas dataframe - ''' - - setSchema(self._session_factory.engine) - q = self.read._session.query(TimeSeriesResultValues) - if series_id: - q = q.filter_by(ResultID=series_id) - q = q.order_by(TimeSeriesResultValues.ValueDateTime) - query = q.statement.compile(dialect=self._session_factory.engine.dialect) - data = pd.read_sql_query(sql=query, - con=self._session_factory.engine, - params=query.params) - data.set_index(data['valuedatetime'], inplace=True) - return data - # Series Catalog methods def get_series_by_site(self , site_id): # try: @@ -359,42 +339,55 @@ def get_series_from_filter(self): # Pass in probably a Series object, match it against the database pass -# + #Data Value Methods def get_values(self, series_id=None): - ''' - :param series_id: Series id + """ + :param series_id: :return: pandas dataframe - ''' - #series= self.get_series_by_id(series_id) - # if series: - # q = self._edit_session.query(DataValue).filter_by( - # site_id=series.site_id, - # variable_id=series.variable_id, - # method_id=series.method_id, - # source_id=series.source_id, - # quality_control_level_id=series.quality_control_level_id) - # - # query=q.statement.compile(dialect=self._session_factory.engine.dialect) - # data= pd.read_sql_query(sql= query, - # con = self._session_factory.engine, - # params = query.params ) - # #return data.set_index(data['LocalDateTime']) - # return data - # else: - # return None + """ + # see get_annotations_by_result around line 850 q = self.read._session.query(TimeSeriesResultValues) if series_id: - q=q.filter_by(ResultID=series_id) - q= q.order_by(TimeSeriesResultValues.ValueDateTime) + q = q.filter_by(ResultID=series_id) + q = q.order_by(TimeSeriesResultValues.ValueDateTime) query = q.statement.compile(dialect=self._session_factory.engine.dialect) data = pd.read_sql_query(sql=query, con=self._session_factory.engine, params=query.params) data.set_index(data['valuedatetime'], inplace=True) + + # if series_id: + # anno = self.get_annotations_by_result(series_id) + # q = pd.merge(data, anno, how="left", on='valueid', indicator=False) + # data.applymap(self.merge_annotation_with_timeseries_result) + + # if len(anno): + # # data.valueid.apply(self.merge_annotation_with_timeseries_result) + # # data.applymap(self.merge_annotation_with_timeseries_result) + # self.merge_annotation_with_timeseries_result(data, anno) + + + return data + # df.drop_duplicates(dup_cols, keep='last', inplace=True) + # newdf = pd.merge(df, pd.read_sql(query, engine), how='left', on=dup_cols, indicator=True) + # newdf = newdf[newdf['_merge'] == 'left_only'] + # newdf.drop(['_merge'], axis=1, inplace=True) + # return df[df['valuedatetime'].isin(newdf['valuedatetime'])] + + # def merge_annotation_with_timeseries_result(self, x): + # print x + # + # # return x + # return 123 + def merge_annotation_with_timeseries_result(self, data, anno): + + print 123 + return + def get_all_values_df(self): """ @@ -877,17 +870,20 @@ def get_all_annotations(self): return self.read.getAnnotations(type=None) def get_annotations_by_result(self, resultid): - setSchema(self._session_factory.engine) + # setSchema(self._session_factory.engine) # ids = [x[0] for x in self.read._session.query(TimeSeriesResultValues.ValueID)\ # .filter(TimeSeriesResultValues.ResultID == resultid).all()] # q = self.read._session.query(TimeSeriesResultValueAnnotations)\ # .filter(TimeSeriesResultValueAnnotations.ValueID.in_(ids)).all() - q =self.read._session.query(TimeSeriesResultValueAnnotations.AnnotationID, TimeSeriesResultValueAnnotations.ValueID, - TimeSeriesResultValues.ResultID, TimeSeriesResultValues.ValueDateTime)\ + resultid = int(resultid) + + q = self.read._session.query(TimeSeriesResultValueAnnotations.AnnotationID, TimeSeriesResultValueAnnotations.ValueID, + TimeSeriesResultValues.ResultID, TimeSeriesResultValues.ValueDateTime, Annotations.AnnotationCode)\ .filter(TimeSeriesResultValues.ResultID == resultid)\ - .filter(TimeSeriesResultValueAnnotations.ValueID == TimeSeriesResultValues.ValueID) + .filter(TimeSeriesResultValueAnnotations.ValueID == TimeSeriesResultValues.ValueID)\ + .filter(Annotations.AnnotationID==TimeSeriesResultValueAnnotations.AnnotationID) query = q.statement.compile(dialect=self._session_factory.engine.dialect) data = pd.read_sql_query(sql=query, con=self._session_factory.engine, From b3f5af0bf588fffc352b5d4f3a0a973c290be1e4 Mon Sep 17 00:00:00 2001 From: Francisco Arrieta Date: Fri, 16 Dec 2016 11:46:00 -0700 Subject: [PATCH 2/7] Fixed bugs when sorting columns and in series service In series_service.py add try except to some methods to prevent errors. Next, when clicking on a column the data was not being sorted correctly because of the previous changes. Last, optimized the merge_annotation method --- odmtools/controller/olvDataTable.py | 82 +++++++++++++------------- odmtools/odmservices/series_service.py | 34 +++++------ 2 files changed, 56 insertions(+), 60 deletions(-) diff --git a/odmtools/controller/olvDataTable.py b/odmtools/controller/olvDataTable.py index 8007aba..e4ff41d 100644 --- a/odmtools/controller/olvDataTable.py +++ b/odmtools/controller/olvDataTable.py @@ -21,7 +21,7 @@ def __init__(self, parent, **kwargs): self.currentItem = None self.dataframe = None self.annotations = None - self.data = None + self.annotations_grouped = {} def init(self, memDB): self.memDB = memDB @@ -31,17 +31,15 @@ def init(self, memDB): self.dataframe = self.memDB.getDataValuesDF() self.annotations = self.memDB.get_annotations() - # sort_by_index = list(self.dataframe.columns).index("valuedatetime") - # columns = self.memDB.get_columns_with_annotations() - # self.dataframe.sort_values(self.dataframe.columns[sort_by_index], inplace=True) - # self.dataObjects = self.dataframe.values.tolist() + + sort_by_index = self.dataframe.columns.tolist().index("valuedatetime") + self.dataframe.sort_values(self.dataframe.columns[sort_by_index], inplace=True) + + self.annotations_grouped = self.__group_annotations() self.dataObjects = self.__merge_dataframe_with_annotations() + col = self.memDB.get_columns_with_annotations() - # columns = \ - # [ColumnDefn(x.strip(), align="left", valueGetter=i, minimumWidth=125, width=125, - # stringConverter='%Y-%m-%d %H:%M:%S' if "valuedatetime" == x.lower() else '%s') - # for x, i in self.memDB.getEditColumns()] columns = \ [ColumnDefn(x.strip(), align="left", valueGetter=i, minimumWidth=125, width=125, stringConverter='%Y-%m-%d %H:%M:%S' if "valuedatetime" == x.lower() else '%s') @@ -51,16 +49,27 @@ def init(self, memDB): self.SetObjectGetter(self.ObjectGetter) - self.SetItemCount(len(self.dataframe)) + self.SetItemCount(len(self.dataObjects)) def __merge_dataframe_with_annotations(self): - sort_by_index = self.dataframe.columns.tolist().index("valuedatetime") - self.dataframe.sort_values(self.dataframe.columns[sort_by_index], inplace=True) - data_list = self.dataframe.values.tolist() - anno_list = self.annotations.values.tolist() data = data_list + for key, value in self.annotations_grouped.iteritems(): + for i in range(0, len(data_list)): + if key in data[i]: + data[i].append(value) + break + + return data + + def __group_annotations(self): + """ + Ideally, this method should only be called once. Use self.grouped_annotations after calling this method + :return: + """ + anno_list = self.annotations.values.tolist() + anno = {} for i in range(0, len(anno_list)): value_id = anno_list[i][1] @@ -70,16 +79,10 @@ def __merge_dataframe_with_annotations(self): else: anno[value_id] = [annotation_code] - for key, value in anno.iteritems(): - for i in range(0, len(data_list)): - if key in data_list[i]: - data_list[i].append(value) - break - - return data + return anno def EnableSorting(self): - self.Bind(wx.EVT_LIST_COL_CLICK, self.onColSelected) + self.Bind(wx.EVT_LIST_COL_CLICK, self.on_column_selected) if not self.smallImageList: self.SetImageLists() if (not self.smallImageList.HasName(ObjectListView.NAME_DOWN_IMAGE) and @@ -93,35 +96,34 @@ def ObjectGetter(self, index): """ return self.dataObjects[index % len(self.dataObjects)] - def onColSelected(self, evt): + def on_column_selected(self, event): """ Allows users to sort by clicking on columns """ - if isinstance(self.dataframe, pd.DataFrame): - if self.dataframe.empty: - return - else: - if not self.dataframe: - return + if not isinstance(self.dataframe, pd.DataFrame): + return + + if self.dataframe.empty: + return - logger.debug("Column: %s" % evt.m_col) - self.sortColumn(evt.m_col) + if not len(self.dataObjects): + return + + self.sortColumn(event.Column) def sortColumn(self, selected_column): oldSortColumnIndex = self.sortedColumnIndex self.sortedColumnIndex = selected_column - ascending = self.sortAscending - if ascending: - self.dataframe.sort_values(self.dataframe.columns[selected_column], inplace=True) - self.sortAscending = False - elif not ascending: - self.dataframe.sort_values(self.dataframe.columns[selected_column], ascending=False, inplace=True) - self.sortAscending = True + + self.sortAscending = not self.sortAscending + self.dataframe.sort_values(self.dataframe.columns[selected_column], ascending=self.sortAscending, inplace=True) self._UpdateColumnSortIndicators(selected_column, oldSortColumnIndex) - self.dataObjects = self.dataframe.values.tolist() - if self.GetItemCount: + # self.dataObjects = self.dataframe.values.tolist() + self.dataObjects = self.__merge_dataframe_with_annotations() + + if self.GetItemCount(): itemFrom = self.GetTopItem() itemTo = self.GetTopItem() + 1 + self.GetCountPerPage() itemTo = min(itemTo, self.GetItemCount() - 1) diff --git a/odmtools/odmservices/series_service.py b/odmtools/odmservices/series_service.py index 4a76710..9a98d30 100644 --- a/odmtools/odmservices/series_service.py +++ b/odmtools/odmservices/series_service.py @@ -378,16 +378,6 @@ def get_values(self, series_id=None): # newdf.drop(['_merge'], axis=1, inplace=True) # return df[df['valuedatetime'].isin(newdf['valuedatetime'])] - # def merge_annotation_with_timeseries_result(self, x): - # print x - # - # # return x - # return 123 - def merge_annotation_with_timeseries_result(self, data, anno): - - print 123 - return - def get_all_values_df(self): """ @@ -863,20 +853,24 @@ def get_quality_code(self): return self.read.getCVs(type="Quality Code") def get_annotation_by_code(self, code): - return self.read.getAnnotations(codes=[code])[0] + try: + return self.read.getAnnotations(codes=[code])[0] + except: + return None + def get_annotation_by_id(self, id): - return self.read.getAnnotations(ids=[id])[0] + try: + return self.read.getAnnotations(ids=[id])[0] + except: + return None + def get_all_annotations(self): - return self.read.getAnnotations(type=None) + try: + return self.read.getAnnotations(type=None) + except: + return None def get_annotations_by_result(self, resultid): - # setSchema(self._session_factory.engine) - - # ids = [x[0] for x in self.read._session.query(TimeSeriesResultValues.ValueID)\ - # .filter(TimeSeriesResultValues.ResultID == resultid).all()] - # q = self.read._session.query(TimeSeriesResultValueAnnotations)\ - # .filter(TimeSeriesResultValueAnnotations.ValueID.in_(ids)).all() - resultid = int(resultid) q = self.read._session.query(TimeSeriesResultValueAnnotations.AnnotationID, TimeSeriesResultValueAnnotations.ValueID, From 91ac688c339d44746f1aae54dfb6584d43ccec13 Mon Sep 17 00:00:00 2001 From: Francisco Arrieta Date: Fri, 16 Dec 2016 11:52:34 -0700 Subject: [PATCH 3/7] Silenced a error when clicking on annotations column. Its a patch for now Will fix soon --- odmtools/controller/olvDataTable.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/odmtools/controller/olvDataTable.py b/odmtools/controller/olvDataTable.py index e4ff41d..ddbea37 100644 --- a/odmtools/controller/olvDataTable.py +++ b/odmtools/controller/olvDataTable.py @@ -112,6 +112,10 @@ def on_column_selected(self, event): self.sortColumn(event.Column) def sortColumn(self, selected_column): + if selected_column >= len(self.dataframe.columns): + # Cannot sort by annotation code yet. Need to fix this + return + oldSortColumnIndex = self.sortedColumnIndex self.sortedColumnIndex = selected_column From b88f20e2c5f876ec53d4aae9297d29ce84287fac Mon Sep 17 00:00:00 2001 From: Francisco Arrieta Date: Wed, 28 Dec 2016 12:40:16 -0700 Subject: [PATCH 4/7] Sort by annotation --- odmtools/controller/olvDataTable.py | 31 +++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-) diff --git a/odmtools/controller/olvDataTable.py b/odmtools/controller/olvDataTable.py index ddbea37..d3f0029 100644 --- a/odmtools/controller/olvDataTable.py +++ b/odmtools/controller/olvDataTable.py @@ -112,20 +112,18 @@ def on_column_selected(self, event): self.sortColumn(event.Column) def sortColumn(self, selected_column): - if selected_column >= len(self.dataframe.columns): - # Cannot sort by annotation code yet. Need to fix this - return + self.sortAscending = not self.sortAscending oldSortColumnIndex = self.sortedColumnIndex self.sortedColumnIndex = selected_column - self.sortAscending = not self.sortAscending - self.dataframe.sort_values(self.dataframe.columns[selected_column], ascending=self.sortAscending, inplace=True) - self._UpdateColumnSortIndicators(selected_column, oldSortColumnIndex) - # self.dataObjects = self.dataframe.values.tolist() - self.dataObjects = self.__merge_dataframe_with_annotations() + if selected_column >= len(self.dataframe.columns): + self.dataObjects = self.sort_columns_by_annotation_code(reverse=self.sortAscending) + else: + self.dataframe.sort_values(self.dataframe.columns[selected_column], ascending=self.sortAscending, inplace=True) + self.dataObjects = self.__merge_dataframe_with_annotations() if self.GetItemCount(): itemFrom = self.GetTopItem() @@ -133,6 +131,23 @@ def sortColumn(self, selected_column): itemTo = min(itemTo, self.GetItemCount() - 1) self.RefreshItems(itemFrom, itemTo) + def sort_columns_by_annotation_code(self, reverse=False): + rows_with_annotation = [] + rows_without_annotation = [] + + column_number_of_dataframe = len(self.dataframe.columns) + + for i in self.dataObjects: + if len(i) > column_number_of_dataframe: + rows_with_annotation.append(i) + else: + rows_without_annotation.append(i) + + if reverse: + return rows_without_annotation + rows_with_annotation + else: + return rows_with_annotation + rows_without_annotation + def onItemSelected(self, event): """ From 15e4b4b13ace308a8a2fcc87a6a4def30d964531 Mon Sep 17 00:00:00 2001 From: Francisco Arrieta Date: Wed, 28 Dec 2016 14:17:35 -0700 Subject: [PATCH 5/7] Bug fix when selecting a different result It was not making a query to the db when showing a different row. Thats fixed now. --- odmtools/odmdata/memory_database.py | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/odmtools/odmdata/memory_database.py b/odmtools/odmdata/memory_database.py index 1bdc792..5a17727 100644 --- a/odmtools/odmdata/memory_database.py +++ b/odmtools/odmdata/memory_database.py @@ -44,18 +44,14 @@ def __init__(self, taskserver=None): #self.annotation_list = pd.DataFrame() columns =['ResultID', 'ValueDateTime', 'ValueID', 'AnnotationID') #send in engine - def reset_edit(self): sm = ServiceManager() self.mem_service = sm.get_series_service(conn_string="sqlite:///:memory:") setSchema(self.mem_service._session_factory.engine) - def set_series_service(self, service): self.series_service = service - - ############## # DB Queries ############## @@ -78,14 +74,10 @@ def getDataValuesDF(self): logging.debug("done updating memory dataframe") return self.df - def get_annotations(self, query_db_again=False): - # self.mem_service._session.commit() - # setSchema(self.mem_service._session_factory.engine) - if self.results_annotations is None or query_db_again: - result_id = self.df.resultid[0] - annotation = self.series_service.get_annotations_by_result(resultid=result_id) - self.results_annotations = annotation - + def get_annotations(self): + result_id = self.df.resultid[0] + annotation = self.series_service.get_annotations_by_result(resultid=result_id) + self.results_annotations = annotation return self.results_annotations def getDataValues(self): From 53ecd865369822beb19272fa981dab0f590b9157 Mon Sep 17 00:00:00 2001 From: Francisco Arrieta Date: Mon, 2 Jan 2017 11:44:49 -0700 Subject: [PATCH 6/7] #273 Fixed the ribbons not highlighting correctly when hovering on and off them --- odmtools/gui/mnuRibbon.py | 37 +++++++++++++++++++++++++++++++++++-- 1 file changed, 35 insertions(+), 2 deletions(-) diff --git a/odmtools/gui/mnuRibbon.py b/odmtools/gui/mnuRibbon.py index 6c21874..eede1aa 100644 --- a/odmtools/gui/mnuRibbon.py +++ b/odmtools/gui/mnuRibbon.py @@ -129,6 +129,7 @@ def _init_ctrls(self, prnt): # ------------------------------------------------------------------------------- editPage = RB.RibbonPage(self, wx.ID_ANY, "Edit") + # editPage.Bind(wx.EVT_ENTER_WINDOW, self.on_mouse_enter) main_panel = RB.RibbonPanel(editPage, wx.ID_ANY, "Main", wx.NullBitmap, wx.DefaultPosition, wx.DefaultSize, RB.RIBBON_PANEL_NO_AUTO_MINIMISE) @@ -204,14 +205,28 @@ def _init_ctrls(self, prnt): self.CurrPage = 1 self.SetActivePageByIndex(self.CurrPage) - self.bindEvents() + self.__bind_events() self.initPubSub() def __init__(self, parent, id, name): self.parent = parent self._init_ctrls(parent) - def bindEvents(self): + def on_mouse_enter(self, event): + ribbon_panel = event.GetEventObject().GetParent() + ribbon_panel._hovered = True + + self.Refresh() + event.Skip() + + def on_mouse_leave(self, event): + ribbon_panel = event.GetEventObject().GetParent() + ribbon_panel._hovered = False + + self.Refresh() + event.Skip() + + def __bind_events(self): ###Docking Window Selection self.Bind(RB.EVT_RIBBONBUTTONBAR_CLICKED, self.onDocking, id=wxID_RIBBONVIEWTABLE) self.Bind(RB.EVT_RIBBONBUTTONBAR_CLICKED, self.onDocking, id=wxID_RIBBONVIEWSERIES) @@ -262,6 +277,24 @@ def bindEvents(self): ###Ribbon Event self.Bind(RB.EVT_RIBBONBAR_PAGE_CHANGED, self.onFileMenu, id=wxID_PANEL1) + # ENTER + self.main_bar.Bind(wx.EVT_ENTER_WINDOW, self.on_mouse_enter) # 1 + self.edit_bar.Bind(wx.EVT_ENTER_WINDOW, self.on_mouse_enter) # 2 + self.record_bar.Bind(wx.EVT_ENTER_WINDOW, self.on_mouse_enter) # 3 + self.PlotsOptions_bar.Bind(wx.EVT_ENTER_WINDOW, self.on_mouse_enter) # 4 + self.plots_bar.Bind(wx.EVT_ENTER_WINDOW, self.on_mouse_enter) # 5 + self.dateTime_buttonbar.Bind(wx.EVT_ENTER_WINDOW, self.on_mouse_enter) # 6 + self.scriptBar.Bind(wx.EVT_ENTER_WINDOW, self.on_mouse_enter) # 7 + + # LEAVE + self.main_bar.Bind(wx.EVT_LEAVE_WINDOW, self.on_mouse_leave) # 1 + self.edit_bar.Bind(wx.EVT_LEAVE_WINDOW, self.on_mouse_leave) # 2 + self.record_bar.Bind(wx.EVT_LEAVE_WINDOW, self.on_mouse_leave) # 3 + self.PlotsOptions_bar.Bind(wx.EVT_LEAVE_WINDOW, self.on_mouse_leave) # 4 + self.plots_bar.Bind(wx.EVT_LEAVE_WINDOW, self.on_mouse_leave) # 5 + self.dateTime_buttonbar.Bind(wx.EVT_LEAVE_WINDOW, self.on_mouse_leave) # 6 + self.scriptBar.Bind(wx.EVT_LEAVE_WINDOW, self.on_mouse_leave) # 7 + def initPubSub(self): Publisher.subscribe(self.toggleEditButtons, "EnableEditButtons") Publisher.subscribe(self.enableButtons, "EnablePlotButtons") From 855cf173489880e67a8fb43949f609509aa652e6 Mon Sep 17 00:00:00 2001 From: stephanie Date: Mon, 9 Jan 2017 15:48:48 -0700 Subject: [PATCH 7/7] anno, set schema --- odmtools/odmdata/memory_database.py | 1 + 1 file changed, 1 insertion(+) diff --git a/odmtools/odmdata/memory_database.py b/odmtools/odmdata/memory_database.py index 5a17727..2d9d24e 100644 --- a/odmtools/odmdata/memory_database.py +++ b/odmtools/odmdata/memory_database.py @@ -76,6 +76,7 @@ def getDataValuesDF(self): def get_annotations(self): result_id = self.df.resultid[0] + setSchema(self.series_service._session_factory.engine) annotation = self.series_service.get_annotations_by_result(resultid=result_id) self.results_annotations = annotation return self.results_annotations