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))