"""
Inicializa el catalogo de libros
"""
return controller.initCatalog(input_type_list)
def loadData(catalog):
"""
Carga los libros en la estructura de datos
"""
controller.loadData(catalog)
# Load data
catalog = initCatalog(args.type_list)
loadData(catalog)
print('Videos cargados: ' + str(lt.size(catalog['videos'])) + ' || ' +
str(args.type_list))
# Sort videos
sort_types = ['selection', 'insertion', 'shell', 'merge', 'quick']
sample_size = [1000, 2000, 4000, 8000, 16000, 32000]
for sort_ in sort_types:
for sample_size_ in sample_size:
sortedVideos = controller.sortVideos(catalog, sample_size_, sort_)
print('Ordenando con: ' + sort_)
print('Para el top ' + str(sample_size_) +
' elementos (videos), el tiempo (mseg) es: ' +
str(sortedVideos[0]))
elif int(inputs[0]) == 2:
#req 1
size=0
category_name = input("Indique la categoría de los videos a consultar: ")
country = input("Indique el país de los videos a consultar: ")
id=controller.getIDbyCategoryName(cont, category_name)
videosByCat=controller.getVideosByCategory(cont, id)
filteredList=controller.filterVideos(videosByCat, ['country'],[country])
while size<1 or size>lt.size(filteredList['videos']):
size = int(input("Indique el número de videos a listar: "))
print("Ordenando datos...\n")
result = controller.sortVideos(filteredList, size, 'views')
print('Videos top {} para {} bajo la categoría {}:\n'.format(size,country,category_name))
print("trending_date | title | channel_title | publish_time | views | likes | dislikes")
for i in lt.iterator(result):
print(i['trending_date'],'|',i['title'],'|',i['channel_title'],'|',
i['publish_time'],'|',i['views'],'|',i['likes'],'|',i['dislikes'])
elif int(inputs[0]) == 3:
#Req 2
size=1
country = input("Indique el país de los videos a consultar: ")
videosByCountry=controller.getVideosByCountry(cont, country)
catalog = initCatalog(tipo)
loadData(catalog)
print('Videos cargados: ' + str(lt.size(catalog['videos'])))
elif int(inputs) == 2:
printOptions2()
inputs2 = int(
input('Seleccione un tipo para el algorítmo de ordenamiento\n'))
if inputs2 == 1:
algorithm = 'Insertion sort'
if inputs2 == 2:
algorithm = 'Selection sort'
if inputs2 == 3:
algorithm = 'Shell sort'
size = int(input('Seleccione un tamaño de la sublista\n'))
print(len(catalog['videos']['elements']))
if size <= len(catalog['videos']['elements']):
tiempo_carga = controller.sortVideos(catalog, size, algorithm)
print('El tiempo de carga del algoritmo ' + str(algorithm) +
' con ' + str(size) + ' datos es igual a: ' +
str(tiempo_carga))
elif size > len(catalog['videos']['elements']):
print(
'El tamaño de la sublista que escogio es mayor que el total de los datos.'
)
else:
sys.exit(0)
sys.exit(0)
elif int(inputs[0]) == 2:
t1 = time.process_time()
print("Tipos de ordenamientos")
print("1-Selection Sort")
print("2-Insertion Sort")
print("3-Shell Sort")
print("4-Quick sort")
print("5-Merge sort")
tipo = int(
input(
"Seleccione el metodo de ordenamiento que desea ejecutar para el catalogo: "
))
size = int(
input("Ingrese el tamaño de la muestra que desea ordenar: "))
controller.sortVideos(catalog, size, tipo)
print("Se ordenó el catalogo de acuerdo a la especificación")
t2 = time.process_time()
print("El tiempo de ejecución fue de " + str((t2 - t1) * 1000) +
" milisegundos")
elif int(inputs[0]) == 3:
t1 = time.process_time()
pais = input("Ingrese el pais que desea consultar: ")
categoria = input("Ingrese la categoria que desea consultar: ")
numero = int(
input("Ingrese el numero de videos que desea visualizar:"))
print("El video con mas dias como tendendia en " + pais +
" para la categoria " + categoria + " es:")
print(
controller.videos_categoria_pais(catalog, categoria, pais, numero))
def sortVideos(catalog):
return controller.sortVideos(catalog)
catalog = initCatalog(new_type)
loadData(catalog)
print('Videos cargados: ' + str(lt.size(catalog['title'])))
else:
print(
"No hizo una selección válida, por favor intente nuevamente a continuacion:\n"
)
elif int(inputs) == 2:
size = int(input("Indique el tamaño de la muestra: "))
pregunta2()
iterable_ord = int(input())
new_order = 0
if iterable_ord == 1:
new_order = "quicksort"
result = controller.sortVideos(catalog, size, new_order)
printResults(result[1], size)
print("Para la muestra de", size,
" elementos, el tiempo (mseg) es: ", str(result[0]))
elif iterable_ord == 2:
new_order = "mergesort"
result = controller.sortVideos(catalog, size, new_order)
printResults(result[1], size)
print("Para la muestra de", size,
" elementos, el tiempo (mseg) es: ", str(result[0]))
elif iterable_ord == 3:
new_order = "selectionsort"
result = controller.sortVideos(catalog, size, new_order)
printResults(result[1], size)
print("Para la muestra de", size,
" elementos, el tiempo (mseg) es: ", str(result[0]))
str(resultado[0]))
print("\n")
printResults(resultado[1], int(n))
else:
print("\n")
print("No se encontró la Categoría")
else:
print("\n")
print("No se encontró el país")
elif str(inputs[0]) == "3":
pais = input("Ingrese el país de referencia: ")
print("\nCargando ....")
lista = controller.getVideosByCountry(catalog['country'], pais)
result = controller.sortVideos(
lista, lt.size(lista), 'ms', 'comparetitles')[1]
dias_tendencia = controller.getMostTrendingDays(result)
print("\n")
printResultsv3(dias_tendencia)
elif str(inputs[0]) == "4":
categoria = int(input('Ingrese la categoría de referencia: '))
print("\nCargando ....")
result1 = controller.getVideosByCategory(
catalog['video'], categoria)
result = controller.sortVideos(
result1, lt.size(result1), 'ms', 'comparetitles')[1]
video_tendencia = controller.getMostTrendingDays(result)
print("\n")
printResultsv3(video_tendencia)
loadData(catalog)
print('Videos cargados: ' + str(lt.size(catalog['videos'])))
print('Categorias cargadas: ' + str(lt.size(catalog['categorias'])))
elif int(inputs[0]) == 2:
size = int(input("Tamaño límite de videos a ordenar:"))
sample = int(input("Tamaño de la muestra a imprimir: "))
country = input("Escoja el pais: ")
category = input("Escriba la categoria: ")
tipo = input(
" Seleccione el tipo de algoritmo de ordenamiento" +
"iterativo escribiendo textualmente alguna de estas opciones:" +
"Insertion, Selection, Shell, Merge, Quick: ")
sorted_list = controller.sameCountryCategory(catalog, country,
category)
try:
printResultsReq_1(controller.sortVideos(sorted_list, size, tipo),
sample)
except TypeError:
print(
"No hay suficientes videos de este tipo y categoria, intente ordenar una cantidad menor."
)
elif int(inputs[0]) == 3:
country = input("Escriba el país a buscar:")
rta = controller.llamar_Trending(catalog, country)
iterador = it.newIterator(rta)
element = it.next(iterador)
print(("Title: {} , Channel_title:{} , Country: {} , Numero dias: {}"
).format(element['title'], element['channel_title'],
element['country'], element['trending_date']))
elif int(inputs[0]) == 4:
# FIN
countryCatalog = controller.getVideosByCountry(
catalog, countryName) # Nuevo catálogo filtrado del país elegido
printCountryData(countryCatalog)
# Inputs secundarios del usuario
categoryCatalog = controller.getVideosByCategory(
countryCatalog, categoryName, catalog) # Mirar parámetros
printCategoryData(
categoryCatalog
) # Se imprime la información filtrada por categoría y país
result = controller.sortVideos(categoryCatalog,
1) # Ordenamiento por views
printResults(result, sample=cantidad_videos)
# INICIO
# toma de tiempo y memoria al final del proceso
stop_memory = getMemory()
stop_time = getTime()
# finaliza el procesos para medir memoria
tracemalloc.stop()
# calculando la diferencia de tiempo y memoria
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
def sortVideos(catalog, size, cmpFunction):
"""
Organiza los videos mediante Merge Sort
"""
return controller.sortVideos(catalog, size, cmpFunction)
print('Videos cargados: ' + str(lt.size(catalog['videos'])))
print('Categorías cargadas: ' + str(lt.size(catalog['categories'])))
elif int(inputs[0]) == 2: # Print Requerimiento 1
pais = input(
"Ingrese el pais para el cual desea realizar la búsqueda: ")
pais = pais.lower()
categoria = input("Ingrese la categoria que desea conocer: ")
categoria = categoria.lower()
categoria = " " + categoria
tamano = int(input("Ingrese la cantidad de videos que desea ver: "))
filtrado_pais = controller.filtrado_pais(catalog, pais)
num_categoria = controller.idCat(catalog, categoria)
filtrado_categoria = controller.filtrado_categoria(
filtrado_pais, num_categoria)
result = controller.sortVideos(filtrado_categoria)
print_resultsReq1(result[1], tamano)
controller.limpieza(filtrado_categoria)
controller.limpieza(filtrado_pais)
controller.limpieza(result)
elif int(inputs[0]) == 3: # Print Requerimiento 2
pais = input(
'Ingrese el pais para el cual desea realizar la búsqueda: ')
pais = pais.lower()
filtrado_pais = controller.filtrado_pais(catalog, pais)
result = controller.sortVideosReq2(filtrado_pais)
video_tendencia = controller.trending_2(result[1])
print_resultsReq2(video_tendencia)
controller.limpieza(video_tendencia)
if int(inputs) == 1:
print("\nCargando información de los archivos ....")
videos = initCatalogVideos()
catalogList = loadDataVideos(videos)
print('\tVideos cargados: ' + str(lt.size(catalogList)))
printVideos(catalogList)
categories = initCatalogCategories()
categoryList = loadDataCategories(categories)
printCategories(categoryList)
elif int(inputs) == 2:
category_name = (input("Indique el nombre de la categoria: ")).title()
country = input("Indique el país a consultar: ")
size = int(input("Indique el tamaño de la lista de videos: "))
result = controller.sortVideos(categoryList, catalogList,
category_name, country, size)
printResultsReq1(result['elements'], size)
elif int(inputs) == 3:
country = input("Indique el nombre del país: ")
controller.loadDays(catalogList)
result = controller.sortVideosCountry(catalogList, country)
printResultsReq2(result['elements'], country)
elif int(inputs) == 4:
category_name = (input("Indique el nombre de la categoria: ")).title()
controller.loadDays(catalogList)
result = controller.sortVideosCategory(categoryList, catalogList,
print("Cargando información de los archivos ...")
print('Videos cargados: ' + str(lt.size(catalog['videos'])))
print('Etiquetas cargadas: ' + str(lt.size(catalog['tagvideos'])))
print('Categorías cargadas: ' + str(lt.size(catalog['categories'])))
if selection == 2:
catalog = initCatalog_Array()
Load_Data(catalog)
print("Cargando información de los archivos ....")
print('Videos cargados: ' + str(lt.size(catalog['videos'])))
print('Etiquetas cargadas: ' + str(lt.size(catalog['tagvideos'])))
print('Categorías cargadas: ' + str(lt.size(catalog['categories'])))
print(catalog['categories'])
elif int(inputs[0]) == 2:
size = int(input("¿Cuántos vídeos desea enlistar?\n"))
# country = str(input("Digite el nombre del país: \n"))
# category_videos = str(input("Digite la categoría: \n"))
if size > lt.size(catalog['videos']):
print('La cantidad de videos a enlistar es mayor a la cantidad de videos disponibles.')
else:
print("1 - Selection Sort \n2 - Insertion Sort \n3 - Shell Sort \n4 - Merge Sort \n5 - Quick Sort \n")
sortType = input("Seleccione el tipo de algoritmo de ordenamiento que desea usar: ")
result = controller.sortVideos(catalog, int(size), sortType)
print("Usando una muestra de ", size, " elementos, el tiempo que tomó ordenar el catálogo (en milisegundos) es ", str(result[0]))
else:
sys.exit(0)
sys.exit(0)
def sortVideos(catalog,list_num,list_alg):
return controller.sortVideos(catalog,list_num,list_alg)
country=controller.GetVideosbyCountry(catalogo, pais)
if lt.size(country)==0 :
print("No se ha encontrado videos del país que ha escrito")
separador()
else:
categoria = int(input("Escriba el numero de la categoría a consultar: "))
categoria=str(categoria)
categ= controller.GetVideosbycategoria(country, categoria)
if lt.size(categ)==0:
separador()
print("No se ha encontrado videos de "+pais+" en al categoría "+ categoria)
separador()
else:
print("sea ha encontrado un total de "+str(lt.size(categ))+" videos, por fabor escriba un numero dentro de ese rango ")
size = int(input("Escriba el Numero de videos que desea consultar: "))
video_ordenados_por_vistas=controller.sortVideos(categ, size)
print(lt.size(video_ordenados_por_vistas))
print(separador())
print("-"+"País: "+pais)
imprime_toda_lista_econtrada_req1(video_ordenados_por_vistas)
elif int(inputs[0]) == 3:
pais = str(input("Nombre del pais a consultar: "))
print(separador())
video_pais = controller.GetVideosbyCountry(catalog["Video"], pais)
if lt.size(video_pais)==0:
print(separador())
print("No se ha encontrado videos en el pais " + pais)
print(separador())
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
input_type_list = 'ARRAY_LIST'
print("Cargando información de los archivos ....")
catalog = initCatalog(input_type_list)
loadData(catalog)
print('Videos cargados: ' + str(lt.size(catalog['videos'])))
elif int(inputs[0]) == 2:
number = input("Buscando los TOP ?: ")
input_sort_type = 'merge'
sortedVideos = controller.sortVideos(catalog, int(number),
str(input_sort_type))
printTop(sortedVideos[1], int(number))
elif int(inputs[0]) == 3:
number = input("Buscando los TOP ?: ")
category = input('Categoria: ')
country = input('País: ')
input_sort_type = 'merge'
categoryVideos = controller.getVideosByCategory(catalog, category)
countryVideos = controller.getVideosByCountry(categoryVideos, country)
sortedVideos = controller.sortVideos(countryVideos, int(number),
str(input_sort_type))
printCategoryCountry(sortedVideos[1], number, category, country)
elif int(inputs[0]) == 4:
country = input('País: ')
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
data = input("Seleccione el tipo de estructura de datos desea " +
"usar (ARRAY_LIST) o (SINGLE_LINKED): ")
print("Cargando información de los archivos ....")
catalog = initCatalog(data)
loadData(catalog)
print('Videos cargados: ' + str(lt.size(catalog['video'])))
print('Categorias cargadas: ' + str(lt.size(catalog['category'])))
elif int(inputs[0]) == 2:
number = input("Cantidad de datos a listar: ")
orden = input("seleccionar el tipo de algoritmo de ordenamiento " +
"iterativo (selection, insertion, shell," +
" quick, merge): ")
pais = input("Seleccione un pais: ")
categoria = input("Seleccione una categoria: ")
top = input('Top?: ')
catOrd = controller.sortVideos(catalog, int(number), orden)[1]
cat = categoriaID(catalog, categoria)
sublist = controller.sublistReq1(catOrd, cat, pais)
print(printVideos1(sublist, int(top)))
else:
sys.exit(0)
sys.exit(0)
print('Videos cargados: ' + str(lt.size(catalog['videos'])))
print('Categorias cargadas: ' + str(lt.size(catalog['categories'])))
print("Tiempo [ms]: ", f"{answer[0]:.3f}", " || ", "Memoria [kB]: ",
f"{answer[1]:.3f}")
elif int(inputs[0]) == 2:
size = int(input("Indique el número de videos que quiere listar: "))
pais = input(
"Ingrese el país para el cual desea realizar la consulta: ")
categoria = input("Ingrese la categoría que quiere consultar: ")
if size > lt.size(catalog['videos']):
print(
"el tamaño de muestra solicitado excede la cantidad de datos de videos cargados"
)
else:
result = controller.sortVideos(catalog, size, pais,
categoria.lower())
printResults(result[0])
print("Tiempo [ms]: ", f"{result[1]:.3f}", " || ", "Memoria [kB]: ",
f"{result[2]:.3f}")
elif int(inputs[0]) == 3:
country = input(
"Ingrese el país para el cual desea realizar la consulta: ")
result = controller.getTrendingVideoByCountry(catalog, country)
video = result[0]
count = result[1]
print('Title: ' + video['title'] + ' Channel_title: ' +
video['channel_title'] + ' Country: ' + video['country'] +
' Días: ' + str(count))
print("2- LinkedList")
lista = input("Seleccione el tipo de Lista\n")
resultado = printDatosCargados(int(lista))
print(resultado)
elif int(inputs[0]) == 2:
print("1- Selection sort")
print("2- Insertion sort")
print("3- Shell sort")
print("4- Merge sort")
print("5- Quick sort")
lista = input("Ingrese el tipo de ordenamiento que desee: ")
ordenamiento = printTipoOrd(int(lista))
size = input("Indique tamaño de la muestra: ")
result = controller.sortVideos(catalog, int(size), ordenamiento)
print("Para la muestra de", size, " elementos, el tiempo (mseg) es: ",
str(result[0]))
elif int(inputs[0]) == 3:
country = input("Ingrese el país a consultar: ")
category_name = input("Ingrese la categoría a consultar: ")
n = input("Ingrese el número de videos que quiere listar: ")
video = controller.getTrendingVideos(catalog, category_name, country,
n)
printTrendingVideos(video)
elif int(inputs[0]) == 4:
countryname = input("Nombre del país: ")
country = controller.getVideosByCountry(catalog, countryname)
if country == None:
else:
pass
catalog = initCatalog(Tipo)
loadData(catalog)
print('Videos cargados: ' + str(lt.size(catalog['videos'])))
videos = (catalog['videos'])
print1stelement(videos, int(input2))
categoryID = catalog['category-id']
printcategoriesList(categoryID)
elif int(inputs[0]) == 2:
pais = input("Ingrese el pais por el que quiere filtrar \n")
categoria = input("Ingrese la categoria por la que quiere filtrar \n")
lista_filtrada = controller.filtrarvideos(catalog, pais, categoria)
lista_filtrada_ordenada = controller.sortVideos(lista_filtrada)
n = int(input('Numero de videos que quiere listar: '))
for i in range(0, n):
print('* * *')
print1stelement(lista_filtrada_ordenada, tipo=1)
lt.removeFirst(lista_filtrada_ordenada)
elif int(inputs[0]) == 3:
pass
elif int(inputs[0]) == 4:
pass
elif int(inputs[0]) == 5:
pass
else:
sys.exit(0)
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = initCatalog()
datos = loadData(catalog)
print('Videos cargados: ' + str(lt.size(catalog['videos'])))
print('Categorias cargadas: ' + str(lt.size(catalog['categorias'])))
print('Estos son los datos del primer video cargado. ' + str(catalog["videos"]["elements"][0]))
print("Tiempo [ms]: ", f"{datos[1]:.3f}", " || ",
"Memoria [kB]: ", f"{datos[0]:.3f}")
elif int(inputs[0]) == 2:
categ = input("Escriba una categoría: ")
pais = input("Escriba un país: ")
size = input("Indique el numero de videos que quiere consultar: ")
print("Sorteando videos ....")
result = controller.sortVideos(catalog, int(size), pais, categ)
if not (result is None):
print("Para la muestra de ", size, " elementos, el tiempo (mseg) es: ",
str(result[0][0]))
printResults(result[0][1], int(size))
print("Tiempo [ms]: ", f"{result[2]:.3f}", " || ",
"Memoria [kB]: ", f"{result[1]:.3f}")
elif int(inputs[0]) == 3:
pais = input("Escriba un país: ")
print("Cargando información del video ....")
resultado = controller.topdiastrendingporpais(catalog, pais)
printResultPais(resultado[0][0], resultado[0][1])
print("Tiempo [ms]: ", f"{resultado[2]:.3f}", " || ",
"Memoria [kB]: ", f"{resultado[1]:.3f}")
elif int(inputs[0]) == 4:
categ = input("Escriba una categoría: ")
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = initCatalog("ARRAY_LIST")
answer = loadData(catalog)
print('Videos cargados: ' + str(lt.size(catalog['videos'])))
print('Categorias cargadas: ' + str(lt.size(catalog['categorias'])))
print('Paises cargados: ' + str(lt.size(catalog['paises'])))
print("Tiempo [ms]: ", f"{answer[0]:.3f}", " || ", "Memoria [kB]: ",
f"{answer[1]:.3f}")
elif int(inputs[0]) == 2:
numeroT = int(input("¿Que tan grande quiere que sea el top? "))
pais = input("Indique el pais que desea analizar: ").lower()
categoria = input("Indique la categoria que desea analizar: ").lower()
print("Cargando videos con más views ....")
answer = controller.sortVideos(catalog, pais, categoria)
printResults(answer[2], numeroT)
print("Tiempo [ms]: ", f"{answer[0]:.3f}", " || ", "Memoria [kB]: ",
f"{answer[1]:.3f}")
elif int(inputs[0]) == 3:
print("Cargando videos con mayor tiempo en trending en un pais ....")
pais = input("Indique el pais que desea analizar: ")
answer = controller.trending_paises(catalog, pais)
print_categoria_pais(answer[2])
print("Tiempo [ms]: ", f"{answer[0]:.3f}", " || ", "Memoria [kB]: ",
f"{answer[1]:.3f}")
elif int(inputs[0]) == 4:
categoria = input("Indique la categoria que desea analizar: ").lower()
print("Cargando video con más dias en trending en una categoria ....")
answer = controller.trending_categoria(catalog, categoria)
