import sys
import ipaddress
import tkinter as tk
from tkinter import ttk
from tkinter import *
from tkinter import messagebox as mb
from netaddr import *
import pprint
import ipcalc
from functools import partial
from datetime import datetime
#import mysql.connector
from window_database import Database_window
from window_user_guide import User_Guide
from constant_ip_calc import *
node_subnetwork = 'None'
class Window:
#Меню и работа с дочерними окнами#
def __init__(self, title = "IP-Калькулятор", resizable = (False, False),icon = None):
self.root = Tk()
self.root.title(title)
self.root.geometry("1024x768+100+100")
self.root.config(bg = color)
menubar = Menu(self.root)
self.root.config(menu = menubar)
fileMenu = Menu(menubar)
menubar.add_cascade(label = "База данных", menu = fileMenu)
fileMenu.add_command(label = "Перейти", command = self.create_history)
#Меню и работа с дочерними окнами#
#Графика#
def chek(self):
# Первый столбец
self.chk_state_level1 = IntVar()
self.level1_var = tk.Checkbutton(self.root, text = 'Определение класса сети', var = self.chk_state_level1,
bg = color, font = font_Checkbutton)
self.level1_var.place(x = 20,y = 120)
self.chk_state_level2 = IntVar()
self.level2_var = Checkbutton(self.root, text = 'Перевод IP из десятичной \nв двоичную систему счисления',
var = self.chk_state_level2, bg=color,font = font_Checkbutton, justify=LEFT)
self.level2_var.place(x = 20,y = 140)
self.chk_state_level3 = IntVar()
self.level3_var = tk.Checkbutton(self.root, text = 'Перевод IP из десятичной \nв шестнадцатеричную систему счисления',
var = self.chk_state_level3, bg = color, font = font_Checkbutton, justify = LEFT)
self.level3_var.place(x = 20, y = 180)
# Второй столбец
self.chk_state_level4 = IntVar()
self.level4_var = tk.Checkbutton(self.root, text = 'Вычисления адреса сети по IP', var = self.chk_state_level4, bg = color, font = font_Checkbutton)
self.level4_var.place(x = 310, y = 120)
self.chk_state_level5 = IntVar()
self.level5_var = tk.Checkbutton(self.root, text = 'Вычисление адреса узла по IP', var = self.chk_state_level5, bg=color, font = font_Checkbutton)
self.level5_var.place(x = 310, y = 140)
self.chk_state_level6 = IntVar()
self.level6_var = tk.Checkbutton(self.root, text = 'Определение широковещательного адреса',var = self.chk_state_level6, bg=color, font = font_Checkbutton)
self.level6_var.place(x = 310, y = 160)
self.chk_state_level7 = IntVar()
self.level7_var = tk.Checkbutton(self.root, text = 'Определение широковещательного узла', var = self.chk_state_level7, bg = color, font = font_Checkbutton)
self.level7_var.place(x = 310, y = 180)
# Третий столбец
self.chk_state_level8 = IntVar()
self.level8_var = tk.Checkbutton(self.root, text = 'Количество доступных узлов',var = self.chk_state_level8, bg = color, font = font_Checkbutton)
self.level8_var.place(x = 620, y = 120)
self.chk_state_level9 = IntVar()
self.level9_var = tk.Checkbutton(self.root, text = 'Распределение адресного пространства на основе маски подсети',
var = self.chk_state_level9, bg = color)
self.level9_var.place(x = 620, y = 150)
self.chk_state_level10 = IntVar()
self.level10_var = tk.Checkbutton(self.root, text='Вычисление подсетей',var = self.chk_state_level10, bg = color, font = font_Checkbutton)
self.level10_var.place(x = 620, y = 180)
self.list_chek = [self.chk_state_level1,self.chk_state_level2,self.chk_state_level3,self.chk_state_level4,
self.chk_state_level5,self.chk_state_level6,self.chk_state_level7,
self.chk_state_level8,self.chk_state_level9,self.chk_state_level10]
# Поля вывода информации
self.text_table = Text(width = 120, height = 30)
self.text_table.place(x = 25, y = 220)
self.scroll = Scrollbar(command=self.text_table.yview)
self.scroll.place(x = 989, y = 220, height = 485)
self.text_table.config(yscrollcommand=self.scroll.set)
def draw_widgets(self):
self.file_frame_Full_name = LabelFrame(self.root, text = 'Пользователь')
self.file_frame_Full_name.place(height = 60, width = 140, x = 880 , y = 5 )
self.str_user_name_result = 'N'
self.str_user_name = 'Алексей'
self.str_user_otecestvo_result = 'N'
self.str_user_otecestvo = 'Алексеевич'
self.str_user_famaly_result = 'None'
self.str_user_famaly = "Иванов"
if len(self.str_user_famaly) > 9:
self.str_user_famaly_result = self.str_user_famaly[0:9]+'.'
else:
self.str_user_famaly_result = self.str_user_famaly
if len(self.str_user_name) != 0:
self.str_user_name_result = self.str_user_name[0:1]
if len(self.str_user_otecestvo) != 0:
self.str_user_otecestvo_result = self.str_user_otecestvo[0:1]
self.label_Full_name = Label(self.root, text = self.str_user_famaly_result + ' ' + self.str_user_name_result + '.' + ' ' + self.str_user_otecestvo_result + '.', bg = color, font = font_label)
self.label_Full_name.place(x = 885, y = 20)
# Первый текст - IP-адрес
self.label_ip = Label(self.root, text = 'IP-адрес', bg = color, font = font_label)
self.label_ip.place(x = 30, y = 17)
# Поле для ввода ip-адреса
self.ent_ip = Entry(self.root )
self.ent_ip.place(x = 120, y = 20, width = 220)
self.label_ip = Label(self.root, text = 'Кол-во узлов:', bg = color, font = 'Segoe_UI 10')
self.label_ip.place(x = 790, y = 180)
self.ent_node = Entry(self.root)
self.ent_node.place(x = 890, y = 180, width = 100)
# Второй текст - маска
self.label_mask = Label(self.root, text = 'Маска', bg = color, font = font_label)
self.label_mask.place(x = 350, y = 17)
#Поле для выбора необходимой маски
self.combo = ttk.Combobox(self.root, values = Mask, state = "readonly")
self.combo.current(0)
self.combo.place(x = 420, y = 20)
# Кнопка старт
self.btn_start = Button(self.root, text = 'Запустить',activebackground = color_new_btn, bg = color_btn, font = font_btn, command = self.main)
self.btn_start.place(x = 600, y = 13)
#Кнопка полного сброса
self.btn_discharge = Button(self.root, text = 'Cброс',activebackground = color_new_btn, bg = color_btn, font = font_btn , command = self.Delete_text_full)
self.btn_discharge.place(x =700, y = 13)
# Кнопка Выхода
self.btn_destroy = Button(self.root, text = 'Выход',activebackground = color_new_btn, bg = color_btn, font = font_btn, command = exit)
self.btn_destroy.place(x = 770, y = 13)
# Кнопка помощь
self.btn_user_guide = Button(self.root, text = '?', bg = color_btn, activebackground = color_new_btn, font = font_btn ,command = self.create_User_Guide )
self.btn_user_guide.place(x = 845, y = 13)
# CHEKBOX кнопки для выбора опции и вставки галочки
self.label_operation = Label(self.root, text = 'Выберите необходимые операции:', bg = color, font = font_label)
self.label_operation.place(x = 350, y = 80)
#Графика#
#Входнные данные#
def get_string(self):
return self.ent_ip.get()
def Ip_input(self):
self.ip_value = self.get_string() #получаем значения IP
return self.ip_value
#Функция проверяет , является ли наша строка числом
def is_int(self, str):
try:
int(str)
return True
except ValueError:
return False
#Функция проверяет , наш десятичного ip на правильность ввода
def chek_ip (self):
self.ip_value = self.Ip_input()
self.Erorr = False
self.spisok_ip = self.ip_value.split('.')
for i in self.spisok_ip:
if len(self.spisok_ip) == 4:
if (self.is_int(i) == True):
if ((int(i) <= 255) and (int(i) >= 0)):
pass
else:
self.Erorr = True
mb.showerror(Erorr_text_main, sErorr_text_IP)
break
else:
self.Erorr = True
mb.showerror(Erorr_text_main, Erorr_text_IP)
break
else:
self.Erorr = True
mb.showerror(Erorr_text_main, Erorr_text_IP)
break
return self.Erorr
#Функция получения значения из формы Mask 255.255.255.255 /32
def Mask_input(self): #получаем значения из формы MASK
self.mask_value = self.combo.get()
for i in self.mask_value: #Делим масску 255.255.255.255 и на /32
self.str_mask = self.mask_value.split(" ")
self.mask_chislo = IPAddress(self.str_mask[0]) #получаем значения 255.255.255.255
return self.str_mask #получаем значения /32
#Функция получение обратной маски
def Wildcard (self):
self.mask_value = self.Mask_input()
self.wildcard = str(ipaddress.IPv4Address(int(ipaddress.IPv4Address(self.mask_value[0]))^(2**32-1)))# преобразование обычной маски в обратную с помощью формулы
return self.wildcard
#Входнные данные#
#Обработка данных#
#Функция перевод из десятичной в двоичную систему нашего MASK
def Converting_MASK_2BINARY(self):
self.mask_value = self.Mask_input()
self.mask_chislo = IPAddress(self.mask_value[0])
return self.mask_chislo.bits()
#Функция перевод из десятичной в двоичную систему нашего IP(Кнопка 1)
def Converting_IP_to_2binary(self):
self.ip_value_chislo = IPAddress(self.Ip_input())
return self.ip_value_chislo.bits()
#Функция перевод из десятичной в шестнадцатеричную систему нашего IP (КНОПКА 2)
def Converting_IPV4_to_IPV6(self):
self.ip_value = self.Ip_input()
self.IPV6 = ipaddress.IPv6Address('::' + self.ip_value).compressed
return str(self.IPV6)
#Функция определения адреса подсети (КНОПКА 3)
def Adress_network(self):
self.ip_value = self.Ip_input()#получаем значения IP
self.mask_value = self.Mask_input()
self.mask_slah = self.mask_value[1]
self.localnet = ipcalc.Network(self.ip_value + self.mask_slah)# получение адреса подсети
return str(self.localnet.network())
#Функция определения узла сети (КНОПКА 6)
def Node(self):
self.ip_value = self.Ip_input()
self.wildcard_mask = self.Wildcard()# преобразование обычной маски в обратную с помощью формулы
self.Address_Node = IPAddress(self.ip_value) & IPAddress(self.wildcard_mask) #рассчет адреса узла, путем умножения IP на обратную маску
return str(self.Address_Node)
#Функция определения Широковещательного адресса (КНОПКА 7)
def Broadcast_address(self):
self.ip_value = self.Ip_input()
self.mask_value = self.Mask_input()
self.wildcard_mask = self.Wildcard() # преобразование обычной маски в обратную с пом0ощью формулы
self.net = ipaddress.IPv4Network(self.ip_value + '/' + self.mask_value[0], False)
self.broadcast = str(self.net.broadcast_address)
self.ip_value = IPAddress(self.ip_value)
self.wildcard_mask =IPAddress(self.wildcard_mask)
self.broadcast = IPAddress(self.broadcast)
self.text_table.configure(state ='normal')
self.text_table.insert('end' ,"Вычисление широковещательного адреса:\n \t" + str(self.ip_value.bits()) + '\n + \n \t' + str(self.wildcard_mask.bits()) + '\n = \n \t' + str(self.broadcast.bits()))
self.text_table.insert('end' , '\n')
self.text_table.configure(state = 'disabled')
return str(self.broadcast)
#Функция определения Широковещательного узла (КНОПКА 8)
def Broadcast_node(self):
self.ip_value = self.Ip_input()
self.wildcard_mask = self.Wildcard()# преобразование обычной маски в обратную с помощью формулы
self.broadcast_node = IPAddress(self.ip_value) & IPAddress(self.wildcard_mask) #рассчет адреса узла, путем умножения IP на обратную маску
self.ip_value = IPAddress(self.ip_value)
self.wildcard_mask =IPAddress(self.wildcard_mask)
self.broadcast_node = IPAddress(self.broadcast_node)
self.text_table.configure(state ='normal')
self.text_table.insert('end' ,"Вычисление широковещательного узла:\n \t" + str(self.ip_value.bits()) + '\n & \n \t' + str(self.wildcard_mask.bits()) + '\n = \n \t' + str(self.broadcast_node.bits()))
self.text_table.insert('end' , '\n')
self.text_table.configure(state = 'disabled')
return str(self.broadcast_node)
#Функция определения класса сети (КНОПКА 1)
def Class_network(self):
self.ip_bin = self.Converting_IP_to_2binary()
for i in self.ip_bin:
if self.ip_bin[0] == ("0"):
self.class_network = "A"#получаем класс сети А
self.Output("Класс сети :", self.class_network)
break
elif (self.ip_bin[0] == ("1") and self.ip_bin[1] == ("0")):
self.class_network = "B"#получаем класс сети B
self.Output("Класс сети :", self.class_network)
break
elif (self.ip_bin[0] == ("1") and self.ip_bin[1] == ("1") and self.ip_bin[2] == ("0")):
self.class_network = "C"#получаем класс сети С
self.Output("Класс сети :", self.class_network)
break
elif (self.ip_bin[0] == ("1") and self.ip_bin[1] == ("1") and self.ip_bin[2] == ("1") and self.ip_bin[3] == ("0")):
self.class_network = "D"#получаем класс сети D
self.Output("Класс сети :", self.class_network)
break
else:
self.class_network = "E"#получаем класс сети E
self.Output("Класс сети :", self.class_network)
break
return self.class_network
#Функции определения номера узла (КНОПКА 10)
def Number_node(self):
self.Erorr_warning = False
self.mask_value = self.Mask_input()
self.mask_slah = int(self.mask_value[1].replace("/",""))
self.number = 2**(32 - self.mask_slah)
self.Output("Количество доступных адресов в порции хоста:",str(self.number))
if (self.number <= 2):
self.Erorr_warning = True
mb.showwarning(Warning_text_main, "Количество рабочих адресов для хоста равно 0")
self.mass_number = str(self.number)+ "/"+ str(0)
else:
self.Output("Количество рабочих адресов для хоста:", str(self.number-2))
self.mass_number = str(self.number)+ "/"+ str(self.number-2)
return self.mass_number
#Функция адресного пространства IP (КНОПКА 11) баг с выводом ip
def Address_space_allocation(self):
self.Erorr_warning = False
self.ip_value = self.Ip_input()
self.mask_value = self.Mask_input()
self.ip = IPNetwork(self.ip_value + self.mask_value[1])
self.mask_slah = int(self.mask_value[1].replace("/",""))
if (int(self.mask_slah) == 31):
self.Output("IP адрес первого хоста:",str(self.ip[0]))
if (self.ip[0] == self.ip [-1]):
self.Erorr_warning = True
mb.showwarning(Warning_text_main, "IP адрес первого хоста совпадает с IP адрес последнего хоста")
else:
self.Output("IP адрес последнего хоста:",str(self.ip[-1]))
self.result_address = str(self.ip[0])+"/"+'\n'+str(self.ip[-1])
elif (int(self.mask_slah) < 31):
self.Output("IP адрес первого хоста:",str(self.ip[0]+1))
self.Output("IP адрес последнего хоста:", str(self.ip[-1]-1))
self.result_address = str(self.ip[0]+1)+"/"+'\n'+str(self.ip[-1]-1)
else:
self.Output("IP адрес первого хоста:", str(self.ip[0]))
self.result_address = str(self.ip[0])
return self.result_address
#Функция Вычисление подсети (КНОПКА 12)
def Address_space_allocation_group(self):
self.Error_input_ip = self.chek_ip()
global node_subnetwork
self.ip_node = int(node_subnetwork)
print(node_subnetwork)
self.mask_value = self.Mask_input()
self.localnet = IPAddress(str(self.Adress_network()))
self.subnetwork = ""
self.subnetwork_list = []
self.old_mask = int(self.mask_value[1].replace('/',''))
self.free_bits = 32 - self.old_mask #
n = 2 #
self.node_bits = 1 #
while n <= self.ip_node: #
n *= 2 #
self.node_bits += 1
if (self.node_bits <= self.free_bits):
self.subnet_bits = self.free_bits - self.node_bits
if (self.subnet_bits >= 1):
self.new_mask = self.old_mask + self.subnet_bits
self.new_subnerwork = str(self.localnet) + '/' + str(self.new_mask)
self.ostatok = 32 - self.old_mask - self.subnet_bits - self.node_bits
self.old_subnerwork = str(self.localnet)+str(self.mask_value[1])
self.old_subnerworkIP = IPNetwork(self.old_subnerwork)
self.delenie_blocks = 2 ** self.subnet_bits
blocks = int((2 ** (32 - self.old_mask)) / self.delenie_blocks)
n = 0
if (self.delenie_blocks <= 2**13):
for i in range(self.delenie_blocks):
self.subnetwork_n = (str(self.old_subnerworkIP[n]) + "/" + str(self.new_mask) + "|")
self.subnetwork = str(self.subnetwork + self.subnetwork_n)
n = n + blocks
self.subnetwork = self.subnetwork.rstrip('.')
self.subnetwork_list = self.subnetwork.split("|")
del self.subnetwork_list[-1]
mb.showinfo(
Info_text_main,
"Число узлов введено верно")
else:
mb.showwarning(Warning_text_main,"Ресурсы компьютера не смогут это обработать")
else:
mb.showerror(Erorr_text_main,"Количество введенных узлов слишком много, нельзя выделить места для подсети")
else:
mb.showerror(Erorr_text_main,"Нет свободных битов")
print("длина списка",len(self.subnetwork_list))
print(self.subnetwork_list)
self.Output_list("Подсеть", self.subnetwork_list)
return len(self.subnetwork_list)
#Обработка данных#
#Вывод выходных данных#
def Output_data(self):
self.text_table.configure(state ='normal')
self.text_table.insert('end', 'Дата и время: \t')
self.text_table.insert('end', datetime.now())
self.text_table.insert('end', '\n')
self.date_now = datetime.now()
return self.date_now
gg = 1
def Output_operation (self):
global gg
self.text_table.configure(state ='normal')
if self.gg != 1:
self.text_table.insert('end', '\n')
self.text_table.insert('end', '****************************** Запись №'+str(self.gg)+' *********************************\n')
self.text_table.insert('end', '\n')
self.text_table.configure(state ='disabled')
#Функция вывода текста
def Output(self, text_value, value):
self.text_table.configure(state ='normal')
self.text_table.insert('end' , text_value + "\t" + value)
self.text_table.insert('end', '\n')
self.text_table.insert('end', '--------------------------------------------------------------------------\n')
self.text_table.configure(state ='disabled')
#Функция вывода лист
def Output_list(self, text_value, value):
self.text_table.configure(state ='normal')
if (len(value)) <= 8:
for i in range(len(value)):
self.text_table.insert('end', '\n' + text_value + " " + "№" + "\t" + str(i + 1) + "\t" + value[i])
self.text_table.insert('end', '\n')
else:
for i in range(4):
self.text_table.insert('end' ,'\n' + text_value + " " + "№" + "\t" + str(i + 1) + "\t"+ value[i])
self.text_table.insert('end' ,'\n')
self.text_table.insert('end' ,'........................................')
for i in range(len(value) - 4, len(value)):
self.text_table.insert('end' ,'\n' + text_value + " " + "№" + "\t" + str(i + 1) + "\t" + value[i])
self.text_table.insert('end', '\n')
self.text_table.configure(state = 'disabled')
#Вывод выходных данных#
#Функция удаления текста построчно (КНОПКА СБРОСА)
def Delete_text(self):
self.text_table.configure(state = 'normal')
self.text_table.delete('3.0', 'end')
self.text_table.configure(state = 'disabled')
def Delete_text_full(self):
self.text_table.configure(state = 'normal')
self.text_table.delete('1.0', 'end')
self.text_table.configure(state = 'disabled')
#Функция проверки поставленной галочки
def flag_chekbutton_list(self):
self.flag_chekbutton = False
for i in self.list_chek:
if i.get() == 1:
self.flag_chekbutton = True
else:
pass
return self.flag_chekbutton
#Функция main запуск всех опций если поставленна галочка
def main(self):
self.Error_input_ip = self.chek_ip()
if (self.Error_input_ip == True): #Проверка на правильность ввода IP
pass
else:
self.database()
self.Count1 = "SELECT Count, Entry_number FROM Users"
self.mycursor.execute(self.Count1)
self.result = self.mycursor.fetchall()
print(self.result)
if self.result == []:
self.count = 1
else:
if self.count == self.result[-1][0]:
self.count = self.result[-1][0] + 1
self.Id_users = 18
if self.result == []:
self.Entry_number = 1
else:
if self.Entry_number == self.result[-1][1]:
self.Entry_number = self.result[-1][1] + 1
self.mycursor.execute("INSERT INTO Users(Count, ID_users, Entry_number, Time) VALUES(%s, %s, %s, %s)", [ self.count, self.Id_users, self.Entry_number, self.date])
self.mydb.commit()
self.flag_chekbutton = self.flag_chekbutton_list()
self.ip = self.Ip_input()
self.mask = self.combo.get()
if (self.flag_chekbutton == True): #Проверка на поставлена ли галочка
self.date = self.Output_operation()
self.date = self.Output_data()
self.Output("IP aдрес:", self.ip) #Вывод ip
if self.chk_state_level1.get() == 1: #Если 1 галочка поставлена
self.class_n = self.Class_network()
#Функция определения класса сети (КНОПКА 1)
else:
self.class_n = 'None'
if self.chk_state_level2.get() == 1: #Если 2 галочка поставлена
self.ip_bits = self.Converting_IP_to_2binary() #Функция перевод из десятичной в двоичную систему нашего IP(Кнопка 2)
self.Output("IP в двоичной записи ", self.ip_bits)
else:
self.ip_bits = 'None'
if self.chk_state_level3.get() == 1: #Если 3 галочка поставлена
self.IPV6 = self.Converting_IPV4_to_IPV6() #Функция перевод из десятичной в шестнадцатеричную систему нашего IP(Кнопка 3)
self.Output("IP в шестнадцатеричной записи", self.IPV6)
else:
self.IPV6 = 'None'
if self.chk_state_level4.get() == 1: #Если 4 галочка поставлена
self.Address_network_output = self.Adress_network() #Функция определения адреса подсети (КНОПКА 4)
self.Output("IP адрес сети:", self.Address_network_output)
else:
self.Address_network_output = 'None'
if self.chk_state_level5.get() == 1: #Если 5 галочка поставлена
self.Node_output = self.Node() #Функция определения узла сети (КНОПКА 5)
self.Output("IP адрес узла:", self.Node_output)
else:
self.Node_output = 'None'
if self.chk_state_level6.get() == 1: #Если 6 галочка поставлена
self.Broadcast_address_output = self.Broadcast_address() #Функция определения Широковещательного адресса (КНОПКА 6)
self.Output("Широковещательный адрес:", self.Broadcast_address_output)
else:
self.Broadcast_address_output = 'None'
if self.chk_state_level7.get() == 1: #Если 7 галочка поставлена
self.Broadcast_node_output = self.Broadcast_node() #Функция определения Широковещательного узла (КНОПКА 7)
self.Output("Широковещательный узел: ", self.Broadcast_node_output)
else:
self.Broadcast_node_output = 'None'
if self.chk_state_level8.get() == 1: #Если 8 галочка поставлена
self.Aval_node_all = self.Number_node() #Функции определения количетсва доступных узлов (КНОПКА 8)
else:
self.Aval_node_all = 'None'
if self.chk_state_level9.get() == 1: #Если 9 галочка поставлена
self.Address_space = self.Address_space_allocation() #Функция адресного пространства IP (КНОПКА 9)
else:
self.Address_space = 'None'
if self.chk_state_level10.get() == 1:
global node_subnetwork
self.nodes_result = self.input_nodes()
node_subnetwork = self.nodes_result
self.len_subnetwork = self.Address_space_allocation_group()
print(self.len_subnetwork)
#Если 10 галочка поставлена
#Функция вычисление подсетей (КНОПКА 10)
else:
self.len_subnetwork ='None'
self.mycursor.execute("INSERT INTO ip_adress_table(Entry_number_employeer, IP_address, Subnet_Mask, Class_network, Converting_IP_Address_to_Binary_system, Converting_IP_Address_to_Decimal_system) VALUES(%s, %s, %s, %s, %s, %s)",[ self.Entry_number, self.ip, self.mask, self.class_n, self.ip_bits, self.IPV6])
self.mycursor.execute("INSERT INTO mask_table(Entry_number_for_mask, Mask, Network_address, Node_address, Number_of_node, Broadcast_address, Broadcast_node_addres, Available_address, IP_hostmin_hostmax, Subnet) VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)", [ self.Entry_number, self.mask, self.Address_network_output, self.Node_output, self.ip_node_str, self.Broadcast_address_output, self.Broadcast_node_output, self.Address_space, self.Aval_node_all, self.long_subnetwork_list])
self.mydb.commit()
else:#Если галочка нет
mb.showwarning(Warning_text_main, "Пожалуйста поставьте хотя бы одну галочку, чтобы операция была выполнена")
def database(self):
self.mydb = mysql.connector.connect(
host="127.0.0.1",
user="root",
password="Dbrnjh123456",
database="data_calculate1"
)
self.mycursor = self.mydb.cursor()
def run(self):
self.root.mainloop()
def exit(self):
choise = mb.askyesno("Выход","Вы хотите выйти?")
if choise:
self.root.destroy()
def create_history(self):
Database_window(self.root)
def create_User_Guide(self):
User_Guide(self.root)
def input_nodes(self):
self.nodes = self.ent_node.get() #получаем значения IP
return self.nodes
window = Window()
window.chek()
window.draw_widgets()
window.run()
Соседние файлы в папке view