def addInner(self,value,name,dad,typeDate):
current = self.searchInTree(dad) #Busca y retorna el padre al que le sera agregado el elemento.
if(self.root.children == None): #Si no tiene hijos.
self.root.children = LinkedList()
self.root.tabulated = 0 #El root su tabulado es 0
if(current != None): #Si tiene hijos.
if(current.children == None):
current.children = LinkedList()
newTab = 1 + current.tabulated
current.children.add(value,name,typeDate,current,newTab)
self.totalNodes += 1 #Contador.
else:
newTab= 1 + current.tabulated
current.children.add(value,name,typeDate,current,newTab)
#current.children.searchInLL(value,0).father = current
#nodeAdded = current.children.searchInLL(value,0)
#self.totalNodes += 1
else:
print('No se agrego al arbol')
def BSTAddFromLinkedList(self, ll=LinkedList()):
if (isinstance(ll, LinkedList)):
current = ll.first
while (current):
value = current.value
self.BSTAdd(value)
current = current.next
return True
def enableBtnLeft(self):
self.enableLabels2(False)
listSelected = self.listTree2.selectedItems(
) #Guarda los items seleccionados.
listTemp = LinkedList()
currentFather = self.treeN1.searchInTree(
self.clickedItems1[-1].value
) #Retorna el elemento al que se le pegara los items.
if (len(listSelected) != 0): #En caso que haya seleccionado.
for i in range(len(listSelected)):
currentCopied = self.treeN2.searchInTree(listSelected[i])
if (currentCopied.typeDate == 1):
itemToAdd = QListWidgetItem(
QIcon("Nucleo/Imagenes/folder.png"),
currentCopied.name)
if (currentFather.children != None):
if (currentFather.children.searchItemForNameAndType(
currentCopied.name, 1) == True):
currentFather.children.removeForNameAndType(
currentCopied.name, 1)
self.warningMessage(
"Elemento ya existente",
"El elemento '%s' ha sido reemplazado" %
(currentCopied.name))
self.addDirTree1(itemToAdd, currentFather.value)
else:
self.addDirTree1(itemToAdd, currentFather.value)
else:
self.addDirTree1(itemToAdd, currentFather.value)
newFather = self.treeN1.searchInTree(itemToAdd)
self.treeN1.addNewElements(currentCopied, newFather.value,
self.treeN1)
elif (currentCopied.typeDate == 2):
if (currentFather.children != None):
if (currentFather.children.searchItemForNameAndType(
currentCopied.name, 2) == True):
currentFather.children.removeForNameAndType(
currentCopied.name, 2)
self.warningMessage(
"Elemento ya existente",
"El elemento '%s' ha sido reemplazado" %
(currentCopied.name))
self.addFileTree1(currentCopied.name,
currentFather.value)
else:
self.addFileTree1(currentCopied.name,
currentFather.value)
else:
self.addFileTree1(currentCopied.name,
currentFather.value)
if (currentFather.name != 'home'):
self.repaintListView(self.listTree1, currentFather)
elif (currentFather.name == 'home'):
self.repaintListView(self.listTree1, currentFather, False)
self.treeN1.convertTreeToPlaneText(1)
else:
self.enableLabels2(True, '¡No hay elementos copiados!')
def BSTConvert(self, ll=LinkedList()):
current = ll.first
if (not current):
return False
tree = BST()
rootNode = self.getValue(current.value)
tree.g.add_node(rootNode)
while (current):
value = current.value
tree.BSTAdd(value)
current = current.next
return tree
import ast
import os
from Nucleo import Acerca_de
from Nucleo import Agregar_Pélicula
from Nucleo import Árbol_Binario_de_Duración
from Nucleo import Árbol_Jerárquico_de_Categorías
from Nucleo.Tamaño_Pantalla import *
from Nucleo import Ventana_Principal
from Nucleo import Ver_y_Editar_Péliculas
from Nucleo.Información_Pélicula import *
from Nucleo.LinkedList import *
from Nucleo.Manejador_de_Archivos import *
from Memoria import *
ll = LinkedList()
objeto = FileManager()
posicion = 0
class Ventana_Principal(QMainWindow,
Ventana_Principal.Ui_Principal_MainWindow):
def __init__(self, parent=None):
super(Ventana_Principal, self).__init__(parent)
self.setupUi(self)
Center.center(self)
self.actualizar_desde_JSON()
self.Acerca_de_button.clicked.connect(self.abrir_Acerca_de)
self.Agregar_Principal_button.clicked.connect(
self.abrir_Agregar_Pelicula)
def __init__(self): self.root = None #Inicialmente no hay root. self.listToTextPlane = LinkedList() #LL Basica para simplemente guardar los nodos del arbol. self.totalNodes = 0 #Un simple contador, para saber cuantos items hay en el arbol.
class TreeN:
def __init__(self):
self.root = None #Inicialmente no hay root.
self.listToTextPlane = LinkedList() #LL Basica para simplemente guardar los nodos del arbol.
self.totalNodes = 0 #Un simple contador, para saber cuantos items hay en el arbol.
#Agregar al arbol con sus respectivos parametros.
def addElementoToTree(self,value,name,dad,typeDate):
if(self.root == None and dad == 0):
self.root = Node(value,name,typeDate,"/")
#self.root.father = "/"
self.final = None
self.totalNodes += 1
self.final2 = None
else:
self.addInner(value,name,dad,typeDate)
#Agregado interno, haciendo uso de la funcion recursiva 'search'.
def addInner(self,value,name,dad,typeDate):
current = self.searchInTree(dad) #Busca y retorna el padre al que le sera agregado el elemento.
if(self.root.children == None): #Si no tiene hijos.
self.root.children = LinkedList()
self.root.tabulated = 0 #El root su tabulado es 0
if(current != None): #Si tiene hijos.
if(current.children == None):
current.children = LinkedList()
newTab = 1 + current.tabulated
current.children.add(value,name,typeDate,current,newTab)
self.totalNodes += 1 #Contador.
else:
newTab= 1 + current.tabulated
current.children.add(value,name,typeDate,current,newTab)
#current.children.searchInLL(value,0).father = current
#nodeAdded = current.children.searchInLL(value,0)
#self.totalNodes += 1
else:
print('No se agrego al arbol')
#Funcion que busca en el arbol.
def searchInTree(self,value):
return self.searchInnerInTree(self.root,value) #Llama a la funcion interna.
#Funcion recursiva interna de buscar dentro del arbol. Retornando en caso de una coincidencia.
def searchInnerInTree(self,root,value):
if(self.root.value == value ): #Si el item a buscar es el root
return self.root #Retorna el root
if(root.children == None): #Si el item no tiene hijos, caso que el dir no tenga elemento o el item sea un archivo.
pass #Salto.
else:
size = root.children.length() #Guarda el tamano de la LL del hijo.
for i in range(size):
item = root.children.atPosition(i) #Devuelve un elemento del ChildList y lo guarda en item.
if(item.value == value): #En caso de coincidencia.
self.final = item #Se agrega a la variable global final.
else: #En caso no de haber coincidencia, hace el llamado recursivo con el nuevo elemento.
self.searchInnerInTree(root.children.atPosition(i),value) #Vuelve a llamarse.
return self.final #Devuelve el nodo encontrado. None, en caso que no.
def searchInTreeForName(self,name):
return self.searchInnerInTreeForName(self.root,name) #Llama a la funcion interna.
#Funcion recursiva interna de buscar dentro del arbol. Retornando en caso de una coincidencia.
def searchInnerInTreeForName(self,root,name):
if(self.root.name == name ): #Si el item a buscar es el root
return self.root #Retorna el root
if(root.children == None): #Si el item no tiene hijos, caso que el dir no tenga elemento o el item sea un archivo.
pass #Salto.
else:
size = root.children.length() #Guarda el tamano de la LL del hijo.
for i in range(size):
item = root.children.atPosition(i) #Devuelve un elemento del ChildList y lo guarda en item.
if(item.name == name): #En caso de coincidencia.
self.final2 = item #Se agrega a la variable global final.
else: #En caso no de haber coincidencia, hace el llamado recursivo con el nuevo elemento.
self.searchInnerInTreeForName(root.children.atPosition(i),name) #Vuelve a llamarse.
return self.final2 #Devuelve el nodo encontrado. None, en caso que no.
#Elimina un elemento en el arbol, incluyendo si este tiene hijos.
def deleteElementToTree(self,element):
if(self.searchInTree(element) != None):
temp = self.searchInTree(element).father #Guarda el nodo padre.
temp = temp.children
temp.removeToNormal(element)
print('Borrado')
else:
print('No pudo borrarse')
#Este metodo guarda en una LL TODOS los nodos que existen en el arbol.
def convertTreeToLL(self):
return self.convertInner(self.root)
#Funcion recursiva para poder GUARDAR TODOS los nodos del arbol en una LL.
def convertInner(self,root): #Conversion a LL recursiva.
if(root == self.root):
self.listToTextPlane.add(self.root,None,None,None,None,False) #Agregado al LL que sera usada para crear .mem
if(root.children == None):
pass
else:
size = root.children.length()
for i in range(size): #Recorrera los uhis
item = root.children.atPosition(i)
self.listToTextPlane.add(item,None,None,None,None,False)
self.convertInner(root.children.atPosition(i)) #Llamado recursivo.
def addNewElements(self,NodeToAdd,fatherToAdd,objectToTree): #[NodoPadre,Lista que se le extraera los elementos]
if(NodeToAdd.children == None):
pass
else:
size = NodeToAdd.children.length()
for i in range(size):
currentItem = NodeToAdd.children.atPosition(i)
itemType = self.itemExtension(currentItem.name)
if(currentItem.typeDate == 1):
itemToAdd = QListWidgetItem(QIcon("Nucleo/Imagenes/folder.png"),currentItem.name)
objectToTree.addElementoToTree(itemToAdd,currentItem.name,fatherToAdd,1)
else:
itemToAdd = QListWidgetItem(QIcon(itemType),currentItem.name)
objectToTree.addElementoToTree(itemToAdd,currentItem.name,fatherToAdd,2)
self.addNewElements(NodeToAdd.children.atPosition(i),itemToAdd,objectToTree)
#Funcion para convertir el arbol en una Texto Plano y guardse en la carpeta /Memoria con el respectivo nombre del archivo.
def convertTreeToPlaneText(self,numberTree):
self.convertTreeToLL()
listTemp = self.listToTextPlane
if(numberTree == 1):
path = 'Memoria/Tree-A.mem'
elif(numberTree == 2):
path = 'Memoria/Tree-B.mem'
self.clearContentOfPlaneText(numberTree) #Limpia el contenido 'actual' del archivo.
temp = open(path,"w") #Abre el texto plano.
for i in range(listTemp.length()): #Recorrera la lista que contiene todos los nodos del arbol.
item = listTemp.atPosition(i) #Extra un item de la LL
temp.write("\t"*item.value.tabulated) #Escribira el tabulado de dicho item.
if(item.value.typeDate == 1): #En caso que el nodo sea carpeta.
temp.write("%s/" % (item.value.name)) #Escribira el nombre del nodo + /.
else: #En caso que sea archivo.
temp.write(item.value.name)
temp.write('\n') #Al final de cada linea salta de linea.
temp.close()
self.listToTextPlane.first = None #Se limpia la lista, SINO al siguiente guardado ira concatenando.
#Extrae todos los elementos del texto plano, linea por linea.
def extracItemsToPlaneText(self,numberOfTree):
lista = []
self.listaFinal = []
self.tabMax = 0
tempParent = 0
if(numberOfTree == 1):
path = "Memoria/Tree-A.mem"
if(numberOfTree == 2):
path = "Memoria/Tree-B.mem"
temp = open(path,"r")
lineas = temp.readlines()
for i in lineas:
a = i.split("\t")
lista.append(a)
temp.close()
#-------------------------------------------------------------
#Quita el '\n' del final
for k in range(len(lista)):
for m in range(len(lista[k])):
#lista[k][m] = lista[k][m].replace(" ","")
lista[k][m] = lista[k][m].strip('\n')
#-------------------------------------------------------------
newList = []
subList = []
typeD = 1
for n in range(len(lista)):
tab = 0
for i in range(len(lista[n])):
currentIndex = lista[n][i]
if(currentIndex == ''):
tab += 1
if(currentIndex != ''):
if(currentIndex[-1] == '/'):
typeD = 1
currentIndex = currentIndex.strip('/')
elif(currentIndex[-1] != '/'):
typeD = 2
subList.append(currentIndex)
subList.append(typeD)
subList.append(tab)
newList.append(subList)
subList = None
subList = []
return self.buildListToPlaneText(newList) #[value,typed,tabulated]
#Asigna los respectivos padres a cada elemento, basado en su tabulado y recorrido de la lista dada.
def buildListToPlaneText(self,_list):
parentSaves = []
parentSaves.append(_list[0][0])
sizeOfList = len(_list)
for i in range(1,sizeOfList):
count = i + 1
if(count < sizeOfList):
if(_list[count][2] >= _list[i][2] or _list[i][2] == _list[i-1][2]):
_list[i].append(parentSaves[-1])
if(_list[i][2] != _list[count][2] and _list[i][2] < _list[count][2]):
parentSaves.append(_list[i][0])
if(_list[count][2] < _list[i][2]):
tabu = _list[i][2] - _list[count][2]
_list[i].append(parentSaves[-1])
for j in range(0,tabu):
parentSaves.pop() #-----
count = 0
else:
_list[i].append(parentSaves[-1])
return _list
#Funcion para limpiar el contenido actual del archivo texto plano.
def clearContentOfPlaneText(self,numberTree):
if(numberTree == 1):
path = 'Memoria/Tree-A.mem'
elif(numberTree == 2):
path = 'Memoria/Tree-B.mem'
f = open(path,"r")
lineas = f.readlines()
f.close()
f = open(path,"w")
for linea in lineas:
if linea==""+"\n":
f.write(linea)
f.close()
#Esta funcion transforma una lista de elementos extraidos, agregandolos al arbol con sus respectivas transformaciones a items de tipo QListWidgetItem
def convertPlaneTextToTree(self,numberOfTree):
listItems = self.extracItemsToPlaneText(numberOfTree) #[value,typeDate,tabulado,parent]
listItems.pop(0)
for i in range(len(listItems)):
element = listItems[i]
name = element[0]
itemType = self.itemExtension(name)
typedate = element[1]
parent = self.searchInTreeForName(element[3]).value
if(typedate == 1):
value = QListWidgetItem(QIcon("Nucleo/Imagenes/folder.png"),name)
self.addElementoToTree(value,name,parent,1)
elif(typedate == 2):
value = QListWidgetItem(QIcon(itemType),name)
self.addElementoToTree(value,name,parent,2)
def itemExtension(self,item):
ext = item.split(".")
if(len(ext)!= 1):
if(ext[1]=="txt"):
return "Nucleo/Imagenes/file.png"
elif(ext[1]=="mp3"):
return "Nucleo/Imagenes/Mp3.png"
elif(ext[1]=="pdf"):
return "Nucleo/Imagenes/pdf.png"
elif(ext[1]=="py"):
return "Nucleo/Imagenes/py.png"
elif(ext[1]=="js"):
return "Nucleo/Imagenes/js.png"
elif(ext[1]=="html"):
return "Nucleo/Imagenes/html.png"
else:
return "Nucleo/Imagenes/file.png"
return "Nucleo/Imagenes/file.png"
def __init__(self):
self.listMovie = LinkedList()
self.tree = BST()
self.treeN = TreePure()
class Catalog:
def __init__(self):
self.listMovie = LinkedList()
self.tree = BST()
self.treeN = TreePure()
"""
Nombre addMovie
Parametros: Recibe un objeto Movie.
Descripcion: Agrega peliculas a la lista Enlazada.
Retorno: Retorna True si el objeto a ingresar es un objeto Movie, False en caso contrario.
"""
def addMovie(self, movie):
if (isinstance(movie, Movie)):
self.listMovie.push(movie)
self.tree = BST()
self.tree = self.tree.BSTConvert(self.listMovie)
self.tree.AddToG(self.tree.root)
self.viewTree()
self.viewTreeN()
return True
return False
"""
Nombre: addCatalogToTreeN
Parametros: No recibe parametros.
Descripcion: Agrega las categorias de peliculas y los elementos de la lista de este catalogo
al árbol de n nodos.
Retorno: Retorna un boleano.
"""
def addCatalogToTreeN(self):
self.setCategoryTree()
current = self.listMovie.first
while (current):
parent = current.value.categoryMovie
self.treeN.add(parent, current.value)
current = current.next
return True
"""
Nombre: viewTreeN
Parametros: No recibe parametros.
Descripcion: Genera una imagen en formato png con la reprecentacion del árbol jerarquico.
Retorno: Retorna un boleano.
"""
def viewTreeN(self):
self.addCatalogToTreeN()
try:
self.treeN.generateGraph()
G = self.treeN.getGraphN()
nx.nx_agraph.write_dot(G, "Nucleo/treeN.dot")
A = nx.nx_agraph.to_agraph(G)
A.layout(
'dot',
args=
'-Nfontsize=14 -Nwidth=".5" -Nheight=".5" -Nmargin=0 -Gfontsize=36'
)
A.draw('Nucleo/treeN.png')
except ValueError:
print("Error")
return True
"""
Nombre: setCategoryTree
Parametros: No recibe parametros.
Descripcion: Agrega las categorías de peliculas al árbol jerárquico
Retorno: Retorna True.
"""
def setCategoryTree(self):
self.treeN = TreePure()
self.treeN.add("Categorias", "Acción")
self.treeN.add("Categorias", "Artes marciales")
self.treeN.add("Categorias", "Aventuras")
self.treeN.add("Categorias", "Bélicas")
self.treeN.add("Categorias", "Comedia")
self.treeN.add("Categorias", "Comedias musicales")
self.treeN.add("Categorias", "Ciencia ficción")
self.treeN.add("Categorias", "Deportivas")
self.treeN.add("Categorias", "Dibujos Animados")
self.treeN.add("Categorias", "Documental")
self.treeN.add("Categorias", "Dramáticas")
self.treeN.add("Categorias", "Espada y hechicería")
self.treeN.add("Categorias", "Espionaje")
self.treeN.add("Categorias", "Fantásticas")
self.treeN.add("Categorias", "Hechos reales")
self.treeN.add("Categorias", "Horror")
self.treeN.add("Categorias", "Infantiles")
self.treeN.add("Categorias", "Misterio")
self.treeN.add("Categorias", "Muertos vivientes")
self.treeN.add("Categorias", "Musicales")
self.treeN.add("Categorias", "Policíales")
self.treeN.add("Categorias", "Propaganda")
self.treeN.add("Categorias", "Psicológicas")
self.treeN.add("Categorias", "Suspenso")
self.treeN.add("Categorias", "Románticas")
self.treeN.add("Categorias", "Sobre Animales")
self.treeN.add("Categorias", "Sobre aviación")
self.treeN.add("Categorias", "Sobre delincuencia")
self.treeN.add("Categorias", "Sobre discapacitados")
self.treeN.add("Categorias", "Sobre religión")
self.treeN.add("Categorias", "Sobre política")
return True
"""
Nombre: viewTree
Parametros: No recibe parametros.
Descripcion: Genera una imagen en formato png con la reprecentacion del árbol Binario.
Retorno: Retorna un boleano.
"""
def viewTree(self):
try:
if (self.tree):
G = self.tree.getGraph()
nx.nx_agraph.write_dot(G, "Nucleo/tree.dot")
A = nx.nx_agraph.to_agraph(G)
A.layout(
'dot',
args=
'-Nfontsize=14 -Nwidth=".5" -Nheight=".5" -Nmargin=0.1 -Gfontsize=36'
)
A.draw('Nucleo/tree.png')
return True
return False
except:
print("Es necesario instalar pygraphviz")
"""
Nombre: editMovie
Parametros:
idEdit: Id del objeto que se quiere editar
Movie: Objeto Movie que se quiere agregar como nuevo objeto.
Descripción: Remplaza un objeto de la lista enlazada según su ID
Retorno: Retorna True en caso de que el objeto nuevo sea un objeto Movie, False en caso contrario.
"""
def editMovie(self, idEdit, movie):
index = self.getIndex(idEdit)
if (isinstance(movie, Movie)):
self.listMovie.replace(index, movie)
self.tree = self.tree.BSTConvert(self.listMovie)
self.tree.AddToG((self.tree.root))
self.viewTree()
self.viewTreeN()
return True
return False
"""
Nombre: deleteMovie
Parametros:
idRemove: Id del objeto que se desea eliminar.
Descripcion: Elimina un elemento de la lista enlazada.
Retorno: Retorna True
"""
def deleteMovie(self, idRemove):
index = self.getIndex(idRemove)
self.listMovie.pop(index)
self.tree = self.tree.BSTConvert(self.listMovie)
try:
self.tree.AddToG((self.tree.root))
self.viewTree()
self.viewTreeN()
except:
return False
return True
"""
Nombre: asignateId
Parametros:
start: Por defecto esta inicializado en 0, es el inicio desde donde se quiere
encontrar una disponibilidad de ID
Descripcion: Asigna un Id a un nuevo objeto que se quiera agregar a la lista.
Retorno: retorna un Entero con el id encontrado.
"""
def asignateId(self, start=0):
size = self.listMovie.length()
obj = self.getMovieFromList(start)
if (not obj):
return start
return self.asignateId(start + 1)
"""
Nombre: getIndex
Parametros:
idSearch: Id del elemento al que se quiere obtener su posición den la lista.
Descripción: Permite encontrar la posicion de un elemento seleccionado segun su ID.
Retorno: Retorna su posicion si fue encontrado, False en caso contrario.
"""
def getIndex(self, idSearch):
size = self.listMovie.length()
count = 0
while (count != size):
objMovie = self.listMovie.getElementFromIndex(count)
if (isinstance(objMovie, Movie)):
if (objMovie.idMovie == idSearch):
return count
count += 1
return -1
"""
Nombre: getMovieFromList
Parametros:
idMovie: Identificador del objeto que se quiere buscar.
Descripcion: Se obtendra una pelicula del catalogo segun su posicion.
Retorno: Retorna el objeto encontrado.
"""
def getMovieFromList(self, idMovie):
index = self.getIndex(idMovie)
objMovie = self.listMovie.getElementFromIndex(index)
return objMovie
"""
Nombre: printCatalog
Parametros: No recibe parametros.
Descripcion: Genera un string con todos los valores agregados en el catalogo.
Retorno: Retorna un String.
"""
def printCatalog(self):
txt = ""
size = self.listMovie.length()
if (size == 0):
return "null"
for i in range(size):
objMovie = self.listMovie.getElementFromIndex(i)
txt += "%s->" % (objMovie.nameMovie)
txt += "null"
return txt
"""
Nombre: search
Parametros: Recibe un Id para verificar su existencia en la lista.
Descripcion: verifica si hay un id con el parametro recibido dentro de la lista.
Retorno: retorna un boleano.
"""
def search(self, idCheck):
index = self.getIndex(idCheck)
check = self.listMovie.search(index)
return check
"""
Nombre: getSize
Parametros: No recibe parametros.
Descripcion: Obtiene el tamaño de la lista de peliculas.
Retorno: retorna un entero con el tamaño de la lista.
"""
def getSize(self):
size = self.listMovie.length()
return size
"""
Nombre: getMovieFromIndex
Parametros:
index: pocision en memoria del objeto a retornar.
Descripción: Busca un objeto pelicula segun su posicion en memoria.
Retorno: Retorna el objeto encontrado.
"""
def getMovieFromIndex(self, index):
movie = self.listMovie.getElementFromIndex(index)
return movie