def weightConnection(catalog, origin, destination): """ Se obtiene el peso entre 2 landing_point """ # Obtener la tabla de origin tabla_origin_Entry = mp.get(catalog['map_landing_points'], origin) tabla_origin = me.getValue(tabla_origin_Entry) # Obtener la tabla de destination tabla_destination_Entry = mp.get(catalog['map_landing_points'], destination) tabla_destination = me.getValue(tabla_destination_Entry) # Obtener el elemento de origin values_origin_list = mp.valueSet(tabla_origin) # Obtener el elemento de destination values_destination_list = mp.valueSet(tabla_destination) # Iterar sobra values origin values_origin_iterator = it.newIterator(values_origin_list) element_origin = it.next(values_origin_iterator) # Iterar sobra values destination values_destination_iterator = it.newIterator(values_destination_list) element_destination = it.next(values_destination_iterator) # Obtener la altitud y longitud de origin altitud_origin = element_origin['latitude'] longitud_origin = element_origin['longitude'] # Obtener la altitud y longitud de destination altitud_destination = element_destination['latitude'] longitud_destination = element_destination['longitude'] weight = haversine(float(altitud_origin), float(longitud_origin), float(altitud_destination), float(longitud_destination)) return weight
def parteA_consulta(inicial, rankingM, rankingN): orden_compañias = m.valueSet(inicial["compañias"]) compañias_servicios_ordenados = m.valueSet(inicial["compañias"]) mergesort.mergesort(orden_compañias, comparador_de_taxis) mergesort.mergesort(compañias_servicios_ordenados, comparador_de_servicios) numero_compañias = m.size(inicial["compañias"]) topM = lt.newList("ARRAY_LIST") topN = lt.newList("ARRAY_LIST") cuantas_tengoM = 1 while cuantas_tengoM <= rankingM: elemento_agregar = lt.getElement(orden_compañias, cuantas_tengoM) lt.addLast(topM, elemento_agregar) cuantas_tengoM += 1 cuantas_tengoN = 1 while cuantas_tengoN <= rankingN: elemento_agregar = lt.getElement(compañias_servicios_ordenados, cuantas_tengoN) lt.addLast(topN, elemento_agregar) cuantas_tengoN += 1 return (topM, topN, numero_compañias, len(inicial["taxis"]))
def consulta2(Inite, fecha_ini, fecha_fin, top2): fecha_fin = transformador_fecha(fecha_fin) fecha_ini = transformador_fecha(fecha_ini) datos_entre_medio = om.values(Inite["mapa_fecha"], fecha_ini, fecha_fin) mapa_intermedio = m.newMap(maptype="PROBING", comparefunction=compareStationsv2) for i in range(1, lt.size(datos_entre_medio) + 1): lista = lt.getElement(datos_entre_medio, i) lista = m.valueSet(lista) for e in range(1, lt.size(lista) + 1): elemento = lt.getElement(lista, e) existe = m.get(mapa_intermedio, elemento["taxi"]) if existe is None: m.put(mapa_intermedio, elemento["taxi"], elemento) else: nodo_new = incrementalV3(me.getValue(existe), elemento) m.put(mapa_intermedio, nodo_new["taxi"], nodo_new) top_2 = lt.newList("ARRAY_LIST") mapa_intermedio_ordenado = m.valueSet(mapa_intermedio) mergesort.mergesort(mapa_intermedio_ordenado, comparador_ascendente) # SHELLSORT for i in range(1, lt.size(mapa_intermedio_ordenado) + 1): elemento = lt.getElement(mapa_intermedio_ordenado, i) lt.addLast(top_2, elemento) if i == top2: break return top_2
def updateHour_Tree(catalog, event): Hour = timeStrip(event) entry = om.get(catalog['hourTree'], Hour) if entry is None: hourEntry = mp.newMap(numelements=9, maptype='PROBING') for genre in lt.iterator(mp.valueSet(catalog['genres'])): if float(event['tempo']) >= genre['min_tempo'] and float( event['tempo']) <= genre['max_tempo']: eventsInGenre = lt.newList(datastructure='ARRAY_LIST') lt.addLast(eventsInGenre, event) mp.put(hourEntry, genre['name'], eventsInGenre) om.put(catalog['hourTree'], Hour, hourEntry) else: hourEntry = me.getValue(entry) #mete el event al mapa for genre in lt.iterator(mp.valueSet(catalog['genres'])): if float(event['tempo']) >= genre['min_tempo'] and float( event['tempo']) <= genre['max_tempo']: parejaEventsInGenre = mp.get(hourEntry, genre['name']) if (parejaEventsInGenre is None): eventsInGenre = lt.newList(datastructure='ARRAY_LIST') lt.addLast(eventsInGenre, event) mp.put(hourEntry, genre['name'], eventsInGenre) else: eventsInGenre = me.getValue(parejaEventsInGenre) lt.addLast(eventsInGenre, event)
def req1_return(Inite, ranking1, ranking2): companies_orden = m.valueSet(Inite["mapa_companies"]) services_orden = m.valueSet(Inite["mapa_companies"]) mergesort.mergesort(services_orden, comparador_ascendente_services) # SHELLSORT mergesort.mergesort(companies_orden, comparador_ascendente_taxis) # SHELLSORT cantidad_compañias_taxi = m.size(Inite["mapa_companies"]) top1 = lt.newList("ARRAY_LIST") top2 = lt.newList("ARRAY_LIST") for i in range(1, lt.size(companies_orden) + 1): elemento = lt.getElement(companies_orden, i) lt.addLast(top1, elemento) if i == ranking1: break for i in range(1, lt.size(services_orden) + 1): elemento = lt.getElement(services_orden, i) lt.addLast(top2, elemento) if i == ranking2: break return { "ranking1": top1, "ranking2": top2, "compañias taxi": cantidad_compañias_taxi, "total taxis": len(Inite["Taxis sin repetir"]), }
def getMinimumSpaningTree(analyzer): mst = prim.PrimMST(analyzer['connections']) distance = 0 numberOfElements = lt.size(mp.valueSet(mst['marked'])) for element in lt.iterator(mp.valueSet(mst['distTo'])): distance = distance + float(element) print ('La cantidad de elementos es: ' + str(numberOfElements) + ' la distancia total es ' + str(distance)) return mst
def __init__(self, catalog): super_list = mp.valueSet(catalog.videos) self.super_iter = lliterator.newIterator(super_list) country_map = lliterator.next(self.super_iter) country_list = mp.valueSet(country_map) self.country_iter = lliterator.newIterator(country_list) self.category_iter = aliterator.newIterator( lliterator.next(self.country_iter))
def sacar_info(analyzer): vertices = gr.numVertices(analyzer['Arcos']) arcos = gr.numEdges(analyzer['Arcos']) paises = mp.keySet(analyzer["paises_nombre"]) Num_paises = lt.size(paises) landings = mp.valueSet(analyzer['landing_points']) landing = lt.firstElement(landings) ciudades = mp.valueSet(analyzer['countries']) ciudad = lt.lastElement(ciudades) poblacion = ciudad["Population"] usuarios = ciudad["Internet users"] return vertices, arcos, Num_paises, landing, poblacion, usuarios
def videosLikesTags(catalogo, numero, tag, pais): catalog2 = mp.newMap(40, maptype="PROBING") vids = mp.valueSet(catalogo["videos"]) for i in range(mp.valueSet(catalogo["videos"])["size"]): video = lt.getElement(vids, i) if (tag in video["tags"]) and (pais == video["country"]): mp.put( catalog2, str(video["video_id"]) + str(video["trending_date"]) + str(video["country"]), video) if mp.valueSet(catalog2)["size"] < numero: print("Excede el tamaño de la lista, ingrese un valor válido") else: lista_ord = ms.sort(mp.valueSet(catalog2), cmpVideosByLikes) return lista_ord
def videospaiscategoría(numero, pais, categoria, catalogo): category = sacaridcategoria(catalogo, categoria) mapacondiciones = mp.newMap(40, maptype="PROBING") videos = mp.valueSet(catalogo["videos"]) for x in range(mp.valueSet(catalogo["videos"])["size"]): video = lt.getElement(videos, x) if (video["country"] == pais) and (int(video["category_id"]) == int(category)): mp.put( mapacondiciones, str(video["video_id"]) + str(video["trending_date"]) + str(video["country"]), video) sorteado = ms.sort(mp.valueSet(mapacondiciones), cmpVideosByViews) listavideos = lt.subList(sorteado, 1, int(numero)) return listavideos
def analisis_por_hora(catalog, tmin, tmax): mindate = datetime.datetime.strptime(tmin, '%H:%M:%S') maxdate = datetime.datetime.strptime(tmax, '%H:%M:%S') mintime = mindate.time() maxtime = maxdate.time() map_hora = mp.get(catalog['index_caracteristica'], 'created_at') arbol_hora = me.getValue(map_hora) eventos_rango = om.values(arbol_hora, mintime, maxtime) total_rep = lt.size(eventos_rango) arbol = llenar_mapa_tempo(eventos_rango) genero_mas = None genero_nombre = None tamaño_genero = 0 lista_generos = lt.newList(datastructure='ARRAY_LIST') for genero in lt.iterator(mp.keySet(catalog['genero-rango'])): rango = cambiar_genero_rango(catalog, genero) valores_rango = om.values(arbol, float(rango[0]), float(rango[1])) total = lt.size(valores_rango) tupla = (genero, valores_rango, total) lt.addLast(lista_generos, tupla) ordenada_por_genero = sa.sort(lista_generos, cmpgeneros) genero_mas = lt.getElement(ordenada_por_genero, 1) promedio = promedio_vader(catalog, genero_mas[1]) lista_unica = mp.valueSet(pistas_unicas(promedio)) ordenada_hashtag = sa.sort(lista_unica, cmphashtags) return (ordenada_por_genero, genero_mas, promedio, ordenada_hashtag, total_rep)
def getHashtagsByTime(analyzer, initialValue, finalValue): """ Crea un mapa que tiene como llaves el valor 'created_at' de los hashtags """ values = mp.valueSet(analyzer["hashtags"]) mapHash = om.newMap('RBT') for value in lt.iterator(values): date = value['created_at'] time = datetime.datetime.strptime(date, '%Y-%m-%d %H:%M:%S').time() hashEntry = om.get(mapHash, time) if hashEntry is None: hashEntry = newDataEntry(value) om.put(mapHash, time, hashEntry) else: hashEntry = me.getValue(hashEntry) lt.addLast(hashEntry, value) maps = mp.newMap(maptype='PROBING') times = om.values(mapHash, initialValue, finalValue) for tracks in lt.iterator(times): for uTrack in lt.iterator(tracks): entry = mp.get(maps, uTrack['track_id']) if entry is None: entry = newDataEntry(uTrack) mp.put(maps, uTrack['track_id'], entry) else: entry = me.getValue(entry) lt.addLast(entry, uTrack['hashtag'].lower()) return maps
def __init__(self, catalog, category): self.category = category super_list = mp.valueSet(catalog.videos) self.super_iter = lliterator.newIterator(super_list) country_map = lliterator.next(self.super_iter) category_list = mp.get(country_map, category)['value'] self.category_iter = aliterator.newIterator(category_list)
def musicaFestejar(analyzer, energyMin, energyMax, danceabilityMin, danceabilityMax): """ Requerimiento 2: Encontrar musica para festejar """ entry = mp.get(analyzer['content'], 'energy') arbolEnergy = me.getValue(entry) valoresEnergy = om.values(arbolEnergy, energyMin, energyMax) arbolDance = om.newMap(omaptype='RBT', comparefunction=compareValues) for valor in lt.iterator(valoresEnergy): for evento in lt.iterator(valor): dance = float(evento['danceability']) existe = om.get(arbolDance, dance) if existe is None: eventList = lt.newList('ARRAY_LIST', cmpfunction=compareValues) om.put(arbolDance, dance, eventList) else: eventList = me.getValue(existe) lt.addLast(eventList, evento) valoresDance = om.values(arbolDance, danceabilityMin, danceabilityMax) tracks_unicas = mp.newMap(maptype='PROBING') for lista in lt.iterator(valoresDance): for evento in lt.iterator(lista): mp.put(tracks_unicas, evento['track_id'], evento) listaUnicas = mp.valueSet(tracks_unicas) num_tracks = lt.size(listaUnicas) res = [random.randrange(1, num_tracks, 1) for i in range(5)] random_tracks = lt.newList('ARRAY_LIST') for numero in res: chosen_track = lt.getElement(listaUnicas, numero) lt.addLast(random_tracks, chosen_track) return num_tracks, random_tracks
def Requerimiento1(analyzer, landing_point1, landing_point2): """ Retorna ... """ clusters = scc.KosarajuSCC(analyzer['connections']) numClusters = scc.connectedComponents(clusters) mismoCluster = -1 punto1 = None punto2 = None listaPuntos = mp.valueSet(analyzer['landing_points']) for punto in lt.iterator(listaPuntos): nombre = punto['name'].split(", ")[0] if nombre == landing_point1.title(): punto1 = punto['landing_point_id'] if nombre == landing_point2.title(): punto2 = punto['landing_point_id'] if punto1 is not None and punto2 is not None: entry = mp.get(analyzer["points_vertices"], punto1) if entry is not None: lstLP1 = me.getValue(entry) lp1 = lt.firstElement(lstLP1) entry = mp.get(analyzer["points_vertices"], punto2) if entry is not None: lstLP2 = me.getValue(entry) lp2 = lt.firstElement(lstLP2) if lp1 != "" and lp2 != "": mismoCluster = scc.stronglyConnected(clusters, lp1, lp2) return numClusters, mismoCluster
def addCapitals(analyzer, country): capital = country['CapitalName'] + "-" + country['CountryName'] addPoint(analyzer, capital) grado = gr.degree(analyzer['connections'], capital) if grado == 0: info = mp.get(analyzer['countries'], country['CountryName'])['value'] latitud = info['CapitalLatitude'] longitud = info['CapitalLongitude'] listaPoints = mp.valueSet(analyzer["landing_points"]) difMasCercana = 100 for point in lt.iterator(listaPoints): difLat = abs(float(point['latitude']) - float(latitud)) difLon = abs(float(point['longitude']) - float(longitud)) difTot = difLat + difLon if difTot < difMasCercana: difMasCercana = difTot LPmasCercano = point listaVertices = mp.get(analyzer['points_vertices'], LPmasCercano['landing_point_id'])['value'] coordOrigen = (float(latitud), float(longitud)) coordDestino = (float(LPmasCercano["latitude"]), float(LPmasCercano["longitude"])) distancia = round(hs.haversine(coordOrigen, coordDestino), 2) for vertice in lt.iterator(listaVertices): addConnection(analyzer, capital, vertice, distancia) addConnection(analyzer, vertice, capital, distancia)
def topN(theServices,N): valores=[] res={} i=0 n=0 keys= m.keySet(theServices) values=m.valueSet(theServices) itv=it.newIterator(values) itk=it.newIterator(keys) orden=mpq.newMinPQ(comparemaxpq) while it.hasNext(itv): value=it.next(itv) key= it.next(itk) if key!= "Independent Owner": mpq.insert(orden,value[1]) while i<N: valor=mpq.min(orden) valores.append(valor) res[valor]=[] mpq.delMin(orden) i+=1 itval=it.newIterator(values) itke=it.newIterator(keys) while it.hasNext(itval): val=it.next(itval) ke= it.next(itke) if ke!= "Independent Owner": for i in valores: if i==val[1]: if ke not in res[i] and n<N: res[i].append(ke) n+=1 return res
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 Req3(analyzer, limInf1, limSup1, limInf2, limSup2): try: entry = mp.get(analyzer['content'], "instrumentalness") arbolInstr = me.getValue(entry) valoresInstr = om.values(arbolInstr, limInf1, limSup1) arbol_Tempo = om.newMap(omaptype="RBT", comparefunction=compareValues) for lista in lt.iterator(valoresInstr): for evento in lt.iterator(lista): tempo = float(evento["tempo"]) existe = om.get(arbol_Tempo, tempo) if existe is None: eventList = lt.newList("ARRAY_LIST", cmpfunction=compareValues) om.put(arbol_Tempo, evento["tempo"], eventList) else: eventList = me.getValue(existe) lt.addLast(eventList, evento) valoresTempo = om.values(arbol_Tempo, limInf2, limSup2) unique_tracks = mp.newMap(maptype="PROBING") for lista in lt.iterator(valoresTempo): for evento in lt.iterator(lista): mp.put(unique_tracks, evento["track_id"], evento) total_tracks = mp.valueSet(unique_tracks) num_tracks = lt.size(total_tracks) random5Tracks = lt.subList(total_tracks, random.randint(1, num_tracks - 5), 5) return num_tracks, random5Tracks except Exception: return None
def getTrendVidByCountry(catalog, country_name): countries = catalog['countries'] existsCountry = mp.contains(countries, country_name) if existsCountry: entry = mp.get(countries, country_name) videoList = me.getValue(entry) trendVids = mp.newMap(comparefunction=compareVideoName2) for video in lt.iterator(videoList): vidTitle = video['title'] existVid = mp.contains(trendVids, vidTitle) if existVid: entry = mp.get(trendVids, vidTitle) videoUnique = me.getValue(entry) videoUnique['cuenta'] += 1 else: mp.put(trendVids, vidTitle, {"info": video, "cuenta": 1}) trendVidList = mp.valueSet(trendVids) mayorVideo = None cuentaMayor = 0 for video in lt.iterator(trendVidList): cuenta = video["cuenta"] if cuenta > cuentaMayor: mayorVideo = video["info"] cuentaMayor = cuenta return mayorVideo, cuentaMayor return None
def R_4(analyzer, genero, num, min_value, max_value): artist_10 = lt.newList('ARRAY_LIST') unique_artists = mp.newMap(numelements=65, maptype='PROBING', loadfactor=0.3) total_songs, artists, total_artists = 0, 0, 0 if num == 1: total_artists = mp.size(analyzer[genero]) for songs in lt.iterator(mp.valueSet(analyzer[genero])): total_songs += lt.size(songs['lstContent']) artists += 1 if artists <= 10: artist_id = lt.getElement(songs['lstContent'], 1) lt.addLast(artist_10, artist_id['artist_id']) else: lst = om.values(analyzer['generos'], min_value, max_value) for artists_lst in lt.iterator(lst): total_songs += lt.size(artists_lst['lstContent']) artists += 1 for elements in lt.iterator(artists_lst['lstContent']): if mp.get(unique_artists, elements['artist_id']) is None: mp.put(unique_artists, elements['artist_id'], 0) if artists <= 10: artist_id = lt.getElement(artists_lst['lstContent'], 1) lt.addLast(artist_10, artist_id['artist_id']) total_artists = lt.size(unique_artists) return total_artists, total_songs, artist_10
def Requerimiento2(catalog, country): videos = mp.get(catalog['videos_by_country'], country) videos = me.getValue(videos) retorno = mp.newMap(comparefunction=compareMapVideosIds) print(lt.size(videos)) for i in range(1, lt.size(videos)): video = lt.getElement(videos, i) exists = mp.contains(retorno, video['video_id']) if not exists: dic = {} dic['title'] = video['title'] dic['channel_title'] = video['channel_title'] dic['country'] = video['country'].lower() dic['trending_days'] = 1 mp.put(retorno, video['video_id'], dic) else: key_value = mp.get(retorno, video['video_id']) value = me.getValue(key_value) value['trending_days'] += 1 mayor = 0 mayor1 = {} result = mp.valueSet(retorno) for i in range(0, lt.size(result)): video = lt.getElement(result, i) if video['trending_days'] > mayor: mayor = video['trending_days'] mayor1 = video return mayor1
def addPointConnections(analyzer): # Para cada landing point es necesario realizar dos acciones: # 1. Crear arcos entre los vertices correspondientes al landing point, con un peso mínimo # 2. Crear arcos entre los vertices del landing point y el vertice correspondiente a la capital del país for lp in lt.iterator(mp.valueSet(analyzer['landingPoints'])): vertices = lp['vertices'] originIndex = lt.size(vertices) # Se obtiene el vertice de la capital del país country = me.getValue(mp.get(analyzer['countries'], lp['country'])) countryVertex = country['vertex'] # Se calcula la distancia del landing point a la capital, mediante coordenadas origin = (float(lp["latitude"]), float(lp["longitude"])) destination = (float(country['data']["CapitalLatitude"]), float(country['data']["CapitalLongitude"])) haversineLength = round(hs.haversine(origin, destination), 2) # Para cada vertice del landing point, se crean los arcos correspondientes for vertex in lt.iterator(vertices): addEdge(analyzer, vertex, countryVertex, haversineLength) addEdge(analyzer, countryVertex, vertex, haversineLength) # Si el landing point solo tiene un vertice (solo se conecta a un cable) no es necesario crear más arcos if originIndex <= 1: continue # Si el landing point tiene más de un vertice, se crean arcos entre ellos. La distancia se considera mínima for i in range(1, lt.size(vertices)): originVertex = lt.getElement(vertices, originIndex) destinationVertex = lt.getElement(vertices, i) addEdge(analyzer, originVertex, destinationVertex, 0.1) addEdge(analyzer, destinationVertex, originVertex, 0.1) originIndex = i
def consulta_req4(analyzer, list_gen): mapa_final = mp.newMap(numelements=10, maptype='PROBING') entry_2 = mp.get(analyzer['EvByCaracteristics'], 'tempo') arbol_tempo = me.getValue(entry_2) tot_eventos = 0 for gender in list_gen: num_artistas = 0 num_eventos = 0 entry_1 = mp.get(analyzer['Genders'], gender) rango = me.getValue(entry_1) estructuras = om.values(arbol_tempo, rango[0], rango[1]) mapa_trabajo = mp.newMap(numelements=80, maptype='PROBING') for estruc in lt.iterator(estructuras): for track in lt.iterator(mp.valueSet(estruc['mapa_completo'])): num_eventos += 1 artista = track['artist_id'] if mp.contains(mapa_trabajo, artista) == False: mp.put(mapa_trabajo, artista, 1) num_artistas += 1 tot_eventos += num_eventos keys = mp.keySet(mapa_trabajo) top_artistas = lt.subList(keys, 1, 10) info = (num_eventos, num_artistas, top_artistas) mp.put(mapa_final, gender, info) return tot_eventos, mapa_final
def countries_to_landing_point(analyzer, landing_name): #req 5 landing_id = name_to_id(analyzer, landing_name) country_origin = m.get(analyzer['landing_points_info'], landing_id)['value']['country'] lstcables = m.get(analyzer['landing_points_cables'], landing_id)['value'] mapa = m.newMap() for cable in lt.iterator(lstcables): vertex = format_vertex(landing_id, cable) arcos = gr.adjacentEdges(analyzer['connections'], vertex) for arco in lt.iterator(arcos): landing_id2 = arco['vertexB'].split('~')[0] distance = arco['weight'] country = m.get(analyzer['landing_points_info'], landing_id2)['value']['country'] if country == country_origin: distance = 0 entry = (country, distance) if not m.contains(mapa, country): m.put(mapa, country, entry) else: entry2 = m.get(mapa, country)['value'] if distance < entry2[1]: m.put(mapa, country, entry) lista = merge.sort(m.valueSet(mapa), compare_entry_req5) numcountries = lt.size(lista) return numcountries, lista
def estaciones_criticas(analyzer): estaciones = m.valueSet(analyzer["trips_age"]) estaciones_inicio = {} estaciones_final = {} for i in range(lt.size(estaciones)): station = lt.getElement(estaciones, i) estaciones_inicio[station[0][1]] = station[0][0] estaciones_final[station[1][0]] = station[1][1] orden_inicio = sorted(estaciones_inicio, reverse=True) orden_final = sorted(estaciones_final, key=operator.itemgetter(1), reverse=True) if len(orden_inicio) >= 3: llegada_top = orden_inicio[0], orden_inicio[1], orden_inicio[2] else: llegada_top = orden_inicio[0] if len(orden_final) >= 3: salida_top = orden_final[0], orden_final[1], orden_final[2] else: salida_top = orden_final[0] orden_inicio = sorted(estaciones_inicio.items(), key=operator.itemgetter(1)) orden_final = sorted(estaciones_final.items(), key=operator.itemgetter(1)) menos_utilizadas = [] if len(orden_inicio) >= 3 and len(orden_final) >= 3: menos_utilizadas.append(int(orden_inicio[0][1]) + orden_final[0][1]) menos_utilizadas.append(int(orden_inicio[1][1]) + orden_final[1][1]) menos_utilizadas.append(int(orden_final[2][1]) + orden_final[2][1]) else: menos_utilizadas.append( [orden_inicio[0][1] + orden_final[0][1], int(orden_inicio[0][0])]) mayor = max(menos_utilizadas[0]) menos_utilizadas = mayor return llegada_top, salida_top, menos_utilizadas
def videos_a_dias_trending(videos): lst = lt.newList("ARRAY_LIST") listaids = [] todosvideos = mp.valueSet(videos) for i in range(mp.valueSet(videos)["size"]): video = lt.getElement(todosvideos, i) if not video["video_id"] == "#NAME?": if not video["video_id"] in listaids: listaids.append(video["video_id"]) lt.addFirst(lst, {"id": video["video_id"], "apariciones": 1}) else: for y in lst["elements"]: if y["id"] == video["video_id"]: y["apariciones"] += 1 diccionariosorteado = ms.sort(lst, cmpVideosByAppearances) return diccionariosorteado
def reproductionsByCharacteristic(analyzer, option, iValue, fValue): """ Tiene como return el numero de artistas unicos y un map con los artistas como llave """ eventsMap = om.newMap("RBT") values = mp.valueSet(analyzer["artists"]) for value in lt.iterator(values): for track in lt.iterator(value): optionKey = float(track[option]) optionEntry = om.get(eventsMap, optionKey) if optionEntry is None: optionEntry = newDataEntry(track) om.put(eventsMap, optionKey, optionEntry) else: optionEntry = me.getValue(optionEntry) lt.addLast(optionEntry, track) artistMap = mp.newMap(maptype="PROBING") valuesFiltered = om.values(eventsMap, iValue, fValue) sizeEvents = 0 for track in lt.iterator(valuesFiltered): sizeEvents += lt.size(track) for uniqueEvent in lt.iterator(track): artistKey = uniqueEvent["artist_id"] artistEntry = mp.get(artistMap, artistKey) if artistEntry is None: artistEntry = newDataEntry(uniqueEvent) mp.put(artistMap, artistKey, artistEntry) else: artistEntry = me.getValue(artistEntry) lt.addLast(artistEntry, uniqueEvent) return mp.size(artistMap), sizeEvents
def edges(graph): """ Retorna una lista con todos los arcos del grafo graph Args: graph: El grafo sobre el que se ejecuta la operacion Returns: Una lista con los arcos del grafo Raises: Exception """ try: lstmap = map.valueSet(graph['vertices']) itervertex = it.newIterator(lstmap) lstresp = lt.newList('SINGLE_LINKED', e.compareedges) while it.hasNext(itervertex): lstedge = it.next(itervertex) iteredge = it.newIterator(lstedge) while (it.hasNext(iteredge)): edge = it.next(iteredge) if (graph['directed']): lt.addLast(lstresp, edge) elif (not lt.isPresent(lstresp, edge)): lt.addLast(lstresp, edge) return lstresp except Exception as exp: error.reraise(exp, 'ajlist:edges')
def generoMasEscuchadoEnTiempo(catalog, hora_min, hora_max): hora_min = datetime.strptime(hora_min, '%H:%M:%S') hora_max = datetime.strptime(hora_max, '%H:%M:%S') #hay que ver en que formato entran las horas para ver si es necesario transformarlas antes de empezar a ejecutar lista_mapas_reps = om.values(catalog['RepsPor_hora'], hora_min, hora_max) #esto es una lista de tuplas (genero, cantidad_reps_genero) ORDENADA por cantidad_reps_genero generos_ordenados_por_reps = model.Reps_genero_en_horario( catalog, lista_mapas_reps) max_genero = lt.firstElement(generos_ordenados_por_reps)[0] unique_tracks = model.unique_tracks(catalog, max_genero, lista_mapas_reps) model.calculo_vaders_tracks(unique_tracks) unique_tracks = mp.valueSet(unique_tracks) #aqui quedan ordenados los tracks por numero de hashtags model.Ordenar_tracks_por_hashtags(unique_tracks) '''for track in lt.iterator(unique_tracks): if track[0]>4: print(track[0])''' #esto puede borrarse y pasar la informacion de otra forma cantidad_track_max_genero = lt.size(unique_tracks) return generos_ordenados_por_reps, unique_tracks, cantidad_track_max_genero