def BCU(origen, destino, grafoP):
raiz = Arbol(None, -1, (origen, 0))
frontera = [raiz]
visitados = []
while frontera:
menorCosto = 9999
menor = -1
for i in range(len(frontera)):
nodo = frontera[i]
nodoElemento, nodoCosto = nodo.elemento
if nodoCosto < menorCosto:
menorCosto = nodoCosto
menor = i
nodo = frontera.pop(menor)
nodoE, nodoC = nodo.elemento
if nodoE == destino:
print("Arbol generado")
print(raiz)
return nodo.rutaNodoRaiz()
if not (nodo.elemento in visitados):
for i in range(0, len(grafoP[nodoE])):
if grafoP[nodoE][i] < 9999:
if not ((i, grafoP[nodoE][i]) in visitados):
raiz.agregar(nodo.elemento, nodo.nivel,
(i, nodoC + grafoP[nodoE][i]))
frontera.append(
Arbol(nodo, nodo.nivel,
(i, nodoC + grafoP[nodoE][i])))
visitados.append(nodo.elemento)
return None
def generaArbol(tablero, player):
Tablero = tablero[:]
antPlayer = player
actPlayer = None
raiz = Arbol(None, -1, (Tablero, antPlayer))
frontera = [raiz]
visitados = []
while frontera:
nodo = frontera.pop(0)
nodoE, antPlayer = nodo.elemento
"""CAMBIAR LA MANETrueNER LAS HOJAS EN EL ARBOL"""
if not (nodo.elemento in visitados):
if (antPlayer is 'O'):
actPlayer = 'X'
else:
actPlayer = 'O'
for i in range(1, 10):
auxTablero = copy.deepcopy(nodoE)
flag = movesArbol(auxTablero, actPlayer, i)
if (flag):
# bandera=estado_tablero(auxTablero)
# if(bandera):
elemento = (auxTablero, actPlayer)
raiz.agregar(
nodo.elemento, nodo.nivel, elemento
) #Se va agregando un hijo al nodo padre(nodo donde si huboc enexion)
frontera.append(Arbol(nodo, nodo.nivel, elemento))
#print(elemento)
visitados.append(nodo.elemento)
print(raiz)
def BPP(origen, destino, grafo):
raiz = Arbol(None, -1, origen) #Se crea el nodo de origen
frontera = [raiz] #Se almacena los nodos ha ser desmenuzados jeje
visitados = [
] #Este arrglo avita hacer visitas inecesarias si ya fue visitado anteriormente un nodo
while frontera: # si frontera aun tiene hijos
nodo = frontera.pop() #Sacamos siempre el de la frontera
if nodo.elemento == destino: #Se regresa el arbol desmenuzado cuando se encontro el destino
print("Arbol generado")
print(raiz)
return nodo.rutaNodoRaiz(
) #Se regresa la ruta segun el metodo del profe
if not (nodo.elemento in visitados):
for i in range(
-len(grafo[nodo.elemento]) + 1, 1
): #Va a recorrer la fila del nodo en especifico(conexiones entre los demas nodos)
if grafo[nodo.elemento][
i *
-1] == 1: #Va a checar las conexiones que tiene con otros nodos(vecinos)
if not (i * -1 in visitados):
raiz.agregar(
nodo.elemento, nodo.nivel, i * -1
) #Se va agregando un hijo al nodo padre(nodo donde si huboc enexion)
frontera.append(Arbol(nodo, nodo.nivel, i * -1))
visitados.append(nodo.elemento)
return None
def treeConstructor(self, output):
if len(output[1]) is 1:
path = output[1][0]
if output[0] is "folder":
rootName = os.path.basename(path)
else:
rootName = os.path.basename(os.path.dirname(path))
self.tree = Arbol(rootName)
if output[0] == "folder":
self.buildTree(path=path, tree=self.tree)
else:
self.buildTree(tree=self.tree, rootChilds=output)
else:
#crear arbol con las hijos en root
rootName = os.path.basename(os.path.dirname(output[1][0]))
self.tree = Arbol(rootName)
self.buildTree(tree=self.tree, rootChilds=output)
self.tree.currentNode = self.tree.root
self.LoadTreeStructure(self.tree, self.treeWidget)
self.tree.currentNode = self.tree.root
self.saveTree(self.tree)
self.tree.currentNode = self.tree.root
def generar_reporte_arbol(self):
if self.scanner != None:
if isinstance(self.scanner, JsScanner):
arbol = Arbol(self.scanner.out_er)
arbol.generar_grafo()
else:
print(
'El diagrama de Arbol unicamente se genera para el archivo Js'
)
def busqueda_bidireccional(inicio, meta, grafo):
#Listas de nodos expandidos
busqueda_adelante = []
busqueda_reversa = []
busqueda_adelante.append(inicio)
busqueda_reversa.append(meta)
#Listas nodos visitados
visitados_adelante = []
visitados_adelante.append(inicio)
visitados_reversa = []
visitados_reversa.append(meta)
#Arboles de ambas busquedas
arbol_adelante = Arbol(inicio, [inicio])
arbol_reversa = Arbol(meta, [meta])
se_interceptan = False
nodo_interceptado = None
while (busqueda_adelante or busqueda_reversa) and not se_interceptan:
nodo_actual = busqueda_adelante.pop(0)
for sucesor, distancia in grafo[nodo_actual]:
if sucesor not in visitados_adelante:
visitados_adelante.append(sucesor)
busqueda_adelante.append(sucesor)
arbol_adelante.añadir(nodo_actual, sucesor)
if sucesor in busqueda_reversa:
se_interceptan = True
nodo_interceptado = sucesor
break
nodo_actual = busqueda_reversa.pop(0)
for sucesor, distancia in grafo[nodo_actual]:
if sucesor not in visitados_reversa:
visitados_reversa.append(sucesor)
busqueda_reversa.append(sucesor)
arbol_reversa.añadir(nodo_actual, sucesor)
if sucesor in busqueda_adelante:
se_interceptan = True
nodo_interceptado = sucesor
break
camino_mas_corto = arbol_adelante.buscar(nodo_interceptado).camino
listaAux = arbol_reversa.buscar(nodo_interceptado).camino
listaAux.reverse()
print('Arbol de la busqueda desde el inicio:')
arbol_adelante.imprimir()
print('\nÁrbol de la búsqueda desde la meta:')
arbol_reversa.imprimir()
camino_mas_corto.extend(listaAux)
return camino_mas_corto
class BusquedaProfunda:
__n = 0
__edoIni = None
__edoFnl = None
__matriz = None
nodoFinal = None
__arbol = None
def __init__(self,n, edoIni, edoFnl):
self.__n = n
self.__edoFnl = edoFnl
self.__edoIni = edoIni
self.__matriz = Matriz(n)
self.__arbol = Arbol(self.__n)
def buscar(self):
self.__arbol.estadoFinal = self.__edoFnl
self.__arbol.raiz = Nodo(self.__edoIni, None, None)
if self.busquedaProfunda(self.__arbol.raiz,0):
msg = []
msg.append('Estado final encontrado a una profundidad de: ')
msg.append(str(self.__arbol.obtenerProfundidad(self.nodoFinal)))
msg.append('\n\nSe utilizaron %i nodos' % len(self.__arbol.estadosRevisados))
msg.append('\n\n%s'%str(self.nodoFinal.estado))
msg.append('\n\nSe utilizaron las siguientes acciones: ')
msg.append(str(self.__arbol.obtenerAcciones()))
return ''.join(msg)
else:
return 'Lo siento no he encontrado nada a esa profundidad'
def busquedaProfunda(self,nodo, deep):
if deep ==350 or nodo.estado is None:
return False
if nodo.estado == self.__edoFnl:
self.nodoFinal = nodo
return True
if tuple(nodo.estado) in self.__arbol.estadosRevisados:
return False
else:
self.__arbol.estadosRevisados.add(tuple(nodo.estado))
if self.busquedaProfunda(Nodo(self.__matriz.moverIzquierda(nodo.estado),nodo,'I'),deep+1):
return True
elif self.busquedaProfunda(Nodo(self.__matriz.moverDerecha(nodo.estado),nodo,'D'),deep+1):
return True
elif self.busquedaProfunda(Nodo(self.__matriz.moverArriba(nodo.estado),nodo,'A'),deep+1):
return True
elif self.busquedaProfunda(Nodo(self.__matriz.moverAbajo(nodo.estado),nodo,'AB'),deep+1):
return True
else:
return False
def __init__(self, id, nombre, clave, carpeta):
self.nombre = nombre
self.id = id
if id != 'contadorid':
contador = get_persona('contadorid', carpeta)
print(contador.cant_guardado)
self.archivos = Arbol(contador.cant_guardado)
self.camino_archivos = Arbol(contador.cant_guardado)
print(self.archivos)
write_persona(contador, carpeta)
else:
self.archivos = Arbol('0')
self.persona_favorita = ''
self.cant_guardado = 0
self.clave = clave
def __init__(self,n, edoIni, edoFnl): self.__n = n self.__edoFnl = edoFnl self.__edoIni = edoIni self.__matriz = Matriz(n) self.__arbol = Arbol(self.__n) self.initFun()
def primero_en_amplitud(grafo, llave_ciudad, meta):
nodos_visitados = []
nodos_expandidos = []
nodos_visitados.append(llave_ciudad)
nodos_expandidos.append(llave_ciudad)
encontrado = False
arbol_en_amplitud = Arbol(llave_ciudad)
while nodos_expandidos and not encontrado:
nodo_actual = nodos_expandidos.pop(0)
for sucesor, distancia in grafo[nodo_actual]:
if sucesor not in nodos_visitados:
nodos_visitados.append(sucesor)
nodos_expandidos.append(sucesor)
arbol_en_amplitud.añadir(nodo_actual, sucesor)
if sucesor == meta:
encontrado = True
break
return arbol_en_amplitud
def BPA(origen, destino, grafo):
raiz = Arbol(None, -1, origen)
frontera = [raiz]
visitados = []
while frontera:
nodo = frontera.pop(0)
if nodo.elemento == destino:
print("Arbol generado")
print(raiz)
return nodo.rutaNodoRaiz()
if not (nodo.elemento in visitados):
for i in range(0, len(grafo[nodo.elemento])):
if grafo[nodo.elemento][i] == 1:
if not (i in visitados):
raiz.agregar(nodo.elemento, nodo.nivel, i)
frontera.append(Arbol(nodo, nodo.nivel, i))
visitados.append(nodo.elemento)
return None
def infixToPrefix(expresion):
arbol = Arbol()
#Obtenemos la operacion mas externa
external = getExternal(expresion)
#print("external:",external)
#Si existe la operacion la separamos
if (external != 0):
val = external[1]
left = expresion[:external[0]]
right = expresion[external[0] + 1:]
#Quitamos parentesis mas externos
if (left[0] == '(' and left[len(left) - 1] == ')'):
left = left[1:]
left = left[:len(left) - 1]
if (right[0] == '(' and right[len(right) - 1] == ')'):
right = right[1:]
right = right[:len(right) - 1]
#El arreglo direction va indicando si el elemento a ingresar va a la derecha o a la izquierda del nodo en que se encuentre
direction = []
#Tras separar la expresion la ingresamos en el arbol
arbol.insertar(val, direction)
#Si hay mas operaciones del lado izquierdo las separamos e ingresamos al arbol
if (len(left) > 2):
infixToPrefixLeft(left, direction, arbol)
else:
#La ingresamos del lado izquierdo del nodo
direction = [0]
arbol.insertar(left, direction)
#Si hay mas operaciones del lado derecho las separamos e ingresamos al arbol
if (len(right) > 2):
infixToPrefixRight(right, direction, arbol)
else:
#La ingresamos del derecho izquierdo del nodo
direction = [1]
arbol.insertar(right, direction)
#Obtenemos la cadena correspondiente al prefix
prefix = ""
prefix = arbol.preorden(arbol.root, prefix)
return prefix
else:
return expresion
def __init__(self, client, mainwindow):
QWidget.__init__(self)
self.mainwindow = mainwindow
self.que = ''
self.client = client
self.arbol = Arbol('')
self.crear_arbol('')
self.treeView = QTreeView()
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.customContextMenuRequested.connect(self.openmenu)
self.model = QStandardItemModel()
self.additems(self.model, self.arbol)
self.treeView.setModel(self.model)
self.model.setHorizontalHeaderLabels([self.tr("Dropbox")])
layout = QVBoxLayout()
layout.addWidget(self.treeView)
self.setLayout(layout)
def buscar(self):
arbol = Arbol(self.__n)
arbol.estadoFinal = self.__edoFnl
arbol.raiz = Nodo(self.__edoIni, None, None)
arbol.estadosPendientes.add(arbol.raiz)
encontrado = False
nodoFinal = None
while not encontrado:
nodosTmp = []
while len(arbol.estadosPendientes) != 0:
nodo = arbol.estadosPendientes.pop()
if nodo.estado == arbol.estadoFinal:
encontrado = True
nodoFinal = nodo
break
else:
nodosTmp.append(nodo)
for nodoT in nodosTmp:
arbol.estadosPendientes.update(arbol.expandirNodos(nodoT))
msg = []
msg.append('Estado final encontrado a una profundidad de: ')
msg.append(str(arbol.obtenerProfundidad(nodoFinal)))
msg.append('\n\nSe utilizaron %i nodos' % len(arbol.estadosRevisados))
msg.append('\n\nSe utilizaron las siguientes acciones:\n')
msg.append(str(arbol.obtenerAcciones()))
return ''.join(msg)
def generaArbol(tablero, player):
Tablero = tablero[:]
antPlayer = player
raiz = Arbol(None, -1, Tablero)
frontera = [raiz]
visitados = []
i = 1
while frontera:
nodo = frontera.pop(0)
nodoE = nodo.elemento
if not (nodo.elemento in visitados):
if (antPlayer is "O"):
actualPlayer = "X"
elif (antPlayer is "X"):
actualPlayer = "O"
for i in range(1, 10):
auxTablero = copy.deepcopy(nodoE)
movesCPU(auxTablero, actualPlayer, i)
raiz.agregar(nodo.elemento, nodo.nivel, auxTablero)
frontera.append(Arbol(nodo, nodo.nivel, auxTablero))
visitados.append(nodo.elemento)
print(raiz)
return None
def __init__(self, client, mainwindow):
QWidget.__init__(self)
self.mainwindow = mainwindow
self.que = ''
self.client = client
self.arbol = Arbol('')
self.crear_arbol('')
self.treeView = QTreeView()
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.customContextMenuRequested.connect(self.openmenu)
self.model = QStandardItemModel()
self.additems(self.model, self.arbol)
self.treeView.setModel(self.model)
self.model.setHorizontalHeaderLabels([self.tr("Dropbox")])
layout = QVBoxLayout()
layout.addWidget(self.treeView)
self.setLayout(layout)
class AEstrella:
__n = 0
__edoIni = None
__edoFnl = None
__matriz = None
__arbol = None
__dis = 0
f={}
def __init__(self,n, edoIni, edoFnl):
self.__n = n
self.__edoFnl = edoFnl
self.__edoIni = edoIni
self.__matriz = Matriz(n)
self.__arbol = Arbol(self.__n)
self.initFun()
def manhattan(self, edo):
meta = self.__edoFnl
n = self.__n
dist = 0
for e in edo:
i = edo.index(e) #Posicion del numero en el estado actual
j = meta.index(e) #Posicion del numero en el estado meta
edoTmp = edo[:]
while (i-j) > n or (j-i) > n:
if i < j: #Esta arriba, lo movemos abajo
edoTmp[i],edoTmp[i+n] = edoTmp[i+n],edoTmp[i]
elif i > j: #Esta abajo
edoTmp[i],edoTmp[i-n] = edoTmp[i-n],edoTmp[i]
dist += 1
i = edoTmp.index(e)
while i != j:
if i > j: #Esta a la derecha
edoTmp[i],edoTmp[i-1] = edoTmp[i-1],edoTmp[i]
elif i < j: #Esta a la izquierda
edoTmp[i],edoTmp[i+1] = edoTmp[i+1],edoTmp[i]
dist += 1
i = edoTmp.index(e)
return dist
def initFun(self):
self.f['A'] = self.__matriz.moverArriba
self.f['AB'] = self.__matriz.moverAbajo
self.f['I'] = self.__matriz.moverIzquierda
self.f['D'] = self.__matriz.moverDerecha
def getValues(self, nodos):
lista=[]
for nodo in nodos:
lista.append([self.manhattan(nodo.estado),nodo])
return lista
def buscar(self):
nodosAbiertos = []
nodo = Nodo(self.__edoIni,None,None)
while nodo.estado != self.__edoFnl or len(self.__arbol.estadosPendientes) != 0:
nodosAbiertos.extend(self.getValues(self.__arbol.expandirNodos(nodo)))
nodosAbiertos.sort()
nodo = nodosAbiertos.pop(0)[1]
#self.__dis += 1
profundidad = (str(self.__arbol.obtenerProfundidad(nodo)))
msg = []
msg.append('Maximo local encontrado a una profundidad de: ')
msg.append(profundidad)
msg.append('\n\nCon un costo de %s ' % profundidad)
msg.append('\n\n%s'%str(nodo.estado))
msg.append('\n\nCon las siguientes acciones: ')
msg.append(str(self.__arbol.obtenerAcciones()))
return ''.join(msg)
#!/usr/bin/python3
from Arbol import Arbol
A1 = Arbol("1")
A1.agregar("1","1.1")
A1.agregar("1","1.2")
A1.agregar("1","1.3")
A1.agregar("1.1","1.1.1")
A1.agregar("1.2","1.2.1")
A1.agregar("1.2","1.2.2")
A1.agregar("1.1.1","1.1.1.1")
A1.agregar("1.1.1","1.1.1.2")
A1.agregar("1.1.1","1.1.1.3")
A1.agregar("1.2.1","1.2.1.1")
A1.agregar("1.2.2","1.2.2.1")
A1.agregar("1.2.2","1.2.2.2")
print ("Arbol inicial")
print (A1)
flag = True
while flag:
print ("1) Agregar elemento")
print ("2) Borrar elemento")
print ("3) Imprimir sub-arbol")
print ("4) Salir")
opc = int(input("Eliga una opción: "))
if opc == 1:
padre, elemento = input("Ingrese el padre y elemento: ").split()
A1.agregar(padre,elemento)
elif opc == 2:
elemento = input("Ingrese el elemento para borrar: ")
A1.borrarSubA(elemento)
elif opc == 3:
try:
os.mkdir('plots')
except OSError as e:
if e.errno != errno.EEXIST:
raise
crearCarpeta()
cantCiudades = 4
x = []
y = []
while True:
# Se calcula la heuristica
heuristica = crearHeuristica(cantCiudades)
# Se arma el arbol y se obtiene el recorrido con best first
arbol = Arbol(cantCiudades)
print(arbol.foo, arbol.__var)
inicio = datetime.now()
recorrido = arbol.bestFirst(heuristica)
fin = datetime.now()
tiempo = round((fin - inicio).total_seconds() * 1000, 2)
# Se muestra el recorrido
print(recorrido)
print(f"Tiempo total: {tiempo} [ms]")
# Se guardan los resultados
x.append(cantCiudades)
y.append(tiempo)
# Se grafican y se guardan los datos
graficar(x, y)
crearCSV(x, y)
# Se incrementan las ciudades en 2
objs= []
arboles= []
rayos= []
nubes= []
fondo= Fondo(ancho, alto)
cordillera= Cordillera(ancho, alto)
objs.append(fondo)
objs.append(cordillera)
reloj= pygame.time.Clock()
FPS= 6.0
for i in range(10):
suelo= cordillera.getPuntosBorde()
arbol= Arbol(suelo, alto)
arboles.append(arbol)
for i in range(4):
nube= Nube(ancho, alto)
nubes.append(nube)
def lanzarRayo():
if arboles != []:
al= random.randint(0, len(arboles)-1)
arbol= arboles[al]
arbol.atacar(1)
al= random.randint(0, len(nubes)-1)
nube= nubes[al]
rayo= Rayo(nube.getPosicion(), arbol.getBlanco())
rayos.append(rayo)
class Window(QWidget):
def __init__(self, client, mainwindow):
QWidget.__init__(self)
self.mainwindow = mainwindow
self.que = ''
self.client = client
self.arbol = Arbol('')
self.crear_arbol('')
self.treeView = QTreeView()
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.customContextMenuRequested.connect(self.openmenu)
self.model = QStandardItemModel()
self.additems(self.model, self.arbol)
self.treeView.setModel(self.model)
self.model.setHorizontalHeaderLabels([self.tr("Dropbox")])
layout = QVBoxLayout()
layout.addWidget(self.treeView)
self.setLayout(layout)
def init_GUI(self):
self.model = QStandardItemModel()
self.additems(self.model, self.arbol)
self.treeView.setModel(self.model)
self.model.setHorizontalHeaderLabels([self.tr("Dropbox")])
def additems(self, parent, elements):
for text in elements.hijos.keys():
nombre = elements.hijos[text].nombre
item = QStandardItem(nombre)
parent.appendRow(item)
if elements.hijos[text]:
self.additems(item, elements.hijos[text])
def crear_arbol(self, path):
lista = self.client.files_list_folder('').entries
lista2 = self.client.files_list_folder('', recursive=True).entries
for text in lista:
nombre = text.name
path_nuevo = text.path_lower
if type(text) == FolderMetadata:
self.arbol.agregar_nodo(path_nuevo, nombre, '013', '')
else:
self.arbol.agregar_nodo(path_nuevo, nombre, '012', '')
for text in lista2:
nombre = text.name
path_nuevo = text.path_lower
nombre2 = path_nuevo.split('/')
padre = path_nuevo.replace('/{}'.format(nombre2[-1]), '')
if type(text) == FolderMetadata:
self.arbol.agregar_nodo(path_nuevo, nombre, '013', padre)
else:
self.arbol.agregar_nodo(path_nuevo, nombre, '012', padre)
def agregar_archivo(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
if nodo.valor == '013':
self.mainwindow.padre = nodo.id_nodo
self.mainwindow.botonnuevo_archivo()
else:
self.mainwindow.padre = nodo.id_padre
self.mainwindow.botonnuevo_archivo()
def agregar_carpeta(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
if nodo.valor == '013':
self.mainwindow.padre = nodo.id_nodo
self.mainwindow.botonnueva_carpeta()
else:
self.mainwindow.padre = nodo.id_padre
self.mainwindow.botonnueva_carpeta()
def crear_carpeta(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
texto, ok = QInputDialog.getText(self, "Titulo", "Nombre de la nueva carpeta:")
if ok:
if texto == '':
pass
else:
if nodo.valor == '012':
nombre = nodo.id_padre + '/' + texto
try:
self.client.files_create_folder(nombre)
self.form.arbol.agregar_nodo(id_nodo=nombre, nombre=texto, valor='013', id_padre=nodo.id_padre)
self.statusBar().showMessage('Carpeta agregada: {}'.format(nombre))
self.form.init_GUI()
except dropbox.exceptions.ApiError:
self.statusBar().showMessage('Nombre de carpeta ya existe: {}'.format(nombre))
elif nodo.valor == '013':
nombre = nodo.id_nodo + '/' + texto
try:
self.client.files_create_folder(nombre)
self.form.arbol.agregar_nodo(id_nodo=nombre, nombre=texto, valor='013', id_padre=nodo.id_nodo)
self.statusBar().showMessage('Carpeta agregada: {}'.format(nombre))
self.form.init_GUI()
except dropbox.exceptions.ApiError:
self.statusBar().showMessage('Nombre de carpeta ya existe: {}'.format(nombre))
def descargar_archivo(self):
fileName = QFileDialog.getExistingDirectory(self, 'Escoge Carpeta de descarga', QDir.rootPath())
if fileName:
nodo = self.arbol.obtener_nodo_nombre(self.que)
nombre = nodo.id_nodo.split('/')
self.client.files_download_to_file(fileName + '\\' + nombre[-1], nodo.id_nodo)
self.mainwindow.statusBar().showMessage('Descargado: {}'.format(nombre[-1]))
def descargar_carpeta(self):
fileName = QFileDialog.getExistingDirectory(self, 'Escoge Carpeta de descarga', QDir.rootPath())
if fileName:
os.makedirs("{}".format(str(fileName + '\\' + self.que)))
nodo = self.arbol.obtener_nodo_nombre(self.que)
self.mainwindow.statusBar().showMessage('Descargando: {}'.format(self.que))
self.mandar_descarga_carpeta(fileName + '\\' + self.que, nodo)
self.mainwindow.statusBar().showMessage('Listo la descarga: {}'.format(self.que))
def borrar(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
self.client.files_delete(nodo.id_nodo)
self.mainwindow.statusBar().showMessage('Borrando: {}'.format(self.que))
self.arbol.borrar_nodo(id_padre=nodo.id_padre, id_nodo=nodo.id_nodo)
self.mainwindow.statusBar().showMessage('Listo: {}'.format(self.que))
self.init_GUI()
def mandar_descarga_carpeta(self, path, nodo):
for i in nodo.hijos.keys():
archivo = nodo.hijos[i].valor
if archivo == '012':
self.client.files_download_to_file(path + '\\' + nodo.hijos[i].nombre, nodo.hijos[i].id_nodo)
else:
os.makedirs("{}".format(str(path + '\\' + nodo.hijos[i].nombre)))
self.mandar_descarga_carpeta(str(path + '\\' + nodo.hijos[i].nombre), nodo.hijos[i])
def historial(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
if nodo.valor == '012':
data = self.client.files_list_revisions(nodo.id_nodo, limit=10).entries
self.historia = Historial(data)
self.historia.table.show()
elif nodo.valor == '013':
data = []
for i in nodo.hijos.values():
if i.valor == '012':
data2 = self.client.files_list_revisions(i.id_nodo, limit=10).entries
data += data2
self.historia2 = Historial(data)
self.historia2.table.show()
def mover(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
texto, ok = QInputDialog.getText(self, "Mover",
"Ingresa nombre de la carpeta contenedora(dropbox para carpeta principal):")
if ok:
if texto == '':
pass
else:
if texto == 'dropbox':
try:
self.client.files_move(nodo.id_nodo, '/' + nodo.nombre)
aux = self.arbol.sacar_nodo(nodo)
aux.agregando_a_arbol(self.arbol, '')
except dropbox.exceptions.ApiError:
self.mainwindow.statusBar().showMessage('Carpeta ya existe con el mismo nombre en el destino')
else:
nodo_llegada = self.arbol.obtener_nodo_nombre(texto)
if nodo_llegada is not None and nodo_llegada.valor == '013':
try:
self.client.files_move(nodo.id_nodo, nodo_llegada.id_nodo + '/' + nodo.nombre)
aux = self.arbol.sacar_nodo(nodo)
aux.agregando_a_arbol(self.arbol, nodo_llegada.id_nodo)
except dropbox.exceptions.ApiError:
otra = self.mainwindow.statusBar()
otra.showMessage('Carpeta ya existe con el mismo nombre en el destino')
elif nodo_llegada is not None and nodo_llegada.valor == '012':
otra = self.mainwindow.statusBar()
otra.showMessage('Tienes que moverlo a una carpeta')
else:
otra = self.mainwindow.statusBar()
otra.showMessage('Tienes que moverlo a una carpeta')
self.init_GUI()
def renombrar(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
texto, ok = QInputDialog.getText(self, "Renombrar",
"Nuevo nombre con la extencion si es archivo:")
if ok:
if texto == '':
pass
else:
if self.arbol.obtener_nodo_nombre(texto) is None:
if nodo.valor == '012':
numero = texto.find('.')
if numero != -1:
if texto.split('.')[1] == nodo.nombre.split('.')[1]:
id_padre = nodo.id_padre
nuevo_id = id_padre + '/' + texto
self.client.files_move(nodo.id_nodo, nuevo_id)
aux = self.arbol.sacar_nodo(nodo)
self.arbol.agregar_nodo(id_nodo=nuevo_id, valor=nodo.valor, id_padre=id_padre,
nombre=texto)
for i in aux.hijos.values():
i.agregando_a_arbol(self.arbol, nuevo_id)
self.init_GUI()
else:
self.mainwindow.statusBar().showMessage('Falta la extencion')
else:
self.mainwindow.statusBar().showMessage('Falta la extencion')
elif nodo.valor == '013':
id_padre = nodo.id_padre
nuevo_id = id_padre + '/' + texto
try:
self.client.files_move(nodo.id_nodo, nuevo_id)
aux = self.arbol.sacar_nodo(nodo)
self.arbol.agregar_nodo(id_nodo=nuevo_id, valor=nodo.valor, id_padre=id_padre, nombre=texto)
for i in aux.hijos.values():
i.agregando_a_arbol(self.arbol, nuevo_id)
self.init_GUI()
except dropbox.exceptions.ApiError:
self.mainwindow.statusBar().showMessage('Nombre ya existe, escoja uno diferente')
else:
self.mainwindow.statusBar().showMessage('Nombre ya existe, escoja uno diferente')
def openmenu(self, position):
indexes = self.treeView.selectedIndexes()
ver_status = QAction(QIcon(None), '&Agregar Archivo', self)
ver_status.setStatusTip('Agregar Archivo')
ver_status.triggered.connect(self.agregar_archivo)
ver_status2 = QAction(QIcon(None), '&Agregar Carpeta', self)
ver_status2.setStatusTip('Agregar Carpeta')
ver_status2.triggered.connect(self.agregar_carpeta)
ver_status3 = QAction(QIcon(None), '&Descargar Archivo', self)
ver_status3.setStatusTip('Descargando Archivo')
ver_status3.triggered.connect(self.descargar_archivo)
ver_status4 = QAction(QIcon(None), '&Descargar Carpeta', self)
ver_status4.setStatusTip('Descargando Carpeta')
ver_status4.triggered.connect(self.descargar_carpeta)
ver_status5 = QAction(QIcon(None), '&Borrar Archivo', self)
ver_status5.setStatusTip('Borrando Archivo')
ver_status5.triggered.connect(self.borrar)
ver_status6 = QAction(QIcon(None), '&Borrar Carpeta', self)
ver_status6.setStatusTip('Borrando Carpeta')
ver_status6.triggered.connect(self.borrar)
ver_status10 = QAction(QIcon(None), '&Crear Carpeta', self)
ver_status10.setStatusTip('Crear Carpeta')
ver_status10.triggered.connect(self.crear_carpeta)
ver_status7 = QAction(QIcon(None), '&Ver Historial', self)
ver_status7.setStatusTip('Ver Historial')
ver_status7.triggered.connect(self.historial)
ver_status8 = QAction(QIcon(None), '&Mover', self)
ver_status8.setStatusTip('Mover')
ver_status8.triggered.connect(self.mover)
ver_status9 = QAction(QIcon(None), '&Renombrar', self)
ver_status9.setStatusTip('Renombrar')
ver_status9.triggered.connect(self.renombrar)
menu = QMenu()
if len(indexes) > 0:
self.que = indexes[0].data()
menu.addAction(ver_status)
menu.addAction(ver_status2)
nodo = self.arbol.obtener_nodo_nombre(self.que)
if nodo.valor == '013':
menu.addAction(ver_status4)
menu.addAction(ver_status6)
else:
menu.addAction(ver_status3)
menu.addAction(ver_status5)
menu.addAction(ver_status10)
menu.addAction(ver_status7)
menu.addAction(ver_status8)
menu.addAction(ver_status9)
menu.exec_(self.treeView.viewport().mapToGlobal(position))
def salir(self):
QCoreApplication.instance().quit()
def Laberinto(laberinto):
posR = 0
posC = 0
#Se tiene que buscar las coordenadas de I y van a ir como tupla
for fila in range(0, len(laberinto)):
for columna in range(0, len(laberinto[fila])):
if laberinto[fila][columna] == "I":
posR = fila
posC = columna
origen = (posR, posC)
raiz = Arbol(None, -1, origen)
frontera = [raiz]
visitados = []
while frontera: # si frontera aun tiene hijos
nodo = frontera.pop(0) #Sacamos siempre el primero de la frontera
posR, posC = nodo.elemento
if laberinto[posR][
posC] == 'S': #Se regresa el arbol desmenuzado cuando se encontro el destino
print("Arbol generado")
print(raiz)
return nodo.rutaNodoRaiz(
) #Se regresa la ruta segun el metodo del profe
if not (nodo.elemento in visitados):
try:
if (laberinto[posR][posC - 1] != 'X'): #Izquierda
elemento = (posR, posC - 1)
raiz.agregar(
nodo.elemento, nodo.nivel, elemento
) #Se va agregando un hijo al nodo padre(nodo donde si huboc enexion)
frontera.append(Arbol(nodo, nodo.nivel, elemento))
except:
pass
try:
if (laberinto[posR + 1][posC] != 'X'): #Abajo
elemento = (posR + 1, posC)
raiz.agregar(
nodo.elemento, nodo.nivel, elemento
) #Se va agregando un hijo al nodo padre(nodo donde si huboc enexion)
frontera.append(Arbol(nodo, nodo.nivel, elemento))
except:
pass
try:
if (laberinto[posR][posC + 1] != 'X'): #derecha
elemento = (posR, posC + 1)
raiz.agregar(
nodo.elemento, nodo.nivel, elemento
) #Se va agregando un hijo al nodo padre(nodo donde si huboc enexion)
frontera.append(Arbol(nodo, nodo.nivel, elemento))
except:
pass
try:
if (laberinto[posR - 1][posC] != 'X'): #Arriba
elemento = (posR - 1, posC)
raiz.agregar(
nodo.elemento, nodo.nivel, elemento
) #Se va agregando un hijo al nodo padre(nodo donde si huboc enexion)
frontera.append(Arbol(nodo, nodo.nivel, elemento))
except:
pass
visitados.append(nodo.elemento)
return None
def generarArbol(self):
suelo= self.cordillera.getPuntosBorde()
arbol= Arbol(suelo, ALTO_ESCENA)
self.arboles.append(arbol)
def PUZZLE(origen, destino):
posR = 0
posC = 0
for fila in range(0, len(origen)):
for columna in range(0, len(origen[fila])):
if origen[fila][columna] == 0:
posR = fila
posC = columna
heuri = heuristica(origen, destino)
raiz = Arbol(None, -1, (origen, heuri, posR, posC))
frontera = [raiz]
visitados = []
while frontera:
menorHeuristica = 9999
menor = -1
for i in range(len(frontera)):
nodo = frontera[i]
nodoHeuristica = nodo.elemento[1]
if nodoHeuristica < menorHeuristica:
menorHeuristica = nodoHeuristica
menor = i
nodo = frontera.pop(menor)
nodoE, nodoH, posR, posC = nodo.elemento
if nodoE == destino and nodoH == 0:
print("Arbol generado")
print(raiz)
return nodo.rutaNodoRaiz()
if not (nodo.elemento in visitados):
try:
if (nodoE[posR][posC - 1] != 0): #Izquierda
sinVisitar = copy.deepcopy(nodoE)
varAux = sinVisitar[posR][posC - 1]
sinVisitar[posR][posC - 1] = 0
sinVisitar[posR][posC] = varAux
nodoEHeuristica = heuristica(sinVisitar, destino)
elemento = (sinVisitar, nodoEHeuristica, posR, posC - 1)
raiz.agregar(
nodo.elemento, nodo.nivel, elemento
) #Se va agregando un hijo al nodo padre(nodo donde si huboc enexion)
frontera.append(Arbol(nodo, nodo.nivel, elemento))
except:
pass
try:
if (nodoE[posR + 1][posC] != 0): #Abajo
sinVisitar = copy.deepcopy(nodoE)
varAux = sinVisitar[posR + 1][posC]
sinVisitar[posR + 1][posC] = 0
sinVisitar[posR][posC] = varAux
nodoEHeuristica = heuristica(sinVisitar, destino)
elemento = (sinVisitar, nodoEHeuristica, posR + 1, posC)
raiz.agregar(
nodo.elemento, nodo.nivel, elemento
) #Se va agregando un hijo al nodo padre(nodo donde si huboc enexion)
frontera.append(Arbol(nodo, nodo.nivel, elemento))
except:
pass
try:
if (nodoE[posR][posC + 1] != 0): #derecha
sinVisitar = copy.deepcopy(nodoE)
varAux = sinVisitar[posR][posC + 1]
sinVisitar[posR][posC + 1] = 0
sinVisitar[posR][posC] = varAux
nodoEHeuristica = heuristica(sinVisitar, destino)
elemento = (sinVisitar, nodoEHeuristica, posR, posC + 1)
raiz.agregar(
nodo.elemento, nodo.nivel, elemento
) #Se va agregando un hijo al nodo padre(nodo donde si huboc enexion)
frontera.append(Arbol(nodo, nodo.nivel, elemento))
except:
pass
try:
if (nodoE[posR - 1][posC] != 0): #Arriba
sinVisitar = copy.deepcopy(nodoE)
varAux = sinVisitar[posR - 1][posC]
sinVisitar[posR - 1][posC] = 0
sinVisitar[posR][posC] = varAux
nodoEHeuristica = heuristica(sinVisitar, destino)
elemento = (sinVisitar, nodoEHeuristica, posR - 1, posC)
raiz.agregar(
nodo.elemento, nodo.nivel, elemento
) #Se va agregando un hijo al nodo padre(nodo donde si huboc enexion)
frontera.append(Arbol(nodo, nodo.nivel, elemento))
except:
pass
visitados.append(nodo.elemento)
return None
class Window(QWidget):
def __init__(self, client, mainwindow):
QWidget.__init__(self)
self.mainwindow = mainwindow
self.que = ''
self.client = client
self.arbol = Arbol('')
self.crear_arbol('')
self.treeView = QTreeView()
self.treeView.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeView.customContextMenuRequested.connect(self.openmenu)
self.model = QStandardItemModel()
self.additems(self.model, self.arbol)
self.treeView.setModel(self.model)
self.model.setHorizontalHeaderLabels([self.tr("Dropbox")])
layout = QVBoxLayout()
layout.addWidget(self.treeView)
self.setLayout(layout)
def init_GUI(self):
self.model = QStandardItemModel()
self.additems(self.model, self.arbol)
self.treeView.setModel(self.model)
self.model.setHorizontalHeaderLabels([self.tr("Dropbox")])
def additems(self, parent, elements):
for text in elements.hijos.keys():
nombre = elements.hijos[text].nombre
item = QStandardItem(nombre)
parent.appendRow(item)
if elements.hijos[text]:
self.additems(item, elements.hijos[text])
def crear_arbol(self, path):
lista = self.client.files_list_folder('').entries
lista2 = self.client.files_list_folder('', recursive=True).entries
for text in lista:
nombre = text.name
path_nuevo = text.path_lower
if type(text) == FolderMetadata:
self.arbol.agregar_nodo(path_nuevo, nombre, '013', '')
else:
self.arbol.agregar_nodo(path_nuevo, nombre, '012', '')
for text in lista2:
nombre = text.name
path_nuevo = text.path_lower
nombre2 = path_nuevo.split('/')
padre = path_nuevo.replace('/{}'.format(nombre2[-1]), '')
if type(text) == FolderMetadata:
self.arbol.agregar_nodo(path_nuevo, nombre, '013', padre)
else:
self.arbol.agregar_nodo(path_nuevo, nombre, '012', padre)
def agregar_archivo(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
if nodo.valor == '013':
self.mainwindow.padre = nodo.id_nodo
self.mainwindow.botonnuevo_archivo()
else:
self.mainwindow.padre = nodo.id_padre
self.mainwindow.botonnuevo_archivo()
def agregar_carpeta(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
if nodo.valor == '013':
self.mainwindow.padre = nodo.id_nodo
self.mainwindow.botonnueva_carpeta()
else:
self.mainwindow.padre = nodo.id_padre
self.mainwindow.botonnueva_carpeta()
def crear_carpeta(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
texto, ok = QInputDialog.getText(self, "Titulo",
"Nombre de la nueva carpeta:")
if ok:
if texto == '':
pass
else:
if nodo.valor == '012':
nombre = nodo.id_padre + '/' + texto
try:
self.client.files_create_folder(nombre)
self.form.arbol.agregar_nodo(id_nodo=nombre,
nombre=texto,
valor='013',
id_padre=nodo.id_padre)
self.statusBar().showMessage(
'Carpeta agregada: {}'.format(nombre))
self.form.init_GUI()
except dropbox.exceptions.ApiError:
self.statusBar().showMessage(
'Nombre de carpeta ya existe: {}'.format(nombre))
elif nodo.valor == '013':
nombre = nodo.id_nodo + '/' + texto
try:
self.client.files_create_folder(nombre)
self.form.arbol.agregar_nodo(id_nodo=nombre,
nombre=texto,
valor='013',
id_padre=nodo.id_nodo)
self.statusBar().showMessage(
'Carpeta agregada: {}'.format(nombre))
self.form.init_GUI()
except dropbox.exceptions.ApiError:
self.statusBar().showMessage(
'Nombre de carpeta ya existe: {}'.format(nombre))
def descargar_archivo(self):
fileName = QFileDialog.getExistingDirectory(
self, 'Escoge Carpeta de descarga', QDir.rootPath())
if fileName:
nodo = self.arbol.obtener_nodo_nombre(self.que)
nombre = nodo.id_nodo.split('/')
self.client.files_download_to_file(fileName + '\\' + nombre[-1],
nodo.id_nodo)
self.mainwindow.statusBar().showMessage('Descargado: {}'.format(
nombre[-1]))
def descargar_carpeta(self):
fileName = QFileDialog.getExistingDirectory(
self, 'Escoge Carpeta de descarga', QDir.rootPath())
if fileName:
os.makedirs("{}".format(str(fileName + '\\' + self.que)))
nodo = self.arbol.obtener_nodo_nombre(self.que)
self.mainwindow.statusBar().showMessage('Descargando: {}'.format(
self.que))
self.mandar_descarga_carpeta(fileName + '\\' + self.que, nodo)
self.mainwindow.statusBar().showMessage(
'Listo la descarga: {}'.format(self.que))
def borrar(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
self.client.files_delete(nodo.id_nodo)
self.mainwindow.statusBar().showMessage('Borrando: {}'.format(
self.que))
self.arbol.borrar_nodo(id_padre=nodo.id_padre, id_nodo=nodo.id_nodo)
self.mainwindow.statusBar().showMessage('Listo: {}'.format(self.que))
self.init_GUI()
def mandar_descarga_carpeta(self, path, nodo):
for i in nodo.hijos.keys():
archivo = nodo.hijos[i].valor
if archivo == '012':
self.client.files_download_to_file(
path + '\\' + nodo.hijos[i].nombre, nodo.hijos[i].id_nodo)
else:
os.makedirs("{}".format(str(path + '\\' +
nodo.hijos[i].nombre)))
self.mandar_descarga_carpeta(
str(path + '\\' + nodo.hijos[i].nombre), nodo.hijos[i])
def historial(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
if nodo.valor == '012':
data = self.client.files_list_revisions(nodo.id_nodo,
limit=10).entries
self.historia = Historial(data)
self.historia.table.show()
elif nodo.valor == '013':
data = []
for i in nodo.hijos.values():
if i.valor == '012':
data2 = self.client.files_list_revisions(i.id_nodo,
limit=10).entries
data += data2
self.historia2 = Historial(data)
self.historia2.table.show()
def mover(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
texto, ok = QInputDialog.getText(
self, "Mover",
"Ingresa nombre de la carpeta contenedora(dropbox para carpeta principal):"
)
if ok:
if texto == '':
pass
else:
if texto == 'dropbox':
try:
self.client.files_move(nodo.id_nodo, '/' + nodo.nombre)
aux = self.arbol.sacar_nodo(nodo)
aux.agregando_a_arbol(self.arbol, '')
except dropbox.exceptions.ApiError:
self.mainwindow.statusBar().showMessage(
'Carpeta ya existe con el mismo nombre en el destino'
)
else:
nodo_llegada = self.arbol.obtener_nodo_nombre(texto)
if nodo_llegada is not None and nodo_llegada.valor == '013':
try:
self.client.files_move(
nodo.id_nodo,
nodo_llegada.id_nodo + '/' + nodo.nombre)
aux = self.arbol.sacar_nodo(nodo)
aux.agregando_a_arbol(self.arbol,
nodo_llegada.id_nodo)
except dropbox.exceptions.ApiError:
otra = self.mainwindow.statusBar()
otra.showMessage(
'Carpeta ya existe con el mismo nombre en el destino'
)
elif nodo_llegada is not None and nodo_llegada.valor == '012':
otra = self.mainwindow.statusBar()
otra.showMessage('Tienes que moverlo a una carpeta')
else:
otra = self.mainwindow.statusBar()
otra.showMessage('Tienes que moverlo a una carpeta')
self.init_GUI()
def renombrar(self):
nodo = self.arbol.obtener_nodo_nombre(self.que)
texto, ok = QInputDialog.getText(
self, "Renombrar", "Nuevo nombre con la extencion si es archivo:")
if ok:
if texto == '':
pass
else:
if self.arbol.obtener_nodo_nombre(texto) is None:
if nodo.valor == '012':
numero = texto.find('.')
if numero != -1:
if texto.split('.')[1] == nodo.nombre.split(
'.')[1]:
id_padre = nodo.id_padre
nuevo_id = id_padre + '/' + texto
self.client.files_move(nodo.id_nodo, nuevo_id)
aux = self.arbol.sacar_nodo(nodo)
self.arbol.agregar_nodo(id_nodo=nuevo_id,
valor=nodo.valor,
id_padre=id_padre,
nombre=texto)
for i in aux.hijos.values():
i.agregando_a_arbol(self.arbol, nuevo_id)
self.init_GUI()
else:
self.mainwindow.statusBar().showMessage(
'Falta la extencion')
else:
self.mainwindow.statusBar().showMessage(
'Falta la extencion')
elif nodo.valor == '013':
id_padre = nodo.id_padre
nuevo_id = id_padre + '/' + texto
try:
self.client.files_move(nodo.id_nodo, nuevo_id)
aux = self.arbol.sacar_nodo(nodo)
self.arbol.agregar_nodo(id_nodo=nuevo_id,
valor=nodo.valor,
id_padre=id_padre,
nombre=texto)
for i in aux.hijos.values():
i.agregando_a_arbol(self.arbol, nuevo_id)
self.init_GUI()
except dropbox.exceptions.ApiError:
self.mainwindow.statusBar().showMessage(
'Nombre ya existe, escoja uno diferente')
else:
self.mainwindow.statusBar().showMessage(
'Nombre ya existe, escoja uno diferente')
def openmenu(self, position):
indexes = self.treeView.selectedIndexes()
ver_status = QAction(QIcon(None), '&Agregar Archivo', self)
ver_status.setStatusTip('Agregar Archivo')
ver_status.triggered.connect(self.agregar_archivo)
ver_status2 = QAction(QIcon(None), '&Agregar Carpeta', self)
ver_status2.setStatusTip('Agregar Carpeta')
ver_status2.triggered.connect(self.agregar_carpeta)
ver_status3 = QAction(QIcon(None), '&Descargar Archivo', self)
ver_status3.setStatusTip('Descargando Archivo')
ver_status3.triggered.connect(self.descargar_archivo)
ver_status4 = QAction(QIcon(None), '&Descargar Carpeta', self)
ver_status4.setStatusTip('Descargando Carpeta')
ver_status4.triggered.connect(self.descargar_carpeta)
ver_status5 = QAction(QIcon(None), '&Borrar Archivo', self)
ver_status5.setStatusTip('Borrando Archivo')
ver_status5.triggered.connect(self.borrar)
ver_status6 = QAction(QIcon(None), '&Borrar Carpeta', self)
ver_status6.setStatusTip('Borrando Carpeta')
ver_status6.triggered.connect(self.borrar)
ver_status10 = QAction(QIcon(None), '&Crear Carpeta', self)
ver_status10.setStatusTip('Crear Carpeta')
ver_status10.triggered.connect(self.crear_carpeta)
ver_status7 = QAction(QIcon(None), '&Ver Historial', self)
ver_status7.setStatusTip('Ver Historial')
ver_status7.triggered.connect(self.historial)
ver_status8 = QAction(QIcon(None), '&Mover', self)
ver_status8.setStatusTip('Mover')
ver_status8.triggered.connect(self.mover)
ver_status9 = QAction(QIcon(None), '&Renombrar', self)
ver_status9.setStatusTip('Renombrar')
ver_status9.triggered.connect(self.renombrar)
menu = QMenu()
if len(indexes) > 0:
self.que = indexes[0].data()
menu.addAction(ver_status)
menu.addAction(ver_status2)
nodo = self.arbol.obtener_nodo_nombre(self.que)
if nodo.valor == '013':
menu.addAction(ver_status4)
menu.addAction(ver_status6)
else:
menu.addAction(ver_status3)
menu.addAction(ver_status5)
menu.addAction(ver_status10)
menu.addAction(ver_status7)
menu.addAction(ver_status8)
menu.addAction(ver_status9)
menu.exec_(self.treeView.viewport().mapToGlobal(position))
def salir(self):
QCoreApplication.instance().quit()
