def updateDf(self, files: list):
"""
checks if the dataframe can be updated by the newly imported filepaths
calls the merge function if there is more than 1 file inside the filelist
also udpates the detector frame (displaying dialect data)
:param files: the whole filepath list
"""
if len(files) > 1 or len(self.XMLList) > 0:
canMerge = merger.prepareMerge(files, self.XMLList,
self.DialectList)
self.DialectList = merger.dialectList
if canMerge:
newDataFrame = merger.mergeFiles()
importer.setDataFrame(newDataFrame)
self.pt.updateModel(TableModel(newDataFrame))
self.pt.redraw()
elif len(files) > 0 and files[0].endswith(".csv"):
if not any(files[0] in x for x in self.DialectList):
self.dialect.guessDialectCSV(files[0])
self.DialectList.append([files[0], self.dialect])
else:
x = [x for x in self.DialectList if files[0] in x][0]
self.dialect = self.DialectList[self.DialectList.index(x)][1]
importer.importCSV(files[0], self.dialect)
updatedDataframe = importer.getDataFrame()
self.pt.updateModel(TableModel(updatedDataframe))
self.pt.redraw()
self.updateDialect(self.dialect)
def import_csv(self):
# Get file to import
input_file = tkFileDialog.askopenfilename()
if not input_file.strip():
tkMessageBox.showerror(title="Import Failed",
message="Import failed as no file was selected.")
return
try:
import_df = pd.read_csv(input_file)
except ParserError:
tkMessageBox.showerror(
"The supplied file is not a valid CSV file, could not import.")
if len(import_df) > 0:
# Data was loaded.
DataStore.data.reset_index(level=["id_product"], inplace=True)
table_df = DataStore.data.append(import_df, ignore_index=False)
table_df.set_index("id_product", inplace=True)
DataStore.data = table_df
self.data_table.updateModel(TableModel(table_df))
self.data_table.redraw()
tkMessageBox.showinfo(title="Import Successful",
message="Import Completed Successfully!")
else:
tkMessageBox.showinfo(title="Import Failed",
message="Input file did not have any CSV data so no data was added.")
def __init__(self, parent=None):
self.parent = parent
Frame.__init__(self)
self.main = self.master
self.main.geometry('600x400+200+100')
self.main.title('Table app')
f = Frame(self.main)
f.pack(fill=BOTH, expand=1)
df = TableModel.getSampleData()
self.table = pt = Table(f,
dataframe=df,
showtoolbar=True,
showstatusbar=True)
pt.show()
return
def smmm(u):
#f.grid(row=15,column=0,sticky=W,ipadx=600,ipady=17)
df = TableModel.getSampleData()
pt = Table(leftFrame2,dataframe=u,showtoolbar=True, showstatusbar=True)
pt.grid(row=15,column=0,sticky=W,ipadx=345,ipady=17)
pt.show()
def use_global_filter_local(self):
pattern_df_lists = []
for n in self.global_pattern_table.multiplerowlist:
model_name = self.global_pattern_table.model.df.iloc[int(
n)]['model']
# logger.debug("model_name"+model_name)
global_partition = self.global_pattern_table.model.df.iloc[int(
n)]['partition']
global_predictor = self.global_pattern_table.model.df.iloc[int(
n)]['predictor']
g_filter_l_query = " select array_to_string(fixed,',') as Partition,array_to_string(variable,',') as Predictor,"+\
"array_to_string(fixed_value,',') as partition_values,agg,model,fixed,fixed_value,variable,"+\
"theta,param,stats,dev_pos,dev_neg from "+self.assigned_local_table+\
" where array_to_string(fixed,',')='"+global_partition+\
"' and array_to_string(variable,',')='"+global_predictor+\
"' and model = '"+model_name+"';"
self.local_output_pattern_df = pd.read_sql(g_filter_l_query,
self.conn)
# logger.debug(g_filter_l_query)
local_shown = self.local_output_pattern_df[[
'partition', 'partition_values', 'predictor', 'agg'
]]
model = TableModel(dataframe=local_shown)
self.local_pattern_table.updateModel(model)
self.local_pattern_table.redraw()
def filter_data():
global df
global table
# df.drop('column_name', axis=1, inplace=True)
# df.drop(df.columns[[0, 1, 3]], axis=1)
# df.drop([Column Name or list],inplace=True,axis=1)
def f(x):
suf = '(?={0})[^0-9]*'.format(re.escape(suf_filter.get()))
bf = '(?={0})[^0-9]*'.format(re.escape(bf_filter.get()))
hf = '(?={0})[^0-9]*'.format(re.escape(hf_filter.get()))
chf = '(?={0})[^0-9]+'.format(re.escape(chf_filter.get()))
b = ((active_characters[x[CHAR]].get() == 1)
and (command_filter.get() == '' or x[CMD] == command_filter.get())
and (hl_filter.get() == ''
or re.match(hl_filter.get(), x[HL]) is not None)
and (suf_filter.get() == '' or re.match(suf, x[SUF]) is not None)
and (bf_filter.get() == '' or re.search(bf, x[BF]) is not None)
and (hf_filter.get() == '' or re.search(hf, x[HF]) is not None)
and
(chf_filter.get() == '' or re.search(chf, x[CHF]) is not None))
return b
tf = df[df[[CHAR, CMD, HL, SUF, BF, HF, CHF]].apply(f, axis=1)]
temp = table.model.columnwidths
table.model = TableModel(tf)
table.model.columnwidths = temp
table.redraw()
def userData(self): self.__foodButton['state'] = NORMAL self.__userButton['state'] = DISABLED self.__selectedState = Sheets.USER self.df = self.table.model.df self.table.updateModel(TableModel(self.uf)) self.table.redraw()
def show_updated_output(self):
filtered_result_df = self.use_local_filter_output()[1]
self.query_result_df = filtered_result_df
model = TableModel(dataframe=filtered_result_df)
self.query_result_table.updateModel(model)
self.query_result_table.redraw()
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
df = self.get_cryptocurrency()
tb_m = TableModel(dataframe=df)
table = Table(self, model=tb_m)
table.show()
table.redraw()
def update_window(self, x0, y0, x, h):
"""
Updates the graphs and the table accroding to the given data
:param x0: initial position on x-axis
:param y0: f(x0)
:param x: final position on x-axis
:param h: a grid step
:return: None
"""
x0_new, y0_new, x_new, h_new = float(x0.get()), float(y0.get()), float(
x.get()), float(h.get())
if x0_new < x_new and h_new > 0 and y0_new > 0 and (
x_new - x0_new) / h_new <= 10000:
plt.figure(1).gca().clear()
plt.figure(2).gca().clear()
plt.figure(3).gca().clear()
df = self.plot.draw_functions(
plt.figure(1).gca(), x0_new, y0_new, x_new, h_new)
self.canvas1.draw()
self.plot.draw_local_errors(
plt.figure(2).gca(), x0_new, y0_new, x_new, h_new)
self.canvas2.draw()
self.plot.draw_approximation_errors(
plt.figure(3).gca(), x0_new, y0_new, x_new)
self.canvas3.draw()
self.table.updateModel(TableModel(df))
self.table.show()
def reset_output(self):
model = TableModel(dataframe=self.original_query_result_df)
self.query_result_table.updateModel(model)
self.query_result_table.redraw()
self.query_result_df = self.original_query_result_df
def run_query(self):
self.user_query, self.query_group_str, self.agg_function, self.user_agg, self.agg_name, self.cur_table_name = self.query_temp.get_query(
)
# logger.debug(self.user_query)
self.handle_view ="\nDROP VIEW IF EXISTS user_query;"+\
"\nCREATE VIEW user_query as "+ self.user_query
# logger.debug(self.handle_view)
try:
self.cur.execute(self.handle_view)
except:
tkinter.messagebox.showinfo("Info",
"Invalid Query, Please Doublecheck!")
self.original_query_result_df = pd.read_sql(self.user_query, self.conn)
self.query_result_df = self.original_query_result_df
self.plot_data_convert_dict, self.query_data_convert_dict = self.db_info.get_db_data_type(
self.cur_table_name)
self.plot_data_convert_dict[self.agg_name] = 'numeric'
self.query_data_convert_dict[self.agg_name] = 'float'
self.assigned_global_table = 'dev.{}_global'.format(
self.cur_table_name)
self.assigned_local_table = 'dev.{}_local'.format(self.cur_table_name)
model = TableModel(dataframe=self.original_query_result_df)
self.query_result_table.updateModel(model)
self.query_result_table.redraw()
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
df = self.get_history()
tb_m = TableModel(dataframe=df)
table = Table(self, model=tb_m)
table.show()
#alter the DataFrame in some way, then update
table.redraw()
def get_data_for_symbol_list(self, parameter):
self.parameter = parameter
self.setting_view.update_view(parameter=parameter)
df = self.get_correlation()
tbm = TableModel(dataframe=df)
self.table.model = tbm
self.table.show()
self.table.redraw()
def __init__(self, parent=None):
window = Toplevel(chirag)
f = Frame(window)
f.pack(fill=BOTH,expand=1)
df = TableModel.getSampleData()
table = pt = Table(f, dataframe=df,showtoolbar=True, showstatusbar=True)
pt.importCSV(chirag.filename)
pt.show()
return
def reset_output(self):
model = TableModel(dataframe=self.original_query_result_df)
self.query_result_table.updateModel(model)
self.query_result_table.redraw()
self.query_result_table.setRowColors(
rows=self.high_outlier_row_numbers, clr='#ffffff', cols='all')
self.query_result_table.setRowColors(rows=self.low_outlier_row_numbers,
clr='#ffffff',
cols='all')
self.query_result_df = self.original_query_result_df
def refresh_table_data(self):
res = tkMessageBox.askyesno(title="Are you sure you want to refresh the DB.",
message="Are you sure that you want to refresh the DB.\n"
"This will undo any changes that you made before saving your data. This includes CSV file that you have imported")
if res == tkMessageBox.NO:
return
data_df = get_db_data()
DataStore.data = data_df
self.data_table.updateModel(TableModel(data_df))
self.data_table.redraw()
def update(self):
history = HistoryController.History()
self.parameters = history.get_all_parameter_from_history()
self.parameter_list = ParameterList(self, self.parameters)
self.parameter_list.grid(row=1, column=1, sticky=(tk.N, tk.S, tk.E, tk.W))
self.parameter_list.config(relief=tk.GROOVE, bd=2)
df = self.get_correlation()
tbm = TableModel(dataframe=df)
if df.empty:
return True
self.table.model = tbm
self.table.show()
self.table.redraw()
def refresh_table_data(self):
res = tkMessageBox.askyesno(title="Ready to reboot DB.",
message="Ready to reboot DB.\n"
"Undo")
if res == tkMessageBox.NO:
return
data_df = get_db_data()
Vault.data = data_df
self.data_table.updateModel(TableModel(data_df))
self.data_table.redraw()
def show_global_pattern(self):
global_query = "select array_to_string(fixed,',') as Partition,array_to_string(variable,',') as Predictor,agg,"+\
"round((lambda)::numeric(4,2),2) as Support,model from "+self.assigned_global_table+\
" where array_to_string(array_sort(fixed||variable),',')='"+self.query_group_str+"';"
# logger.debug(global_query)
self.global_pattern_df = pd.read_sql(global_query, self.conn)
# logger.debug(self.global_pattern_df.head())
# logger.debug(list(self.global_pattern_df))
pattern_model = TableModel(dataframe=self.global_pattern_df)
self.global_pattern_table.updateModel(pattern_model)
self.global_pattern_table.redraw()
def __init__(self, passed_dataframe=TableModel.getSampleData(), parent=None):
self.is_showing = True
self.parent = parent
tk.Frame.__init__(self)
self.main = tk.Toplevel(parent)
self.main.geometry('1000x400+200+100')
self.main.title('My Trades Table')
self.main.protocol('WM_DELETE_WINDOW', self.on_closing)
f = tk.Frame(self.main)
f.pack(fill=tk.BOTH, expand=1)
df = passed_dataframe
self.table = pt = Table(f, dataframe=df, showtoolbar=True, showstatusbar=True)
pt.show()
return
def show_updated_output(self):
self.low_outlier_text = Label(self.high_low_frame,
text='Unusually\nLow: ',
font=('Times New Roman bold', 10),
bg='light yellow')
self.low_outlier_text.grid(column=0, row=0)
self.low_outlier_label = Label(self.high_low_frame,
bg='#98df8a',
height=2,
width=2)
self.low_outlier_label.grid(column=1, row=0)
self.high_outlier_text = Label(self.high_low_frame,
text='Unusually\nHigh: ',
font=('Times New Roman bold', 10),
bg='light yellow')
self.high_outlier_text.grid(column=0, row=1)
self.high_outlier_label = Label(self.high_low_frame,
bg='#ff9896',
height=2,
width=2)
self.high_outlier_label.grid(column=1, row=1)
if (self.low_outlier_row_numbers):
self.query_result_table.setRowColors(
rows=self.low_outlier_row_numbers, clr='#ffffff', cols='all')
if (self.high_outlier_row_numbers):
self.query_result_table.setRowColors(
rows=self.high_outlier_row_numbers, clr='#ffffff', cols='all')
chosen_row, filtered_result_df = self.use_local_filter_output()
low_outlier_rows, self.low_outlier_row_numbers, high_outlier_rows, self.high_outlier_row_numbers = self.get_outlier_frame(
chosen_row, filtered_result_df)
self.query_result_df = filtered_result_df
model = TableModel(dataframe=filtered_result_df)
self.query_result_table.updateModel(model)
self.query_result_table.redraw()
if (self.low_outlier_row_numbers):
self.query_result_table.setRowColors(
rows=self.low_outlier_row_numbers, clr='#98df8a', cols='all')
if (self.high_outlier_row_numbers):
self.query_result_table.setRowColors(
rows=self.high_outlier_row_numbers, clr='#ff9896', cols='all')
def show_local_pattern(self):
local_query = "select array_to_string(fixed,',') as Partition,array_to_string(variable,',') as Predictor,"+\
"array_to_string(fixed_value,',') as partition_values,agg,model,fixed,fixed_value,variable,"+\
"theta,param,stats,dev_pos,dev_neg from "+self.assigned_local_table+\
" where array_to_string(array_sort(fixed||variable),',')='"+self.query_group_str+"';"
for n in self.local_pattern_table.multiplerowlist:
self.chosen_local_pattern = self.global_pattern_table.model.df.iloc[
int(n)]
self.local_output_pattern_df = pd.read_sql(local_query, self.conn)
local_shown = self.local_output_pattern_df[[
'partition', 'partition_values', 'predictor', 'agg'
]]
pattern_model = TableModel(local_shown)
self.local_pattern_table.updateModel(pattern_model)
self.local_pattern_table.redraw()
def run_query(self):
self.low_outlier_text.destroy()
self.low_outlier_label.destroy()
self.high_outlier_text.destroy()
self.high_outlier_label.destroy()
self.user_query, self.query_group_str, self.agg_function, self.user_agg, self.agg_name, self.cur_table_name = self.query_temp.get_query(
)
# logger.debug(self.user_query)
self.handle_view ="\nDROP VIEW IF EXISTS user_query;"+\
"\nCREATE VIEW user_query as "+ self.user_query
# logger.debug(self.handle_view)
try:
self.cur.execute(self.handle_view)
self.conn.commit()
except:
tkinter.messagebox.showinfo("Info",
"Invalid Query, Please Doublecheck!")
self.original_query_result_df = pd.read_sql(self.user_query, self.conn)
self.query_result_df = self.original_query_result_df
self.plot_data_convert_dict, self.query_data_convert_dict = self.db_info.get_db_data_type(
self.cur_table_name)
self.plot_data_convert_dict[self.agg_name] = 'numeric'
self.query_data_convert_dict[self.agg_name] = 'float'
self.assigned_global_table = 'pattern.{}_global'.format(
self.cur_table_name)
self.assigned_local_table = 'pattern.{}_local'.format(
self.cur_table_name)
model = TableModel(dataframe=self.original_query_result_df)
self.query_result_table.updateModel(model)
self.query_result_table.setRowColors(
rows=self.high_outlier_row_numbers, clr='#ffffff', cols='all')
self.query_result_table.setRowColors(rows=self.low_outlier_row_numbers,
clr='#ffffff',
cols='all')
self.query_result_table.redraw()
def __init__(self, parent, controller):
from tkinter import ttk
tk.Frame.__init__(self, parent)
s=str("Month: "+m+" and Weather Condition: "+c+".")
from pandastable import Table, TableModel
lbl=tk.Label(self, text=s, font=("Arial Bold", 18))
lbl.grid(row=0, column=1)
f = Frame(self)
f.grid(row=2, column=0, columnspan=3)
df = TableModel.getSampleData()
print(type(df))
self.table = pt = Table(f, dataframe=df1,
showtoolbar=True, showstatusbar=True)
pt.show()
btn122=tk.Button(self, text="Back", command=lambda : controller.show_frame(pageone))
btn122.grid(row=0, column=0)
btn122=tk.Button(self, text='Go to Home', command=lambda : controller.show_frame(startpage))
btn122.grid(row=3, column=1)
label=tk.Label(self, text=txt)
label.grid(row=1, column=0, columnspan=4)
def open(self):
if self.view.column_mapping_dataframe is None:
self.model = TableModel(dataframe=pd.read_excel(
io=self.view.wb_filename,
header=self.view.header_row - 1,
sheet_name=self.view.ws_name_selection))
self.mapper_dict = {}
for column_name in self.model.df.columns.values.tolist():
self.mapper_dict[column_name] = ColumnMapper(
master_frame=self,
paned_frame=self.mapping_paned_window,
col_name=column_name)
for obj in self.mapper_dict.values():
self.mapping_paned_window.add(obj, minsize=30, stretch="never")
else:
self.model = self.view.column_mapping_dataframe
self.table.updateModel(self.model)
self.table.statusbar.update()
self.bind_all("<KP_8>", self.table.handle_arrow_keys)
self.bind_all("<Return>", self.table.handle_arrow_keys)
self.bind_all("<Tab>", self.table.handle_arrow_keys)
self.grid()
def import_csv(self):
input_file = tkFileDialog.askopenfilename()
if not input_file.strip():
tkMessageBox.showerror(title="Error, Failed!", message="...")
return
try:
import_df = pd.read_csv(input_file)
except ParserError:
tkMessageBox.showerror("Failed, Try again!.")
if len(import_df) > 0:
Vault.data.reset_index(level=["id_product"], inplace=True)
table_df = Vault.data.append(import_df, ignore_index=False)
table_df.set_index("id_product", inplace=True)
Vault.data = table_df
self.data_table.updateModel(TableModel(table_df))
self.data_table.redraw()
tkMessageBox.showinfo(title="Done",message="Pass")
else:
tkMessageBox.showinfo(title="Error, Failed!", message="...")
def __update_table(self):
"""__update_table updates pandastable to display the actual dataframe"""
self.__pdtable.updateModel(TableModel(self.__importer.dfx))
self.__pdtable.redraw()
def handle_question(self, direction):
self.question_tuple = ''
config = ExplConfig()
config.conn = self.config.conn
config.cur = self.config.cur
config.query_table_name = self.cur_table_name
eg = ExplanationGenerator(
config, {
'pattern_table': 'dev.{}'.format(self.cur_table_name),
'query_result_table': self.cur_table_name
})
eg.initialize()
col_name = [
'Explanation_Tuple', "Score", 'From_Pattern', "Drill_Down_To",
"Distance", "Outlierness", "Denominator", "relevent_model",
"relevent_param", "refinement_model", "drill_param"
]
exp_df = pd.DataFrame(columns=[
"From_Pattern", "Drill_Down_To", "Score", "Distance",
"Outlierness", "Denominator", "relevent_model", "relevent_param",
"refinement_model", "drill_param"
])
for n in self.query_result_table.multiplerowlist:
self.question = self.query_result_table.model.df.iloc[[int(n)]]
self.original_question = self.question.copy(deep=True)
self.question.rename(columns={self.agg_name: self.user_agg},
inplace=True)
self.question_tuple = self.query_result_df.iloc[[int(n)]]
# logger.debug(self.question)
self.question['direction'] = direction
self.question['lambda'] = 0.2
question = self.question.iloc[0].to_dict()
# logger.debug(question)
elist = eg.do_explain_online(question)
exp_list = []
for e in elist:
tuple_list = []
# print(str(e.tuple_value))
# print(str(e.tuple_value.keys()))
# e_tuple_str = ','.join(map(str, e.tuple_value.values()))
e_tuple_str = e.ordered_tuple_string()
tuple_list.append(e_tuple_str)
score = round(e.score, 2)
tuple_list.append(score)
if e.expl_type == 1:
local_pattern=(
'[' + ','.join(e.relevent_pattern[0]) +\
'=' + ','.join(list(map(str, e.relevent_pattern[1]))) +']:'+ \
','.join(list(map(str, e.relevent_pattern[2])))+' \u2933 '+self.agg_name
)
relevent_model = e.relevent_pattern[4]
if e.relevent_pattern[4] == 'const':
relevent_param = str(
round(
float(e.relevent_pattern[6].split(',')[0][1:]),
2))
else:
# relevent_param = 'Intercept=' + str(e.relevent_pattern[7]['Intercept'])+', '+str(list(e.relevent_pattern[7])[1])+'='+str(round(e.relevent_pattern[7][list(e.relevent_pattern[7])[1]],2))
relevent_param = e.relevent_pattern[7]
drill_down_to = ','.join([
x for x in e.refinement_pattern[0]
if x not in e.relevent_pattern[0]
])
refinement_model = e.refinement_pattern[4]
if e.refinement_pattern[4] == 'const':
drill_param = str(
round(
float(
e.refinement_pattern[6].split(',')[0][1:]),
2))
else:
drill_param = e.refinement_pattern[7]
else:
relevent_model = e.relevent_pattern[4]
local_pattern=(
'[' + ','.join(e.relevent_pattern[0]) +\
'=' + ','.join(list(map(str, e.relevent_pattern[1]))) +']:'+ \
','.join(list(map(str, e.relevent_pattern[2])))+' \u2933 '+self.agg_name
)
if e.relevent_pattern[4] == 'const':
relevent_param = str(
round(
float(e.relevent_pattern[6].split(',')[0][1:]),
2))
else:
# relevent_param = 'Intercept=' + str(e.relevent_pattern[7]['Intercept'])+', '+str(list(e.relevent_pattern[7])[1])+'='+str(e.relevent_pattern[7][list(e.relevent_pattern[7])[1]])
relevent_param = e.relevent_pattern[7]
refinement_model = ''
drill_down_to = ''
drill_param = ''
tuple_list.append(local_pattern)
tuple_list.append(drill_down_to)
distance = round(e.distance, 2)
tuple_list.append(distance)
outlierness = round(e.deviation, 2)
tuple_list.append(outlierness)
denominator = round(e.denominator, 2)
tuple_list.append(denominator)
tuple_list.append(relevent_model)
tuple_list.append(relevent_param)
tuple_list.append(refinement_model)
tuple_list.append(drill_param)
exp_list.append(tuple_list)
df_exp = pd.DataFrame(exp_list, columns=col_name)
exp_df = exp_df.append(df_exp, ignore_index=True)
self.exp_df = exp_df[col_name]
model = TableModel(dataframe=self.exp_df)
self.exp_table.updateModel(model)
self.exp_table.redraw()
def test(self):
path = 'test_batch'
for i in range(20):
df = TableModel.getSampleData()
df.to_csv(os.path.join(path, 'test%s.csv' % str(i)))
return