def accept(self):
try:
self._check_input()
self._assemble_return()
super().accept()
except Exception as e:
qtcommon.message_exc(self, "Input error", e=e)
def accept(self):
try:
self._ret_value = []
# assemble result
for r in filter(lambda x: x.has_changes(), self.titems):
self._ret_value.append(r)
# ---- CHECKS
# check table names
nms = [r.new_name for r in self.titems if not r.do_remove]
for n in nms:
self.proj.is_possible_table_name(n)
if len(set(nms)) < len(nms):
raise Exception("Repeating table names are not valid.")
# check column names
for r in self._ret_value:
cnms = [c.new_name for c in r.citems if not c.do_remove]
for c in cnms:
self.proj.is_possible_column_name(c)
if len(set(cnms)) < len(cnms):
raise Exception("Repeating column names are not valid.")
self._ret_value = self.new_dictionaries(), self._ret_value
# return
return super().accept()
except Exception as e:
qtcommon.message_exc(self, "Invalid input", e=e)
def accept(self):
try:
self.assemble_ret_value()
if self.check_input():
super().accept()
except Exception as e:
qtcommon.message_exc(self, "Invalid input", e=e)
def do(self):
import subprocess
try:
# temporary filename
fname = export.get_unused_tmp_file('xlsx')
# choose editor
prog = self.mainwin.require_editor('xlsx')
if not prog:
return
# export to a temporary
opts = basic.CustomObject()
opts.filename = fname
opts.with_caption = True
opts.with_id = True
opts.format = 'xlsx'
opts.numeric_enums = False
opts.grouped_categories = 'None'
opts.with_formatting = True
export.model_export(self.amodel().dt, opts, self.amodel(),
self.aview())
# open with editor
path = ' '.join([prog, fname])
subprocess.Popen(path.split())
except Exception as e:
qtcommon.message_exc(self.mainwin, "Open error", e=e)
def do(self):
all_cols = self.valid_col_names()
used_cols = [
self.amodel().dt.get_column(ivis=x).name
for x in self.aview().selected_columns()
]
tp = [self.amodel().dt.get_column(x).col_type() for x in all_cols]
dialog = dlgs.CovarMatDlg(self.mainwin, used_cols, all_cols, tp)
if dialog.exec_():
try:
colnames, bias, mtype = dialog.ret_value()
if mtype.startswith('sym'):
mtype = 'both'
mat = npinterface.mat_raw_values(self.amodel().dt, colnames)
if len(mat) < 2 or len(mat[0]) < 2:
raise Exception("No enough data")
if bias == 'population':
cm = stats.population_covariance_matrix(mat)
else:
cm = stats.sample_covariance_matrix(mat)
w = matrixview.MatrixView("Covariance matrix",
self.mainwin,
cm,
colnames,
colnames,
sym=mtype)
self.mainwin.add_subwindow(w)
w.show()
except Exception as e:
qtcommon.message_exc(self.mainwin, 'Error', e=e)
def do(self):
from bgui import importdlgs
dialog = dlgs.ImportTablesDlg(self.mainwin)
if dialog.exec_():
fname, frmt = dialog.ret_value()
try:
if frmt == "plain text":
dialog2 = importdlgs.ImportPlainText(
self.proj, fname,
lambda: self.mainwin.require_editor('text'),
self.mainwin)
elif frmt == "xlsx":
dialog2 = importdlgs.ImportXlsx(
self.proj, fname,
lambda: self.mainwin.require_editor('xlsx'),
self.mainwin)
else:
raise Exception("Unknow format {}".format(frmt))
except Exception as e:
qtcommon.message_exc(self.mainwin, "Import error", e=e)
return
if dialog2.exec_():
newdicts, comimp = dialog2.ret_value()
com = maincoms.ComImport(self.mainwin, newdicts, comimp)
self.flow.exec_command(com)
def confirm_input(self):
"check errors and invoke parent accept"
try:
self.check_input()
return True
except Exception as e:
qtcommon.message_exc(self, "Invalid input", e=e)
return False
def ext_preview(self):
try:
prog = self.require_editor()
if prog:
path = ' '.join([prog, self.fn])
subprocess.Popen(path.split())
except Exception as e:
qtcommon.message_exc(self, "Open editor error", e=e)
def __init__(self, flow, proj, opts):
'proj - prog.projroot.ProjectDB'
super().__init__()
# init position (will be changed by opts data)
self.resize(800, 600)
self.setWindowIcon(QtGui.QIcon(":/biostata"))
self.setGeometry(
QtWidgets.QStyle.alignedRect(
QtCore.Qt.LeftToRight, QtCore.Qt.AlignCenter, self.size(),
QtWidgets.qApp.desktop().availableGeometry()))
self.__subwindows = []
# data
self.proj = proj
self.flow = flow
self.opts = opts
self.models = []
self.tabframes = []
self.active_model = None
self.reload_options()
# assemble actions
self._build_acts()
# interface
self._ui()
# restore
try:
state, geom = self.opts.mainwindow_state()
self.restoreState(state)
self.restoreGeometry(geom)
except Exception as e:
basic.ignore_exception(e)
# signals to slots
self.flow.command_done.add_subscriber(self._update_menu_status)
self.active_model_changed.connect(self._update_menu_status)
self.database_saved.connect(self._update_menu_status)
self.wtab.currentChanged.connect(self._tab_changed)
self.proj.xml_saved.add_subscriber(self.to_xml)
self.proj.xml_loaded.add_subscriber(self.restore_from_xml)
self.proj.monitor_recent_db(self.opts)
QtWidgets.qApp.aboutToQuit.connect(self._on_quit)
# Load data
self.reset_title()
filename = self.opts.default_project_filename()
if filename is not None:
try:
self.acts['Open database'].load(filename)
except Exception as e:
qtcommon.message_exc(self, "Load error", e=e)
self._close_database()
def do(self):
from bgui import joindlg
dialog = joindlg.JoinTablesDialog(self.amodel().dt, self.mainwin)
if dialog.exec_():
try:
name, tabentries = dialog.ret_value()
dt = derived_tabs.join_table(name, tabentries, self.proj)
com = maincoms.ComAddTable(self.mainwin, dt)
self.flow.exec_command(com)
except Exception as e:
qtcommon.message_exc(self.mainwin, 'Join error', e=e)
def do(self):
from bgui import dictdlg
try:
dialog = dictdlg.DictInformation(self.proj, self.mainwin)
if dialog.exec_():
ret = dialog.ret_value()
if ret:
com = maincoms.ComChangeDictionaries(self.mainwin, ret)
self.flow.exec_command(com)
except Exception as e:
qtcommon.message_exc(self.mainwin, "Error", e=e)
self.mainwin.update()
def do_load(self):
try:
if self.spec.confirm_input():
od = self.spec.ret_value()
self.load_table(od)
tab = self.com.tab
cap = self.com.caps
self.draw_table(cap, tab)
self.buttonbox.button(
QtWidgets.QDialogButtonBox.Ok).setEnabled(True)
self.data_was_loaded.emit()
except Exception as e:
qtcommon.message_exc(self, "File parsing error", e=e)
def do(self):
from bgui import colinfodlg
try:
dialog = colinfodlg.TablesInfo(self.proj, self.mainwin)
if dialog.exec_():
newdicts, ret = dialog.ret_value()
if not ret:
return
else:
com = maincoms.ComConvertColumns(self.mainwin, newdicts,
ret)
self.flow.exec_command(com)
except Exception as e:
qtcommon.message_exc(self.mainwin, "Error", e=e)
self.mainwin.update()
def accept(self):
from prog import valuedict
try:
name = self.e_name.text().strip()
if len(name) == 0 or name[0] == '_':
raise Exception("Invalid dictionary name")
if name != self._ignore_name and name in self.projdict:
raise Exception("{} dictionary already exists".format(name))
tp = self.e_type.currentText()
keys = self.e_table.model().get_keys()
vals = self.e_table.model().get_values()
comms = self.e_table.model().get_comms()
self._ret_value = valuedict.Dictionary(name, tp, keys, vals, comms)
return super().accept()
except Exception as e:
qtcommon.message_exc(self, "Invalid input", e=e)
def _act_eview(self):
from fileproc import export
import subprocess
try:
# temporary filename
fname = export.get_unused_tmp_file('xlsx')
# choose editor
prog = self.mw.require_editor('xlsx')
if not prog:
return
# export to a temporary
export.qmodel_xlsx_export(self.tab.model(), fname, True, True)
# open with editor
path = ' '.join([prog, fname])
subprocess.Popen(path.split())
except Exception as e:
qtcommon.message_exc(self, "Open error", e=e)
def calc(self):
# get colnames which currently present in dt
cn = []
for nm in self.colnames:
if self.dt.get_column(nm) is not None:
cn.append(nm)
if len(cn) == 0:
qtcommon.message_exc(self, text='Data columns are not availible.')
# build linkage
self.linkage = stats.HierarchicalLinkage(self.dt, cn, None)
self.acts['Inspect selection'].reset()
self._bu_captions = {}
# save state
self.tab_state = self.dt.state_hash()
# set possible x-axis captions
self.xlab_wdg.set_items(
[x.name for x in self.dt.all_columns if x.is_category()])
# calculate
self.recalc()
def accept(self):
try:
ret = {}
# Find removed dicts
# [(removed name, was it in use?)], [not removed dicts]
rem_dicts, left_dicts =\
DictInfoItem.search_for_removed(self.ditems, self.proj)
# [(changed name, new dict, was it shrinked?)]
changed_dicts = DictInfoItem.search_for_changed(self.ditems)
# new dicts:
ret['__new__'] = DictInfoItem.search_for_new(self.ditems)
# check if length > 0:
rdicts = ret['__new__'] + left_dicts
lenum = len([x for x in rdicts if x.dt_type == 'ENUM'])
lbool = len([x for x in rdicts if x.dt_type == 'BOOL'])
if lenum == 0:
raise Exception("At least one enum dictionary is needed.")
if lbool == 0:
raise Exception("At least one bool dictionary is needed.")
# removed
ask_reconvert = False
for a in rem_dicts:
ret[a[0]] = None
if a[1]:
ask_reconvert = True
# changed
for a in changed_dicts:
ret[a[0]] = a[1]
if a[2]:
ask_reconvert = True
if ask_reconvert:
r = QtWidgets.QMessageBox.question(
self, "Confirmation", "Edited dictionaries were used by "
"table data. Related columns "
"will be reconverted, "
"related filters will be removed. Continue?",
QtWidgets.QMessageBox.Ok | QtWidgets.QMessageBox.Cancel)
if r != QtWidgets.QMessageBox.Ok:
return
self._ret_value = ret
super().accept()
except Exception as e:
qtcommon.message_exc(self, "Invalid input", e=e)
def accept(self):
try:
name = self.get_table_name()
self.proj.is_valid_table_name(name)
columns = self.table.model().get_columns()
cnames = [c[0] for c in columns]
for c in cnames:
self.proj.is_possible_column_name(c)
if len(set(cnames)) != len(cnames):
raise Exception("Column names should be unique.")
self.com.opt.tabname = name
self.com.tab = self.table.model().get_tab()
self.com.caps = [c[0] for c in columns]
self.com.tps = [c[1] for c in columns]
self.com.dnames = [c[2] for c in columns]
return super().accept()
except Exception as e:
qtcommon.message_exc(self, "Invalid input", e=e)
def set_captions(self):
if not self.linkage.was_calculated():
return
cn = self.xlab_wdg.combo.currentText()
if cn == '_row index':
vfrom = self.linkage.rowid
else:
if cn in self._bu_captions:
vfrom = self._bu_captions[cn]
else:
if self.is_legal_state():
vfrom = np.array(self.dt.get_column_values(cn))
vfrom = vfrom[self.linkage.rowid - 1]
self._bu_captions[cn] = vfrom
else:
qtcommon.message_exc(self, text='Syncronize data!')
return self.xlab_wdg.combo.setCurrentText('_row index')
caps = list(
map(lambda x: str(vfrom[x]), self.scene.dendrogram.bottom_order))
self.scene.set_captions(caps)
def save(self):
try:
self.proj.commit_all_changes()
self.database_saved.emit()
except Exception as e:
qtcommon.message_exc(self, "Save error", e=e)
