def loadData(catalog):
"""
La función LoadData() carga el catalogo de Videos en la
estructura de datos escogida retornando la función
correspondiente del controller
"""
controller.loadData(catalog)
def loadData(catalog):
"""
Args:
catalog: Catálogo de videos.
Carga los videos en la estructura de datos.
"""
controller.loadData(catalog)
def prueba(tamano_lista: int, tipo_lista: int,
tipo_ordenamiento: int) -> float:
tipo_lista = str(tipo_lista)
catalog = controller.initCatalog(tipo_lista)
controller.loadData(catalog)
tamano_datos_cargados = lt.size(catalog['videos']) + 1
result = controller.sort_videos(catalog, tipo_ordenamiento, tamano_lista)
return float(result[0])
def loadData(catalog):
"""
Carga los libros en el catalogo
"""
time = controller.loadData(catalog)
return time
def optionTwo(cont):
# toma de tiempo
start_time = controller.getTime()
tracemalloc.start()
start_memory = controller.getMemory()
controller.loadData(cont, landingFile, connectionsFile, countriesFile)
stop_memory = controller.getMemory()
tracemalloc.stop()
delta_memory = round(controller.deltaMemory(start_memory, stop_memory), 2)
numedges = controller.totalConnections(cont)
numvertex = controller.totalPoints(cont)
numCountries = controller.totalCountries(cont)
firstVertex = controller.firstVertex(cont)
lastCountry = controller.firstCountry(cont)
print("=" * 5 + " DATOS CARGADOS " + "=" * 5)
print('Numero de vertices: ' + str(numvertex))
print('Numero de arcos: ' + str(numedges))
print('Numero de paises:' + str(numCountries))
print('Primer landing point cargado: ' +
str(firstVertex['landing_point_id']))
print('Nombre landing point: ' + firstVertex['name'])
print('Latitud: ' + str(firstVertex['latitude']))
print('Longitud: ' + str(firstVertex['longitude']))
print('Ultimo pais cargado:', lastCountry['CountryName'])
print('Población de ' + lastCountry['CountryName'] + ": " +
lastCountry['Population'])
print('Usuarios de internet de ' + lastCountry['CountryName'] + ": " +
str(lastCountry['Internet users']))
print('El limite de recursion actual: ' + str(sys.getrecursionlimit()))
# toma de tiempo
stop_time = controller.getTime()
delta_time = round(stop_time - start_time, 2)
# toma de tiempo
print(f"Uso de memoria: {delta_memory} kB")
print(f"Tiempo de ejecucion: {delta_time} ms")
print('')
def main():
while True:
printMenu()
inputs = input("Seleccione una opción para continuar\n")
if int(inputs[0]) == 1:
t = controller.loadData()
elif int(inputs[0]) == 2:
y = controller.consulta_integrante_prom_desv(t)
print(y)
for r in y.keys():
print("Para integrante : " + str(r) + " ")
print(" Glucosa inicial, promedio : " +
str(y[r]['Inicial'][0]) + " desviacion: " +
str(y[r]['Inicial'][1]) + "")
print(" Glucosa final, promedio : " + str(y[r]['Final'][0]) +
" desviacion: " + str(y[r]['Final'][1]) + "")
print(
"---------------------------------------------------------------------------------------------------------"
)
elif int(inputs[0]) == 3:
y = controller.consulta_por_genero(t)
print(y)
for r in y.keys():
print("Para integrante: " + str(r) + " ")
print(" Hombres : ")
print("Glucosa promedio inicial : " +
str(y[r]['Hombres']['Inicial'][0]) + " desviacion : " +
str(y[r]['Hombres']['Inicial'][1]) + " ")
print("Glucosa promedio final : " +
str(y[r]['Hombres']['Final'][0]) + " desviacion : " +
str(y[r]['Hombres']['Final'][1]) + " ")
print("Mujeres : ")
print("Glucosa promedio inicial : " +
str(y[r]['Mujeres']['Inicial'][0]) + " desviacion : " +
str(y[r]['Mujeres']['Inicial'][1]) + " ")
print("Glucosa promedio final : " +
str(y[r]['Mujeres']['Final'][0]) + " desviacion : " +
str(y[r]['Mujeres']['Final'][1]) + " ")
print(
"-----------------------------------------------------------------------------------------------------------"
)
elif int(inputs[0]) == 4:
y = controller.consulta_total_generos(t)
print("Total mujeres : " + str(y[1]) + " ")
print("Total hombres : " + str(y[0]) + " ")
else:
sys.exit(0)
sys.exit(0)
def optionTwo(cont):
print("\nCargando información de los archivos ....")
info = controller.loadData(cont, connectionsfile, countriesfile, landingpfile)
numedges = controller.totalConnections(cont)
numvertex = controller.totalVertexs(cont)
numcountries = controller.totalCountries(cont)
lp = info[0]
c = info[1]
print("\nInformación del primer landing point cargado:")
print("Numero de identificación: " + lp['landing_point_id'])
print("Identificador: " + lp['id'])
print("Nombre: " + lp['name'])
print("Latitud: " + str(lp['latitude']))
print("Longitud: " + str(lp['longitude']))
print("\nInformación del ultimo pais cargado:")
print("Pais: " + c['CountryName'])
print("Población: " + c['Population'])
print("Numero de usuarios: " + c['Internet users'])
print('\nNumero de landing points: ' + str(numvertex))
print('Numero de cables: ' + str(numedges))
print('Numero de paises: ' + str(numcountries))
def loadData(catalog):
return controller.loadData(catalog)
def printMenu():
print("Bienvenido")
print("1- Cargar información en el catálogo")
print("2- ")
catalog = None
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
cont = controller.init()
controller.loadData(cont)
elif int(inputs[0]) == 2:
minimo = input('valor minimo: ')
maximo = input('valor maximo: ')
car = input('caracteristica de contenido: ')
total = controller.getMusicByRange(cont, minimo, maximo, car)
print('el numero de eventos en ', car, ' son: ', total)
else:
sys.exit(0)
sys.exit(0)
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n>')
if int(inputs[0]) == 1:
print("\nInicializando....")
# cont es el controlador que se usará de acá en adelante
cont = controller.init()
elif int(inputs[0]) == 2:
print('=' * columns)
print("Cargando información de las pistas ....")
controller.loadData(cont, file)
controller.loadData2(cont, files2)
controller.loadData3(cont, files3)
print('\nTotal de eventos cargados: ' +
str(controller.sizeEvents(cont)))
print('\nInstrumentalness altura: ' +
str(controller.indexHeight(cont['instrumentalness'])))
print('Acousticness altura: ' +
str(controller.indexHeight(cont['acousticness'])))
print('Liveness altura: ' +
str(controller.indexHeight(cont['liveness'])))
print('Speechiness altura: ' +
str(controller.indexHeight(cont['speechiness'])))
print('Energy altura: ' + str(controller.indexHeight(cont['energy'])))
print('Danceability altura: ' +
str(controller.indexHeight(cont['danceability'])))
tracemalloc.stop()
delta_time = round(stop_time - start_time, 2)
delta_memory = round(deltaMemory(start_memory, stop_memory), 2)
print("Tiempo [ms]:", delta_time)
print(
"Memoria [kB]:",
delta_memory,
)
print('-' * 80)
elif int(inputs[0]) == 2:
#------------------------------------------------
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
#***************************************
analyzer = controller.loadData(cont, filename, filename2, filename3)
#**************************************
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = round(stop_time - start_time, 2)
delta_memory = round(deltaMemory(start_memory, stop_memory), 2)
#-------------------------------------------------
print("El numero de landing points es de: " +
str(gr.numVertices(analyzer['connections'])))
print("El total de conexiones entre landing points es de: " +
str((gr.numEdges(analyzer['connections']))))
print("El total de paises es de: " +
str(mp.size(analyzer['countries'])))
interno = me.getValue(mp.get(analyzer['landing'], '3316'))
nombre = me.getValue(mp.get(interno, 'name'))
def loadData(catalog):
"""
Carga los libros en la estructura de datos
"""
controller.loadData(catalog)
controller.loadListGeneros(cont)
controller.loadListTempos(cont)
elif int(inputs[0]) == 2:
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = controller.getTime()
start_memory = controller.getMemory()
model.updateTempoGenero(cont['tempo_genero'])
controller.loadDataSentiment(cont, sentiment_values_file)
controller.loadDataHashTrack(cont, hashtags_file)
controller.loadData(cont, content_file)
controller.loadListGeneros(cont)
controller.loadListTempos(cont)
#controller.loadHashData(cont, content_file_hash)
#controller.loadSentiment(cont, content_file_sentiment)
print('++++ Carga de datos ++++')
print('-----------------------------------------------------------')
print('Total de registros de eventos de escucha cargados: ' + str(controller.content_size(cont)))
print('Total de artistas únicos cargados: '+str(mp.size(cont['artistas'])))
print('Total de pistas de audio únicas cargadas: '+str(mp.size(cont['unique_tracks_init'])))
print('-----------------------------------------------')
videos = controller.videos_carga(cont)
printVideosCarga(videos)
print('-------------------------------------------------------------------')
print('')
stop_memory = controller.getMemory()
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if inputs[0] == 'i':
print("\nInicializando...Por favor, espere en linea.")
# cont es el controlador que se usará de acá en adelante
cont = controller.init()
print("\nAgradecemos su estadia en la linea.")
print("\nInicializado correctamente!")
elif inputs[0] == 'c':
print("\nCargando información de los eventos...")
controller.loadData(cont, crimefile,contextfile)
print('Eventos cargados: ' + str(controller.crimesSize(cont)))
print('Altura del arbol: ' + str(controller.indexHeight(cont)))
print('Elementos en el arbol: ' + str(controller.indexSize(cont)))
print('Menor Llave: ' + str(controller.minKey(cont)))
print('Mayor Llave: ' + str(controller.maxKey(cont)))
print('Cantidad de artistas: ' + str(controller.autoresSize(cont)))
elif int(inputs[0])==1:
caracteristica = input('Digite la característica de contenido: ').lower()
valormin = input('Digite el valor mínimo de la característica: ')
valormax = input('Digite el valor máximo de la característica: ')
print("*******************************************")
delta_time = -1.0
delta_memory = -1.0
def loadData(catalog):
controller.loadData(catalog)
catalog = None
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = initCatalog()
answer = controller.loadData(catalog)
print("Tiempo [ms]: ", f"{answer[0]:.3f}", " || ", "Memoria [kB]: ",
f"{answer[1]:.3f}")
#print('Elementos en el árbol: ' + str(controller.indexSizeInstrumentalness(catalog)))
#print('Altura del árbol: ' + str(controller.indexHeightInstrumentalness(catalog)))
elif int(inputs[0]) == 2:
categoria = input(
'Ingrese la categoría de la que quiere ver información: ')
categoria = categoria.lower()
rango_menor = float(
input('Ingrese el rango menor de valores que quiere ver: '))
rango_mayor = float(
input('Ingrese el rango mayor de valores que quiere ver: '))
canciones = controller.consultaArtistas(catalog, categoria,
rango_menor, rango_mayor)
catalog = None
cont = None
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Inicializando analizador....")
cont = controller.init()
elif int(inputs[0]) == 2:
print("Cargando información de los archivos ....")
answer = controller.loadData(cont, eventsfile)
print('Eventos cargados: ' + str(controller.eventsSize(cont)))
print('Artistas cargados: ' + str(controller.artistsSize(cont)))
print('Altura del árbol: ' + str(controller.indexHeight1(cont)))
print('Menor Llave: ' + str(controller.minKey1(cont)))
print('Mayor Llave: ' + str(controller.maxKey1(cont)))
print('Pistas de audio cargados: ' + str(controller.tracksSize(cont)))
printEvents(cont)
print("Tiempo [ms]: ", f"{answer[1]:.3f}", " || ", "Memoria [kB]: ",
f"{answer[2]:.3f}")
elif int(inputs[0]) == 3:
characteristic = input(
"Ingrese la característica a evaluar (en inglés): ")
' ||Likes: ' + video['likes'] + ' ||Dislikes: ' + video['dislikes'] + \
' ||Tags: ' + video['tags'])
print('\n')
else:
print('No se encontraron videos')
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
cont = controller.initCatalog()
delta_t, delta_m = controller.loadData(cont)
print("Cargando información de los archivos ....")
print('Videos cargados: ' + str(controller.videosSize(cont)))
print('Categorias cargadas: ' + str(controller.categoriesSize(cont)))
print('Tiempo [ms]: ', f'{delta_t:.3f}', ' || ', 'Memoria [kB]: ',
f'{delta_m:.3f}')
elif int(inputs[0]) == 2:
n_videos = input('Top videos por views: ')
category = input('Categoría: ')
country = input('Pais: ')
videosCategoryCountry = controller.getVideosByCategoryAndCountry(
cont, category, country)
topVideosViews = controller.sortVideosViews(
videosCategoryCountry['videos'], int(n_videos))
printTopLikes(topVideosViews, int(n_videos))
catalog = None
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar: ')
if int(inputs[0]) == 1:
print("Inicializando ....")
catalog = controller.init()
elif int(inputs[0]) == 2:
print("\nCargando información de los archivos ....")
resources=controller.loadData(catalog, contextfile,usertrack,sentiment)
artists = controller.artistsSize(catalog)
tracks = controller.tracksSize(catalog)
events = controller.eventsSize(catalog)
print("La cantidad de artistas caragados es: "+str(artists))
print("La cantidad de tracks caragados es: "+str(tracks))
print("La cantidad de eventos caragados es: "+str(events))
print("Tiempo gastado en la carga de datos : ", resources[0]," ms" )
print("Memoria usada en la carga de datos : ",resources[1]," kb")
elif int(inputs[0]) == 3:
#REQ 1
characteristic = (input("Bajo que caracteristica desea buscar: ")).lower()
loValue = float(input("Digite el valor minimo de la caracteristica del contenido: "))
hiValue = float(input("Digite el valor maximo de la caracteristica del contenido: "))
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("\nInicializando....")
# catalog es el controlador que se usará de acá en adelante
catalog = controller.initCatalog()
elif int(inputs[0]) == 2:
print("\nCargando información de eventos ....")
controller.loadData(catalog)
print('\n-Eventos cargados: ' + str(controller.sizeList(catalog, "eventos")))
print('\n-Canciones únicas: ' + str(controller.sizeMap(catalog, "track_id")))
printResults(catalog["eventos"])
print('\n-Artistas únicos: ' + str(controller.sizeMap(catalog, "artist_id")))
elif int(inputs[0]) == 3:
caracteristica = input("Ingrese la característica: ")
menor = float(input("Ingrese el rango menor: "))
mayor = float(input("Ingrese el rango mayor: "))
#
caracteristica, menor, mayor = 'instrumentalness', 0.75, 1.0
#
respuesta = controller.requerimiento1(catalog, menor, mayor, caracteristica)
def loadData(catalog):
"""
Carga los libros en el catalogo
"""
controller.loadData(catalog)
def loadData(catalog):
"""
Carga los datos en la estructura de datos
"""
return controller.loadData(catalog)
catalog = None
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Inicializando ....")
catalog = controller.init()
elif int(inputs[0]) == 2:
print("Cargando información de los archivos ....")
controller.loadData(catalog, musicfile)
print("Total de registros de eventos cargados: " +
str(controller.eventsSize(catalog)))
print("Total de artistas unicos cargados: " +
str(controller.artistsSize(catalog)))
print("Total de pistas de audio unicas cargadas: " +
str(controller.tracksSize(catalog)))
elif int(inputs[0]) == 3:
#REQ 1
characteristic = input("Bajo que caracteristica desea buscar: ")
loValue = float(
input(
"Digite el valor minimo de la caracteristica del contenido: "))
hiValue = float(
input(
def loadData(catalog):
controller.loadData(catalog)
print('TOP', n, 'track:', key, 'vader:', actualvalue[0], 'hashtags',
actualvalue[1])
n += 1
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
analyzer = controller.init()
print("Cargando información de los archivos...")
answer = controller.loadData(analyzer, events_analysis_file,
hashtag_file, sentiment_values)
print('Registro de eventos Cargados: ' +
str(controller.eventsSize(analyzer)))
print('Artistas únicos Cargados: ' +
str(controller.artistsSize(analyzer)))
print('Pistas únicas Cargados: ' +
str(controller.tracksSize(analyzer)))
print('\n')
print('Primeros y últimos 5 cargados, respectivamente: ')
printfirstandlast5(analyzer)
print('\n')
print("Tiempo [ms]: ", f"{answer[0]:.3f}", " || ", "Memoria [kB]: ",
f"{answer[1]:.3f}")
print('instrumentalness: ', om.height(analyzer['instrumentalness']))
print('acousticness: ', om.height(analyzer['acousticness']))
print('liveness: ', om.height(analyzer['liveness']))
def loadData(catalog):
#carga los videos en la estructura de datos
controller.loadData(catalog)
# ===================================
# Menu principal
# ===================================
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Inicializando Catálogo ....")
cont = controller.initCatalog()
elif int(inputs[0]) == 2:
# TODO: modificaciones para observar el tiempo y memoria
print("Cargando información de los archivos ....")
answer = controller.loadData(cont)
print('Libros cargados: ' + str(controller.booksSize(cont)))
print('Autores cargados: ' + str(controller.authorsSize(cont)))
print('Géneros cargados: ' + str(controller.tagsSize(cont)))
print("Tiempo [ms]: ", f"{answer[0]:.3f}", " || ", "Memoria [kB]: ",
f"{answer[1]:.3f}")
elif int(inputs[0]) == 3:
# TODO: modificaciones para observar el tiempo y memoria
number = input("Buscando libros del año?: ")
answer = controller.getBooksYear(cont, int(number))
printBooksbyYear(answer[0])
print("Tiempo [ms]: ", f"{answer[1]:.3f}", " || ", "Memoria [kB]: ",
f"{answer[2]:.3f}")
elif int(inputs[0]) == 4:
def loadData(catalog, TypeList):
controller.loadData(catalog, TypeList)
distancia = dic['distancia']
print(pais + " se encontraría afectado y tiene un Landing Point a " + str(distancia) + " kilómetros.")
i += 1
catalog = None
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
analyzer = controller.initialize()
controller.loadData(analyzer)
vertices= gr.numVertices(analyzer['connections'])
aristas= gr.numEdges(analyzer['connections'])
print("El numero de vertices cargados es: " + str(vertices))
print("El numero de arcos en el grafo es: " + str(aristas))
elif int(inputs[0]) == 2:
landing_point1 = input('Ingrese el landing point A: ')
landing_point2 = input('Ingrese el landing point B: ')
componentes = controller.componentesConectados(analyzer)
estan = controller.estanLosDosLandingPoints(analyzer, landing_point1, landing_point2)
print('*' * 25)
print('El número de clústers es: ' + str(componentes))
print_Req1(landing_point1, landing_point2, estan)
delta_memory = delta_memory + stat.size_diff
# de Byte -> kByte
delta_memory = delta_memory / 1024.0
return delta_memory
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = controller.init()
rtas = controller.loadData(catalog)
primerVertice = rtas[0]
ultimoPais = rtas[1]
numCountries = controller.totalLandingPoints(catalog)
numLanding = controller.numeroPoints(catalog)
numConexiones = controller.totalConexiones(catalog)
# numConexiones = controller.totalConexiones(catalog)
print('Total de landing points: ' + str(numLanding))
print('Total de conexiones: ' + str(numConexiones))
print('Total de Paises: ' + str(numCountries))
print('Primer landing points cargados: ' +
primerVertice['landing_point_id'] + ' || ' +
primerVertice['name'] + ' || ' + primerVertice['latitude'] +
' || ' + primerVertice['longitude'])
def loadData (catalog):
"""
Carga las peliculas en la estructura de datos
"""
controller.loadData(catalog)
