dyploma

import sys
import math
import numpy as np

from tkinter import *
from PIL import Image, ImageTk


def recount_pow(_indexes_arr, _covered_rows):
    _pow_col = np.zeros([2, appr_sol_binary.shape[1]])

    for i in range(appr_sol_binary.shape[1]):
        for j in range(appr_sol_binary.shape[0]):
            if i in _indexes_arr:
                _pow_col[:, i] = 0
            if j not in _covered_rows:
                _pow_col[0, i] += appr_sol_binary[j, i]
                _pow_col[1, i] += appr_sol_weighted[j, i]

    return _pow_col


def L1_func(_appr_sol_binary, _marks, _covered_rows, _indexes_arr):
    _L1 = 0

    for i in range(_appr_sol_binary.shape[1]):
        if i in mark_mass:
            _L1 += -alpha + betta * alpha_j[i]

    _tmp_sum_pow = 0
    _tmp_pow = recount_pow(_indexes_arr, _covered_rows)
    max_index = 0

    while _tmp_sum_pow < _appr_sol_binary.shape[0] - len(_covered_rows):
        for i in range(_tmp_pow.shape[1]):
            if _tmp_pow[1, i] == np.max(_tmp_pow[1]):
                max_index = i

        _L1 += -alpha + betta * _tmp_pow[1, max_index]
        _tmp_sum_pow += _tmp_pow[0, max_index]
        _tmp_pow[:, max_index] = 0

    return _L1


def _quit():
    global root
    root.destroy()


def remember_message():
    global root, alpha, betta

    alpha = var_alpha.get()
    betta = var_betta.get()

    root.destroy()


def remember_matrix_weights():
    global root

    get_values_tmp = [float(entry.get()) for entry in root.entries]

    k = 0
    for i in range(weighted_matrix.shape[0]):
        for j in range(weighted_matrix.shape[1]):
            weighted_matrix[i, j] = get_values_tmp[k]
            k += 1

    root.destroy()


def remember_k():
    get_values_tmp_ki = [float(entry.get()) for entry in root.entries_ki]
    get_values_tmp_kij = [float(entry.get()) for entry in root.entries_kij]

    k = 0
    for i in range(len(character_names)):
        character_names[i][4] = get_values_tmp_kij[i]

        if i == 0:
            character_names[i][1] = get_values_tmp_ki[0]
        if character_names[i][0] == character_names[i - 1][0] and i > 0:
            character_names[i][1] = get_values_tmp_ki[k]
        if character_names[i][0] != character_names[i - 1][0] and i > 0:
            k += 1
            character_names[i][1] = get_values_tmp_ki[k]

    root.destroy()


def rgb(r, g, b):
    return "#%s%s%s" % tuple([hex(c)[2:].rjust(2, "0") for c in (r, g, b)])

from itertools import permutations

data = []

with open('datascience/binary_matrix.tsv', 'r') as fin:
    for line in fin:
        data.append([int(x) for x in line.split()])

data = np.asarray(data, dtype=np.int64)

sums_by_rows = data.sum(axis=1)
sums_by_cols = data.sum(axis=0)

if 0 in sums_by_rows:
    print('Решения нет')
    sys.exit()

appr_sol = np.zeros(data.shape, dtype=np.int64)

redundant_rows = []

while len(redundant_rows) < data.shape[0]:
    for j in range(data.shape[1]):
        if sums_by_cols[j] == max(sums_by_cols):
            appr_sol[:, j] = data[:, j]

            for i in range(data.shape[0]):
                if data[i][j] == 1 and i not in redundant_rows:
                    redundant_rows.append(i)
            sums_by_cols[j] = 0

appr_sol_indexes = [j for j in range(data.shape[1]) if appr_sol.sum(axis=0)[j] > 0]
appr_sol_sums_by_rows = appr_sol.sum(axis=1)
exact_sol = np.zeros(data.shape, dtype=np.int64)

for i in range(data.shape[0]):
    if appr_sol_sums_by_rows[i] > 1:
        for j in range(data.shape[1]):
            if appr_sol[i, j] == 1:
                exact_sol[:, j] = appr_sol[:, j]

exact_sol_sums_by_rows = exact_sol.sum(axis=1)
exact_sol_sums_by_cols = exact_sol.sum(axis=0)

exact_sol_col_num = []

for i in range(data.shape[1]):
    if exact_sol_sums_by_cols[i] > 0:
        exact_sol_col_num.append(i)

