def print_req4(catalog):
info = controller.req4(catalog["connections"])
print("Numero de nodos conectados:" + str(info[0]))
print_separador_sensillo()
print("Costo total de la red de expanción minima: " + str(info[1]))
print_separador_sensillo()
print("La conexión más larga es en dirección a " + str(info[2]["key"]) +
" con un costo de " + str(info[2]["value"]))
print_separador_sensillo()
print("La conexión más corta es en dirección a " + str(info[3]["key"]) +
" con un costo de " + str(info[3]["value"]))
print_separador_sensillo()
delta_time = stop_time - start_time
delta_memory = controller.deltaMemory(start_memory, stop_memory)
print('Tiempo[ms]: ', f"{delta_time:.3f}", "-", "Memoria [kB]: ",
f"{delta_memory:.3f}")
pass
elif int(inputs[0]) == 6:
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = controller.getTime()
start_memory = controller.getMemory()
resultado = controller.req4(cont)
print(
'Hay ' + str(resultado[1]) +
' nodos conectados a la red de expansión mínima. La distancia total de la red de expansión mínima es de '
+ str(resultado[0]) + ' km.')
stop_memory = controller.getMemory()
stop_time = controller.getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = controller.deltaMemory(start_memory, stop_memory)
print('Tiempo[ms]: ', f"{delta_time:.3f}", "-", "Memoria [kB]: ",
f"{delta_memory:.3f}")
pass
elif int(inputs[0]) == 7:
print("------------------------------------------------- Requerimiento #4 --------------------------------------------------------")
print("")
generos = lt.newList(datastructure='ARRAY_LIST')
continuar = True
while continuar:
nuevo = preguntar_generos()
lt.addLast(generos, nuevo)
continuar = preguntar_crear()
tracemalloc.start()
delta_time = -1.0
delta_memory = -1.0
start_time = controller.getTime()
start_memory = controller.getMemory()
resultado = controller.req4(catalog, generos)
stop_time = controller.getTime()
stop_memory = controller.getMemory()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = controller.deltaMemory(start_memory, stop_memory)
mediciones = [delta_time, delta_memory]
print("El total de eventos para los siguientes géneros fue de: " + str(resultado[1]))
for genero in lt.iterator(resultado[0]):
print_genero(genero)
print("------------------------------------------------------")
print("> Tiempo y memoria consumidos:")
print("> Tiempo [ms]: ", f"{mediciones[0]:.3f}", " || ", "Memoria [kB]: ", f"{mediciones[1]:.3f}")
elif genero == 'HIP-HOP': #
minimo = 85.0
maximo = 115.0
elif genero == 'JAZZ AND FUNK':
minimo = 120.0
maximo = 125.0
elif genero == 'R&B':
minimo = 60.0
maximo = 80.0
elif genero == "ROCK":
minimo = 110.0
maximo = 140.0
else:
minimo = 100.0
maximo = 160.0
pra = controller.req4('tempo', minimo, maximo, cont)
artistas = pra[0][0]
reproducciones = pra[0][1]
lista = pra[0][2]
x = 1
cantidad = lt.size(lista)
total += int(reproducciones)
sumat += float(pra[1])
sumam += float(pra[2])
print("*******************************************")
print("*******************************************")
print("Para el genero: " + str(genero) + ' se tiene que hay ' +
str(artistas) + ' artistas y ' + str(reproducciones) +
' reproducciones')
print("Donde el tempo minimo es " + str(minimo) +
" y el maximo es " + str(maximo))
tracemalloc.start()
start_time = controller.getTime()
start_memory = controller.getMemory()
x = int(
input(
'¿Desea conocer información sobre géneros ya existentes? [0: sí // 1: no]: '
))
if x == 0:
genres = input(
'¿Cuáles? [escríbalos separados por una coma y espacio. Ej: reggae, hip-hop]: '
)
lista = (genres.lower()).split(', ')
for genre in lista:
controller.req4(catalog, genre, None, None)
print('\n')
y = int(
input(
'¿Desea conocer información sobre un género no existente? [0: sí // 1: no]: '
))
if y == 0:
name = input('Ingrese el nombre del nuevo género: ')
minim = float(input('Ingrese el valor mínimo de tempo: '))
maxim = float(input('Ingrese el valor máximo de tempo: '))
controller.req4(catalog, name, minim, maxim)
print('\n')
stop_memory = controller.getMemory()
stop_time = controller.getTime()
tracemalloc.stop()
print(resul)
elif int(inputs[0]) == 3:
print ("Encontrar video tendencia por país")
country = input("Ingrese el nombre del país del cual quiere saber el video que más fue tendencia: ")
print(controller.req2(catalog, country))
elif int(inputs[0]) == 4:
print('Encontrar videos tendencias por categoría')
category = input("Ingrese la categoria de la cual quiera saber el video que más fue tendencia: ")
print(controller.req3(catalog,category))
elif int(inputs[0]) == 5:
print('Buscar los videos con mas likes de un pais y con un tag determinados')
country = input("Ingrese el pais del cual quiera conocer los videos con mas likes: ")
tag = input("Ingrese el tag del cual quiera saber los videos: ")
size = int(input("Ingrese la cantidad de videos que quiera conocer: "))
result = controller.req4(catalog,tag,country,size)
if result == 0:
print("El numero de muestra seleccionado, excede el tamaño de la cantidad total de elementos que hay")
else:
print(result)
else:
sys.exit(0)
sys.exit(0)
elif int(inputs[0]) == 4: # Req 3
paisA = input(
"\nIngrese el nombre del primer país que desea consultar. Ejemplo: Colombia\n~ "
)
paisB = input(
"\nIngrese el nombre del segundo país que desea consultar. Ejemplo: Indonesia\n~ "
)
controller.minimumCostPaths(analyzer, paisA)
pathReq3 = printReq3(analyzer, paisB)
elif int(inputs[0]) == 5: # Req 4
resultados = controller.req4(analyzer)
distanciaMax = controller.bfsReq4(analyzer)
print(
f"\nNúmero de nodos conectados en la red de expansión mínima: {resultados[0]}\n"
)
print(f"Distancia de la red de expansión mínima: {resultados[1]} km\n")
print(
"\nLa rama más larga que hace parte de la red de expansión mínima desde 'Bogotá-Colombia' tiene una longitud de {0} y corresponde al landing point: {1}"
.format(distanciaMax[0]['distTo'], distanciaMax[0]['edgeTo']))
print(
"\nEl recorrido desde 'Bogotá-Colombia' hasta {0} es el siguiente:\n"
.format(distanciaMax[0]['edgeTo']))
printReq4andReq7(distanciaMax[1])
elif int(inputs[0]) == 6: # Req 5
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
print(str(delta_time) + " " + str(delta_memory))
elif int(inputs[0]) == 5:
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
resultado = controller.req4(catalog)
print("Número de nodos incluidos en el arbol de expansión mínima: " +
str(resultado[0]))
print("El peso de todos los arcos del arbol es: " + str(resultado[1]) +
" Km")
print("La ruta más larga es: ")
for vertice in lt.iterator(resultado[2]):
print(vertice)
stop_time = getTime()
stop_memory = getMemory()
tracemalloc.stop()
delta_time = stop_time - start_time
print(respuesta)
elif int(inputs[0]) == 5:
print("Cargando información de los archivos ....")
pais_a = input('Inserte el país a: ')
pais_b = input('Inserte el país b: ')
respuesta = controller.req3(catalog, pais_a, pais_b)
print("Tiempo [ms]: ", f"{respuesta[1]:.3f}", " || ",
"Memoria [kB]: ", f"{respuesta[2]:.3f}")
print(respuesta)
elif int(inputs[0]) == 6:
print("Cargando información de los archivos ....")
respuesta = controller.req4(catalog)
print(respuesta)
print("Tiempo [ms]: ", f"{respuesta[1]:.3f}", " || ",
"Memoria [kB]: ", f"{respuesta[2]:.3f}")
elif int(inputs[0]) == 7:
print("Cargando información de los archivos ....")
nombre_landing_point = input('Inserte el nombre del landing_point: ')
respuesta = controller.req5(catalog, nombre_landing_point)
print("Tiempo [ms]: ", f"{respuesta[1]:.3f}", " || ",
"Memoria [kB]: ", f"{respuesta[2]:.3f}")
print(respuesta)
elif int(inputs[0]) == 8:
print("Cargando información de los archivos ....")
elif int(inputs[0]) == 9:
elif int(inputs[0]) == 4:
category = input('Ingrese la categoría: ').lower()
x = input('Desea organizar videos por... (0: título / 1: video ID): ')
if x == '0':
td = 'title'
elif x == '1':
td = 'video_id'
else:
print('Ingrese una opción válida (0,1)')
answer = controller.req3(catalog, category, td)
print('\n' + answer[0] + '\n')
print("Tiempo [ms]: " + f"{answer[1]:.3f}" + " || " +
"Memoria [kB]: " + f"{answer[2]:.3f}")
print('\n')
input('Presione enter para continuar')
elif int(inputs[0]) == 5:
country = input('Ingrese el país: ').lower()
tag = input('Ingrese el tag: ').lower()
n = int((input('Ingrese el número: ')))
answer = controller.req4(catalog, country, tag, n)
print("Tiempo [ms]: " + f"{answer[0]:.3f}",
" || " + "Memoria [kB]: " + f"{answer[1]:.3f}")
print('\n')
input('Presione enter para continuar')
else:
sys.exit(0)
sys.exit(0)
landingb = input("ingrese un landing point: ")
x = controller.req1(datos, landinga, landingb)
print(x)
elif int(inputs[0]) == 4:
d = controller.req2(datos)
for i in d:
print('el vertice {0} tiene {1} cables coonectados'.format(
i, d[i]))
elif int(inputs[0]) == 5:
pais_a = "Colombia"
pais_b = 'Indonesia'
controller.req3(datos, pais_a, pais_b)
elif int(inputs[0]) == 6:
controller.req4(datos)
elif int(inputs[0]) == 7:
landingpoint = 'fortaleza'
#landingpoint=input('ingresa el landing point que deseas consultar: ')
x = controller.req5(datos, landingpoint)
print('la cantidad de paises afectados es:{0} '.format(len(x)))
print('la lista de paises afectados es : {0}'.format(x))
elif int(inputs[0]) == 8:
pass
elif int(inputs[0]) == 9:
#primero latitud y despues longitud
ip1 = '165.132.67.89'
ip2 = '8.8.8.8'
x = controller.req7(datos, ip1, ip2)
controller.loadData(catalog)
elif int(inputs[0]) == 2:
lp1=input('Ingrese el primer landing point: ')
lp2=input('Ingrese el segundo landing point: ')
controller.req1(catalog,lp1,lp2)
elif int(inputs[0]) == 3:
pass
elif int(inputs[0]) == 4 :
p1=input('Ingrese el pais inicial: ')
p2=input('Ingrese el pais final: ')
controller.req3(catalog,p1,p2)
elif int(inputs[0]) == 5 :
controller.req4(catalog)
pass
elif int(inputs[0]) == 6 :
lp=input('Ingrese el nombre del landing point: ')
controller.req5(catalog,lp)
elif int(inputs[0]) == 7 :
np=input('Ingrese el nombre del pais: ')
nc=input('Ingrese el nombre del cable: ')
elif int(inputs[0]) == 8 :
ip1=input('Ingrese el numero de direccion IP 1: ')
ip2=input('Ingrese el numero de direccion IP 2: ')
num_vids = int(input("ingrese el numero de videos que desea listar"))
a = controller.req1(category_name, country, num_vids, cont['videos'],
loadCategories())
print(a)
elif int(inputs[0]) == 4:
country = str(
input("ingrese el nombre del pais por el que desea buscar"))
a = controller.req2(country, cont['videos'])
print(a)
elif int(inputs[0]) == 5:
category_name = str(
input("ingrese el nombre de la categoria que desea buscar")
).translate({ord(c): None
for c in string.whitespace})
a = controller.req3(category_name, cont['videos'], loadCategories())
print(a)
elif int(inputs[0]) == 6:
tag = str(input("ingrese el nombre del tag que desea buscar"))
country = str(
input("ingrese el nombre del pais por el que desea buscar"))
num_vids = int(input("ingrese el numero de videos que desea listar"))
a = controller.req4(tag, country, num_vids, cont['videos'])
print(a)
else:
sys.exit(0)
sys.exit(0)
elif int(inputs[0]) == 3:
t1=time.process_time()
print("Cargando Video con mas trading segun su país ....")
country=input('Ingrese el pais que desea ver: ')
controller.req2(country,catalog)
t2=time.process_time()
print('El tiempo de procesamiento es: {}.'.format(t2-t1))
elif int(inputs[0]) == 4:
t1=time.process_time()
categ = ' '+input("Ingrese la categoria que desea ver:\n")
print("Cargando Video con mas trading segun su categoria ....")
controller.req3(categ,catalog)
t2=time.process_time()
print('El tiempo de procesamiento es: {}.'.format(t2-t1))
elif int(inputs[0]) == 5:
t1=time.process_time()
print("Cargando Video con mas likes segun Tags ....")
country= input("Ingrese el pais del video que desea ver:\n")
tag=input("Ingrese el tag del video que desea ver:\n")
num=input("Ingrese el numero de videos que desea ver:\n")
controller.req4(country,tag,num,catalog)
t2=time.process_time()
print('El tiempo de procesamiento es: {}.'.format(t2-t1))
else:
sys.exit(0)
sys.exit(0)
print('Country:' , retorno[0]["country"])
print('Dias:', retorno[1])
elif int(inputs[0]) == 4:
idCategoria = input("Digite la categoria ")
retorno = controller.estudianteB(catalog, idCategoria)
print('Title:', retorno[0]["title"])
print('Channel_title:' , retorno[0]["channel_title"])
print('Category_id:' , retorno[0]["category_id"])
print('Dias:', retorno[1])
elif int(inputs[0]) == 5:
numeroVideos = input('Digite el numero de videos que quiere listar \n : ')
idCategoria = input("Digite el id de la categoria a mostrar en el top \n : ")
pais = input("digite el pais \n : ")
req4 = controller.req4( pais, idCategoria, catalog)
controller.shellVideos(req4)
muestra = controller.crearSubLista(catalog, int(numeroVideos))
for i in range (1, lt.size(muestra)):
a = lt.getElement(muestra, i)
print("title: ", a["title"])
print("channel_title: ", a["channel_title"])
print("publish_time: ", a["publish_time"])
print("trending_date: ", a["trending_date"])
print("views: ", a["views"])
print("likes: ", a["likes"])
print("dislikes: ", a["dislikes"])
elif int(inputs[0]) == 6:
numeroVideos = input("Digite el numero de videos que quiere listar \n: ")
pais = input("Digite el pais \n: ")
number = result[1]
a = lit.newIterator(result[0])
while lit.hasNext(a):
e = lit.next(a)
print("from " + str(e['vertexA']) + " to " + str(e['vertexB']) +
" in " + str(e['weight']))
print("The total distances is " + str(number))
# if result[0]==True:
# r="si"
#else:
#r="no"
#print("Los landingpoints {0} y {1} {2} son del mismo cluster ".format(l1,l2,r))
#print("EL total de clusters es de" + str(result[1]))
elif int(inputs[0] == 4):
result = controller.req4(analyzer)
elif int(inputs[0]) == 5:
paisA = input("ingrese el nombre del landingpoint completo ")
result = controller.Fallas(analyzer, paisA)
lis = lt.newList()
a = lit.newIterator(result)
while lit.hasNext(a):
e = lit.next(a)
if e != None:
b = lt.isPresent(lis, e)
if b == 0:
lt.addLast(lis, e)
print("El numero de paises afectados es:" + str(lt.size(lis)))
print("Los paises afectados son:")
a = lit.newIterator(lis)
paisB = input("\n")
ruta_cola, distancia = controller.RutaMinima(catalog, paisA, paisB)
print(
'---------------------------------------------------------------------------------------------------'
)
print(' INFO DE LA RUTA MINIMA:')
print('La distancia total de la ruta es: {} km'.format(distancia))
print('La ruta es:')
print('-{}, 0 km'.format(paisA))
while not qu.isEmpty(ruta_cola):
punto, dist = qu.dequeue(ruta_cola)
print('-{}, {} km'.format(punto, dist))
elif int(inputs[0]) == 5:
# -------------------------------------------------- REQ 4 -------------------------------------------------- #
total_dist, num_vert, max_rama = controller.req4(catalog)
print(
'--------------------------------------------------------------------------------------'
)
print('La distancia total del árbol de expansión mínima es: {} km.'.
format(total_dist))
print(
'El numero de vertices que tiene el árbol de expansión mínima es: {}.'
.format(num_vert))
print(
'La mayor longitud posible de una rama es : {}.'.format(max_rama))
elif int(inputs[0]) == 6:
# -------------------------------------------------- REQ 5 -------------------------------------------------- #
print("Indique el nombre del landing point que desea que falle:")
elif int(inputs[0]) == 3:
t1 = time.process_time()
print("Cargando Video con mas trading segun su país ....")
country = input('Ingrese el pais que desea ver: ')
controller.req2(country, cont)
t2 = time.process_time()
print('El tiempo de procesamiento es: {}.'.format(t2 - t1))
elif int(inputs[0]) == 4:
t1 = time.process_time()
categ = ' ' + input("Ingrese la categoria que desea ver:\n")
print("Cargando Video con mas trading segun su categoria ....")
controller.req3(categ, cont)
t2 = time.process_time()
print('El tiempo de procesamiento es: {}.'.format(t2 - t1))
elif int(inputs[0]) == 5:
t1 = time.process_time()
print("Cargando Video con mas likes segun Tags ....")
country = input("Ingrese el pais del video que desea ver:\n")
tag = input("Ingrese el tag del video que desea ver:\n")
num = input("Ingrese el numero de videos que desea ver:\n")
controller.req4(country, tag, num, cont)
t2 = time.process_time()
print('El tiempo de procesamiento es: {}.'.format(t2 - t1))
else:
sys.exit(0)
sys.exit(0)
input('\nPresione enter para continuar.\n')
elif int(inputs[0]) == 4:
print("")
pais1 = input('Ingrese el primer país de interés: ')
pais2 = input('Ingrese el segundo país de interés: ')
x = controller.req3(analyzer, pais1, pais2)
print('')
print("Tiempo [ms]: " + f"{x[0]:.3f}" + " || " + "Memoria [kB]: " +
f"{x[1]:.3f}" + '\n')
print('')
input('\nPresione enter para continuar.')
elif int(inputs[0]) == 5:
print("")
x = controller.req4(analyzer)
print('')
print("Tiempo [ms]: " + f"{x[0]:.3f}" + " || " + "Memoria [kB]: " +
f"{x[1]:.3f}" + '\n')
print('')
input('\nPresione enter para continuar.\n')
elif int(inputs[0]) == 6:
print("")
lp_name = str(
input("Ingrese el landing point donde ocurriria el fallo: ")
).lower()
x = controller.req5(analyzer, lp_name)
print('')
print("Tiempo [ms]: " + f"{x[0]:.3f}" + " || " + "Memoria [kB]: " +
f"{x[1]:.3f}" + '\n')
mp.put(catalog["generos-intervalos"], nombreGenero, (min, max))
generos = input(
"Ingrese los generos que desea consultar (separados por comas sin espacios) -> "
)
listaGeneros = generos.split(",")
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
resultado = controller.req4(catalog, listaGeneros)
print("Total de eventos de escucha cargados: " + str(resultado[0]))
for elemento in lt.iterator(resultado[1]):
print("Genero: " + elemento[0])
tempo = me.getValue(
mp.get(catalog["generos-intervalos"], elemento[0]))
print("Tempo: " + str(tempo[0]) + " - " + str(tempo[1]))
print("Numero de eventos de escucha para este genero: " +
str(elemento[1]))
print("Numero de artistas únicos para este genero: " +
str(elemento[2]))
print("10 primeros artistas para este género: ")
generos_a_correr = lt.newList('ARRAY_LIST')
for genero_preguntar in lt.iterator(mp.keySet(catalog['Generos'])):
print('¿Deseas incluir el genero {}?'.format(genero_preguntar))
incluido = input(
'Presiona: 1 para consultar este genero o 0 para continuar.\n')
if incluido == '1':
lt.addLast(generos_a_correr, genero_preguntar)
#--------------------------------
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
#--------------------------------
respuesta_cruda = controller.req4(catalog, generos_a_correr)
total_reproducciones = respuesta_cruda[1]
info_generos = respuesta_cruda[0]
#--------------------------------
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
#--------------------------------
printR4(info_generos, total_reproducciones)
#--------------------------------
print('Tiempo [ms]: {}'.format(delta_time))
print('Memoria [kB]: {}'.format(delta_memory))
print("------------------------------------------------------------")