def EstudyMusic(analyzer, min_instru, max_instru, min_tempo, max_tempo):
track_map = om.newMap(omaptype='RBT', comparefunction=compareDates)
videosct = lt.newList("ARRAY_LIST")
track_map = om.newMap(omaptype='RBT', comparefunction=compareDates)
videosct = lt.newList("ARRAY_LIST")
# filtro 1: por minKey y MaxKey de energy
lst = om.values(analyzer["instrumentalness"], min_instru, max_instru)
for lstdate in lt.iterator(lst):
for element in lt.iterator(lstdate["events"]):
if (element["tempo"] > min_tempo) and (element["tempo"] <
max_tempo):
if om.contains(track_map, element["track_id"]) == False:
om.put(
track_map, element["track_id"], {
"instrumentalness": element["instrumentalness"],
"tempo": element["tempo"]
})
size = om.size(track_map)
print("Total of unique track events: ", size)
for pos in random.sample(range(1, size), 5):
key = om.select(track_map, pos)
item = om.get(track_map, key)
value = me.getValue(item)
lt.addLast(
videosct, {
"track_id": key,
"instrumentalness": value["instrumentalness"],
"tempo": value["tempo"]
})
return videosct
def genreSearch(analyzer, genres):
videosct = lt.newList("ARRAY_LIST")
for every_genre in genres:
tagg = mp.get(analyzer["musical_genre"], every_genre)
taggg = me.getValue(tagg)
minor = taggg["lower"]
mayor = taggg["upper"]
# filtro 1: por minKey y MaxKey
lst = om.values(analyzer["tempo"], minor, mayor)
totchar = 0 # contador
for lstdate in lt.iterator(lst):
# cuenta el número de tracks y las suma
totchar += lt.size(lstdate['events'])
taggg["totchar"] = totchar
for element in lt.iterator(lstdate["events"]):
if om.contains(taggg["events"], element["artist_id"]) == False:
om.put(taggg["events"], element["artist_id"], None)
different_artist = om.size(taggg["events"])
reproductions = taggg["totchar"]
print("========{}========".format(every_genre))
print("For {} the tempo is between {} and {} BPM".format(
every_genre, minor, mayor))
print("{} reproductions: {} with {} different artists".format(
every_genre, reproductions, different_artist))
print("---- Some artists for {}----".format(every_genre))
for pos in random.sample(range(1, different_artist), 10):
key = om.select(taggg["events"], pos)
print("Artist {}:{}".format(pos, key))
return "-"
def servicesRanking(analyzer, N):
companies = om.keySet(analyzer["companiesServices"])
services = om.valueSet(analyzer["companiesServices"])
mapaServ = om.newMap(omaptype="BST", comparefunction=cmpCompanies)
for i in range(lt.size(companies)):
empresa = lt.getElement(companies, i)
numserv = lt.getElement(services, i)
if om.contains(mapaServ, numserv) == True:
infoserv = om.get(mapaServ, numserv)
empresas = infoserv["value"]
lt.addLast(empresas, empresa)
om.put(mapaServ, numserv, empresas)
else:
empresas = lt.newList("ARRAY_LIST", None)
lt.addLast(empresas, empresa)
om.put(mapaServ, numserv, empresas)
tam = om.size(mapaServ)
tam = tam - 1
for i in range(N):
k = tam - i
emp = om.select(mapaServ, k)
pareja = om.get(mapaServ, emp)
lista = pareja["value"]
nums = lista["elements"]
info = str(tam - k + 1) + ". " + str(nums[0]) + ": " + str(emp)
print(info)
def tercera_consulta(citibike):
tree = om.newMap(omaptype='RBT', comparefunction=compareroutes)
diccionario = {}
list_vertext = gr.vertices(citibike["graph"])
ite = it.newIterator(list_vertext)
while it.hasNext(ite):
vertex = it.next(ite)
arrive = gr.indegree(citibike["graph"], vertex)
if arrive > 0:
om.put(tree, arrive, vertex)
l = []
number = om.size(tree)
resta = abs(number - 3)
less = om.select(tree, resta)
greater = om.maxKey(tree)
ran = om.values(tree, less, greater)
i = it.newIterator(ran)
while it.hasNext(i):
name = it.next(i)
l.append(name)
diccionario["llegadas"] = l
tree_1 = om.newMap(omaptype='RBT', comparefunction=compareroutes)
list_vertext_1 = gr.vertices(citibike["graph"])
ite_1 = it.newIterator(list_vertext_1)
while it.hasNext(ite_1):
vertex_1 = it.next(ite_1)
arrive_1 = gr.outdegree(citibike["graph"], vertex_1)
if arrive_1 > 0:
om.put(tree_1, arrive_1, vertex_1)
print((citibike["graph"]))
l_1 = []
number_1 = om.size(tree_1)
resta_1 = abs(number_1 - 3)
less_1 = om.select(tree_1, resta_1)
greater_1 = om.maxKey(tree_1)
ran_1 = om.values(tree_1, less_1, greater_1)
iterar = it.newIterator(ran_1)
while it.hasNext(iterar):
name_1 = it.next(iterar)
l_1.append(name_1)
diccionario["salidas"] = l_1
return diccionario
def taxisPointsByDateRange(analyzer, M, fecha1, fecha2):
taxis = om.keySet(analyzer["taxisPoints"])
rankingFechas = om.newMap(omaptype="BST", comparefunction=cmpTaxiId)
dia1 = fecha1[8:10]
mes1 = fecha1[5:7]
año1 = fecha1[0:4]
dia2 = fecha1[8:10]
mes2 = fecha1[5:7]
año2 = fecha1[0:4]
for i in range(lt.size(taxis)):
puntosLlave = 0.00000
taxi = lt.getElement(taxis, i)
info = om.get(analyzer["taxisPoints"], taxi)
tuplas = info["value"]
for j in range(lt.size(tuplas)):
tupla = lt.getElement(tuplas, j)
puntosFecha = tupla[1]
dia = puntosFecha[8:10]
mes = puntosFecha[5:7]
año = puntosFecha[0:4]
if (año1 < año and año < año2) or año1 == año or año2 == año:
if (mes1 < mes and mes < mes2) or mes1 == mes or mes2 == mes:
if (dia1 < dia
and dia < dia2) or dia1 == dia or dia2 == dia:
if tupla[0] > puntosLlave:
puntosLlave = tupla[0]
puntosFecha = tupla[1]
if om.contains(rankingFechas, puntosLlave) == False:
taxiList = lt.newList("ARRAY_LIST", None)
lt.addLast(taxiList, taxi)
om.put(rankingFechas, puntosLlave, taxiList)
elif om.contains(rankingFechas, puntosLlave) == True:
info = om.get(rankingFechas, puntosLlave)
taxiList = info["value"]
lt.addLast(taxiList, taxi)
om.put(rankingFechas, puntosLlave, taxiList)
tam = om.size(rankingFechas)
tam = tam - 1
for i in range(M):
k = tam - i
puntos = om.select(rankingFechas, k)
pareja = om.get(rankingFechas, puntos)
lista = pareja["value"]
taxisN = lista["elements"]
x = "x"
info = str(tam - k + 1) + ". Taxi ID: " + str(
taxisN) + ", Puntos: " + str(puntos)
print(info)
def test_select(tree):
tree = om.put(tree, 23, 'book21')
tree = om.put(tree, 7, 'book7')
tree = om.put(tree, 30, 'book30')
tree = om.put(tree, 5, 'book5')
tree = om.put(tree, 4, 'book4')
tree = om.put(tree, 3, 'book3')
tree = om.put(tree, 20, 'book20')
tree = om.put(tree, 25, 'book25')
tree = om.put(tree, 35, 'book35')
tree = om.put(tree, 29, 'book29')
tree = om.put(tree, 11, 'book11')
tree = om.put(tree, 15, 'book15')
tree = om.put(tree, 10, 'book10')
assert om.size(tree) == 13
assert om.select(tree, 6) == 15
def requerimiento3(catalog, menor1, mayor1, menor2, mayor2):
"""
Devuelve el total de canciones únicas y un mapa con 5 canciones
aleatorias que cumplen con dos rangos de características
"""
# Mapa donde se guardan las canciones que cumplen con el rango
# de tempo, el valor es una tupla con el instrumentalness y el
# energy de la canción
mapa_tempo = om.newMap('BST')
# Lista de listas de eventos que cumplen con el rango de tempo
lista_rango = om.values(catalog['tempo'], menor2, mayor2)
for lista_instrumentalness in lt.iterator(lista_rango):
for e in lt.iterator(lista_instrumentalness):
om.put(mapa_tempo, e['track_id'],
(e['instrumentalness'], e['tempo']))
# Lista de las canciones que cumplen con el tempo
canciones = om.keySet(mapa_tempo)
# Se recorre la lista de canciones que cumple con tempo y
# se revisa cuáles de esas no cumplen con el rango de
# instrumentalness y se eliminan del mapa
for cancion in lt.iterator(canciones):
instrumental = (me.getValue(om.get(mapa_tempo, cancion)))[0]
tempo = (me.getValue(om.get(mapa_tempo, cancion)))[1]
if not (instrumental <= mayor1 and instrumental >= menor1):
om.remove(mapa_tempo, cancion)
# Se obtiene el tamaño del mapa
tamaño = om.size(mapa_tempo)
# Se crea un mapa para guardar las 5 llaves aleatorias y sus valores
mapa_aleatorias = om.newMap('RBT')
# Se obtiene una lista con cinco números aleatorios no repetidos
# que estén dentro del rango del tamaño
lista_cinco_aleatorios = random.sample(range(tamaño), 5)
for i in lista_cinco_aleatorios:
llave_aleatoria = om.select(mapa_tempo, i)
valor = me.getValue(om.get(mapa_tempo, llave_aleatoria))
om.put(mapa_aleatorias, llave_aleatoria, valor)
return tamaño, mapa_aleatorias
def requerimiento2(catalog, menor1, mayor1, menor2, mayor2):
"""
Devuelve el total de canciones únicas y un mapa con 5 canciones
aleatorias que cumplen con dos rangos de características
"""
# Mapa donde se guardan las canciones que cumplen con el rango
# de danceability, el valor es una tupla con el energy y el
# danceability de la canción
mapa_dance = om.newMap('BST')
# Lista de listas de eventos que cumplen con el rango de danceability
lista_rango = om.values(catalog['danceability'], menor2, mayor2)
for lista_energy in lt.iterator(lista_rango):
for e in lt.iterator(lista_energy):
om.put(mapa_dance, e['track_id'], (e['energy'], e['danceability']))
# Lista de las canciones que cumplen con el danceability
canciones = om.keySet(mapa_dance)
# Se recorre la lista de canciones que cumple con danceability y
# se revisa cuáles de esas no cumplen con el rango de energy y
# se eliminan del mapa
for cancion in lt.iterator(canciones):
energy = (me.getValue(om.get(mapa_dance, cancion)))[0]
dance = (me.getValue(om.get(mapa_dance, cancion)))[1]
if not (energy <= mayor1 and energy >= menor1):
om.remove(mapa_dance, cancion)
# Se obtiene el tamaño del mapa
tamaño = om.size(mapa_dance)
# Se crea un mapa para guardar las llaves aleatorias y sus valores
mapa_aleatorias = om.newMap('RBT')
# Se obtiene una lista con cinco números aleatorios no repetidos
# que estén dentro del rango del tamaño
lista_cinco_aleatorios = random.sample(range(tamaño), 5)
for i in lista_cinco_aleatorios:
llave_aleatoria = om.select(mapa_dance, i)
valor = me.getValue(om.get(mapa_dance, llave_aleatoria))
om.put(mapa_aleatorias, llave_aleatoria, valor)
return tamaño, mapa_aleatorias
def taxisPointsByDate(analyzer, N, fecha):
taxis = om.keySet(analyzer["taxisPoints"])
#pointsLists = om.valueSet(analyzer["taxisPoints"])
rankingFechas = om.newMap(omaptype="BST", comparefunction=cmpTaxiId)
for i in range(lt.size(taxis)):
puntosLlave = 0.00000
taxi = lt.getElement(taxis, i)
info = om.get(analyzer["taxisPoints"], taxi)
tuplas = info["value"]
for j in range(lt.size(tuplas)):
tupla = lt.getElement(tuplas, j)
puntosFecha = tupla[1]
if tupla[0] > puntosLlave and tupla[1] == fecha:
puntosLlave = tupla[0]
puntosFecha = tupla[1]
if puntosFecha == fecha and om.contains(rankingFechas,
puntosLlave) == False:
taxiList = lt.newList("ARRAY_LIST", None)
lt.addLast(taxiList, taxi)
om.put(rankingFechas, puntosLlave, taxiList)
elif puntosFecha == fecha and om.contains(rankingFechas,
puntosLlave) == True:
info = om.get(rankingFechas, puntosLlave)
taxiList = info["value"]
lt.addLast(taxiList, taxi)
om.put(rankingFechas, puntosLlave, taxiList)
tam = om.size(rankingFechas)
tam = tam - 1
for i in range(N):
k = tam - i
puntos = om.select(rankingFechas, k)
pareja = om.get(rankingFechas, puntos)
lista = pareja["value"]
taxisN = lista["elements"]
info = str(tam - k + 1) + ". Taxi ID: " + str(
taxisN) + ", Puntos: " + str(puntos)
print(info)
def partyMusic(analyzer, min_energy, max_energy, min_danceability,
max_danceability):
"""
Requerimiento 2
"""
# Creación de un map y lista
track_map = om.newMap(omaptype='RBT', comparefunction=compareDates)
videosct = lt.newList("ARRAY_LIST")
#variable = addlist_id(analyzer)#
# filtro 1: por minKey y MaxKey de energy
lst = om.values(analyzer["energy"], min_energy, max_energy)
for lstdate in lt.iterator(lst):
# filtro 1: por minKey y MaxKey de danceability
for element in lt.iterator(lstdate["events"]):
#tracku =str(str(element["track_id"])+ str(int(element["user_id"]))+ str(element["created_at"]))#
if (element["danceability"] >= min_danceability) and (
element["danceability"] <= max_danceability):
if om.contains(
track_map, element["track_id"]
) == False: #and tracku in variable["elements"]:#
om.put(
track_map, element["track_id"], {
"danceability": element["danceability"],
"energy": element["energy"]
})
size = om.size(track_map)
print("Total of unique track events: ", size)
# Generación Random de 5 track_ID
for pos in random.sample(range(1, size), 5):
key = om.select(track_map, pos)
item = om.get(track_map, key)
value = me.getValue(item)
lt.addLast(
videosct, {
"track_id": key,
"danceability": value["danceability"],
"energy": value["energy"]
})
return videosct
def generosmusicales(cat, listgenres):
l_genres = lt.newList(datastructure="ARRAY_LIST")
tot_reps = 0
for gen in listgenres:
info = caracterizarrep(cat, "tempo", gen["min_tempo"],
gen["max_tempo"])
gen["escuchas"] = info[0]
tot_reps += gen["escuchas"]
gen["artistas"] = info[1]
tree = info[2]
l_id_artists = lt.newList(datastructure="ARRAY_LIST")
for i in range(1, 11):
id_artist = om.select(tree, i)
lt.addLast(l_id_artists, id_artist)
gen["id_artistas"] = l_id_artists
lt.addLast(l_genres, gen)
return (tot_reps, l_genres)
def musica(cat, carac_1, carac_2, min_1, max_1, min_2, max_2):
m = cat["features"]
m_reps = mp.newMap(4000, maptype='PROBING', loadfactor=0.5)
m_tracks = om.newMap(omaptype='RBT', comparefunction=compareValue)
a = mp.get(m, carac_1)
m_1 = me.getValue(a)
l_1 = om.values(m_1, min_1, max_1)
for lists in lt.iterator(l_1):
for e in lt.iterator(lists):
mp.put(m_reps, e["track_id"], "")
b = mp.get(m, carac_2)
m_2 = me.getValue(b)
l_2 = om.values(m_2, min_2, max_2)
for lists in lt.iterator(l_2):
for e in lt.iterator(lists):
if mp.contains(m_reps, e["track_id"]):
om.put(m_tracks, e["track_id"], e)
n_tracks = om.size(m_tracks)
if n_tracks >= 5:
num = 5
else:
num = n_tracks
random_tracks = random.sample(range(0, n_tracks), num)
keys = lt.newList(datastructure="ARRAY_LIST")
l_tracks = lt.newList(datastructure="ARRAY_LIST")
for n in random_tracks:
key = om.select(m_tracks, n)
lt.addLast(keys, key)
for a in lt.iterator(keys):
rep = om.get(m_tracks, a)
rep_info = me.getValue(rep)
lt.addLast(l_tracks, rep_info)
return (n_tracks, l_tracks)
def companyRanking(analyzer, M):
companies = om.keySet(analyzer["companiesRanking"])
taxis = om.valueSet(analyzer["companiesRanking"])
mapa = om.newMap(omaptype="BST", comparefunction=cmpCompanies)
for i in range(lt.size(companies)):
empresa = lt.getElement(companies, i)
numtaxi = lt.getElement(taxis, i)
if om.contains(mapa, numtaxi) == True:
infonum = om.get(mapa, numtaxi)
empresas = infonum["value"]
lt.addLast(empresas, empresa)
om.put(mapa, numtaxi, empresas)
else:
empresas = lt.newList("ARRAY_LIST", None)
lt.addLast(empresas, empresa)
om.put(mapa, numtaxi, empresas)
tam = om.size(mapa)
tam = tam - 1
for i in range(M):
k = tam - i
emp = om.select(mapa, k)
pareja = om.get(mapa, emp)
lista = pareja["value"]
numt = lista["elements"]
info = str(tam - k + 1) + ". " + str(numt[0]) + ": " + str(emp)
print(info)
result = ".."
return result