uncovered_rows_num = 0

for i in range(exact_sol_sums_by_rows.shape[0]):
    if exact_sol_sums_by_rows[i] == 0:
        uncovered_rows_num += 1

if uncovered_rows_num > 0:
    print('cтрок осталось не покрыто: ' + str(uncovered_rows_num))

    uncovered_cols_num = len(appr_sol_indexes) - len(exact_sol_col_num)
    _matrix = np.zeros((uncovered_rows_num, uncovered_cols_num), dtype=np.int64)
    interior_matrix_j = np.zeros(uncovered_cols_num, dtype=np.int64)
    interior_matrix_i = np.zeros(uncovered_rows_num, dtype=np.int64)

    q, p = 0, 0

    for i in range(exact_sol_sums_by_rows.shape[0]):
        if exact_sol_sums_by_rows[i] == 0:
            for j in appr_sol_indexes:
                if j not in exact_sol_col_num:
                    _matrix[q, p] = appr_sol[i, j]
                    interior_matrix_j[p] = j
                    p += 1
            interior_matrix_i[q] = i
            q += 1
        p = 0
        q = 0

    print('матрица, для которой будем искать оптимальное решение')
    print(_matrix)

    L0 = uncovered_cols_num
    L1 = 0

    matrix_attrs = np.zeros((3, uncovered_cols_num), dtype=np.int64)
    mass_sum_cnt = matrix_attrs.copy()

    covered_rows = []
    mass_tmp_ind0 = []

    L1_tmp = 0
    sum_pow = 0
    max_pow = 0

    validated_sol = []

    while L1 < L0 and len(covered_rows) < uncovered_rows_num:
        for i in range(uncovered_rows_num):
            for j in range(uncovered_cols_num):
                matrix_attrs[0, j] = 0
                if _matrix[i, j] == 1 and i not in covered_rows:
                    matrix_attrs[0, j] += 1

        for j in range(uncovered_cols_num):
            if len(covered_rows) < uncovered_rows_num and \
                    matrix_attrs[1, j] == 0 and matrix_attrs[0, j] == max(matrix_attrs[0]):
                validated_sol.append(j)
                matrix_attrs[1, j] = 1
                matrix_attrs[2, j] = 1

                for i in range(uncovered_rows_num):
                    if _matrix[i, j] == 1:
                        covered_rows.append(i)

                for m in matrix_attrs[2]:
                    if m == 1:
                        L1_tmp += 1

                for n in range(uncovered_cols_num):
                    if matrix_attrs[1, n] == 0:
                        mass_tmp_ind0.append(n)

                candidates = np.array(list(permutations(mass_tmp_ind0)))
                mass_sum_cnt = np.zeros(candidates.shape, dtype=np.int64)

                for k in range(len(candidates)):
                    for t in range(len(candidates[k])):
                        sum_pow += matrix_attrs[0, candidates[k, t]]
                        mass_sum_cnt[k, t] = sum_pow
                    sum_pow = 0

                mass_sum_cnt = mass_sum_cnt.transpose()

                for a in range(len(mass_sum_cnt)):
                    for b in range(len(mass_sum_cnt[a])):
                        if mass_sum_cnt[a, b] >= uncovered_rows_num - len(covered_rows):
                            L1 = L1_tmp + a + 1
                            break
                    break

                if L1_tmp >= L1:
                    L1 = uncovered_rows_num

                L0 = len(validated_sol)

    cnt_ind0 = 0
    L0 = len(validated_sol)
    L1_tmp = 0
    mass_tmp_ind1 = []

    if uncovered_cols_num > 1:
        while cnt_ind0 < uncovered_cols_num:
            validated_sol = list(reversed(validated_sol))
            uncovered_cols_num = len(validated_sol)

            for j in range(uncovered_cols_num):
                if matrix_attrs[2, validated_sol[j]] == 1:
                    matrix_attrs[2, validated_sol[j]] = 0

                    for i in range(uncovered_rows_num):
                        if _matrix[i, validated_sol[j]] == 1:
                            covered_rows.remove(i)
                else:
                    if matrix_attrs[1, validated_sol[j]] == 1:
                        matrix_attrs[1, validated_sol[j]] = 0
                    else:
                        cnt_ind0 += 1

                while L0 < L1 and uncovered_cols_num > 1:
                    for m in range(uncovered_cols_num):
                        if matrix_attrs[2, validated_sol[m]] == 1:
                            L1_tmp += 1

                    for n in range(len(validated_sol)):
                        if matrix_attrs[1, validated_sol[n]] == 0:
                            mass_tmp_ind1.append(n)

                    candidates = np.array(list(permutations(mass_tmp_ind1)))
                    mass_sum_cnt = np.zeros(candidates.shape, dtype=np.int64)

                    for k in range(len(candidates)):
                        for t in range(len(candidates[k])):
                            sum_pow += matrix_attrs[0, candidates[k, t]]
                            mass_sum_cnt[k, t] = sum_pow
                        sum_pow = 0

                    mass_sum_cnt = mass_sum_cnt.transpose()

                    for a in range(len(mass_sum_cnt)):
                        for b in range(len(mass_sum_cnt[a])):
                            if mass_sum_cnt[a, b] >= uncovered_rows_num - len(covered_rows):
                                L1 = L1_tmp + a + 1
                                break
                        break

    for k in range(uncovered_cols_num):
        exact_sol_col_num.append(interior_matrix_j[validated_sol[k]])

    exact_sol_col_num.sort()

