def unir(b1: Bosque, b2: Bosque) -> Bosque:
if b1.nodo is None:
return b2
if b2.nodo is None:
return b1
b3 = Bosque()
node = b1.nodo
while node is not None:
b3.add_arbol(Arbol(node.valor, node.primog))
node = node.sig_herm
node = b2.nodo
while node is not None:
b3.add_arbol(Arbol(node.valor, node.primog))
node = node.sig_herm
return b3
def CrearVentana():
raiz = Tk()
#Configuracion de ventana
raiz.title("TytuSQL") #Cambiar el nombre de la ventana
#raiz.iconbitmap('resources/icon.ico')
raiz.rowconfigure(0, minsize=800, weight=1)
raiz.columnconfigure(1, minsize=800, weight=1)
raiz.config(menu=CrearMenu(raiz), background='silver')
#Frame del Arbol
FrameIzquiero = Frame(raiz, relief=RAISED, bd=2)
FrameIzquiero.pack(side="left", fill="both")
#Se llama a la clase Arbol
Arbol(FrameIzquiero)
#Boton para realizar consulta
Button(raiz, text="Enviar Consulta").pack(side="top", fill="both")
#Consola de Salida
consola = Text(raiz)
consola.pack(side="bottom", fill="both")
consola.insert(1.0, "Consola de Salida")
consola.config(state=DISABLED)
#Campo de texto
Campo(raiz).pack(side="right", fill="both", expand=True)
###### CREAMOS EL PANEL PARA LAS PESTAÑAS ########
raiz.mainloop()
def obtenerRecetario():
'''
@return arbolRecetas devuelve un estructura de datos arbol que contendra todas las recetas
Devuelve todo el recetario de la base de datos
Para obtener todo el recetario necesitamos cargar todo las recetas en la memoria y conservar su contenido
hasta que se finalize el programa por lo tanto se necesitara una estructurda datos en cual podamos almacenar nuestra informacion
de manera organizada para puedan ser utlizados de manera eficiente
Utilizaresmo una estructuras de datos no lineales o estructuras multi-enlazadas se pueden presentar relaciones
más complejas entre los elementos
Ulizaremos Arboles binarios de busqueda
'''
with open('baseDatosRecetas/recetario.txt', 'r') as recetario:
nombreReceta = recetario.readline()
lista = []
arbolRecetas = Arbol()
#Una cadena vacia lo representa como Falso
while (nombreReceta):
#print(nombreReceta)
ruta = 'baseDatosRecetas/' + nombreReceta.replace(
"\n", "") + ".txt" #quitamos el salto de linea
#print(ruta)
#Como ejemplo ulizaremos un lista para probar algunas funcionalidades
receta = obtenerReceta(ruta)
#lista.append(receta)
arbolRecetas.agregar(receta)
nombreReceta = recetario.readline()
recetario.close()
#return lista
return arbolRecetas
def main():
#Creo mi arbol
miArbol = Arbol()
#Agrego los valores de mi arbol
#El primer valor que agregue sera mi raiz de mi arbol
miArbol.agregar(8)
#Agregar hijos
miArbol.agregar(3)
miArbol.agregar(10)
miArbol.agregar(1)
miArbol.agregar(6)
miArbol.agregar(14)
miArbol.agregar(4)
miArbol.agregar(7)
miArbol.agregar(9)
#Imprimir arbol en preorden
miArbol.imprimirPreorden()
#miArbol.imprimirInorden()
#Busqueda de un valor especifico
#Devolvera el nodo subyacente
print("---------------------------")
nodo = busqueda(miArbol.obtenerRaiz(), 14)
print("Nodo con el valor que contiene: ", nodo.val)
# print(miArbol.obtenerRaiz().val)
pass
def CrearVentana():
global raiz
global load
raiz = Tk()
#Configuracion de ventana
raiz.title("TytuDB") #Cambiar el nombre de la ventana
#cambiar icono de pantalla
load = Image.open("../team08/resources/icondb.png")
render = ImageTk.PhotoImage(load)
img = Label(raiz, image=render)
img.image = render
img.place(x=0, y=0)
raiz.iconphoto(False, ImageTk.PhotoImage(load))
#raiz.iconbitmap('resources/icon.ico')
raiz.configure(bg='gray20')
raiz.rowconfigure(0, minsize=800, weight=1)
raiz.columnconfigure(1, minsize=800, weight=1)
raiz.config(menu=CrearMenu(raiz), background='silver')
#Frame del Arbol
FrameIzquiero = Frame(raiz, relief=RAISED, bd=2, bg='gray21')
FrameIzquiero.pack(side="left", fill="both")
#Se llama a la clase Arbol
Arbol(FrameIzquiero)
#Boton para realizar consulta
buton1 = Button(raiz,
text="Enviar Consulta",
bg='#1BA1FD',
fg='white',
activebackground='slate gray',
command=DataQuery).pack(side="top", fill="both")
#Consola de Salida
global consola
consola = Text(raiz, bg='gray7', fg='white', selectbackground="gray21")
#inactiveselectbackground="green"
consola.pack(side="bottom", fill="both")
consola.insert(1.0, "Consola de Salida:")
consola.config(wrap=WORD)
consola.config(state=DISABLED)
###### CREAMOS EL PANEL PARA LAS PESTAÑAS ########
global notebook
global control
style = ttk.Style()
style.theme_use("classic")
style.configure("TNotebook.Tab",
background="gray21",
font="helvetica 14",
foreground='white')
style.map("TNotebook.Tab",
background=[("selected", "#0854A9"), ("active", "#0876F1")],
foreground=[("selected", "#ffffff"), ("active", "#000000")])
notebook = ttk.Notebook(raiz)
notebook.pack(side="right", fill="both", expand=True)
añadir('Nuevo')
raiz.mainloop()
def CrearVentana():
global raiz
raiz = Tk()
#Configuracion de ventana
raiz.title("TytuSQL") #Cambiar el nombre de la ventana
#raiz.iconbitmap('resources/icon.ico')
raiz.configure(bg='gray21')
raiz.rowconfigure(0, minsize=800, weight=1)
raiz.columnconfigure(1, minsize=800, weight=1)
raiz.config(menu=CrearMenu(raiz), background='silver')
#Frame del Arbol
FrameIzquiero = Frame(raiz, relief=RAISED, bd=2, bg='gray21')
FrameIzquiero.pack(side="left", fill="both")
#Se llama a la clase Arbol
global bases
bases = Arbol(FrameIzquiero)
#Boton para realizar consulta
Button(raiz,
text="Enviar Consulta",
bg='gray',
fg='white',
activebackground='slate gray',
command=enviarQuery).pack(side="top", fill="both")
#Consola de Salida
global consola
consola = Text(raiz, bg='gray7', fg='white', selectbackground="gray21")
#inactiveselectbackground="green"
consola.pack(side="bottom", fill="both")
consola.insert(1.0, "Consola de Salida:")
consola.config(wrap=WORD)
consola.config(state=DISABLED)
###### CREAMOS EL PANEL PARA LAS PESTAÑAS ########
global notebook
global control
global textos
global _words
style = ttk.Style()
style.theme_use("classic")
style.configure("TNotebook.Tab",
background="gray21",
font="helvetica 14",
foreground='white')
style.map("TNotebook.Tab", background=[("selected", "slate gray")])
notebook = ttk.Notebook(raiz)
notebook.pack(side="right", fill="both", expand=True)
añadir('Nuevo')
b = notebook.select()
a = notebook.index(b)
textos[a].text.bind("<KeyRelease>", Spellcheck)
textos[a].text.bind("<Key>", Spellcheck)
# initialize the spell checking dictionary. YMMV.
_words = open("clave").read().split("\n")
raiz.mainloop()
def p_init(p):
'init : instrucciones'
#p[0] = [p[1]]
p[0] = Arbol(p[1])
'código': 9877,
'ubicación': '1H'
},
{
'nombre': 'Diplodocus',
'código': 36415,
'ubicación': '4X'
},
{
'nombre': 'Diplodocus',
'código': 21583,
'ubicación': '7Q'
},
]
arbol_ordnombre = Arbol()
arbol_ordcodigo = Arbol()
# Punto 2: se deben almacenar los datos en dos arboles uno ordenado por nombre y otro por código;
for dinosaurio in datos:
arbol_ordnombre = arbol_ordnombre.insertar_nodo(dinosaurio['nombre'],
dinosaurio)
print('Nombre de los dinosaurios ordenados alfabeticamente:')
arbol_ordnombre.inorden()
print()
for codigos in datos:
arbol_ordcodigo = arbol_ordcodigo.insertar_nodo(codigos['código'], codigos)
print('Dinosaurios ordenados por codigos:')
def test_cuando_arbol_vacio_es_true(self): arbol = Arbol() self.assertTrue(arbol.vacio())
def test_devuelve_la_raiz(self): arbol = Arbol(2) self.assertEqual(arbol.raiz(), 2)
def compareHashes():
""" Params: NONE """
""" Return: NONE """
""" Compara los dos diccionarios, uno contiene los hashes cargados del archivo hashes.hash y el otro contiene los hashes recien calculados,
tras dicha comparación los resultados saldran por consola """
numberOfFilesOK = int()
numberOfFilesNoOk = int()
listOfNoMatches = list()
global report
arbolActual = Arbol()
splittedPathsToHash = configDict["Directories to protect"].split(
","
) # para ser mejor, hacer strip con un for para cada elemento por si acaso
for path in splittedPathsToHash:
binaryTreeHash(path, arbolActual)
tupleTree = arbol.recorrer()
dictArbol = dict(tupleTree)
tupleActual = arbolActual.recorrer()
dictArbolActual = dict(tupleActual)
#Comprobamos las rutas de los ficheros que hay actualmente en el sistema de archivos con las que había cuando se inició
#el HIDS para el directorio/s que sea
value = {k: dictArbol[k] for k in set(dictArbol) - set(dictArbolActual)}
for fichero in value:
numberOfFilesNoOk += 1
cadena = "DIR: " + str(fichero) + " ¡Archivo eliminado detectado!"
listOfNoMatches.append(cadena)
value2 = {
k: dictArbolActual[k]
for k in set(dictArbolActual) - set(dictArbol)
}
for fichero in value2:
numberOfFilesNoOk += 1
cadena = "DIR: " + str(fichero) + " ¡Archivo nuevo detectado!"
listOfNoMatches.append(cadena)
aux = (fichero, value2[fichero])
tupleActual.remove(aux)
#z = {**value, **value2}
for tupla in tupleActual:
try:
nodoGuardado = arbol.buscar(tupla)
if nodoGuardado.dato[1] == tupla[1]:
numberOfFilesOK += 1
else:
numberOfFilesNoOk += 1
cadena = "DIR: " + str(tupla[0]) + " ¡Los hashes no coinciden!"
listOfNoMatches.append(cadena)
except:
numberOfFilesNoOk += 1
cadena = "DIR: " + str(tupla[0]) + " ¡Los hashes no coinciden!"
listOfNoMatches.append(cadena)
badIntegrity.append(numberOfFilesNoOk)
fechaHora = datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S")
graphDate.append(fechaHora)
str1 = "Número de archivos OK: " + str(numberOfFilesOK)
str2 = "Número de archivos MODIFICADOS: " + str(numberOfFilesNoOk)
report.append(fechaHora + "\n")
report.append(str1 + "\n")
report.append(str2 + "\n")
#ESTE PODRÍA QUITARSE
logging.info(str1)
logging.info(str2)
if (listOfNoMatches):
str3 = "Archivos con integridad comprometida: "
noMatchesToPrint = list()
for entry in listOfNoMatches:
noMatchesToPrint.append(" " + entry)
logging.warning(str3 + "\n" + '\n'.join(noMatchesToPrint))
toaster.show_toast("HIDS",
"Problema de integridad detectado. Revisar LOG.",
duration=verifyInterval,
threaded=True)
sendEmails(str3 + "\n" + '\n'.join(noMatchesToPrint))
report.append(str3 + "\n" + '\n'.join(noMatchesToPrint))
report.append(
"--------------------------------------------------------------------\n"
)
from arbol import Arbol
a = Arbol()
a.agrega(50)
a.agrega(18)
a.agrega(74)
a.agrega(7)
a.agrega(22)
def ubicar(nodo, buscado):
if nodo.contenido == buscado:
return True
if buscado < nodo.contenido and nodo.izquierdo is not None:
return ubicar(nodo.izquierdo, buscado)
if buscado > nodo.contenido and nodo.derecho is not None:
return ubicar(nodo.derecho, buscado)
return False
print(ubicar(a.raiz, 15))
print(ubicar(a.raiz, 22))
def test_cuando_arbol_vacio_es_false(self): arbol = Arbol() self.assertFalse(arbol.find(4))
def test_rama_derecha_esperada(self): arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) self.assertEqual(arbol.derecha(), Arbol(3, Arbol(6), Arbol(7)))
def test_cuando_rama_derecha_vacia_error(self): arbol = Arbol(1, Arbol(2), Arbol()) self.assertRaises(AttributeError, arbol.derecha)
def test_rama_izquierda_esperada(self): arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) self.assertEqual(arbol.izquierda(), Arbol(2, Arbol(4), Arbol(5)))
def test_cuando_rama_izquierda_vacia_error(self): arbol = Arbol(1, Arbol(), Arbol(2)) self.assertRaises(AttributeError, arbol.izquierda)
def test_no_hay_raiz_error(self): arbol = Arbol() self.assertRaises(AttributeError, arbol.raiz)
def test_cuando_arbol_mal_formado(self): with self.assertRaises(TypeError): arbol = Arbol(None, Arbol(2), Arbol(3))
def __init__(self):
super(Controlador, self).__init__()
self.contenedor = ErdosBloquePrincipal()
self.arbol = Arbol(self.contenedor)
def nuevo_arbol(self):
self.contenedorGUI = ErdosBloquePrincipalItem()
self.arbol = Arbol(self.contenedorGUI.nodo)
def test_cuando_encuentra_elemento_es_true(self): arbol = Arbol(2, Arbol(43, Arbol(3), Arbol(56)), Arbol(4)) self.assertTrue(arbol.find(56))
from tkinter import *
from tkinter import messagebox
from win10toast import ToastNotifier
import smtplib
from pathlib import Path
from arbol import Arbol
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders
# GLOBALS
configDict = dict()
badIntegrity = list()
graphDate = list()
arbol = Arbol()
report = list()
now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
verifyInterval = 0
reportInterval = 0
running = bool()
window = tk.Tk()
entry = ScrolledText(window, width=80, height=20)
logBox = ScrolledText(window, width=80, height=20)
toaster = ToastNotifier()
# Genera una estructura en forma de árbol binario a partir de los directorios escogidos para las comprobaciones de integridad, cada nodo del arbol es una tupla (ruta,hash)
# Donde el hash se realizará de acuerdo al tipo indicado en el fichero de configuración.
def binaryTreeHash(pathName, arbol):
for root, dirs, files in os.walk(pathName):
"""
https://parzibyte.me/blog
"""
from arbol import Arbol
arbol = Arbol("Luis")
arbol.agregar("María José")
arbol.agregar("Maggie")
arbol.agregar("Leon")
arbol.agregar("Cuphead")
arbol.agregar("Aloy")
arbol.agregar("Jack")
nombre = input("Ingresa algo para agregar al árbol: ")
arbol.agregar(nombre)
arbol.preorden()
arbol.inorden()
arbol.postorden()
# Búsqueda
busqueda = input("Busca algo en el árbol: ")
nodo = arbol.buscar(busqueda)
if nodo is None:
print(f"{busqueda} no existe")
else:
print(f"{busqueda} sí existe")
# Aquí tienes en "nodo" toda la información del nodo. Tanto su izquierda, derecha, dato y otros atributos que le hayas agregado
arbol_numeros = Arbol(5)
arbol_numeros.agregar(1984)
arbol_numeros.agregar(60)
arbol_numeros.agregar(10)
def test_cuando_el_elemento_no_esta_es_false(self): arbol = Arbol(2, Arbol(43, Arbol(3), Arbol(56)), Arbol(4)) self.assertFalse(arbol.find(1000))
def test_cuando_arbol_no_vacio_es_false(self): arbol = Arbol(2) self.assertFalse(arbol.vacio())
def test_inorder_esperado(self): arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) self.assertEqual(arbol.inorder(), [4, 2, 5, 1, 6, 3, 7])
def test_espejo_no_modifica_arbol(self): arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) otro_arbol = arbol.espejo() self.assertNotEqual(arbol, otro_arbol)
def test_espejo_de_arbol_vacio_es_vacio(self): arbol = Arbol() self.assertEqual(arbol.espejo(), Arbol())
def test_dos_arboles_distintos_es_false(self): arbol = Arbol(1, Arbol(2, Arbol(4), Arbol(5)), Arbol(3, Arbol(6), Arbol(7))) otro_arbol = Arbol(1, Arbol(8, Arbol(9), Arbol(13)), Arbol(23, Arbol(65), Arbol(337))) self.assertNotEqual(arbol, otro_arbol)