IP-калькулятор (python) / view / window

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()