root = Tk()

x_window = (root.winfo_screenwidth() - root.winfo_reqwidth()) / 2
y_window = (root.winfo_screenheight() - root.winfo_reqheight()) / 2

root.title("Выбор вакансии")
root.geometry("%dx%d+%d+%d" % (900, 400, x_window - 200, y_window - 220))
root.config(relief=RIDGE, bg='lavender')

var = StringVar()

Radiobutton(root, text="Аналитик данных", width=20, height=5, bd=5, font="Vernada 16", relief=RIDGE,
            bg="gainsboro", fg="grey4", variable=var, indicatoron=False, value='analytics',
            command=_quit).place(relx=.03, rely=.14)
Radiobutton(root, text="Разработчик", width=20, height=5, bd=5, font="Vernada 16", relief=RIDGE,
            bg="gainsboro", fg="grey4", variable=var, indicatoron=False, value='developer',
            command=_quit).place(relx=.36, rely=.14)
Radiobutton(root, text="Специалист DS", width=20, height=5, bd=5, font="Vernada 16", relief=RIDGE,
            bg="gainsboro", fg="grey4", variable=var, indicatoron=False, value='datascience',
            command=_quit).place(relx=.69, rely=.14)

image_analyst = ImageTk.PhotoImage(Image.open("pictures/analyst.jpg"))
image_developer = ImageTk.PhotoImage(Image.open("pictures/developer.jpg"))
image_ds = ImageTk.PhotoImage(Image.open("pictures/ds.jpg"))

Label(root, image=image_analyst).place(relx=.09, rely=.55)
Label(root, image=image_developer).place(relx=.42, rely=.55)
Label(root, image=image_ds).place(relx=.75, rely=.55)
Label(root, text="Выберите вакансию для отбора кандидатов", font="Vernada 14", bg='lavender',
      fg="grey4").place(relx=.5, rely=.07, anchor=CENTER)

root.mainloop()

position = var.get()

binary_matrix = np.array(np.genfromtxt(position + '\\binary_matrix.tsv', delimiter='\t'))
weighted_matrix = np.array(np.genfromtxt(position + '\\weighted_matrix.tsv', delimiter='\t'))

row_sum = binary_matrix.sum(axis=1)
col_sum = binary_matrix.sum(axis=0)

root = Tk()
root.title("Этап отбора тестов")
root.geometry("%dx%d+%d+%d" % (400, 150, x_window - 100, y_window - 80))
root.config(relief='sunken', bg='lavender')

Label(root, text="Этап №1.\n\nФормирование оптимального набора тестов", font="Vernada 14",
      bg='lavender', fg="grey4").place(relx=.5, rely=.3, anchor=CENTER)

Button(text="Начать", command=_quit, width=6, height=1, bd=3, font="Vernada 14", bg="lavender",
       fg="grey4").place(relx=.5, rely=.8, anchor=CENTER)

root.mainloop()

root = Tk()
root.title("Определение коэффициентов")
root.geometry("%dx%d+%d+%d" % (680, 320, x_window - 180, y_window - 100))
root.config(relief='sunken', bg='lavender')

