def optionFour(): """ Req B """ print("\nElija entre las siguientes opciones: ") print("\n1. Identificar los N taxis con más puntos para en una fecha determinada") print("2. Identificar los M taxis con más puntos para un rango entre dos fechas determinadas") option = int(input("\nOpción: ")) if option == 1: num = int(input("\nIngrese la cantidad de taxis: ")) initialDate = input("\nIngrese la fecha (YYYY-MM-DD): ") if om.contains(analyzer['dateIndex'], initialDate) == False: print('\nPor favor ingrese una fecha que se encuentre en el archivo.') else: controller.getTaxisByDate(analyzer, num, initialDate) elif option == 2: num = int(input("\nIngrese la cantidad de taxis: ")) initialDate = input("\nIngrese la fecha inicial (YYYY-MM-DD): ") finalDate = input("\nIngrese la fecha final (YYYY-MM-DD): ") if om.contains(analyzer['dateIndex'], initialDate) == False or om.contains(analyzer['dateIndex'], finalDate) == False: print('\nPor favor ingrese fechas que se encuentren en el archivo.') else: controller.getTaxisByDateRange(analyzer, num, initialDate, finalDate) else: print("\nPor favor ingrese una opción válida.")
def getAccidentsByRangeHour(analyzer, initialDate, fecha_final): lst = om.values(analyzer['hourIndex'], initialDate, fecha_final) lstiterator = it.newIterator(lst) tot_accidents = 0 mapa = om.newMap(comparefunction=compareIds) mapa2 = om.newMap(comparefunction=compareIds) while (it.hasNext(lstiterator)): lstdate = it.next(lstiterator) accidentes_max = 0 i = 1 while i <= 4: num = getaccidentesByRangeCodeHour(analyzer, lstdate, str(i)) tot_accidents += num accidentes_max += num i += 1 if om.contains(mapa2, i): om.put(mapa2, i, int(om.get(mapa2, i)['value']) + num) else: om.put(mapa2, i, num) om.put(mapa, accidentes_max, str(lstdate)) resu = om.newMap(comparefunction=compareIds) max_sev = 0 sev = 0 for i in range(1, 6): if om.contains(mapa2, i): val = om.get(mapa2, i) if val['value'] > max_sev: max_sev = val['value'] sev = i om.put(resu, i, val['value']) else: om.put(resu, i, 0) om.put(resu, sev, max_sev) return tot_accidents, om.get(mapa, om.maxKey(mapa)), resu
def auxiliardelaauxiliar(catalog, initial_date, final_date): """ Retorna una tupla dependiendo si el rango abarca uno o dos años """ initial_year = str(initial_date.year) final_year = str(final_date.year) initial_date_accidents = om.contains(catalog[initial_year], initial_date) final_date_accidents = om.contains(catalog[final_year], final_date) i = 0 if i == 0 and initial_date_accidents and final_date_accidents: if initial_year == final_year: keylow = om.get(catalog[initial_year], initial_date)["key"] keyhigh = om.get(catalog[initial_year], final_date)["key"] return 0, om.keys(catalog[initial_year], keylow, keyhigh) else: keymax = om.maxKey(catalog[initial_year]) dates_initial_year = om.keys(catalog[initial_year], initial_date, keymax) keymin = om.minKey(catalog[final_year]) dates_final_year = om.keys(catalog[final_year], final_date, keymin) return 1, dates_initial_year, dates_final_year return None
def getInRange(catalog,initial_date,final_date): """ Función Auxiliar REQ3 y REQ4 Retorna una lista en la que cada posición se encuentran las llaves del RBT de accidentes ocurridos en un rango de fechas de un año. """ initial_year = int(initial_date.year) final_year = int(final_date.year) initial_date_accidents = om.contains(catalog[str(initial_year)],initial_date) final_date_accidents = om.contains(catalog[str(final_year)],final_date) year_RBT_Values_Keys_lst = [] if initial_date_accidents and final_date_accidents: yearIterator = int(initial_date.year) while yearIterator < (int(final_date.year) + 1): if yearIterator == initial_year and final_year == yearIterator: year_values = auxiliarYearIterator(catalog,str(yearIterator),0,initial_date,final_date) elif yearIterator != final_year and yearIterator == initial_year: year_values = auxiliarYearIterator(catalog,str(yearIterator),3,initial_date,None) elif yearIterator != final_year and yearIterator != initial_year: year_values = auxiliarYearIterator(catalog,str(yearIterator),1,None,None) else: year_values = auxiliarYearIterator(catalog,str(yearIterator),2,None,final_date) year_RBT_Values_Keys_lst.append(year_values) yearIterator = yearIterator + 1 return year_RBT_Values_Keys_lst return None
def addUser(analyzer, user): exist = om.contains(analyzer['user_track'], user['track_id']) if not exist: key = user['track_id'] hashtag = user['hashtag'].lower() if om.contains(analyzer['sentiments'], hashtag): pareja = om.get(analyzer['sentiments'], hashtag) vader = me.getValue(pareja) lista_valor_track_id = lt.newList() lt.addFirst(lista_valor_track_id, vader) lt.addLast(lista_valor_track_id, hashtag) om.put(analyzer['user_track'], key, lista_valor_track_id) if exist: key = user['track_id'] hashtag = user['hashtag'].lower() if om.contains(analyzer['sentiments'], hashtag): pareja_lista_valor_track = om.get(analyzer['user_track'], user['track_id']) lista_valor_track = me.getValue(pareja_lista_valor_track) count = 0 for i in range(lt.size(lista_valor_track)): presencia = lt.isPresent(lista_valor_track, hashtag) if presencia == 0: lt.addLast(lista_valor_track, hashtag)
def addEvent(catalog, event): ccs = ['energy', 'tempo', 'liveness', 'acousticness'] lt.addFirst(catalog['events'], event) artist = event['artist_id'] track = event['track_id'] updateTempoIndex(catalog['tempo_req4'], event, 'tempo') if mp.contains(catalog['uni_tracks'], track) == False: a = {'tempo': event['tempo'], 'hashtags': lt.newList(), 't_vader': 0} mp.put(catalog['uni_tracks'], track, a) catalog['uni_artists'][artist] = 1 y = 0 while y < len(ccs): main = ccs[y] main_val = event[main] mini = catalog['sup_inf'][main] mini_val = event[mini] if not main in catalog: catalog[main] = om.newMap() if (om.contains(catalog[main], main_val)) == False: om.put(catalog[main], main_val, om.newMap()) a = om.get(catalog[main], main_val) a = me.getValue(a) if (om.contains(a, mini_val)) == False: a = om.get(catalog[main], main_val) a = me.getValue(a) om.put(a, mini_val, lt.newList()) alpha = om.get(catalog[main], main_val) alpha = me.getValue(alpha) alpha = om.get(alpha, mini_val) alpha = me.getValue(alpha) lt.addFirst(alpha, event) y += 1 #para crear arbol de fechas-------------------------- mapa_track = mp.get(catalog['track'], event['track_id']) info = {} list_track = me.getValue(mapa_track)['lstevents'] for i in lt.iterator(list_track): if event['user_id'] == i['user_id'] and event['created_at'] == i[ 'created_at']: hashtag = mp.get(catalog['hashtag_vader'], i['hashtag']) if hashtag != None: h = hashtag['key'] vader = hashtag['value'] event['hashtag'] = h event['vader'] = vader addTimeStamp(catalog['time_stamps'], event)
def taxisPointsByDateRange(analyzer, M, fecha1, fecha2): taxis = om.keySet(analyzer["taxisPoints"]) rankingFechas = om.newMap(omaptype="BST", comparefunction=cmpTaxiId) dia1 = fecha1[8:10] mes1 = fecha1[5:7] año1 = fecha1[0:4] dia2 = fecha1[8:10] mes2 = fecha1[5:7] año2 = fecha1[0:4] for i in range(lt.size(taxis)): puntosLlave = 0.00000 taxi = lt.getElement(taxis, i) info = om.get(analyzer["taxisPoints"], taxi) tuplas = info["value"] for j in range(lt.size(tuplas)): tupla = lt.getElement(tuplas, j) puntosFecha = tupla[1] dia = puntosFecha[8:10] mes = puntosFecha[5:7] año = puntosFecha[0:4] if (año1 < año and año < año2) or año1 == año or año2 == año: if (mes1 < mes and mes < mes2) or mes1 == mes or mes2 == mes: if (dia1 < dia and dia < dia2) or dia1 == dia or dia2 == dia: if tupla[0] > puntosLlave: puntosLlave = tupla[0] puntosFecha = tupla[1] if om.contains(rankingFechas, puntosLlave) == False: taxiList = lt.newList("ARRAY_LIST", None) lt.addLast(taxiList, taxi) om.put(rankingFechas, puntosLlave, taxiList) elif om.contains(rankingFechas, puntosLlave) == True: info = om.get(rankingFechas, puntosLlave) taxiList = info["value"] lt.addLast(taxiList, taxi) om.put(rankingFechas, puntosLlave, taxiList) tam = om.size(rankingFechas) tam = tam - 1 for i in range(M): k = tam - i puntos = om.select(rankingFechas, k) pareja = om.get(rankingFechas, puntos) lista = pareja["value"] taxisN = lista["elements"] x = "x" info = str(tam - k + 1) + ". Taxi ID: " + str( taxisN) + ", Puntos: " + str(puntos) print(info)
def addTag(analyzer, etiqueta): avg = 'vader_avg' tag = etiqueta['hashtag'] if (etiqueta[avg]=='')==False: if om.contains(analyzer['etiquetas'], tag): lt.addLast(me.getValue(om.get(analyzer['etiquetas'], tag)), (float(etiqueta['vader_avg']))) elif not om.contains(analyzer['etiquetas'], tag): om.put(analyzer['etiquetas'], tag, lt.newList(cmpfunction=cmpUidList)) lt.addLast(me.getValue(om.get(analyzer['etiquetas'], tag)), (float(etiqueta['vader_avg'])))
def addBirthYear(citibike, trip): """ Para los REQs {} """ entry = citibike['components'] year = trip['birth year'] if not om.contains(entry, int(trip['start station id'])): om.put(entry, int(trip['start station id']), year) if not om.contains(entry, int(trip['end station id'])): om.put(entry, int(trip['end station id']), year) return citibike
def cargaridcrimen_2(analyzer_usertrack, crimen): listac = analyzer_usertrack["usuarios"] user_id = analyzer_usertrack["user_id"] index = analyzer_usertrack["index"] hora = analyzer_usertrack["created_at"] horas = hora_convertidor(crimen["created_at"]) fecha = fecha_convertidor(crimen["created_at"]) m.put(listac, crimen["user_id"], crimen) if om.contains(index, fecha) == True and om.contains(hora, horas) == True: agregarid_fecha(index, crimen, fecha) agregarid_2_hora(hora, crimen, horas) else: agregarfecha_2(index, crimen, fecha) agregarhora_2(hora, crimen, horas)
def addPosition(type: int, trip: dict, DataBase: dict) -> None: types = ('start station ', 'end station ') id = int(trip[types[type] + 'id']) latitude = trip[types[type] + 'latitude'] longitude = trip[types[type] + 'longitude'] if orderedmap.contains(DataBase['position']['latitude'], latitude): print(f'la ID {id} comparte latitude') if orderedmap.contains(DataBase['position']['longitude'], longitude): print(f'la ID {id} comparte longitude') orderedmap.put(DataBase['position']['latitude'], latitude, id) orderedmap.put(DataBase['position']['longitude'], longitude, id)
def test_get(tree): tree = om.put(tree, 10, 'book10') tree = om.put(tree, 7, 'book7') tree = om.put(tree, 30, 'book30') tree = om.put(tree, 5, 'book5') tree = om.put(tree, 4, 'book4') tree = om.put(tree, 3, 'book3') assert om.size(tree) == 6 assert om.contains(tree, 3) is True node = om.get(tree, 3) assert node['value'] == 'book3' node = om.get(tree, 34) assert om.contains(tree, 34) is False assert node is None
def cargaridaccidente(analyzer, accidente): listac = analyzer["accidentes"] index = analyzer["index"] index_h = analyzer["index_horas"] hora = hora_convertidor(accidente["Start_Time"]) fecha = fecha_convertidor(accidente["Start_Time"]) m.put(listac, accidente["ID"], accidente) if om.contains(index, fecha)==True: agregarid(index, accidente, fecha) else: agregarfecha(index, accidente, fecha) if om.contains(index_h, hora) == True: agregaridh(index_h, accidente, hora) else: agregarh(index_h, accidente, hora)
def addDate(citibike, date, bikeId, origin, destination, duration): if not om.contains(citibike['dates'], date): # No está la fecha ids = {} # Agregar info stops = lt.newList(cmpfunction=compareIds) lt.addFirst(stops, origin) lt.addFirst(stops, destination) ids[bikeId] = (duration, stops) om.put(citibike['dates'], date, ids) else: # Está la fecha value = om.get(citibike['dates'], date) # print(value.keys()) # print(bikeId) if bikeId not in value.keys(): # No está la bici stops = lt.newList(cmpfunction=compareIds) # Agregar bici lt.addFirst(stops, origin) lt.addFirst(stops, destination) value[bikeId] = (duration, stops) else: # Está la bici # print(value[bikeId]) uso = value[bikeId][0] value[bikeId] = (uso + duration, value[bikeId][1]) if not lt.isPresent(value[bikeId][1], origin): # No está la estación lt.addLast(value[bikeId][1], origin) else: pass if not lt.isPresent(value[bikeId][1], destination): # No está la estación lt.addLast(value[bikeId][1], destination) else: pass
def Requerimiento3(analyzer, minIns, maxIns, minTemp, maxTemp): keys_in_range = om.keys(analyzer['instrumentalness'], minIns, maxIns) mapa = analyzer['instrumentalness'] map_respuesta = om.newMap() lista_tracks = lt.newList() for i in range(lt.size(keys_in_range)): key = lt.getElement(keys_in_range, i) valores = om.get(mapa, key) valores = me.getValue(valores) for i in range(lt.size(valores)): small = lt.getElement(valores, i) if small['tempo'] >= minTemp and small['tempo'] <= maxTemp: track_id = small['track_id'] exist = om.contains(map_respuesta, track_id) if not exist: tupla = small['instrumentalness'], small['tempo'] om.put(map_respuesta, track_id, tupla) lt.addLast(lista_tracks, track_id) print('Total of unique tracks in events: ' + str(lt.size(lista_tracks))) i = 0 while i < 5: rand = rd.randint(0, lt.size(lista_tracks)) track = lt.getElement(lista_tracks, rand) tupla_f = om.get(map_respuesta, track) tupla_f = me.getValue(tupla_f) print('Track ' + str(i + 1) + ' :' + str(track) + ' with instrumentalness of ' + str(tupla_f[0]) + ' and tempo of ' + str(tupla_f[1])) i += 1
def top3lessUsed(analyzer): totaltree = om.newMap(omaptype="RBT", comparefunction=compareIds) pqiterator = it.newIterator(vertexNames(analyzer)) while it.hasNext(pqiterator): vert = int(it.next(pqiterator)) salidas = gr.outdegree(analyzer["graph"], str(vert)) destinos = gr.indegree(analyzer["graph"], str(vert)) usototal = salidas + destinos if not om.contains(totaltree, usototal): om.put(totaltree, usototal, str(vert)) else: A = om.get(totaltree, usototal) B = me.getValue(A) om.put(totaltree, usototal, str(B)+","+str(vert)) estaciones = lt.newList(datastructure="ARRAY_LIST") while lt.size(estaciones) < 3: val = om.get(totaltree, om.minKey(totaltree)) val1 = me.getValue(val) menortotal = val1.split(",") for i in menortotal: if lt.size(estaciones) < 3: K = m.get(analyzer["nameIndex"], i) L = me.getValue(K) lt.addLast(estaciones, L) om.deleteMin(totaltree) return estaciones
def genreSearch(analyzer, genres): videosct = lt.newList("ARRAY_LIST") for every_genre in genres: tagg = mp.get(analyzer["musical_genre"], every_genre) taggg = me.getValue(tagg) minor = taggg["lower"] mayor = taggg["upper"] # filtro 1: por minKey y MaxKey lst = om.values(analyzer["tempo"], minor, mayor) totchar = 0 # contador for lstdate in lt.iterator(lst): # cuenta el número de tracks y las suma totchar += lt.size(lstdate['events']) taggg["totchar"] = totchar for element in lt.iterator(lstdate["events"]): if om.contains(taggg["events"], element["artist_id"]) == False: om.put(taggg["events"], element["artist_id"], None) different_artist = om.size(taggg["events"]) reproductions = taggg["totchar"] print("========{}========".format(every_genre)) print("For {} the tempo is between {} and {} BPM".format( every_genre, minor, mayor)) print("{} reproductions: {} with {} different artists".format( every_genre, reproductions, different_artist)) print("---- Some artists for {}----".format(every_genre)) for pos in random.sample(range(1, different_artist), 10): key = om.select(taggg["events"], pos) print("Artist {}:{}".format(pos, key)) return "-"
def addLandingPoint(analyzer, landing_point): contains_map1 = om.contains(analyzer['landing_points'], landing_point['landing_point_id']) if not contains_map1: dict_landing = {} dict_landing['landing_point_id'] = landing_point['landing_point_id'] dict_landing['id'] = landing_point['id'] lista = landing_point['name'] lista = lista.split(',') if len(lista) == 1: dict_landing['city'] = lista[0] dict_landing['country'] = lista[0] elif len(lista) == 2: dict_landing['city'] = lista[0] dict_landing['country'] = lista[1] elif len(lista) == 3: dict_landing['city'] = lista[0] dict_landing['country'] = lista[2] elif len(lista) == 4: dict_landing['city'] = lista[0] dict_landing['country'] = lista[3] dict_landing['latitude'] = landing_point['latitude'] dict_landing['longitude'] = landing_point['longitude'] dict_landing['cables'] = lt.newList() om.put(analyzer['landing_points'], landing_point['landing_point_id'], dict_landing) contains_map2 = mp.contains(analyzer['landing_names_id'], landing_point['id']) if not contains_map2: mp.put(analyzer['landing_names_id'], landing_point['name'], landing_point['landing_point_id'])
def addContextContent(analyzer, data): exists = mp.contains(analyzer['contextContent'], data['track_id']) if exists: entry = mp.get(analyzer['contextContent'], data['track_id']) newL = me.getValue(entry) else: newL = lt.newList() lt.addLast(newL, data) mp.put(analyzer['contextContent'], data['track_id'], newL) features = [ "instrumentalness", "liveness", "speechiness", "danceability", "valence", "loudness", "tempo", "acousticness", "energy", "mode", "key" ] cara = analyzer['features'] for car in features: r = data[car] exists = om.contains(cara[car], data[car]) if exists: entry = om.get(cara[car], data[car]) newL = me.getValue(entry) else: mewL = lt.newList() wewL = lt.newList() newL = (mewL, wewL) lt.addLast(newL[0], data['track_id']) lt.addLast(newL[1], data['artist_id']) om.put(cara[car], data[car], newL)
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 addCompanyTaxi(analyzer, trip): comp = trip["company"] taxi = trip["taxi_id"] if om.contains(analyzer["companiesTaxis"], comp) == True: taxis = om.get(analyzer["companiesTaxis"], comp) num = om.get(analyzer["companiesRanking"], comp) serv = om.get(analyzer["companiesServices"], comp) taxiList = taxis["value"] numTaxis = num["value"] services = serv["value"] services += 1 om.put(analyzer["companiesServices"], comp, services) if taxi not in taxiList["elements"]: lt.addLast(taxiList, taxi) numTaxis += 1 om.put(analyzer["companiesTaxis"], comp, taxiList) om.put(analyzer["companiesRanking"], comp, numTaxis) else: newTaxis = lt.newList("ARRAY_LIST", None) lt.addLast(newTaxis, taxi) om.put(analyzer["companiesTaxis"], comp, newTaxis) numTaxis = 1 om.put(analyzer["companiesRanking"], comp, numTaxis) services = 1 om.put(analyzer["companiesServices"], comp, services) return analyzer
def update_song(diccionario, audio_event): id = audio_event['track_id'] p = om.contains(diccionario['songs'], id) if not p: create_song(diccionario, audio_event) else: insert_song(diccionario, audio_event)
def update_artist(diccionario, audio_event): id = audio_event['artist_id'] p = om.contains(diccionario['artists'], id) if not p: create_artist(diccionario, audio_event) else: insert_event(diccionario, audio_event)
def requerimiento1(diccionario, feature, minm, maxm): minm = float(minm) maxm = float(maxm) feature = feature.lower() diccionario[feature] = om.newMap(omaptype='RBT', comparefunction=compareByFeature) iterador = li.newIterator(diccionario['audio-events']) while li.hasNext(iterador): event = li.next(iterador) id = float(event[feature]) p = om.contains(diccionario[feature], id) if not p: lista = lt.newList(datastructure='ARRAY_LIST') lt.addLast(lista, event) else: couple = om.get(diccionario[feature], id) lista = me.getValue(couple) lt.addLast(lista, event) om.put(diccionario[feature], id, lista) values = om.values(diccionario[feature], minm, maxm) total = 0 iterador2 = li.newIterator(values) while li.hasNext(iterador2): lista = li.next(iterador2) size = lt.size(lista) total += size return total
def updateAccidentsByDistance(analyzer, lon1, lat1, R): accidentes = analyzer['accidentes'] iterator = it.newIterator(accidentes) while it.hasNext(iterator): accidente = it.next(iterator) lat2 = accidente['Start_Lat'] lon2 = accidente['Start_Lng'] dist = dinstancefunction(float(lat1), float(lon1), np.radians(float(lat2)), np.radians(float(lon2))) updateDistanceIndex(analyzer['distanceIndex'], accidente, dist) mapasemana = om.newMap(comparefunction=compareIds) lst = om.values(analyzer['distanceIndex'], 0, R) lstiterator = it.newIterator(lst) while it.hasNext(lstiterator): element = it.next(lstiterator) mapa = om.get(analyzer['distanceIndex'], element)['value']['severityIndex'] listafechas = m.keySet(mapa) listaiterator = it.newIterator(listafechas) while it.hasNext(listaiterator): fecha = it.next(listaiterator) dia = datetime.datetime.strptime(fecha.split(" ")[0], '%Y-%m-%d').weekday() if om.contains(mapasemana, int(dia)): om.put(mapasemana, dia, int(om.get(mapasemana, dia)['value']) + 1) else: om.put(mapasemana, dia, 1) tot_accidents = 0 return mapasemana
def getEventsByInstrumentalnessAndTempo(analyzer, initialValue1, finalValue1, initialValue2, finalValue2): """ Retorna el número de pistas y el map de pistas para las características de contenido 'instrumentalness' y 'tempo' en un rango de valores """ map = om.newMap('RBT', compareValues) lstinstrumentalness = om.values(analyzer['instrumentalness'], initialValue1, finalValue1) for lstevents in lt.iterator(lstinstrumentalness): for event in lt.iterator(lstevents['events']): key = float(event['tempo']) existkey = om.contains(map, key) if existkey: entry = om.get(map, key) value = me.getValue(entry) else: value = newValue(key) om.put(map, key, value) lt.addLast(value['events'], event) tracks = mp.newMap(maptype='PROBING') lsttempo = om.values(map, initialValue2, finalValue2) for lstevents in lt.iterator(lsttempo): for event in lt.iterator(lstevents['events']): track = event['track_id'] mp.put(tracks, track, event) totaltracks = mp.size(tracks) return totaltracks, tracks
def EstudyMusic(analyzer, min_instru, max_instru, min_tempo, max_tempo): track_map = om.newMap(omaptype='RBT', comparefunction=compareDates) videosct = lt.newList("ARRAY_LIST") track_map = om.newMap(omaptype='RBT', comparefunction=compareDates) videosct = lt.newList("ARRAY_LIST") # filtro 1: por minKey y MaxKey de energy lst = om.values(analyzer["instrumentalness"], min_instru, max_instru) for lstdate in lt.iterator(lst): for element in lt.iterator(lstdate["events"]): if (element["tempo"] > min_tempo) and (element["tempo"] < max_tempo): if om.contains(track_map, element["track_id"]) == False: om.put( track_map, element["track_id"], { "instrumentalness": element["instrumentalness"], "tempo": element["tempo"] }) size = om.size(track_map) print("Total of unique track events: ", size) for pos in random.sample(range(1, size), 5): key = om.select(track_map, pos) item = om.get(track_map, key) value = me.getValue(item) lt.addLast( videosct, { "track_id": key, "instrumentalness": value["instrumentalness"], "tempo": value["tempo"] }) return videosct
def getAccidentsByState(analyzer, initialDate, fecha_final): lst = om.values(analyzer['dateIndex'], initialDate, fecha_final) lstiterator = it.newIterator(lst) tot_accidents = 0 mapaState = om.newMap(comparefunction=compareState) mapallaves = m.newMap(comparefunction=compareState) while (it.hasNext(lstiterator)): lstdate = it.next(lstiterator) states = getaccidentesByRangeState(analyzer, lstdate) llaves = m.keySet(states) iterator = it.newIterator(llaves) while it.hasNext(iterator): state = it.next(iterator) m.put(mapallaves, state, state) numstate = lt.size(m.get(states, state)['value']['lststate']) if om.contains(mapaState, state): om.put(mapaState, state, int(om.get(mapaState, state)['value']) + numstate) else: om.put(mapaState, state, int(numstate)) statemax = "" nummax = 0 llaves = m.keySet(mapallaves) iterator = it.newIterator(llaves) while it.hasNext(iterator): state = it.next(iterator) if int(om.get(mapaState, state)['value']) > nummax: statemax = state nummax = om.get(mapaState, state)['value'] return statemax, nummax
def cargaridcrimen(analyzer, crimen): listac = analyzer["crimenes"] index = analyzer["index"] fecha = fecha_convertidor(crimen["Start_Time"]) m.put(listac, crimen["ID"], crimen) if om.contains(index, fecha) == True: agregarid(index, crimen, fecha) else: agregarfecha(index, crimen, fecha)
def getAccidentsBeforeDate(analyzer, finalDate): try: finalDate = datetime.datetime.strptime(finalDate, '%Y-%m-%d') if om.contains(analyzer['dateIndex'], finalDate.date()) == False: return "fecha" else: return model.getAccidentsBeforeDate(analyzer,finalDate.date()) except: return "formato"