def por_horas(mapa,hora_min,hora_max):
p=0
user_track = om.valueSet(mapa["user_track"]) #saca todos los valores de user_track en una lista
lst = om.valueSet(mapa["context"]) #saca todos los valores de context en una lista
sentiment = om.valueSet(mapa["sentiment"]) #saca todos los valores de sentiment en una lista
o=0
hora_min = hora_min.replace(":","")
hora_max = hora_max.replace(":","")
y=len(hora_min)
g=len(hora_max)
trackId = []
generos = {}
hasta = {}
etiquetas = {} #almacenara las etiquetas de las canciones
ayuda = 0
z = 0
b = 0
art_has = {} #almacenara los artistas y sus hashtag
canci = []
genero_fav = "" #almacenara el genero que mas se repite en las horas
if len(hora_min) != 6: #en caso de que no se coloque la hora completa se completara con 0
while len(hora_min) < 6:
o+=1
hora_min+= "0"
y+=1
if len(hora_max) != 6:
while len(hora_max) < 6: #en caso de que no se coloque la hora completa se completara con 0
o+=1
hora_max+= "0"
y+=1
def TM(analyzer,M):
rank=oms.newMap('BST',comparefunction=comparerMap)
rankp=oms.newMap('BST',comparefunction=comparerMap)
sancocho=om.valueSet(analyzer["indice"])
for papa in sancocho:
if oms.contains(rank,papa["company"])==True:
new=oms.get(rank,papa["company"])
nueva=lt.newList(new.values())
lt.addLast(nueva,papa["taxi_id"])
oms.put(rank,str(new.keys()),nueva)
if papa["company"]=="" and oms.contains(rank,"Independent Owner")==True:
news=oms.get(rank,"Independent Owner")
nuevas=lt.newList(news.values())
lt.addLast(nuevas,papa["taxi_id"])
oms.put(rank,str(news.keys()),nuevas)
else:
if papa["company"]=="":
oms.put(rank,"Independent Owner",1)
oms.put(rank,papa["company"],1)
for com in list(rank):
oms.put(rankp,lt.size(set(list(com.values()))),str(com.keys()))
ranki=lt.newList()
for puesto in range(M):
p=oms.maxKey(rankp)
lt.addLast(ranki,dict(om.keySet(rank)[om.valueSet(rank).index(p)],p))
oms.deleteMax(rankp)
return ranki
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 musica_estudiar(valor_min_instrumentalness,valor_max_instrumentalness,valor_min_tempo,valor_max_tempo,mapa):
lst = om.valueSet(mapa["context"]) #saca todos los valores de context en una lista
p=0 # centinela para recorrer lst
artistas= [] # se creo una lista nueva para almacenar los artistas
respuesta_canciones=[] #almacena los id_track , el tempo y el instrumentalness
entregar =[]
while p < lt.size(lst): #recorrecomos los diccionarios dentro de lst
x=lt.getElement(lst,p)
if (x["instrumentalness"] >= valor_min_instrumentalness) and (x["instrumentalness"] <= valor_max_instrumentalness):
if (x["tempo"] >= valor_min_tempo) and (x["tempo"] <= valor_max_tempo):
if x["track_id"] not in artistas:
agregar = []
artistas.append(x["track_id"]) #en caso de que el id del artista no este en la lista lo agrega
agregar.append(x["track_id"])
agregar.append(x["instrumentalness"])
agregar.append(x["tempo"])
respuesta_canciones.append(agregar)
p+=1
#selecciona 3 canciones al azar que cumplan con las condiciones
cancion1 = random.choice(respuesta_canciones)
respuesta_canciones.remove(cancion1)
entregar.append(cancion1)
cancion2 = random.choice(respuesta_canciones)
respuesta_canciones.remove(cancion2)
entregar.append(cancion2)
cancion3 = random.choice(respuesta_canciones)
respuesta_canciones.remove(cancion3)
entregar.append(cancion3)
return(entregar,len(artistas))
def encontrar_genero(lista_genero,centinela,generos_usuario,mapa):
lst = om.valueSet(mapa["context"]) #saca todos los valores de context en una lista
p=0
artistas = {}
generos = {}
diccionario_generos={"Reggae":[60,90],"Down-tempo":[70,100],"Chill-out":[90,120],"Hip-hop":[85,115],"Jazz and Funk":[120,125],"Pop":[100,130],"R&B":[60,70],"Rock":[110,140],"Metal":[100,160]}
if int(centinela) == 1:
for i in generos_usuario:
diccionario_generos[i]=generos_usuario[i]
while p < lt.size(lst): #recorrecomos los diccionarios dentro de lst
x=lt.getElement(lst,p)
for u in lista_genero:
if u in diccionario_generos:
tempo = diccionario_generos[u]
tempo_min = tempo[0]
tempo_max = tempo[1]
if (float(x["tempo"]) >= float(tempo_min)) and (float(x["tempo"]) <= float(tempo_max)):
if u not in generos:
artista_id = []
artista_id.append(x["artist_id"])
generos[u]=artista_id
else:
lista_x = generos[u]
if x["artist_id"] not in lista_x:
lista_x.append(x["artist_id"])
generos[u]=lista_x
p+=1
return generos
def Reps_genero_en_horario(catalog, lista_mapas_reps):
mapa_generos = catalog['Generos']
mapa_contadores = mp.newMap(loadfactor=4.0)
reps_totales = 0
for genero in lt.iterator(mp.keySet(mapa_generos)):
cantidad_reps_genero = 0
for mapa_reps in lt.iterator(lista_mapas_reps):
for rep in lt.iterator(mp.valueSet(mapa_reps)):
tempo_rep = rep['tempo']
limites = me.getValue(mp.get(mapa_generos, genero))[0]
lim_inf = limites[0]
lim_sup = limites[1]
if lim_inf <= tempo_rep and tempo_rep <= lim_sup:
cantidad_reps_genero = cantidad_reps_genero + 1
mp.put(mapa_contadores, genero, cantidad_reps_genero)
bst_calculo = om.newMap(omaptype='BST', comparefunction=MAPcompareEnteros)
for genero in lt.iterator(mp.keySet(mapa_contadores)):
cantidad_reps_genero = me.getValue(mp.get(mapa_contadores, genero))
om.put(bst_calculo, cantidad_reps_genero,
(genero, cantidad_reps_genero))
generos_ordenados_por_reps = om.valueSet(bst_calculo)
#esto es una lista de tuplas (genero, cantidad_reps_genero) ORDENADA por cantidad_reps_genero
return generos_ordenados_por_reps
def TN(analyzer,N):
rank=oms.newMap('BST',comparefunction=comparerMap)
rankp=oms.newMap('BST',comparefunction=comparerMap)
sancocho=om.valueSet(analyzer["indice"])
for papa in sancocho:
if oms.contains(rank,papa["company"])==True:
new=oms.get(rank,papa["company"])
nueva=int(new.values())+1
oms.put(rank,str(new.keys()),nueva)
if papa["company"]=="" and oms.contains(rank,"Independent Owner")==True:
news=oms.get(rank,"Independent Owner")
nuevas=int(news.values())+1
oms.put(rank,str(news.keys()),nuevas)
else:
if papa["company"]=="":
oms.put(rank,"Independent Owner",1)
oms.put(rank,papa["company"],1)
for com in list(rank):
oms.put(rankp,int(com.values()),str(com.keys()))
rankesito=lt.newList()
for puesto in range(N):
p=oms.maxKey(rankp)
lt.addLast(rankesito,dict(list(rank.keys())[list(rank.values()).index(p)],p))
oms.deleteMax(rankp)
return rankesito
def printSentimentAnalysis(analyzer, events):
"""
Imprime el análisis de sentimientos para el género con
mayor número de reproducciones
"""
index = 1
map = events[0]
genres = controller.getEventsByGenre(map)
values = om.valueSet(genres)
genre = lt.getElement(values, 1)
trackslst = genre[3]
size = lt.size(trackslst)
maphashtags = controller.getHashtagsByTrack(analyzer, trackslst)
mapvaders = controller.getVaderAverageByTrack(analyzer, trackslst)
print("-------- Analisis de Sentimientos para " + str(genre[0]) +
" --------")
print("Total pistas únicas: " + str(genre[2]) + "\n")
print("-------- 10 pistas --------")
while index <= 10:
randomnumber = random.randint(1, size)
key = lt.getElement(trackslst, randomnumber)
entryhashtag = mp.get(maphashtags, key)
valuehashtag = me.getValue(entryhashtag)
entryvader = mp.get(mapvaders, key)
valuevader = me.getValue(entryvader)
print("Track " + str(index) + ": " + str(key) + " con " +
str(valuehashtag['hashtags']) + " hashtags" + " y vader = " +
str(valuevader['vaderaverage']))
index += 1
print()
def getAccidentsByArea(analyzer, latitud, longitud, radio):
lst = om.valueSet(
analyzer['dateIndex']) #Hacemos una lista con los valores
lstiterator = it.newIterator(lst)
totalaccidentes = 0
week = {}
while (it.hasNext(lstiterator)):
lstdate = it.next(lstiterator)
par = ((lt.getElement(lstdate['lstaccident'],
1))['Start_Time']).split()
fecha = par[0]
size = lt.size(lstdate['lstaccident'])
parcial = 0
dia = findDay(fecha)
for i in range(1, size):
element = lt.getElement(lstdate['lstaccident'], i)
latitude = float(element['Start_Lat'])
lenght = float(element['Start_Lng'])
if inratio(latitude, lenght, latitud, longitud, radio):
parcial += 1
else:
parcial += 0
if dia not in week:
week[dia] = 0
week[dia] += parcial
else:
week[dia] += parcial
totalaccidentes += parcial
return totalaccidentes, week
def printConnectedCountries(analyzer, landingpoint):
"""
Imprime los países conectados a un punto de conexión específico
en orden descendente por distancia en km
"""
ordmap = controller.getConnectedCountries(analyzer, landingpoint)
lstcountries = lt.newList('ARRAY_LIST')
keys = om.keySet(ordmap)
values = om.valueSet(ordmap)
size = om.size(ordmap)
index = 1
count = 1
print("\n---------- Países afectados ----------")
while index <= size:
country = lt.getElement(values, index)
distance = lt.getElement(keys, index)
if not lt.isPresent(lstcountries, country):
print(
str(count) + ". " + str(country) + " Distancia: " +
str(distance) + " km")
lt.addLast(lstcountries, country)
index += 1
count += 1
else:
index += 1
print()
print("Total países afectados: " + str(lt.size(lstcountries)) + "\n")
def printMusicapara(respuesta, c1, c2):
print("\nTotal de pistas únicas: " + str(respuesta[0]))
print("\n... Unique track id ...\n")
cont = 0
lst = om.valueSet(respuesta[1])
cod = om.keySet(respuesta[1])
if lt.size(cod) >= 5:
for id in lt.iterator(cod):
datos = om.get(respuesta[1],id)
valor = datos["value"]
cont += 1
print("Track: "+ str(id) + " with " + str(c1) + " of " + str(valor[0]) +
" and " + str(c2) + " of " + str(valor[1]) + "\n")
if cont > 4:
return
else:
for id in lt.iterator(cod):
for pista in lt.iterator(lst):
while cont <= lt.size(lst):
cont += 1
print("Track: "+ str(id) + " with " + str(c1) + " of " + str(pista[0]) +
" and " + str(c2) + " of " + str(pista[1]) + "\n")
def addEventosRBT2(MusicRecomender, catalog2, Requerimiento, tipoCaraCont,
limInf, limSup):
MusicRecomender['Artists'] = m.newMap(numelements=5000,
maptype='CHAINING',
loadfactor=4.0,
comparefunction=compareArtist)
MusicRecomender['Caracs'] = om.newMap(omaptype='RBT',
comparefunction=compareValues)
for elemento in lt.iterator(om.valueSet(catalog2['Caracs'])):
for EventoEscucha in lt.iterator(elemento["lstEvent"]):
updateCaracIndex(MusicRecomender, EventoEscucha, tipoCaraCont,
Requerimiento, limInf, limSup)
return MusicRecomender
def numerotracksestudiar(catalogo, mininstrum, maxinstrum, mintempo, maxtempo):
numerotracks = 0
listracks = lt.newList("ARRAY_LIST")
data = om.valueSet(catalogo["datoscanciones"])
trackmap = mp.newMap(1000000, maptype="PROBING")
for x in range(data["size"]):
y = lt.getElement(data, x)
if not mp.contains(trackmap, y["track_id"]):
if (mininstrum <= float(y["instrumentalness"]) <= maxinstrum) and (
mintempo <= float(y["tempo"]) <= maxtempo):
lt.addLast(listracks, y)
numerotracks += 1
mp.put(trackmap, y["track_id"], None)
return numerotracks, listracks
def numerotracksenergydance(catalogo, minenergy, maxenergy, mindance,
maxdance):
numerotracks = 0
listracks = lt.newList("ARRAY_LIST")
data = om.valueSet(catalogo["datoscanciones"])
trackmap = mp.newMap(1000000, maptype="PROBING")
for x in range(data["size"]):
y = lt.getElement(data, x)
if not mp.contains(trackmap, y["track_id"]):
if (minenergy <= float(y["energy"]) <= maxenergy) and (
mindance <= float(y["danceability"]) <= maxdance):
lt.addLast(listracks, y)
numerotracks += 1
mp.put(trackmap, y["track_id"], None)
return numerotracks, listracks
def addSameOrigin_directed(analyzer):
info = om.valueSet(analyzer['landing_points'])
for i in range(lt.size(info)):
diccionario = lt.getElement(info, i)
lista_cables = diccionario['cables']
for i in range(lt.size(lista_cables)):
verticeA = lt.getElement(lista_cables, i)
cont = 0
j = 1
while j + cont <= lt.size(lista_cables):
verticeB = lt.getElement(lista_cables, j + cont)
if verticeA != verticeB:
gr.addEdge(analyzer['connections_directed'], verticeA,
verticeB, 100)
cont += 1
def getAccidentsGeographicalArea (analyzer,LatC,LongC,radio):
dayAccidents={}
info=om.valueSet(analyzer['dateIndex'])
for j in range(1,lt.size(info)+1):
it1=lt.getElement(info,j)
for i in range(1,lt.size(it1)+1):
it2=lt.getElement(it1,i)
Lat=it2['Start_Lat']
Long=it2['Start_Lng']
date=it2['Start_Time'][:10]
distance=getDistanceBetweenCenterAndPoint(LatC,LongC,Lat,Long)
if distance<=radio:
day=dayOfTheWeek(date)
if day in dayAccidents:
dayAccidents[day]+=1
else:
dayAccidents[day]=1
return dayAccidents
def getGenreList(tempoMap, analyzer):
"""
Tiene como return una lista con todos los generos repetidos
"""
values = om.valueSet(tempoMap)
genre_intervals = analyzer["genre_intervals"]
genre_intervals_keys = mp.keySet(analyzer["genre_intervals"])
genres = lt.newList(datastructure='ARRAY_LIST')
for values in lt.iterator(values):
for track in lt.iterator(values):
for genre in lt.iterator(genre_intervals_keys):
entryGenre = mp.get(genre_intervals, genre)
value = me.getValue(entryGenre)
if float(track["tempo"]) > value[0] and float(
track["tempo"]) < value[1]:
lt.addLast(genres, genre)
total = lt.size(genres)
return genres, total
def caracterizar(caracteristica,valor_minimo,valor_maximo,mapa):
lst = om.valueSet(mapa["context"]) #saca todos los valores de context en una lista
p=0 # centinela para recorrer lst
canciones=0 #centinela para saber el numero de canciones que cumplen los requisitos
artistas = lt.newList(datastructure='SINGLE_LINKED')
llaves = ["instrumentalness","liveness","speechiness","danceability","valence","loudness","tempo","acousticness","energy","mode","key","artist_id","tweet_lang","track_id","created_at","lang","time_zone","user_id","id"] #lista sobre las caracteristicas posibles
while p < lt.size(lst): #recorrecomos los diccionarios dentro de lst
x=lt.getElement(lst,p) #contiene un diccionario
if caracteristica in llaves: #verifica si la llave que introducimos es valida
if (x[caracteristica] <= valor_maximo) and (x[caracteristica] >= valor_minimo): #verifica si cumplen con las condiciones
canciones+=1 #si cumple con las condiaciones sube la cantidad de canciones
if lt.isNotPresent(artistas,x["artist_id"]):
lt.addLast(artistas,x["artist_id"]) #en caso de que el id del artista no este en la lista lo agrega
else: #en caso de que no sea valida muestra este mensaje
print("no incluyo una caracteristica valida")
break
p+=1
return (lt.size(artistas),canciones)
def fallasLP(catalog, lp):
mpRespuesta = model.fallasLP(catalog, lp)
lista_tuplas_paises = mp.valueSet(mpRespuesta)
rbt = om.newMap(omaptype='RBT', comparefunction=model.CompareIntegersOM)
for tupla in lt.iterator(lista_tuplas_paises):
if om.contains(rbt, tupla[1]):
lista = me.getValue(om.get(rbt, tupla[1]))
lt.addLast(lista, tupla)
else:
lista = lt.newList(datastructure='ARRAY_LIST')
lt.addLast(lista, tupla)
om.put(rbt, tupla[1], lista)
lista_listas_tuplas = om.valueSet(rbt)
listaRespuesta = lt.newList(datastructure='ARRAY_LIST')
for lista_tuplas in lt.iterator(lista_listas_tuplas):
for tupla in lt.iterator(lista_tuplas):
lt.addLast(listaRespuesta, tupla)
return listaRespuesta, lt.size(listaRespuesta)
def test_valueSet(tree):
tree = omap.put(tree, 23, 'book21')
tree = omap.put(tree, 7, 'book7')
tree = omap.put(tree, 30, 'book30')
tree = omap.put(tree, 5, 'book5')
tree = omap.put(tree, 4, 'book4')
tree = omap.put(tree, 3, 'book3')
tree = omap.put(tree, 20, 'book20')
tree = omap.put(tree, 25, 'book25')
tree = omap.put(tree, 35, 'book35')
tree = omap.put(tree, 29, 'book29')
tree = omap.put(tree, 11, 'book11')
tree = omap.put(tree, 15, 'book15')
tree = omap.put(tree, 10, 'book10')
tree = omap.put(tree, 37, 'book11')
tree = omap.put(tree, 40, 'book15')
tree = omap.put(tree, 45, 'book10')
assert omap.size(tree) == 16
lst = omap.valueSet(tree)
assert lt.size(lst) == 16
assert lt.isPresent(lst, 'book20') > 0
def recomendadorPorAños(citibike, edad1, edad2):
"""
Recomendador de rutas por rango de edad
req 5
"""
year = citibike['components']
valueList = om.valueSet(year)
keyList = om.keySet(year)
lista = lt.newList(datastructure='ARRAY_LIST')
resultado = lt.newList(datastructure='ARRAY_LIST')
for i in range(om.size(year)):
value = lt.getElement(valueList, i) #Value -> Año
key = lt.getElement(keyList, i)
lt.addLast(lista, (key, value))
for i in lista['elements']:
valores = int(i[1])
today = date.today() #Fecha Actual
anioActual = today.year #Año Actual
anio = anioActual - valores #Diferencia de años -> años
if anio in range(edad1, edad2 + 1):
lt.addLast(resultado, i)
return resultado['elements']
def getTimeSeverity (timeLo, timeHi, dataBase):
severityMap = newSeverity()
index = om.valueSet(dataBase['dateIndex'])
total = 0
entry1 = lt.size(index)
while entry1 > 0:
entry1 -= 1
dateEntry = lt.removeFirst(index)
dateKeys = m.keySet(dateEntry['severityIndex'])
entry2 = lt.size(dateKeys)
while entry2 > 0:
entry2 -= 1
severityKey = lt.removeFirst(dateKeys)
severityEntry = m.get(dateEntry['severityIndex'],severityKey)
severityEntry = me.getValue(severityEntry)
severityEntry = om.values(severityEntry['timeIndex'],timeLo,timeHi)
entry3 = lt.size(severityEntry)
while entry3 > 0:
entry3 -= 1
timeEntry = lt.removeFirst(severityEntry)
timeEntry = timeEntry['size']
total += timeEntry
resultVal = m.contains(severityMap['severityIndex'],severityKey)
if resultVal:
preValue = m.get(severityMap['severityIndex'],severityKey)
preValue = me.getValue(preValue)
m.put(severityMap['severityIndex'],severityKey, preValue + timeEntry)
else:
m.put(severityMap['severityIndex'],severityKey,timeEntry)
severityMap['size'] = total
return severityMap
def lpInterconexion(catalog):
rbt = model.lpInterconexion(catalog)
lista_listas_LandingPoints = om.valueSet(rbt)
cola_retornar = qu.newQueue()
total_cables_resultado = mp.newMap(loadfactor=4.0)
contador = 0
for lista in lt.iterator(lista_listas_LandingPoints):
for tupla_lp_listavertices in lt.iterator(lista):
if contador > 9:
break
else:
lista_vertices = tupla_lp_listavertices[1]
for vertice in lt.iterator(lista_vertices):
# cable = vertice.split('-')[2]
mp.put(total_cables_resultado, vertice, vertice)
qu.enqueue(cola_retornar, tupla_lp_listavertices)
contador = contador + 1
total_cables_resultado = mp.size(total_cables_resultado)
return cola_retornar, total_cables_resultado
def printTopGenres(events):
"""
Imprime el top de géneros por número de reproducciones,
adicionalmente imprime el género con mayor número
de reproducciones
"""
index = 1
map = events[0]
genres = controller.getEventsByGenre(map)
keys = om.keySet(genres)
values = om.valueSet(genres)
print("\n-------- Reproducciones por género --------")
while index <= int(om.size(genres)):
genre = lt.getElement(values, index)
tracks = lt.getElement(keys, index)
print("Top " + str(index) + ": " + str(genre[0]) + " con " +
str(tracks) + " reproducciones")
index += 1
print()
print("Top género: " + str(lt.getElement(values, 1)[0]) + " con " +
str(lt.getElement(keys, 1)) + " reproducciones")
print()
def musica_festejar(valor_min_energy,valor_max_energy,valor_min_Danceability,valor_max_Danceability,mapa):
lst = om.valueSet(mapa["context"]) #saca todos los valores de context en una lista
p=0 # centinela para recorrer lst
tracks = 0 #centinela para saber el numero de canciones unicas que cumplen con las condiciones
tracklst = [] #lista para saber la cantidad de canciones unicas
id_list = [] # lista de id track
entregar_id = [] #almacena los datos para entregarlos como lista al final
while p < lt.size(lst): #recorrecomos los diccionarios dentro de lst
x=lt.getElement(lst,p) #contiene un diccionaio
if (float(x["danceability"]) >= valor_min_Danceability ) and (float(x["danceability"]) <= valor_max_Danceability) :
if ( float(x["energy"]) >= valor_min_energy) and (float(x["energy"]) <= valor_max_energy): #comprueba si cumple con las condiciones
if x["track_id"] not in tracklst:
tracklst.append(x["track_id"])
tracks +=1
agregar = []
agregar.append(x["danceability"])
agregar.append(x["energy"])
agregar.append(x["track_id"])
id_list.append(agregar)
p+=1
#selecciona 5 canciones al azar entre todas las canciones que cumplen con el requisito
cancion1 = random.choice(id_list)
id_list.remove(cancion1)
entregar_id.append(cancion1)
cancion2 = random.choice(id_list)
id_list.remove(cancion2)
entregar_id.append(cancion2)
cancion3 = random.choice(id_list)
id_list.remove(cancion3)
entregar_id.append(cancion3)
cancion4 = random.choice(id_list)
id_list.remove(cancion4)
entregar_id.append(cancion4)
cancion5 = random.choice(id_list)
id_list.remove(cancion5)
entregar_id.append(cancion5)
return (entregar_id,tracks)
def actulizarRuta(analyzer):
lstValores = om.valueSet(analyzer['hora'])
itera = it.newIterator(lstValores)
while (it.hasNext(itera)):
valor = it.next(itera)
lstValor = valor['lstRutas']
itera2 = it.newIterator(lstValor)
while (it.hasNext(itera2)):
val = it.next(
itera2) #{'idRuta': None, 'lstTiempo': None, 'promedio': None}
#obtener promedio de lstTiempo
promedio = 0
itera3 = it.newIterator(val['lstTiempo'])
while (it.hasNext(itera3)):
tiempo = it.next(itera3)
promedio = promedio + tiempo
val['promedio'] = promedio / lt.size(val['lstTiempo'])
return analyzer
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
def valueset(tree):
return om.valueSet(tree)
def C(analyzer):
resto=om.valueSet(analyzer["indice"])
compañias=lt.newList()
for pedaso in resto:
lt.addLast(compañias,pedaso["company"])
return (int(lt.size(compañias))+1)
def req_5_v_2(analyzer, start_time, end_time):
keys = om.valueSet(analyzer['sentiment_values'])
list_of_maps = om.values(analyzer['hash_generos'], start_time, end_time)
registropy = mp.newMap(numelements=65, maptype='PROBING', loadfactor=0.3)
for hash_table in lt.iterator(list_of_maps):
keyset = mp.keySet(hash_table['mapContent'])
for key in lt.iterator(keyset):
entry = mp.get(hash_table['mapContent'], key)
videos_list = me.getValue(entry)
size = lt.size(videos_list['lstContent'])
lamborghini = mp.get(registropy, key)
if lamborghini is not None:
lamborghini = me.getValue(lamborghini)
lamborghini += size
mp.put(registropy, key, lamborghini)
elif lamborghini is None:
mp.put(registropy, key, size)
totalreps = 0
genres = mp.keySet(registropy)
mayor = ''
repsmax = 0
repstemp = 0
for genre in lt.iterator(genres):
repstemp = me.getValue(mp.get(registropy, genre))
if repstemp > repsmax:
repsmax = repstemp
mayor = genre
if 'unique' not in genre:
totalreps += repstemp
print('There is a total of ' + str(totalreps) + ' reproductions between ' +
start_time + ' and ' + end_time)
print(
'================================ GENRES SORTED REPRODUCTIONS ================================'
)
print('Metal unique: ' +
str(me.getValue(mp.get(registropy, 'Metal_unique'))))
print('Metal: ' + str(me.getValue(mp.get(registropy, 'Metal'))))
print('Reggae: ' + str(me.getValue(mp.get(registropy, 'Reggae'))))
print('Down-tempo: ' + str(me.getValue(mp.get(registropy, 'Down-tempo'))))
print('Chill-out: ' + str(me.getValue(mp.get(registropy, 'Chill-out'))))
print('Hip-hop: ' + str(me.getValue(mp.get(registropy, 'Hip-hop'))))
print('Pop: ' + str(me.getValue(mp.get(registropy, 'Pop'))))
print('R&B: ' + str(me.getValue(mp.get(registropy, 'R&B'))))
print('Rock: ' + str(me.getValue(mp.get(registropy, 'Rock'))))
print('Jazz and Funk: ' +
str(me.getValue(mp.get(registropy, 'Jazz and Funk'))))
all_videos = hp.newHeap(heap_compare)
for hash_table in lt.iterator(list_of_maps):
keyset = mp.keySet(hash_table['mapContent'])
for key in lt.iterator(keyset):
if key == mayor:
entry = mp.get(hash_table['mapContent'], key)
videos_list = me.getValue(entry)
for video in lt.iterator(videos_list['lstContent']):
hp.insert(all_videos, video)
print('The TOP GENRE is ' + mayor + ' with ' + str(repsmax) +
' reproductions...')
print(mayor + 'SENTIMENT ANALYSIS')
if mayor == 'Metal':
print('Metal has ' +
str(me.getValue(mp.get(registropy, 'Metal_unique'))) +
' unique tracks...')
for i in range(1, 11):
video = hp.delMin(all_videos)
vader_avg = 0
count = 0
for hashtag in lt.iterator(video['hashtag']):
entry = om.get(analyzer['sentiment_values'], hashtag)
if entry is not None:
value = me.getValue(entry)
lst = value['lstContent']['elements'][0]['vader_avg']
if lst != '':
vader_avg += float(lst)
count += 1
if count > 0:
vader_avg /= count
else:
vader_avg = 0
print('TOP ' + str(i) + ' track: ' + video['track_id'] + ' with ' +
str(lt.size(video['hashtag'])) + ' and VADER = ' +
str(vader_avg))