Label(root,
      text="Необходимо задать значения коэффициентов α и β:\nα - коэффициент важности условия минимизации количества "
           "тестов;\nβ - коэффициент важности условия максимизации степени соответствия теста качеству.\nПо умолчанию "
           "коэффициенты имеют равную значимость.\nПри необходимости измените значения:", font="Vernada 12",
      justify=LEFT, bg='lavender', fg="grey4").place(relx=.03, rely=.03, anchor="nw")

var_alpha = DoubleVar()
var_betta = DoubleVar()
var_alpha.set(0.5)
var_betta.set(0.5)

Label(root, text="α =", font="Vernada 14", bg='lavender', fg="grey4").place(relx=.42, rely=.4,
                                                                              anchor=CENTER)
Entry(textvariable=var_alpha, width=6, font="Vernada 16", bg="white", fg="grey4").place(
    relx=.52, rely=.4, anchor=CENTER)

Label(root, text="β =", font="Vernada 14", bg='lavender', fg="grey4").place(relx=.42, rely=.55,
                                                                              anchor=CENTER)
Entry(textvariable=var_betta, width=6, font="Vernada 16", bg="white", fg="grey4").place(
    relx=.52, rely=.55, anchor=CENTER)

Label(root, text="Обратите внимание:\nα + β = 1", font="Vernada 14", bg='lavender',
      fg="grey4").place(relx=.5, rely=.7, anchor=CENTER)
Button(text="OK", command=remember_message, width=4, height=1, bd=3, font="Vernada 13",
       bg="lavender", fg="grey4").place(relx=.5, rely=.87, anchor=CENTER)

root.mainloop()

if alpha + betta != 1:
    root = Tk()
    root.geometry("%dx%d+%d+%d" % (250, 120, x_window - 100, y_window - 50))
    root.config(relief='sunken', bg='lavender')
    root.title("Определение коэффициентов")

    Label(root, text="α+β != 1", font="Vernada 14", bg='lavender', fg="grey4").place(
        relx=.5, rely=.2, anchor=CENTER)
    Button(root, text="OK", command=_quit, width=4, height=1, bd=3, font="Vernada 13",
           bg="lavender", fg="grey4").place(relx=.5, rely=.6, anchor=CENTER)

    root.mainloop()
    sys.exit()

covered_rows = []
empty_cols = []
exact_cols = []
sum_by_rows_binary_matrix = binary_matrix.sum(axis=1)

with open("test_numbers.txt", "r", encoding='utf-8') as fin:
    test_numbers = [line.split('\t') for line in fin.read().split('\n')]

root = Tk()
root.title("Полный список тестов")
root.geometry("%dx%d+%d+%d" % (800, 670, x_window - 300, y_window - 270))
root.config(relief='sunken', bg='lavender')

with open("test_numbers.txt", "r", encoding='utf-8') as fin:
    text = Text(root, width=87, height=34, font="Vernada 13", bg='lavender', fg="grey4")
    text.place(x=5, y=8)
    text.insert('end', fin.read())

Button(root, text="OK", command=_quit, width=4, height=1, bd=3, font="Vernada 13", bg="lavender",
       fg="grey4").place(relx=.5, rely=.95, anchor=CENTER)

root.mainloop()

with open(position + '/character_names.tsv', "r", encoding='utf-8') as fin:
    character_names = [name.split('\t') for name in fin.read().split('\n')]

root = Tk()
root.title("Важность оцениваемых личных качеств кандидатов")
root.geometry("%dx%d+%d+%d" % (730, 700, x_window - 260, y_window - 290))
root.config(relief='sunken', bg='lavender')

for i in range(4):
    Label(root, text="", bg="lavender", fg="grey4", font="Vernada 10", justify=LEFT).grid(row=i, column=0,
                                                                                            sticky=NW)

Label(root, text="Задайте веса важности общих критериев и частных критериев", bg="lavender", fg="grey4",
      font="Vernada 11 bold", justify=LEFT).place(relx=.5, rely=.02, anchor=CENTER)
Label(root, text="Сумма весов важности общих критериев должна быть равна 1", bg="lavender", fg="gray23",
      font="Vernada 11 italic", justify=LEFT).place(relx=.0, rely=.05, anchor="nw")
Label(root, text="Сумма весов важности частных критериев должна быть равна 1 в группировке до общего критерия",
      bg="lavender", fg="gray23", font="Vernada 11 italic", justify=LEFT).place(relx=.0, rely=.08,
                                                                                  anchor="nw")
Label(root, text="Общий критерий", bg="lavender", fg="grey4", font="Vernada 11 bold", justify=LEFT).grid(
    row=5, column=0, sticky=NW)
