def test_exchange_array(altbooks, books):
book1 = lt.getElement(altbooks, 1)
book5 = lt.getElement(altbooks, 5)
lt.exchange(altbooks, 1, 5)
assert lt.getElement(altbooks, 1) == book5
assert lt.getElement(altbooks, 5) == book1
def point_coords_radians(self, vertex):
landing_point = mp.get(self.points_by_id, vertex)['value']
latitude, longitude = lt.getElement(landing_point, 4), lt.getElement(
landing_point, 5)
return latitude * pi / 180, longitude * pi / 180
def print_categoria_pais(result):
video = lt.getElement(result, 1)
print('Titulo: ' + video['name'] + " Canal: " + video["channel"] +
" Días Trending: " + str(video["trending"]) + " Pais: " +
video["pais"])
return
def Requerimiento5maps(analyzer, minHora, maxHora):
valores = om.keys(analyzer['context_created'], minHora, maxHora)
generos = om.keySet(analyzer['genres'])
respuesta = om.newMap()
for i in range(lt.size(valores)):
key_value = lt.getElement(valores, i)
info_context_pareja = om.get(analyzer['context_created'], key_value)
context = me.getValue(info_context_pareja)
for i in range(lt.size(context)):
info_context = lt.getElement(context, i)
for i in range(lt.size(generos)):
key_genero = lt.getElement(generos, i)
info_genero_pareja = om.get(analyzer['genres'], key_genero)
info_genero = me.getValue(info_genero_pareja)
minTemp = float(info_genero[0])
maxTemp = float(info_genero[1])
if float(info_context['tempo']) >= minTemp and float(
info_context['tempo']) <= maxTemp:
contains = om.contains(respuesta, key_genero)
if not contains:
track_id = info_context['track_id']
#extraccion info relevante
llave_valor_info_adicional = om.get(
analyzer['user_track'], track_id)
info_adicional = me.getValue(llave_valor_info_adicional)
vader = lt.getElement(info_adicional, 1)
hashtags = lt.size(info_adicional) - 1
lista_genero = lt.newList()
track = {}
track['track_id'] = track_id
track['vader'] = vader
track['num_hashtags'] = hashtags
lt.addLast(lista_genero, track)
om.put(respuesta, key_genero, lista_genero)
if contains:
track_id = info_context['track_id']
llave_valor_info_adicional = om.get(
analyzer['user_track'], track_id)
info_adicional = me.getValue(llave_valor_info_adicional)
vader = lt.getElement(info_adicional, 1)
hashtags = lt.size(info_adicional) - 1
pareja_lista_genero = om.get(respuesta, key_genero)
lista_genero = me.getValue(pareja_lista_genero)
track = {}
track['track_id'] = track_id
track['vader'] = vader
track['num_hashtags'] = hashtags
lt.addLast(lista_genero, track)
return respuesta
def name_to_id(self, vertex):
landing_point = mp.get(self.points_by_name, vertex)
if landing_point:
return lt.getElement(landing_point['value'], 1)
else:
return None
def secondreq(answer):
print("La cantidad de pistas únicas es " + str(lt.getElement(answer, 1)))
for elemento in lt.iterator(lt.getElement(answer, 2)):
print(elemento)
print("")
print("")
catalog = None
"""
Menu principal
"""
while True:
print_menu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = init_catalog()
load_data(catalog)
print('Se cargaron: ',lt.size(catalog['videos']), ' videos')
print('El primer video cargado es: ' )
video=lt.getElement(catalog['videos'],1)
print('Titulo: ' + video['title'] + ' , Canal: '+video['channel_title']+' , Fecha de tendencia '+str(video['trending_date']))
print('País: '+video['country'] +' , Vistas: '+str(video['views'])+' , Likes: '+str(video['likes'])
+' , Dislikes: '+str(video['dislikes']))
print('Las categorías cargadas son: ')
print_categories(catalog['category_names'])
elif int(inputs[0]) == 2:
country_name=input('Ingrese el nombre del país: ').lower()
category_name=' '+input('Ingrese el nombre de la categoría: ')
number=int(input('Buscando los TOP ?: '))
print_results_req1(controller.get_most_view_videos(catalog,country_name,category_name),number)
elif int(inputs[0]) == 3:
country_name=input('Ingrese el nombre del país: ').lower()
video = controller.get_most_time_trending_country(catalog,country_name)
print('El titulo del video es '+ video['title']+', el numero de dias en tendencia es '+str(video['counter'])+', el nombre del canal es '+video['channel_title']+' y el pais es '+country_name)
elif int(inputs[0]) == 4:
def req5(cont, miniH, miniM, miniS, maxH, maxM, maxS, sentiment, user, cat2):
sentimen = cf.data_dir + sentiment
input_file3 = csv.DictReader(open(sentimen, encoding="utf-8"),
delimiter=",")
user = cf.data_dir + user #
input_file2 = csv.DictReader(open(user, encoding="utf-8"), delimiter=",")
lst = lt.newList()
for hashtag in input_file2:
lt.addLast(lst, hashtag)
new = it.newIterator(lst) # Ponerlo en controller
sss = lt.newList() #
for senti in input_file3:
lt.addLast(sss, senti)
itet = it.newIterator(
sss
) # Ponerlo en otro controllorer junto con el sentimen y el input_file3 csv.DictReader()
filtrada1 = total(cont, miniH, miniM, miniS, maxH, maxM, maxS)
newsaw = it.newIterator(filtrada1)
while it.hasNext(newsaw):
l = it.next(newsaw)
#cantidad2+=lt.size(l)
#print(cantidad2) #Reproducciones
nuevo = it.newIterator(l)
while it.hasNext(nuevo):
pedazo = it.next(
nuevo) #Mira cada track cumplido con el primer filtro
#ax=mp.get(pedazo,'hashtag')
ex = mp.get(pedazo, 'tempo')
ix = mp.get(pedazo, 'horas')
ox = mp.get(pedazo, 'track_id')
ux = mp.get(pedazo, 'user_id')
ax = mp.get(pedazo, 'artist_id')
#tax=me.getValue(ax)
tex = me.getValue(ex)
tix = me.getValue(ix)
tox = me.getValue(ox)
tux = me.getValue(ux)
tax = me.getValue(ax)
cantidad = 0
vader_avg = 0
while it.hasNext(new):
hashtag = it.next(
new
) #Buscar el hashtag aqui y su valor vader tambien #Mira cada hashtag
if hashtag['track_id'] == tox:
hasht = hashtag['hashtag'].lower(
) #Se busca los que sean iguales al track_id (todos los hashtag del track_id respectivo)
while it.hasNext(itet):
senti = it.next(
itet
) #Se busca basicamente que tenga un valor_vader
if senti['hashtag'].lower() == hasht:
if senti['vader_avg'] != '' and senti[
'vader_avg'] != None:
vader_avg += float(senti['vader_avg'])
cantidad += 1
break
itet = it.newIterator(sss)
new = it.newIterator(lst)
nuevodic = {}
nuevodic['tempo'] = int(tex)
nuevodic['horas'] = tix
nuevodic['track_id'] = tox
nuevodic['artist_id'] = tax
nuevodic['cantidad'] = cantidad
nuevodic['user_id'] = tux
if nuevodic['cantidad'] != 0:
vader_avg = vader_avg / cantidad
nuevodic['vader_avg'] = vader_avg
model.addTrack(cat2, nuevodic)
generos = lt.newList()
lista = [
'POP', 'REGGAE', 'DOWN-TEMPO', 'CHILL-OUT', 'HIP-HOP', 'JAZZ AND FUNK',
'R&B', 'ROCK', 'METAL'
]
#return generos
for gen in lista:
lt.addLast(generos, gen)
fua = it.newIterator(generos)
top = 0
nombretop = ""
listatop = None
cantidadT = 0
resp1 = lt.newList()
while it.hasNext(fua):
genero = it.next(fua)
if genero == "POP":
minimo = 100.0
maximo = 130.0
elif genero == 'REGGAE':
minimo = 60.0
maximo = 90.0
elif genero == 'DOWN-TEMPO': ###
minimo = 70.0
maximo = 100.0
elif genero == 'CHILL-OUT': #
minimo = 90.0
maximo = 120.0
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 = req4('tempo', minimo, maximo, cat2)
artistas = pra[0][0]
reproducciones = pra[0][1]
lista = pra[0][2]
cantidadT += reproducciones
if top < reproducciones:
top = reproducciones
nombretop = genero
listatop = lista
x = 1
cantidad = lt.size(lista)
lt.addLast(
resp1, {
"genero": genero,
"artista": artistas,
"reproducciones": reproducciones,
'minimo': minimo,
'maximo': maximo
})
newisi = it.newIterator(listatop)
lst = lt.newList("SINGLE_LINKED")
paaa = lt.newList("SINGLE_LINKED")
while it.hasNext(newisi):
pedazo = it.next(
newisi
) #Esto devuelve un mapa de la lista iterando (mapa de la lista(cada elemento))
nex = mp.get(
pedazo, 'track_id'
) #Devuelve la llave danceability y el valor respectivo del mapa en forma de diccionario
tax = me.getValue(
ax
) #Devuelve el valor de danceability del track sacado en el mapa de it.next(video)
fex = me.getValue(nex)
if lt.isPresent(lst, fex) == 0:
lt.addLast(paaa, pedazo)
lt.addLast(lst, fex)
totalu = lt.size(paaa)
x = 1
vistos = lt.newList()
n = 1
resp2 = lt.newList("SINGLE_LINKED")
while n <= 10:
rand = random.randint(1, totalu) #
track = lt.getElement(
paaa, rand) #Lo mismo que it.next(de un iterador de lista)
id = me.getValue(mp.get(track, 'track_id'))
hashte = me.getValue(mp.get(track, 'cantidad'))
vader = me.getValue(mp.get(track, 'vader_avg'))
if lt.isPresent(vistos, id) == 0:
lt.addFirst(
resp2, {
"0": str(x) + ':' + str(id),
"hashte": hashte,
"vader_avg": vader_avg
})
lt.addLast(vistos, id)
x += 1
n += 1
return [resp1, cantidadT, genero, totalu, resp2]
def test_getkeys(map):
ltset = ht.keySet(map)
assert lt.size(ltset) == 12
element = lt.getElement(ltset, 1)
assert element is not None
def datoshoras(catalogo, hora_min, hora_max):
generos = mp.keySet(catalogo["mapageneros"])
songs = catalogo["datoscanciones"]
datakeys = om.keySet(songs)
songsgeneros = mp.newMap(20, maptype="PROBING")
for x in range(lt.size(generos)):
genero = lt.getElement(generos, x)
mp.put(songsgeneros,
mp.get(catalogo["mapageneros"], genero)["value"],
lt.newList("ARRAY_LIST"))
numrep = 0
listageneros = mp.keySet(songsgeneros)
for x in range(datakeys["size"]):
key = lt.getElement(datakeys, x)
if (int(key[-8] + key[-7]) >= int(hora_min.split(":")[0])
) and (int(key[-5] + key[-4]) >= int(hora_min.split(":")[1])) and (
int(key[-8] + key[-7]) <= int(hora_max.split(":")[0])) and (
int(key[-5] + key[-4]) <= int(hora_max.split(":")[1])):
generosong = checkgeneros(
om.get(songs, key)["value"], listageneros)
for y in range(lt.size(generosong)):
llavegenero = lt.getElement(generosong, y)
lt.addLast(
mp.get(songsgeneros, (llavegenero))["value"],
om.get(songs, key)["value"])
numrep += 1
generosrep = lt.newList("ARRAY_LIST")
for x in range(lt.size(listageneros)):
generooo = lt.getElement(listageneros, x)
lt.addLast(
generosrep,
(generooo, lt.size(mp.get(songsgeneros, generooo)["value"])))
generosorteados = ms.sort(generosrep, compgeneros)
generomax = lt.getElement(generosorteados, 1)[0]
listamax = mp.get(songsgeneros, generomax)["value"]
listapasortearhashtags = lt.newList("ARRAY_LIST")
dataa = om.valueSet(catalogo["datosusuarios"])
maptags = mp.newMap(100000, maptype="PROBING")
for x in range(lt.size(dataa)):
listen = lt.getElement(dataa, x)
created = listen["created_at"]
if (int(created[-8] + created[-7]) >= int(hora_min.split(":")[0])
) and (
int(created[-5] + created[-4]) >= int(hora_min.split(":")[1])
) and (int(created[-8] + created[-7]) <= int(
hora_max.split(":")[0])) and (int(created[-5] + created[-4]) <=
int(hora_max.split(":")[1])):
if mp.contains(maptags, listen["track_id"]):
if not lt.isPresent(
mp.get(maptags, listen["track_id"])["value"],
listen["hashtag"]):
lt.addLast(
mp.get(maptags, listen["track_id"])["value"],
listen["hashtag"])
else:
mp.put(maptags, listen["track_id"], lt.newList("ARRAY_LIST"))
lt.addLast(
mp.get(maptags, listen["track_id"])["value"],
listen["hashtag"])
listaidsusados = lt.newList("ARRAY_LIST")
for x in range(lt.size(listamax)):
song = lt.getElement(listamax, x)
if not lt.isPresent(listaidsusados, song["track_id"]):
lt.addLast(
listapasortearhashtags,
(song,
vaderprom(catalogo,
mp.get(maptags, song["track_id"])["value"])[1],
vaderprom(catalogo,
mp.get(maptags, song["track_id"])["value"])[0]))
lt.addLast(listaidsusados, song["track_id"])
songhashsort = ms.sort(listapasortearhashtags, compgeneros)
lista10 = lt.subList(songhashsort, 1, 10)
return generosorteados, songsgeneros, numrep, lista10
def find_position_category(catalog, category):
for runner in range(lt.size(catalog)):
element = lt.getElement(catalog, runner)
if element['name'].strip() in category.strip():
return element['id']
return False
'Seleccione una opción para continuar\nSeleccione cualquier otra tecla para salir\n'
)
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = initCatalog()
loadData(catalog)
print("No. Videos cargados: " + str(lt.size(catalog["videos"])))
print("No. Categorías cargadas: " +
str(lt.size(catalog["categories"])))
print("\nPRIMER VIDEO CARGADO:")
printFirstVideo(catalog)
print("\nCATEGORIAS CARGADAS:")
for n in range(1, lt.size(catalog["categories"]) + 1):
print(lt.getElement(catalog["categories"], n))
elif int(inputs[0]) == 2:
category_name = input("Nombre de la categoria a buscar: ")
category_id = getCategoryId(catalog, category_name)
if category_id != None:
country = input("Nombre del pais a buscar: ")
number = input("Numero de videos a listar: ")
result = controller.getBestViews(catalog, category_id,
country.lower())
if lt.isEmpty(result):
print("\nNo se encontro informacion para ese pais")
else:
print("\nTOP " + number + " VIDEOS DE " +
print("Tiempo [ms]: ", f"{tempo[12]:.3f}", " || ",
"Memoria [kB]: ", f"{tempo[13]:.3f}")
print("-"*50)
print("-"*50)
print("El numero total de reproducciones es ",tempo[3])
print("-"*100)
print("El numero de reproducciones de ",nom1," es ",tempo[0]," con ", tempo[5]," artistas diferentes")
print("Los 10 primeros artistas de ",nom1,"son: ")
print("Artista 1",lt.getElement(tempo[9],0))
print("Artista 2",lt.getElement(tempo[9],1))
print("Artista 3",lt.getElement(tempo[9],2))
print("Artista 4",lt.getElement(tempo[9],3))
print("Artista 5",lt.getElement(tempo[9],4))
print("Artista 6",lt.getElement(tempo[9],5))
print("Artista 7",lt.getElement(tempo[9],6))
print("Artista 8",lt.getElement(tempo[9],7))
print("Artista 9",lt.getElement(tempo[9],8))
print("Artista 10",lt.getElement(tempo[9],9))
print("-"*100)
print("El numero de reproducciones de ",nom2," es ",tempo[1]," con ", tempo[6]," artistas diferentes")
def getFirstLP(catalog):
LPs = mp.valueSet(catalog['lp'])
lp = lt.getElement(LPs, 1)
ans = (lt.getElement(lp, 1), lt.getElement(lp, 2), lt.getElement(lp, 3),
lt.getElement(lp, 4))
return ans
def buscarcateporname(categg, catalog):
for i in range(0, lt.size(catalog['cate'])):
cate = lt.getElement(catalog['cate'], i)
if categg in str(cate['name']):
return cate['id']
return "ERROR"
def nameToIdCategory(category_name, categories):
for i in range(1, lt.size(categories) + 1):
category = lt.getElement(categories, i)
if category_name == category["name"]:
return category["id"]
return None
req1 = controller.req1(analyzer, ranking1, ranking2)
print("------------------------------")
print("Cantidad de taxis de los servicios reportados:", req1["total taxis"])
print("------------------------------")
print("Cantidad de compañias con al menos 1 taxi:", req1["compañias taxi"])
print("------------------------------")
print(
"El top:", ranking1, "de compañias con mayor cantidad de taxis registrados."
)
print("------------------------------")
cont = 0
ranking1_ = req1["ranking1"]
for i in range(1, lt.size(ranking1_) + 1):
cont += 1
elemento = lt.getElement(ranking1_, i)
print(cont, elemento["company"], ":", len(elemento["value"]))
print("------------------------------")
print("El top:", ranking2, "de compañias que más servicios prestaron.")
print("------------------------------")
cont = 0
ranking2_ = req1["ranking2"]
for i in range(1, lt.size(ranking2_) + 1):
cont += 1
elemento = lt.getElement(ranking2_, i)
print(cont, elemento["company"], ":", elemento["servicios"])
print("------------------------------")
elif inputs == "4":
print("-----------------------PARTE A----------------------------------")
def test_getElement(lstbooks, books):
book = lt.getElement(lstbooks, 1)
assert book == books[0]
book = lt.getElement(lstbooks, 5)
assert book == books[4]
'Visitas: ': str(first.get('views')),
'Likes: ': str(first.get('likes')),
'Dislikes: ': str(first.get('dislikes'))}
print('\nVideos cargados: ' + str(lt.size(catalog['video'])))
print('\nDatos del primer video: ')
for i in primervideo.keys():
print(str(i) + str(primervideo.get(i)))
print(
"\n" + str(lt.size(catalog['category'])) + ' Categorías cargadas: '
)
i = 1
resultadoxy = []
while i <= int(lt.size(catalog['category'])):
resultadoxy.append(
lt.getElement(catalog['category'], i).get('c_id') + ":" +
lt.getElement(catalog['category'], i).get('name'))
i += 1
print(*resultadoxy, sep=' ')
lista = ''
for i in range(0, lt.size(catalog['country'])):
element = lt.getElement(catalog['country'], i)
pais = str(element.get('country_name'))
if i < (lt.size(catalog['country'])-1):
lista += (pais.lower() + ", ")
else:
lista += pais.lower()
print(
"\n" + str(lt.size(catalog['country'])) + ' Países cargados: ',
lista)
def test_removeFirst(lstbooks, books):
assert lt.size(lstbooks) == 5
lt.removeFirst(lstbooks)
assert lt.size(lstbooks) == 4
book = lt.getElement(lstbooks, 1)
assert book == books[1]
def print_categories(category_names):
size=lt.size(category_names)
for n in range(1,size+1):
category=lt.getElement(category_names,n)
print(category['id'],category['name'])
def test_getElement_array(altbooks, books):
book = lt.getElement(altbooks, 1)
assert book == books[0]
book = lt.getElement(altbooks, 5)
assert book == books[4]
def id_to_fullname(self, vertex):
return lt.getElement(mp.get(self.points_by_id, vertex)['value'], 3)
def test_removeLast_array(altbooks, books):
assert lt.size(altbooks) == 5
lt.removeLast(altbooks)
assert lt.size(altbooks) == 4
book = lt.getElement(altbooks, 4)
assert book == books[3]
def get_capital(self, country):
return lt.getElement(mp.get(self.countries, country)['value'], 1)
def test_changeInfo_array(altbooks):
book10 = {'book_id': '10', 'book_title': 'Title 10', 'author': 'author 10'}
lt.changeInfo(altbooks, 1, book10)
book = lt.getElement(altbooks, 1)
assert book10 == book
def point_coords_degrees(self, vertex):
landing_point = mp.get(self.points_by_id, vertex)['value']
return lt.getElement(landing_point, 4), lt.getElement(landing_point, 5)
elif int(inputs[0]) == 5:
genero = input("Genero(s) que desea estudiar: ")
existe = controller.existeGenero(analyzer,genero)
if(existe[1]):
rta = controller.estudiarGenerosMusicales(analyzer,genero)
imprimirEstudio(rta[0],rta[1],rta[2],rta[3],rta[4])
elif(existe[1]== False):
noEncontrados = existe[0]
rest = None
print("Genero(s) no econtrado(s): ")
tam = lt.size(noEncontrados)
pos = 0
while tam > 0:
elemento = lt.getElement(noEncontrados,pos)
print(elemento)
tam -= 1
pos += 1
rta = input("¿desea crearlo(s)?\n1. Si\n2. No\n")
if(rta == str(1)):
for i in noEncontrados:
T1 = input("Digite el valor minimo para el tempo para " + n +": ")
T2 = input("Digite el valor maximo para el tempo para " + n +": ")
controller.crearGenero(analyzer,n,float(T1),float(T2))
elif int(inputs[0]) == 6:
