def addVideoChannel(catalog, video): """ Esta funcion adiciona un video a la lista de videos que fueron publicados en un canal especifico. """ try: channels = catalog['channels'] if (video['channel_title'] == ''): return videochannel = video['channel_title'] existchannel = mp.contains(channels, videochannel) if existchannel: entry = mp.get(channels, videochannel) channel = me.getValue(entry) else: channel = newChannel(videochannel) mp.put(channels, videochannel, channel) lt.addLast(channel['videos'], video) except Exception: return None
def matchTempo(catalog, tempo, genre_reps, track): genre_map = catalog['genre_dictionary'] for genre in lt.iterator(mp.keySet(genre_map)): ranges = me.getValue(mp.get(genre_map, genre)) if ranges['min'] <= float(tempo) <= ranges['max']: g_reps = mp.get(genre_reps, genre) if g_reps is None: reps = 0 # tracks = lt.newList(datastructure='ARRAY_LIST') tracks = mp.newMap() else: reps = me.getValue(g_reps)['reps'] tracks = me.getValue(g_reps)['tracks'] reps += 1 # lt.addLast(tracks, track) mp.put(tracks, track, 1) mp.put(genre_reps, genre, {'reps': reps, 'tracks': tracks}) return catalog
def addDirectors(catalogo, casting): directors = catalogo['directors'] nombre_director = casting['director_name'] existedirector = mp.contains(directors, nombre_director) if existedirector: entrada_director = mp.get( directors, nombre_director ) # devuelve la key , value. Key nombre del director, y el value todo el dic del director el_director = me.getValue( entrada_director) # deb deser retorna le valor else: el_director = newDirector( casting['director_name'] ) #crea un nuevo "valor" para key: nombre director mp.put( directors, nombre_director, el_director ) # mete en el mapa directors, una key con nombre director y valor el_director el_director['cantidad_peliculas'] = int( el_director['cantidad_peliculas']) + 1 lt.addLast(el_director['movies'], casting)
def addBookAuthor(catalog, authorname, book): """ Esta función adiciona un libro a la lista de libros publicados por un autor. Cuando se adiciona el libro se actualiza el promedio de dicho autor """ authors = catalog['authors'] existauthor = mp.contains(authors, authorname) if existauthor: entry = mp.get(authors, authorname) author = me.getValue(entry) else: author = newAuthor(authorname) mp.put(authors, authorname, author) lt.addLast(author['books'], book) authavg = author['average_rating'] bookavg = book['average_rating'] if (authavg == 0.0): author['average_rating'] = float(bookavg) else: author['average_rating'] = (authavg + float(bookavg)) / 2
def relaxingMusic(catalog, min_instrumentalness, max_instrumentalness, min_tempo, max_tempo): instrumentalness_tree = me.getValue( mp.get(catalog['content_cateogries'], 'instrumentalness')) instrumentalness_values = om.values(instrumentalness_tree, min_instrumentalness, max_instrumentalness) unique_tracks = mp.newMap(numelements=5000, maptype='CHAINING', comparefunction=cmpCategories) final_items = lt.newList(datastructure='ARRAY_LIST') for sublist in lt.iterator(instrumentalness_values): for event in lt.iterator(sublist): if checkWithUser(catalog, event): if min_tempo <= float(event['tempo']) <= max_tempo: lt.addLast(final_items, event) mp.put(unique_tracks, event['track_id'], event) tracks = mp.size(unique_tracks) return final_items, tracks
def addCategoriaa(diccio): iterador = it.newIterator(diccio["videos"]) while it.hasNext(iterador): actual = it.next(iterador) actual["category_id"] if mp.contains(diccio["categorias"], actual["category_id"]) == True: par = mp.get(diccio['categorias'], actual["category_id"]) lis = me.getValue(par) lt.addLast(lis, actual) else: lis = lt.newList() mp.put(diccio['categorias'], actual["category_id"], lis) lt.addLast(lis, actual) return diccio
def addDirector(catalog, movie): """ Esta función adiciona una pelicula por su director en el map """ directors = catalog['director'] director_name = movie["director_name"].lower() movie_avg = movie['vote_average'] title = movie["title"] if director_name != "none": existDirector = mp.contains(directors, director_name) if existDirector: entry = mp.get(directors, director_name) director = me.getValue(entry) else: director = newDirector(director_name) mp.put(directors, director_name, director) lt.addLast(director['movies'], title) director_avg = director['vote_average'] if (director_avg == 0.0): director['vote_average'] = float(movie_avg) else: director['vote_average'] = director_avg + float(movie_avg)
def sinMar(analyzer, country, city): info = mp.get(analyzer["countries"], country)["value"] location = (float(info["CapitalLatitude"]), float(info["CapitalLongitude"])) lista3 = mp.keySet(analyzer["vertices"]) lista_final = lt.newList(datastructure="ARRAY_LIST") i = 1 while i <= lt.size(lista3): country = lt.getElement(lista3, i) mapa = mp.get(analyzer["vertices"], country)["value"] lista2 = mp.keySet(mapa) ii = 1 while ii <= lt.size(lista2): lp_name = lt.getElement(lista2, ii) lp = mp.get(mapa, lp_name)["value"] location_lp = mp.get(analyzer["location_dado_id"], lp_name[0])["value"] capacity = float(lp["capacityTBPS"]) distance = hs.haversine(location_lp, location) lt.addLast(lista_final, (lp_name, distance, capacity)) ii += 1 i += 1 lista_sorteada = mrge.sort(lista_final, cmpSinMar) tupla = lt.getElement(lista_sorteada, 1) cost = {"distance": tupla[1], "capacity": float(tupla[2])} edge_identifier = (tupla[0], (city, 0)) mp.put(analyzer["edges"], edge_identifier, cost) gr.addEdge(analyzer["connections_distance"], tupla[0], (city, 0), cost["distance"]) gr.addEdge(analyzer["connections_distance"], (city, 0), tupla[0], cost["distance"]) gr.addEdge(analyzer["connections_capacity"], tupla[0], (city, 0), cost["capacity"]) gr.addEdge(analyzer["connections_capacity"], (city, 0), tupla[0], cost["capacity"])
def addProductionCompany(catalog, movie): """ Esta función adiciona una pelicula por su productora en el map """ ProductionCompanies = catalog['productionCompany'] comp_name = movie["production_companies"].lower() existProd_Comp = mp.contains(ProductionCompanies, comp_name) title = movie["title"] if existProd_Comp: entry = mp.get(ProductionCompanies, comp_name) company = me.getValue(entry) else: company = newProductionCompany(comp_name) mp.put(ProductionCompanies, comp_name, company) lt.addLast(company['movies'], title) comp_avg = company['vote_average'] movie_avg = movie['vote_average'] if (comp_avg == 0.0): company['vote_average'] = float(movie_avg) else: company['vote_average'] = comp_avg + float(movie_avg)
def addConexion(catalog, conexion): point_salida = conexion["origin"] point_llegada = conexion["destination"] vertice_salida = point_salida + "-" + conexion["cable_name"] vertice_llegada = point_llegada + "-" + conexion["cable_name"] #1. Se añade la conexión al grafo de Ancho de banda ancho = conexion["capacityTBPS"] addAncho(catalog, vertice_salida, vertice_llegada, ancho) mapa_info_point1 = me.getValue(mp.get(catalog["points"], point_salida)) latitud1 = me.getValue(mp.get(mapa_info_point1, "latitude")) longitud1 = me.getValue(mp.get(mapa_info_point1, "longitude")) mapa_info_point2 = me.getValue(mp.get(catalog["points"], point_llegada)) latitud2 = me.getValue(mp.get(mapa_info_point2, "latitude")) longitud2 = me.getValue(mp.get(mapa_info_point2, "longitude")) distancia = CalcularPeso(latitud1, longitud1, latitud2, longitud2) #2. Se añade la conexión al grafo normal (de distancia) addDistance(catalog, vertice_salida, vertice_llegada, distancia) #3. Se añaden a la MinPQ asociada a cada Landing_Point addAnchoQueue(catalog, point_salida, ancho) addAnchoQueue(catalog, point_llegada, ancho) #4. Añade el vertice a la lista de vertices del mapa de points mapa_vertices1 = me.getValue(mp.get(mapa_info_point1, "mapa_vertices")) mp.put(mapa_vertices1, vertice_salida, None) mapa_vertices2 = me.getValue(mp.get(mapa_info_point2, "mapa_vertices")) mp.put(mapa_vertices2, vertice_llegada, None) #5. Añade los vértices al mapa de vértices para un cable dado dentro del mapa de cables addCable(catalog, conexion["cable_name"], vertice_salida, vertice_llegada) #6. Añade los vértices al mapa de vértices dado un país pais1 = me.getValue(mp.get(mapa_info_point1, "country")) addVertexToCountries(catalog, pais1, vertice_salida) pais2 = me.getValue(mp.get(mapa_info_point2, "country")) addVertexToCountries(catalog, pais2, vertice_llegada)
def addVideoCountry(catalog, video): """ Esta funcion adiciona un video a la lista de videos que fueron publicados en un país especifico. """ try: countries = catalog['countries'] if (video['country'] == ''): return videocountry = video['country'] existcountry = mp.contains(countries, videocountry) if existcountry: entry = mp.get(countries, videocountry) country = me.getValue(entry) else: country = newCountry(videocountry) mp.put(countries, videocountry, country) lt.addLast(country['videos'], video) except Exception: return None
def addCountryCategorySorted(catalog, videoname): category_id = videoname["category_id"] category = (mp.get(catalog["categories"], category_id))["value"]["category_name"] country = videoname["country"] if mp.contains(catalog["country_category_sorted"], country + "/" + category): list_exists = mp.get(catalog["country_category_sorted"], country + "/" + category)["value"] lt.addLast(list_exists, videoname) mp.put(catalog["country_category_sorted"], country + "/" + category, list_exists) else: mp.put(catalog["country_category_sorted"], country + "/" + category, lt.newList("ARRAY_LIST")) new_list = mp.get(catalog["country_category_sorted"], country + "/" + category)["value"] lt.addLast(new_list, videoname)
def newDataEntry(catalogo,track,caracteristica): entrada = mp.newMap(numelements=10,maptype='PROBING',loadfactor=0.5) for caracteristica in catalogo: if caracteristica!='tracks': mp.put(entrada,caracteristica,track[caracteristica]) mp.put(entrada,'track_id',track['track_id']) mp.put(entrada,'user_id',track['user_id']) return entrada
def req4(catalog, listaGeneros): numEventos = 0 datos = lt.newList(datastructure= "SINGLE_LINKED") for genero in listaGeneros: numEventosGenero = 0 artistas = mp.newMap(maptype= "CHAINING") entry = mp.get(catalog["generos-intervalos"], genero) nombre = me.getKey(entry) intervalo = me.getValue(entry) llaves = om.keys(catalog["tempo"], intervalo[0], intervalo[1]) for llave in lt.iterator(llaves): entry = om.get(catalog["tempo"], llave) tracks = me.getValue(entry) for referencia in lt.iterator(tracks): track = lt.getElement(catalog["lista_canciones"], referencia) numEventos += 1 numEventosGenero += 1 mp.put(artistas, track["artist_id"], None) sizeArtistas = mp.size(artistas) top10 = lt.subList(mp.keySet(artistas), 1, 10) lt.addLast(datos, (nombre, numEventosGenero, sizeArtistas, top10)) return (numEventos, datos)
def getFirstVideoByTrendDays(catalog): """ Retorna el video con mayor número de trending days """ videoidsmap = mp.newMap(200000, maptype='CHAINING', loadfactor=4.0, comparefunction=compareMapVideosids) try: for video in lt.iterator(catalog): videoid = video['video_id'] existvideoid = mp.contains(videoidsmap, videoid) if existvideoid: entry = mp.get(videoidsmap, videoid) id = me.getValue(entry) else: id = newVideoid(videoid) mp.put(videoidsmap, videoid, id) lt.addLast(id['videos'], video) id['trendingdays'] = lt.size(id['videos']) except Exception: return None mp.remove(videoidsmap, '#NAME?') videoids = mp.keySet(videoidsmap) try: maxTrendDays = 0 firstVideo = None for videoid in lt.iterator(videoids): entry = mp.get(videoidsmap, videoid) trendDays = me.getValue(entry)['trendingdays'] if trendDays > maxTrendDays: maxTrendDays = trendDays firstVideo = entry return firstVideo except Exception: return None
def DepthFirstSearch2(graph, source, components): """ Genera un recorrido DFS sobre el grafo graph Args: graph: El grafo a recorrer source: Vertice de inicio del recorrido. Returns: Una estructura para determinar los vertices conectados a source Raises: Exception """ try: search = { 'source': source, 'visited': None, } search['visited'] = map.newMap( numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) path = stk.newStack() cycles = [[]] weights = [0] map.put(search['visited'], source, {'marked': True, 'edgeTo': None}) dfs_extra(search, graph, source, components, path, cycles, weights) cycles.pop() weights.pop() for i in range(len(weights)): weights[i] return (cycles, weights) except Exception as exp: error.reraise(exp, 'dfs:DFS')
def addLandConnection(analyzer, connection): """ Adiciona los vértices al grafo con el formato: código*nombre_del_cable Añade conexiones entre los vértices tomando como peso la distancia entre los 2 puntos calculada con la función de haversine Guarda los vértices con el mismo código inicial en el mapa relatedVertex """ congr = analyzer['connections'] #connections graph = congr rela = analyzer['relatedVertex'] points = analyzer['points'] try: origin = connection['origin'] oriPoint = me.getValue(m.get(points, origin)) verOrigin = formatVertex(connection, 'origin') addVertex(congr, verOrigin) destination = connection['destination'] destPoint = me.getValue(m.get(points, destination)) verDest = formatVertex(connection, 'destination') addVertex(congr, verDest) distance = haversine(oriPoint, destPoint) addConnection(congr, verOrigin, verDest, distance) esta = m.get(rela, origin) if esta is not None: lista = me.getValue(esta) if lt.isPresent(lista, verOrigin) == False: lt.addLast(lista, verOrigin) else: listaVertex = lt.newList(datastructure='ARRAY_LIST') lt.addLast(listaVertex, verOrigin) m.put(rela, origin, listaVertex) return analyzer except Exception as exp: error.reraise(exp, 'model:addLandConnection')
def initSearch(graph, source): """ Inicializa la estructura de busqueda y deja todos los arcos en infinito. Se inserta en la cola indexada el vertice source Args: graph: El grafo a examinar source: El vertice fuente Returns: Estructura de busqueda inicializada Raises: Exception """ try: search = {'source': source, 'visited': None, 'iminpq': None} search['visited'] = map.newMap( numelements=g.numVertices(graph), maptype='PROBING', comparefunction=graph['comparefunction']) vertices = g.vertices(graph) for vert in lt.iterator(vertices): map.put(search['visited'], vert, { 'marked': False, 'edgeTo': None, 'distTo': math.inf }) map.put(search['visited'], source, { 'marked': True, 'edgeTo': None, 'distTo': 0 }) pq = iminpq.newIndexMinPQ(cmpfunction=graph['comparefunction']) search['iminpq'] = pq iminpq.insert(search['iminpq'], source, 0) return search except Exception as exp: error.reraise(exp, 'dks:init')
def updateFeatures(table, event): '''Todos los features estan en una tabla de Hash, el key es el feature y el value es un rbt este rbt tiene key un valor de instrumentalness (por ejemplo) y como valor un diccionario el diccionario tiene dos elementos: el elemento ['valueevents'] que contiene una array list con todos los eventos de reproduccion el elemento ['track_ids'] que contiene un hash table con key = track_id y value = evento con ese track id el anadido fue el segundo elemento. Lo hice de esta manera para poder completar los requerimientos 2 y 3, que piden reproducciones unicas y comparar diccionarios. Otra cosa es que ahora solo se crean RBTs para features con valores que tiene sentido comparar, antes se creaba para todo feature Ademas hice cambios para que los keys de los RBT sean floats, antes eran strings. ''' i = 1 for feature in event: if mp.size(table) < 9: tree = om.newMap(omaptype='RBT', comparefunction=cmpFunction) dict = {'valueevents': None, 'track_ids': None} dict['valueevents'] = lt.newList(datastructure='ARRAY_LIST') dict['track_ids'] = mp.newMap(maptype='PROBING', loadfactor=0.5) lt.addLast(dict['valueevents'], event) mp.put(dict['track_ids'], event['track_id'], event) om.put(tree, float(event[feature]), dict) mp.put(table, feature, tree) else: tree = me.getValue(mp.get(table, feature)) if om.contains(tree, float(event[feature])): dict = me.getValue(om.get(tree, float(event[feature]))) lt.addLast(dict['valueevents'], event) mp.put(dict['track_ids'], event['track_id'], event) else: dict = {'valueevents': None, 'track_ids': None} dict['track_ids'] = mp.newMap(maptype='PROBING', loadfactor=0.5) dict['valueevents'] = lt.newList(datastructure='ARRAY_LIST') lt.addLast(dict['valueevents'], event) mp.put(dict['track_ids'], event['track_id'], event) om.put(tree, float(event[feature]), dict) if i == 9: break i += 1
def countryid(lista, ide): """ Devuelve un mapa con videos de un category_id en particular, a partir de la lista de videos ya filtrada por pais, cuyas llaves son los títulos de los videos y cuyos valores son entradas de newtviews """ mapa = mp.newMap(numelements=4096, maptype="PROBING", loadfactor=0.5) i = it.newIterator(lista) while it.hasNext(i): vid = it.next(i) if vid['category_id'] == ide: tit = vid["title"] existit = mp.contains(mapa, tit) if existit: entry = mp.get(mapa, tit) value = me.getValue(entry) if vid["views"] > value["views"]: value["views"] = vid["views"] else: entry = newtviews(vid['title']) mp.put(mapa, vid['title'], entry) entry['views'] = vid['views'] entry['info'] = vid return mapa
def getPointsV2(database: DataBase, date1, date2) -> dict: days = database.getDays() days = orderedmap.values(days, date1, date2) days = lti.newIterator(days) top = map.newMap(comparefunction=cmp.compareId) while lti.hasNext(days): day = lti.next(days).points day = map.valueSet(day) day = lti.newIterator(day) while lti.hasNext(day): wallet = lti.next(day) if map.contains(top, wallet.id): node = map.get(top, wallet.id) value = mapentry.getValue(node) value['points'] += wallet.points else: value = {'id': wallet.id, 'points': wallet.points} map.put(top, wallet.id, value) top = map.valueSet(top) sort.mergesort(top, cmp.points) return top
def getAccidentsByTime(analyzer, initialTime, finalTime): accidents = om.values(analyzer['timeIndex'], initialTime, finalTime) lstiterator = it.newIterator(accidents) SeverityMap = m.newMap(numelements=8, maptype='PROBING', comparefunction=CompareAccidentsState) for i in range(1, 5): m.put(SeverityMap, str(i), 0) while (it.hasNext(lstiterator)): eachtime = it.next(lstiterator) SeverityMapEachTime = eachtime["SeverityIndex"] accidents = eachtime['lstAccidents'] accidents = lt.size(accidents) SeverityList = m.keySet(SeverityMapEachTime) SeverityIterator = it.newIterator(SeverityList) while (it.hasNext(SeverityIterator)): severityRange = it.next(SeverityIterator) ValueEachtime = lt.size( me.getValue(m.get(SeverityMapEachTime, severityRange))) ValueSeverity = (me.getValue(m.get(SeverityMap, severityRange))) numberAccidents = ValueEachtime + ValueSeverity m.put(SeverityMap, severityRange, numberAccidents) return SeverityMap
def addMovieGenre(catalog, genrename, movie): """ Esta función adiciona un libro a la lista de libros publicados por un autor. Cuando se adiciona el libro se actualiza el promedio de dicho autor """ genres = catalog['Generos'] existgenre = mp.contains(genres, genrename) if existgenre: entry = mp.get(genres, genrename) genre = me.getValue(entry) else: genre = newGenre(genrename) mp.put(genres, genrename, genre) lt.addLast(genre['movie'], movie) genreavg = genre['average_rating'] movieavg = movie['vote_count'] if (genreavg == 0.0): genre['average_rating'] = float(movieavg) else: genre['average_rating'] = (genreavg + float(movieavg)) / 2 return catalog
def addmovietoactor(catalog, actorname, movie_id): actors = catalog['actors'] directors = catalog['directors'] movies_ids = catalog['moviesIds'] entry = mp.get(movies_ids, movie_id) movie = me.getValue(entry) existactor = mp.contains(actors, actorname) if existactor: entry = mp.get(actors, actorname) actor = me.getValue(entry) else: actor = newActor(actorname) mp.put(catalog['actors'], actorname, actor) lt.addLast(actor['movies'], movie) actor_mov_Avg = actor['average_rating'] movieAvg = movie['vote_average'] if (actor_mov_Avg == 0.0): actor['average_rating'] = float(movieAvg) else: actor['average_rating'] = round((actor_mov_Avg + float(movieAvg)) / 2, 2)
def addEvent(analyzer, event): ''' Agrega individualmente el evento al analyzer, en cada uno de sus mapas ''' lt.addLast(analyzer['events'], event) mp.put(analyzer['artists'], event['artist_id'], 0) addTrackOnOrderedRBTMap(analyzer, event['track_id'], event, 'tracks') addEventOnOrderedRBTMap(analyzer, float(event['instrumentalness']), event, 'instrumentalness') addEventOnOrderedRBTMap(analyzer, float(event['acousticness']), event, 'acousticness') addEventOnOrderedRBTMap(analyzer, float(event['liveness']), event, 'liveness') addEventOnOrderedRBTMap(analyzer, float(event['speechiness']), event, 'speechiness') addEventOnOrderedRBTMap(analyzer, float(event['energy']), event, 'energy') addEventOnOrderedRBTMap(analyzer, float(event['danceability']), event, 'danceability') addEventOnOrderedRBTMap(analyzer, float(event['valence']), event, 'valence') addEventOnOrderedRBTMap(analyzer, float(event['tempo']), event, 'tempo') addTimedEvent(analyzer, event['created_at'], event, 'created_at')
def Actualizar_entrada(trip, datentry): taxis = datentry["taxis"] existtaxi = m.get(taxis, trip["taxi_id"]) if existtaxi is None: taxidata = lt.newList("ARRAY_LIST") if trip["trip_miles"] == "": lt.addLast(taxidata, 0) else: lt.addLast(taxidata, float(trip["trip_miles"])) if trip["trip_total"] == "": lt.addLast(taxidata, 0) else: lt.addLast(taxidata, float(trip["trip_total"])) lt.addLast(taxidata, 1) m.put(taxis, trip["taxi_id"], taxidata) else: entry = existtaxi["value"] if trip["trip_miles"] != "": entry["elements"][0] += float(trip["trip_miles"]) if trip["trip_total"] != "": entry["elements"][1] += float(trip["trip_total"]) entry["elements"][2] += 1 return datentry
def insert(iheap, key, index): """ Inserta la llave key con prioridad index Args: iheap: El heap indexado Returns: El iheap con la nueva paraja indexada Raises: Exception """ try: if not map.contains(iheap['qpMap'], key): iheap['size'] += 1 lt.insertElement(iheap['elements'], { 'key': key, 'index': index }, iheap['size']) map.put(iheap['qpMap'], key, iheap['size']) swim(iheap, iheap['size']) return iheap except Exception as exp: error.reraise(exp, 'indexheap:newindexheap')
def addGenre(catalog, genreName, movie): genres = catalog["genres"] exists = mp.contains(genres, genreName) if exists: entry = mp.get(genres, genreName) genre = me.getValue(entry) lt.addLast(genre["movies"], movie) else: genre = newGenre(genreName) mp.put(genres, genreName, genre) lt.addLast(genre["movies"], movie) genreAvg = genre['vote_count'] movieAvg = movie['vote_count'] if (genreAvg == 0.0): genre['vote_count'] = float(movieAvg) else: genre['vote_count'] = (genreAvg + float(movieAvg)) / 2
def addMovieProductionCompany(catalog, companyName, movie): companies = catalog["productionCompanies"] exists = mp.contains(companies, companyName) if exists: entry = mp.get(companies, companyName) productionCompany = me.getValue(entry) lt.addLast(productionCompany["movies"], movie) else: productionCompany = newProductionCompany(companyName) mp.put(companies, companyName, productionCompany) lt.addLast(productionCompany["movies"], movie) companyAvg = productionCompany['vote_average'] movieAvg = movie['vote_average'] if (companyAvg == 0.0): productionCompany['vote_average'] = float(movieAvg) else: productionCompany['vote_average'] = (companyAvg + float(movieAvg)) / 2
def studyMusic(maps, keylo1, keyhi1, keylo2, keyhi2): ''' Recorre en los index de instrumentalness y tempo buscando las opciones dentro del rango que busca el usuario ''' caract1 = 'instrumentalness' caract2 = 'tempo' easylist = studyMap(maps, keylo1, keyhi1, keylo2, keyhi2, caract1, caract2) if easylist is None: return 0 else: tracksMap = mp.newMap(34500, maptype='PROBING', loadfactor=0.5) iterator = ite.newIterator(easylist) while ite.hasNext(iterator): events = ite.next(iterator) mp.put(tracksMap, events['track_id'], events) size = lt.size(tracksMap) if size > 5: tracklist = 0 else: lista = mp.valueSet(tracksMap) tracklist = get5artists(tracksMap, lista, size) return size, tracklist