Label(root, text="Частный критерий", bg="lavender", fg="grey4", font="Vernada 11 bold", justify=LEFT).grid(
    row=5, column=2, sticky=NW)

for i in range(len(character_names)):
    b_tmp = StringVar()
    b_tmp.set(character_names[i][0])

    if character_names[i][0] != character_names[i - 1][0] and i != 0:
        b = Label(root, textvariable=b_tmp, bg="lavender", fg="grey4", font="Vernada 11", justify=LEFT)
    elif i == 0:
        b = Label(root, textvariable=b_tmp, bg="lavender", fg="grey4", font="Vernada 11", justify=LEFT)
    else:
        b = Label(root, textvariable=StringVar(), bg="lavender", fg="grey4", font="Vernada 11", justify=LEFT)

    b.grid(row=i + 6, column=0, sticky=NW)

root.entries_ki = []

for i in range(len(character_names)):
    b_tmp = StringVar()
    b_tmp.set(character_names[i][1])

    if character_names[i][0] != character_names[i - 1][0] and i != 0:
        b = Entry(root, textvariable=b_tmp, width=5, bg="white", fg="grey4", font="Vernada 11", justify=LEFT)
        root.entries_ki.append(b)
    elif i == 0:
        b = Entry(root, textvariable=b_tmp, width=5, bg="white", fg="grey4", font="Vernada 11", justify=LEFT)
        root.entries_ki.append(b)
    else:
        b = Label(root, textvariable=StringVar(), bg="lavender", fg="grey4", font="Vernada 11",
                  justify=LEFT)

    b.grid(row=i + 6, column=1, sticky=NW)

for i in range(len(character_names)):
    b_tmp = StringVar()
    b_tmp.set(character_names[i][2])
    b = Label(root, textvariable=b_tmp, bg="lavender", fg="grey4", font="Vernada 11", justify=LEFT)
    b.grid(row=i + 6, column=2, sticky=NW)

root.entries_kij = []

for i in range(len(character_names)):
    b_tmp = StringVar()
    b_tmp.set(character_names[i][4])
    b = Entry(root, textvariable=b_tmp, width=5, bg="white", fg="grey4", font="Vernada 11", justify=LEFT)
    root.entries_kij.append(b)
    b.grid(row=i + 6, column=3, sticky=NW)

Button(root, text="Сохранить", command=remember_k, bd=3, font="Vernada 11", bg="lavender",
       fg="grey4").grid(row=len(character_names) + 7, column=2, sticky=S)

root.mainloop()

root = Tk()
root.geometry("%dx%d+%d+%d" % (1350, 510, x_window - 580, y_window - 250))
root.config(relief='sunken', bg='lavender')
root.title("Степени соответствия тестов качествам")

for i in range(weighted_matrix.shape[1]):
    b_tmp = IntVar()
    b_tmp.set(i+1)
    b = Entry(root, width=5, textvariable=b_tmp, bg="gainsboro", fg="grey4", font="Vernada 9 bold")
    b.grid(row=0, column=i+1)

for i in range(len(character_names)):
    b_tmp = StringVar()
    b_tmp.set(character_names[i][3])
    b = Entry(root, width=12, textvariable=b_tmp, bg="gainsboro", fg="grey4", font="Vernada 9 bold")
    b.grid(row=i+1, column=0)

root.entries = []

for i in range(weighted_matrix.shape[0]):
    for j in range(weighted_matrix.shape[1]):
        b_tmp = DoubleVar()
        b_tmp.set(weighted_matrix[i, j])
        b = Entry(root, width=5, textvariable=b_tmp, bg='thistle' + str(math.floor(weighted_matrix[i, j]*4 + 1)),
                  font="Vernada 9")
        b.grid(row=i+1, column=j+1)
        root.entries.append(b)

Button(root, text="Сохранить", command=remember_matrix_weights, bd=3, font="Vernada 11", bg="lavender",
       fg="grey4").grid(row=weighted_matrix.shape[0] + 1, column=0)

root.mainloop()

exact_sol_binary = np.zeros(binary_matrix.shape, dtype=np.int64)

for i in range(row_sum.shape[0]):
    if row_sum[i] == 0:
        print('Решения нет')
        sys.exit()

    if row_sum[i] == 1:
        for j in range(binary_matrix.shape[1]):
            if binary_matrix[i, j] == 1 and j not in exact_cols:
                exact_cols.append(j)

                for k in range(binary_matrix.shape[0]):
                    if binary_matrix[k, j] == 1 and k not in covered_rows:
                        covered_rows.append(k)

