class Window(QWidget):
def __init__(self, connection):
super(Window, self).__init__()
self.conn = connection
self.proxyModel = MySortFilterProxyModel(self)
self.proxyModel.setDynamicSortFilter(True)
self.proxyView = QTreeView()
set_tree_view(self.proxyView)
self.proxyView.setModel(self.proxyModel)
self.proxyView.customContextMenuRequested.connect(self.pop_menu)
self.filterType = QComboBox()
self.filterModule = QComboBox()
self.filterClass = QComboBox()
self.filterNote = QComboBox()
self.infLabel = QLabel()
self.link_type = QComboBox()
self.resView = QTreeView()
set_tree_view(self.resView)
self.resModel = QSortFilterProxyModel(self.resView)
self.resView.setModel(self.resModel)
self.resView.customContextMenuRequested.connect(self.menu_res_view)
self.link_box = self.set_layout()
self.sort_key = None
self.repo = []
self.old_links = []
self.new_links = []
self.query_time = time_run()
self.curr_id_db = 0
self.setWindowTitle("Custom Sort/Filter Model")
self.resize(900, 750)
def set_layout(self):
filter_box: QGroupBox = self.set_filter_box()
height = 92
filter_box.setMaximumHeight(height)
link_box = self.set_link_box()
link_box.setMaximumHeight(height)
link_box.hide()
stack_layout = QVBoxLayout()
stack_layout.addWidget(filter_box)
stack_layout.addWidget(link_box)
proxyLayout = QGridLayout()
proxyLayout.addWidget(self.proxyView, 0, 0)
proxyLayout.addLayout(stack_layout, 1, 0)
proxyLayout.addWidget(self.resView, 2, 0)
proxyLayout.setRowStretch(0, 5)
proxyLayout.setRowStretch(1, 0)
proxyLayout.setRowStretch(2, 3)
proxyGroupBox = QGroupBox("Module/Class/Method list")
proxyGroupBox.setLayout(proxyLayout)
mainLayout = QVBoxLayout()
mainLayout.addWidget(proxyGroupBox)
self.setLayout(mainLayout)
return link_box
def save_clicked(self, btn):
{
"Unload DB": save_init,
"Copy all links": copy_to_clipboard
}[btn.text()]()
def set_filter_box(self):
save_btn = QDialogButtonBox(Qt.Vertical)
save_btn.addButton("Unload DB", QDialogButtonBox.ActionRole)
save_btn.addButton("Copy all links", QDialogButtonBox.ActionRole)
save_btn.clicked.connect(self.save_clicked)
self.filterNote.addItem("All")
self.filterNote.addItem("Not blank")
filterTypeLabel = QLabel("&Type Filter")
filterTypeLabel.setBuddy(self.filterType)
filterModuleLabel = QLabel("&Module Filter")
filterModuleLabel.setBuddy(self.filterModule)
filterClassLabel = QLabel("&Class Filter")
filterClassLabel.setBuddy(self.filterClass)
filterNoteLabel = QLabel("&Remark Filter")
filterNoteLabel.setBuddy(self.filterNote)
filter_box = QGridLayout()
filter_box.addWidget(filterTypeLabel, 0, 0)
filter_box.addWidget(filterModuleLabel, 0, 1)
filter_box.addWidget(filterClassLabel, 0, 2)
filter_box.addWidget(filterNoteLabel, 0, 3)
filter_box.addWidget(save_btn, 0, 4, 2, 1)
filter_box.addWidget(self.filterType, 1, 0)
filter_box.addWidget(self.filterModule, 1, 1)
filter_box.addWidget(self.filterClass, 1, 2)
filter_box.addWidget(self.filterNote, 1, 3)
self.set_filters_combo()
self.textFilterChanged()
self.filterType.currentIndexChanged.connect(self.textFilterChanged)
self.filterModule.currentIndexChanged.connect(
self.textFilterModuleChanged)
self.filterClass.currentIndexChanged.connect(self.textFilterChanged)
self.filterNote.currentIndexChanged.connect(self.textFilterChanged)
grp_box = QGroupBox()
grp_box.setFlat(True)
grp_box.setLayout(filter_box)
return grp_box
def set_filters_combo(self):
curs = self.conn.cursor()
self.filterType.clear()
self.filterType.addItem("All")
curs.execute(qsel3)
for cc in curs:
self.filterType.addItem(memb_type[cc[0]])
self.filterModule.clear()
self.filterModule.addItem("All")
self.filterModule.addItem("")
curs.execute(qsel0)
for cc in curs:
self.filterModule.addItem(cc[0])
self.filterClass.clear()
self.filterClass.addItem("All")
curs.execute(qsel1)
for cc in curs:
self.filterClass.addItem(cc[0])
def textFilterModuleChanged(self):
curs = self.conn.cursor()
self.filterClass.clear()
self.filterClass.addItem("All")
if self.filterModule.currentText() == "All":
curs.execute(qsel1)
else:
curs.execute(
("select distinct class from methods2 "
"where module = ? order by class;"),
(self.filterModule.currentText(), ),
)
for cc in curs:
self.filterClass.addItem(cc[0])
for cc in curs:
self.filterType.addItem(memb_type[cc[0]])
def menu_res_view(self, pos):
"""
only copy to clipboard
"""
menu = QMenu(self)
menu.addAction("clipboard")
# menu.addAction("refresh")
action = menu.exec_(self.resView.mapToGlobal(pos))
if action:
self._to_clipboard()
def _to_clipboard(self):
rr = []
for rep in self.repo:
pp = [str(x) for x in rep]
rr.append("\t".join(pp))
QApplication.clipboard().setText("\n".join(rr))
def pop_menu(self, pos):
idx = self.proxyView.indexAt(pos)
menu = QMenu(self)
if idx.isValid():
menu.addAction("First level only")
menu.addSeparator()
menu.addAction("sort by level")
menu.addAction("sort by module")
menu.addSeparator()
menu.addAction("append row")
if idx.isValid():
menu.addAction("delete rows")
menu.addAction("edit links")
menu.addSeparator()
menu.addAction("not called")
menu.addSeparator()
menu.addAction("complexity")
menu.addSeparator()
menu.addAction("refresh")
menu.addAction("reload DB")
action = menu.exec_(self.proxyView.mapToGlobal(pos))
if action:
self.menu_action(action.text())
def setSourceModel(self, model: QStandardItemModel):
self.proxyModel.setSourceModel(model)
set_columns_width(self.proxyView)
set_headers(self.proxyModel, main_headers)
def textFilterChanged(self):
self.proxyModel.filter_changed(
self.filterType.currentText(),
self.filterModule.currentText(),
self.filterClass.currentText(),
self.filterNote.currentText(),
)
def menu_action(self, act: str):
{
"First level only": self.first_level_only,
"sort by level": self.sort_by_level,
"sort by module": self.sort_by_module,
"append row": self.append_row,
"refresh": self.refresh,
"not called": self.is_not_called,
"complexity": self.recalc_complexity,
"reload DB": self.reload_data,
"edit links": self.edit_links,
"delete rows": self.delete_selected_rows,
}[act]()
def recalc_complexity(self):
"""
add radon cyclomatic complexity repor data
"""
mm = self.filterModule.currentText()
module = "" if mm == "All" else mm
cc_list = cc_report(module)
for row in cc_list:
self.update_cc(row)
mark_deleted_methods(cc_list, module)
def update_cc(self, row: Iterable):
"""
@param row: CC, length, type(C/F/M), module, class, method
"""
sql_sel = ("select id from methods2 where "
"type = ? and module = ? and class = ? and method = ?")
sql_upd = "update methods2 set cc = ?, length = ? " "where id = ?"
sql_ins = ("insert into methods2 (CC, length, type, module, "
"Class, method, remark) values(?,?,?,?,?,?,?);")
rr = (*row, )
qq = self.conn.cursor()
id = qq.execute(sql_sel, rr[2:]).fetchone()
if id:
qq.execute(sql_upd, (*rr[:2], id[0]))
else:
tt = datetime.now().strftime("%Y-%m-%d %H:%M")
qq.execute(sql_ins, (*rr, tt))
self.conn.commit()
def is_not_called(self):
qq = self.conn.cursor()
qq.execute(not_called)
self.set_res_model(qq, call_headers, False)
set_columns_width(self.resView, proportion=(2, 2, 5, 7, 7, 2, 3, 5))
set_headers(self.resModel, call_headers)
def reload_data(self):
sql1 = (
"delete from methods2;",
"insert into methods2 ("
"ID, type, module, class, method, CC, length, remark) "
"values (?, ?, ?, ?, ?, ?, ?, ?);",
)
input_file = prj_path / input_meth
load_table(input_file, sql1)
sql2 = (
"delete from one_link;",
"insert into one_link (id, call_id) values (?, ?);",
)
input_file = prj_path / input_link
load_table(input_file, sql2)
curs = conn.cursor()
curs.execute("delete from links;")
conn.commit()
curs.execute(all_levels_link)
conn.commit()
self.refresh()
def refresh(self):
model = QStandardItemModel(0, len(main_headers.split(",")),
self.proxyView)
qq = conn.cursor()
qq.execute(qsel2)
vv = ((x[0], memb_type[x[1]], *x[2:-2], x[-2].rjust(4), x[-1])
for x in qq)
fill_in_model(model, vv)
self.setSourceModel(model)
def clear_report_view(self):
self.repo.clear()
model = QStandardItemModel(0, len(rep_headers.split(",")),
self.resView)
self.resModel.setSourceModel(model)
set_columns_width(self.resView,
proportion=(3, 2, 2, 2, 7, 7, 7, 2, 2, 1))
set_headers(self.resModel, rep_headers)
self.query_time = time_run()
def append_row(self):
crs = conn.cursor()
items = (
memb_key[self.proxyModel.type_filter],
self.proxyModel.module_filter,
self.proxyModel.class_filter,
"",
"",
"",
"",
self.query_time[0],
)
crs.execute(ins0, items)
idn = crs.lastrowid
conn.commit()
param = (
self.proxyModel.rowCount(),
(self.proxyModel.type_filter, *items[1:]),
idn,
)
add_row(self.proxyModel, param)
def delete_selected_rows(self):
idx_list = self.proxyView.selectionModel().selectedRows()
idx_list.reverse()
for p_idx in idx_list:
if p_idx.isValid():
row = p_idx.row()
self.delete_from_db(p_idx)
self.proxyModel.removeRows(row, 1)
def delete_from_db(self, index: QModelIndex):
id_db = self.proxyModel.get_data(index, Qt.UserRole)
conn.execute("delete from methods2 where id=?;", (id_db, ))
conn.commit()
def edit_links(self):
index = self.proxyView.currentIndex()
ss = self.proxyModel.get_data(index)
id_db = self.proxyModel.get_data(index, Qt.UserRole)
self.infLabel.setText("{:04d}: {}".format(id_db, ".".join(ss[1:4])))
self.link_box.show()
qq = conn.cursor()
qq.execute(sql_links.format(id_db, id_db))
self.set_res_model(qq, link_headers, True)
self.repo.append((id_db, 'Sel', *ss[:4]))
set_columns_width(self.resView, proportion=(3, 2, 8, 8, 8))
set_headers(self.resModel, link_headers)
self.old_links = qq.execute(sql_id2.format(id_db, id_db)).fetchall()
self.new_links = self.old_links[:]
self.curr_id_db = id_db
def set_res_model(self, qq: Iterable, headers: str, user_data: bool):
self.repo.clear()
for row in qq:
self.repo.append(row)
model = QStandardItemModel(0, len(headers.split(",")), self.resView)
fill_in_model(model, self.repo, user_data)
self.resModel.setSourceModel(model)
def set_link_box(self):
self.link_type.addItem("What")
self.link_type.addItem("From")
f_type = QLabel("Link &type:")
f_type.setBuddy(self.link_type)
ok_btn = QDialogButtonBox()
ok_btn.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
ok_btn.addButton("+", QDialogButtonBox.ActionRole)
ok_btn.addButton("-", QDialogButtonBox.ActionRole)
ok_btn.clicked.connect(self.btn_clicked)
l_box = QGridLayout()
l_box.addWidget(self.infLabel, 0, 0)
l_box.addWidget(f_type, 1, 0)
l_box.addWidget(self.link_type, 1, 1)
l_box.addWidget(ok_btn, 1, 2)
l_box.setRowStretch(0, 1)
l_box.setRowStretch(1, 0)
l_box.setRowStretch(2, 1)
grp = QGroupBox()
grp.setFlat(True)
grp.setLayout(l_box)
return grp
def btn_clicked(self, btn):
{
"OK": self.ok_clicked,
"Cancel": self.cancel_cliked,
"+": self.plus_clicked,
"-": self.minus_clicked,
}[btn.text()]()
def ok_clicked(self):
s_new = set(self.new_links)
s_old = set(self.old_links)
added = s_new - s_old
removed = s_old - s_new
if removed:
for link in removed:
conn.execute("delete from one_link where id=? and call_id=?;",
link)
if added:
for link in added:
conn.execute(
"insert into one_link (id, call_id) values (?, ?);", link)
conn.commit()
self.resModel.sourceModel().clear()
self.link_box.hide()
if removed or added:
recreate_links()
def cancel_cliked(self):
self.resModel.sourceModel().clear()
self.link_box.hide()
def plus_clicked(self):
"""
add link to resModel
"""
to_insert = self.collect_links_with_selected()
row_no = self.resModel.rowCount()
for row in to_insert:
add_row(self.resModel, (row_no, row[1:], row[0]))
row_no += 1
def collect_links_with_selected(self):
"""
creation links according to selected rows in proxyView
and direction of link selected in self.link_type:
self.curr_id_db - DB id of edited method (object)
link is a pair of ids (what called, called from)
"""
stat = self.link_type.currentText()
idx_sel = self.proxyView.selectedIndexes()
idx_col0 = [ix for ix in idx_sel if ix.column() == 0]
to_insert = []
for idx in idx_col0:
id = self.proxyModel.get_data(idx, Qt.UserRole)
link = (id,
self.curr_id_db) if stat == "What" else (self.curr_id_db,
id)
if link in self.new_links or link[::-1] in self.new_links:
continue
self.new_links.append(link)
row = self.proxyModel.get_data(idx)[:-1]
to_insert.append([id, stat] + row)
return to_insert
def minus_clicked(self):
idx_sel = self.resView.selectionModel().selectedRows()
idx_sel.reverse()
for idx in idx_sel:
self.remove_in_new_links(idx)
self.remove_in_model(idx)
def remove_in_new_links(self, index: QModelIndex):
link_type = self.resModel.data(index)
id_db = self.resModel.data(index, Qt.UserRole)
link = ((id_db, self.curr_id_db) if link_type == "What" else
(self.curr_id_db, id_db))
self.new_links.remove(link)
def remove_in_model(self, index):
row = index.row()
self.resModel.removeRows(row, 1)
def get_selected_methods(self):
"""
Returns lists of rows selected in the proxyView:
@return: list of selected methods
"""
indexes = self.proxyView.selectionModel().selectedRows()
methods = []
for idx in indexes:
methods.append(self.proxyModel.get_data(idx))
return methods
def first_level_only(self):
"""
select method to create link-report
depending on number of selected methods
@return: None
"""
self.clear_report_view()
self.sort_key = sort_keys["by module"]
ids = self.proxyView.selectionModel().selectedRows()
opt = len(ids) if len(ids) < 3 else "more than 2"
{
1: self.selected_only_one,
2: self.selected_exactly_two,
"more than 2": self.selected_more_than_two
}[opt](1)
def prep_sql(self, sql: str, lvl: int = 0) -> str:
mod = self.filterModule.currentText()
cls = self.filterClass.currentText()
return (sql + ("" if mod == "All" else where_mod.format(mod)) +
("" if cls == "All" else where_cls.format(cls)) +
(and_level if lvl else "") + group_by)
def selected_only_one(self, lvl):
pre = (self.query_time[1], "Sel", "")
names = self.get_selected_methods()
self.sorted_report(self.repo, (pre, names, ""))
lst = self.first_1_part(what_call_1, lvl)
pre = (self.query_time[1], "What", "")
self.sorted_report(self.repo, (pre, lst, ""))
lst = self.first_1_part(called_from_1, lvl)
pre = (self.query_time[1], "From", "")
self.sorted_report(self.repo, (pre, lst, ""))
fill_in_model(self.resModel.sourceModel(), self.repo, user_data=False)
def first_1_part(self, sql: str, lvl: int):
p_sql = self.prep_sql(sql, lvl)
ids = self.get_db_ids()
lst = self.exec_sql_b(p_sql, ids)
return [(*map(str, x), ) for x in lst]
def get_db_ids(self):
ids = []
indexes = self.proxyView.selectionModel().selectedRows()
for idx in indexes:
ids.append(self.proxyModel.get_data(idx, Qt.UserRole))
return ids
def selected_exactly_two(self, lvl):
pre = (self.query_time[1], "Sel")
names = self.get_selected_methods()
n_names = [("A", *names[0]), ("B", *names[1])]
self.sorted_report(self.repo, (pre, n_names, ""))
self.report_four("What", lvl)
self.report_four("From", lvl)
fill_in_model(self.resModel.sourceModel(), self.repo, user_data=False)
def report_four(self, what, lvl):
sql = {"What": what_call_1, "From": called_from_1}[what]
p_sql = self.prep_sql(sql, lvl)
ids = self.get_db_ids()
lst_a = self.first_2_part((ids[0], ), sql)
lst_b = self.first_2_part((ids[1], ), sql)
self.sorted_report(self.repo, (
(self.query_time[1], what, "A | B"),
list(set(lst_a) | set(lst_b)),
"",
))
self.sorted_report(self.repo, (
(self.query_time[1], what, "A - B"),
list(set(lst_a) - set(lst_b)),
"",
))
self.sorted_report(self.repo, (
(self.query_time[1], what, "B - A"),
list(set(lst_b) - set(lst_a)),
"",
))
self.sorted_report(self.repo, (
(self.query_time[1], what, "A & B"),
list(set(lst_a) & set(lst_b)),
"",
))
def first_2_part(self, ids: Iterable, sql: str) -> list:
lst = self.exec_sql_b(sql, ids)
return [(*map(str, x), ) for x in lst]
def selected_more_than_two(self, lvl):
pre = (self.query_time[1], "Sel", "")
names = self.get_selected_methods()
self.sorted_report(self.repo, (pre, names, ""))
self.report_23("What", lvl)
self.report_23("From", lvl)
fill_in_model(self.resModel.sourceModel(), self.repo, user_data=False)
def report_23(self, param, lvl):
sql = {"What": what_id, "From": from_id}[param]
ids = self.get_db_ids()
links = self.exec_sql_2(ids, lvl, sql)
rep_prep = pre_report(links)
self.methods_by_id_list(three_or_more, rep_prep[0:3:2], param, "ALL")
self.methods_by_id_list(three_or_more, rep_prep[1:], param, "ANY")
def exec_sql_2(self, ids, lvl, sql) -> list:
"""
@param: ids - list of id of selected rows
@param: lvl - level of call: all or only first
@param: sql - select methods by type of link: "call What"/"called From"
@return: list of tuples (method_id, level of call)
"""
res = []
curs = self.conn.cursor()
loc_sql = sql.format("and level=1" if lvl else "")
for id_ in ids:
w_id = curs.execute(loc_sql, (id_, ))
res.append(dict(w_id))
return res
def methods_by_id_list(self, sql: str, ids: list, what: str, all_any: str):
if ids:
cc = self.exec_sql_f(sql, (",".join((map(str, ids[0]))), ))
pre = (self.query_time[1], what, all_any)
vv = insert_levels(cc, ids[1])
self.sorted_report(self.repo, (pre, vv, ""))
def sort_by_level(self):
"""
Show lists of methods sorted by level
@param ids: indexes of selected methods
@param names: selected methods as (module, class, method) list
@return: None
"""
self.clear_report_view()
self.sort_key = sort_keys["by level"]
self.sel_count_handle()
def sort_by_module(self):
"""
Show lists of methods sorted by module name
@param ids: indexes of selected methods
@param names: selected methods as (module, class, method) list
@return: None
"""
self.clear_report_view()
self.sort_key = sort_keys["by module"]
self.sel_count_handle()
def sel_count_handle(self):
"""
This method does the same as the "first_level_only" method
@return: None
"""
ids = self.proxyView.selectionModel().selectedRows()
opt = len(ids) if len(ids) < 3 else "more than 2"
{
1: self.selected_only_one,
2: self.selected_exactly_two,
"more than 2": self.selected_more_than_two
}[opt](0)
def exec_sql_b(self, sql: str, sql_par: tuple):
"""
exesute SQL - bind parameters with '?'
@param sql:
@param sql_par:
@return: list of lists of strings
"""
curs = self.conn.cursor()
cc = curs.execute(sql, sql_par)
return [(*map(str, x), ) for x in cc]
def exec_sql_f(self, sql: str, sql_par: tuple):
"""
exesute SQL - insert parameters into SQL with str.format method
@param sql:
@param sql_par:
@return: list of lists of strings
"""
curs = self.conn.cursor()
cc = curs.execute(sql.format(*sql_par))
return [(*map(str, x), ) for x in cc]
def sorted_report(self, report: list, rep_data: tuple):
pre, lst, post = rep_data
lst.sort(key=self.sort_key)
for ll in lst:
report.append((*pre, *ll, *post))