size_exact_sol = [binary_matrix.shape[0], len(exact_cols)]

appr_sol_binary = binary_matrix.copy()
appr_sol_weighted = weighted_matrix.copy()

for i in range(binary_matrix.shape[0]):
    if i in covered_rows:
        for j in range(binary_matrix.shape[1]):
            appr_sol_binary[i, j] = 0

for j in range(binary_matrix.shape[1]):
    if j in exact_cols:
        for i in range(binary_matrix.shape[0]):
            appr_sol_binary[i, j] = 0

for i in range(weighted_matrix.shape[0]):
    if i in covered_rows:
        for j in range(weighted_matrix.shape[1]):
            appr_sol_weighted[i, j] = 0

for j in range(weighted_matrix.shape[1]):
    if j in exact_cols:
        for i in range(weighted_matrix.shape[0]):
            appr_sol_weighted[i, j] = 0

SumInStrAppr = appr_sol_binary.sum(axis=1)
redundant_rows = []

for i in range(len(SumInStrAppr)):
    if SumInStrAppr[i] == 0:
        redundant_rows.append(i)

appr_sol_binary = np.delete(appr_sol_binary, redundant_rows, axis=0)
appr_sol_weighted = np.delete(appr_sol_weighted, redundant_rows, axis=0)

# 3.Решение
alpha_j = weighted_matrix.sum(axis=0)
weights_j = -alpha + betta * alpha_j

ind_mass = []
mark_mass = []

L1 = 0
L0 = -1

exact_sol_v2_tmp = []
exact_sol_v2 = []
exact_sol = []
cov_str_v2 = []

tmp_pow = np.zeros([2, appr_sol_binary.shape[1]])
pow_col = np.zeros([2, appr_sol_binary.shape[1]])

rev = 0
tmp_sum_pow = 0
cov_str_v2_tmp = []
pow_str = appr_sol_binary.sum(axis=1)

while (len(ind_mass) > 0 or rev == 0) and len(cov_str_v2) < appr_sol_binary.shape[0]:
    if len(exact_sol_v2_tmp) == len(mark_mass) or rev == 0:
        if rev > 0:
            del_ind = mark_mass[-1]

            for i in range(appr_sol_binary.shape[0]):
                if appr_sol_binary[i, del_ind] == 1 and i in cov_str_v2_tmp:
                    cov_str_v2_tmp.remove(i)

            if len(mark_mass) > 0:
                mark_mass.pop()
            L1 = L1_func(appr_sol_binary, mark_mass, cov_str_v2_tmp, ind_mass)

        if L1 > L0:
            cov_str_v2.clear()

            while len(cov_str_v2) < appr_sol_binary.shape[0]:

                if L1 > L0:
                    pow_col = recount_pow(ind_mass, cov_str_v2)

                    for j in range(appr_sol_binary.shape[1]):
                        if (pow_col[1, j]) == max(pow_col[1]):
                            ind_mass.append(j)
                            mark_mass.append(j)
                            exact_sol_v2.append(j)
                            exact_sol_v2_tmp.append(j)

                            for i in range(appr_sol_binary.shape[0]):
                                if appr_sol_binary[i, j] == 1 and i not in cov_str_v2 and i not in cov_str_v2_tmp:
                                    cov_str_v2.append(i)
                                    cov_str_v2_tmp.append(i)

                    L1 = L1_func(appr_sol_binary, mark_mass, cov_str_v2, ind_mass)
                    rev += 1
                else:
                    break
            L0 = L1

    else:
        ind_mass.pop()
        exact_sol_v2_tmp.pop()

exact_col_all = exact_cols + exact_sol_v2
exact_test_names = []

for i in range(len(test_numbers)):
    if int(test_numbers[i][0]) - 1 in sorted(exact_col_all):
        exact_test_names.append(test_numbers[i][1])

with open('exact_test_names.txt', 'w', encoding='utf-8') as fout:
    for i in range(len(exact_test_names)):
        fout.write(exact_test_names[i])
        fout.write('\n')

root = Tk()
root.title("Оптимальный список тестов")
root.geometry("%dx%d+%d+%d" % (800, 290, x_window - 300, y_window - 100))
root.config(relief='sunken', bg='lavender')

with open("exact_test_names.txt", "r", encoding='utf-8') as fin:
    text = Text(root, width=70, height=12, font="Vernada 14", bg='lavender', fg="grey4")
    text.place(x=10, y=10)
    text.insert('end', fin.read())

b_tmp = StringVar()
b_tmp.set(str(round(L1, 1)))

Label(root, text="Оценка =", bg="lavender", fg="grey4", font="Vernada 11 bold").place(relx=.48, rely=.75,
                                                                                        anchor=CENTER)
Label(root, textvariable=b_tmp, bg="lavender", fg="grey4", font="Vernada 11 bold").place(relx=.55, rely=.75,
                                                                                           anchor=CENTER)
Button(root, text="OK", command=_quit, width=4, height=1, bd=3, font="Vernada 13", bg="lavender",
       fg="grey4").place(relx=.5, rely=.85, anchor=CENTER)

root.mainloop()

print('Номера тестов, входящих в оптимальное решение:')
print(sorted(exact_col_all))

class Fuzzy:
    a = 0
    b = 0
    c = 0
    d = 0

    def __init__(self, a, b, c, d):
        self.a = a
        self.b = b
        self.c = c
        self.d = d

    def print(self):
        print(self.a, " ", self.b, " ", self.c, " ", self.d)

    def isNull(self):
        return (self.a == 0) and (self.b == 0) and (self.c == 0) and (self.d == 0)

root = Tk()
root.title("Этап оценки кандидатов")
root.geometry("%dx%d+%d+%d" % (400, 150, x_window - 100, y_window - 80))
root.config(relief=FLAT, bg='lavender')

Label(root, text="Этап №2.\n\nОценка кандидатов", font="Vernada 14", bg='lavender',
      fg="gray4").place(relx=.5, rely=.3, anchor=CENTER)
Button(text="Начать", command=_quit, width=6, height=1, bd=3, font="Vernada 14", bg="gainsboro",
       fg="gray4").place(relx=.5, rely=.8, anchor=CENTER)

root.mainloop()

bin_matr = np.genfromtxt(position + '\\binary_matrix.tsv', delimiter='\t')
w_matr = np.genfromtxt(position + '\\weighted_matrix.tsv', delimiter='\t')

bin_matr_mass = np.array(bin_matr)
w_matr_mass = np.array(w_matr)
charact_w_mass = np.zeros(len(character_names))

for i in range(len(character_names)):
    charact_w_mass[i] = character_names[i][1] * character_names[i][4]

weight_tests = np.zeros(w_matr_mass.shape)

for i in range(w_matr_mass.shape[0]):
    for j in range(w_matr_mass.shape[1]):
        if j in exact_col_all:
            weight_tests[i, j] = w_matr_mass[i, j]

SumInStrWT = weight_tests.sum(axis=1)
CountInStrWT = np.zeros(w_matr_mass.shape[0])

for i in range(weight_tests.shape[0]):
    for j in range(weight_tests.shape[1]):
        weight_tests[i, j] = weight_tests[i, j] / SumInStrWT[i]
        if weight_tests[i, j] > 0:
            CountInStrWT[i] += 1

with open('weight_tests.txt', 'w') as fout:
    for i in range(weight_tests.shape[0]):
        for j in range(weight_tests.shape[1]):
            if j in exact_col_all:
                fout.write(str(round(weight_tests[i, j], 2)))
                fout.write('\t')
        fout.write('\n')


root = Tk()
root.title("Выбор кандидата для оценивания")
root.geometry("%dx%d+%d+%d" % (500, 150, x_window - 170, y_window - 70))
root.config(relief='sunken', bg='lavender')

Label(root, text="Введите номер кандидата,\n для которого необходимо сформировать оценку",
      font="Vernada 14", bg='lavender', fg="gray4").place(relx=.5, rely=.3, anchor=CENTER)

cand_num = StringVar()
cand_num.set(str(1))

Entry(root, textvariable=cand_num, width=5, bg="white", fg="gray4", font="Vernada 11",
      justify=CENTER).place(relx=.5, rely=.5, anchor=CENTER)
Button(text="OK", command=_quit, width=6, height=1, bd=3, font="Vernada 14", bg="gainsboro",
       fg="gray4").place(relx=.5, rely=.8, anchor=CENTER)

root.mainloop()

with open(position + '\\candidates\\Trap_numb_x' + cand_num.get() + '.tsv') as fin:
    rows = fin.readlines()

strMass_spl = [row.split('\t') for row in rows]

strMass_spl_exact = []

for i in range(len(strMass_spl)):
    arr = [strMass_spl[i][j] for j in range(len(strMass_spl[i])) if j in exact_col_all]
    strMass_spl_exact.append(arr)

strMass_spl_exact_ling = []
for i in range(len(strMass_spl_exact)):
    strMass_spl_exact_ling.append([])

    for j in range(len(strMass_spl_exact[i])):
        if strMass_spl_exact[i][j] == '0,0,0,0':
            strMass_spl_exact_ling[i].append('-')
        if strMass_spl_exact[i][j] == '0,0,1,2':
            strMass_spl_exact_ling[i].append('слишком слабо')
        if strMass_spl_exact[i][j] == '1,2,2,3':
            strMass_spl_exact_ling[i].append('слабо')
        if strMass_spl_exact[i][j] == '2,3,4,5':
            strMass_spl_exact_ling[i].append('немного слабо')
        if strMass_spl_exact[i][j] == '4,5,5,6':
            strMass_spl_exact_ling[i].append('удовлетворительно')
        if strMass_spl_exact[i][j] == '5,6,7,8':
            strMass_spl_exact_ling[i].append('не очень хорошо')
        if strMass_spl_exact[i][j] == '7,8,8,9':
            strMass_spl_exact_ling[i].append('хорошо')
        if strMass_spl_exact[i][j] == '8,9,10,10':
            strMass_spl_exact_ling[i].append('очень хорошо')

root = Tk()
root.title("Оценки кандидатов по отобранным тестам")
root.geometry("%dx%d+%d+%d" % (750, 520, x_window - 300, y_window - 200))
root.config(relief='sunken', bg='lavender')

for i in range(len(exact_col_all)):
    b_tmp = IntVar()
    b_tmp.set(exact_col_all[i]+1)
    b = Entry(root, width=10, textvariable=b_tmp, bg="gainsboro", fg="gray4", font="Vernada 9 bold")
    b.grid(row=0, column=i+1)

for i in range(len(character_names)):
    b_tmp = StringVar()
    b_tmp.set(character_names[i][3])
    b = Entry(root, width=12, textvariable=b_tmp, bg="gainsboro", fg="gray4", font="Vernada 9 bold")
    b.grid(row=i+1, column=0)

for i in range(len(strMass_spl_exact)):
    for j in range(len(strMass_spl_exact[i])):
        b_tmp = StringVar()
        b_tmp.set(strMass_spl_exact[i][j])
        b = Entry(root, width=10, textvariable=b_tmp, font="Vernada 9")
        b.grid(row=i+1, column=j+1)

Button(text="OK", command=_quit, bd=3, font="Vernada 12", bg="gainsboro", fg="gray4").grid(
    row=len(strMass_spl_exact) + 2, column=round(len(strMass_spl_exact[0]) / 2), sticky="s")

root.mainloop()

root = Tk()
root.title("Оценки кандидатов по отобранным тестам (лингвистические значения)")
root.geometry("%dx%d+%d+%d" % (1300, 520, x_window - 550, y_window - 200))
root.config(relief=RIDGE, bg='lavender')

for i in range(len(exact_col_all)):
    b_tmp = IntVar()
    b_tmp.set(exact_col_all[i] + 1)
    b = Entry(root, width=18, textvariable=b_tmp, bg="gainsboro", fg="gray4", font="Vernada 9 bold")
    b.grid(row=0, column=i+1)

for i in range(len(character_names)):
    b_tmp = StringVar()
    b_tmp.set(character_names[i][3])
    b = Entry(root, width=12, textvariable=b_tmp, bg="gainsboro", fg="gray4", font="Vernada 9 bold")
    b.grid(row=i+1, column=0)

for i in range(len(strMass_spl_exact_ling)):
    for j in range(len(strMass_spl_exact_ling[i])):
        b_tmp = StringVar()
        b_tmp.set(strMass_spl_exact_ling[i][j])
        b = Entry(root, width=18, textvariable=b_tmp, font="Vernada 9")
        b.grid(row=i+1, column=j +1)

Button(text="OK", command=_quit, bd=3, font="Vernada 12", bg="gainsboro", fg="gray4").grid(
    row=len(strMass_spl_exact) + 2, column=round(len(strMass_spl_exact[0]) / 2), sticky="s")

root.mainloop()