def addinstrumentalness(analyzer, context): contiene = om.contains(analyzer["instrumentalness"], context["instrumentalness"]) if not contiene: lista = lt.newList() lt.addLast(lista, context) om.put(analyzer["instrumentalness"], context["instrumentalness"], lista) else: obtener = om.get(analyzer["instrumentalness"], context["instrumentalness"]) valores = me.getValue(obtener) lt.addLast(valores, context)
def updateIndex(map, content, llave, indice, date): num = content[llave] if date == True: num = datetime.datetime.strptime(num, '%Y-%m-%d %H:%M:%S') entry = om.get(map, num.time()) num = num.time() elif date == False: num = float(num) entry = om.get(map, num) if entry is None: datentry = newdataentry(content) om.put(map, num, datentry) else: datentry = me.getValue(entry) addIndex(datentry, content, indice) return map
def topCompanies(analyzer,quantity): llaves=m.keySet(analyzer["company"]) iterador=it.newIterator(llaves) orderedmap=om.newMap(omaptype="RBT",comparefunction=CompaniesComparer) while it.hasNext(iterador): llave=it.next(iterador) clave=m.get(analyzer['company'],llave)['value'][0] compañia={'quantity':clave,'company':llave} om.put(orderedmap,clave,llave) llaves=om.keySet(orderedmap) iterador=it.newIterator(llaves) retorno=[] for x in range(lt.size(llaves)-quantity,lt.size(llaves)): llave=lt.getElement(llaves,x) retorno.append([om.get(orderedmap,llave)['value'],om.get(orderedmap,llave)['key']]) return retorno
def user_time(catalog, event): """Arbol solo tiempos""" mapDates = catalog["user_times"] eventDate = event["created_at"] eventDate = datetime.datetime.strptime(eventDate, '%Y-%m-%d %H:%M:%S') eventTime = eventDate.time() entry = om.get(mapDates, eventTime) if entry is None: datentry = lt.newList(datastructure="ARRAY_LIST") om.put(mapDates, eventTime, datentry) else: datentry = me.getValue(entry) lt.addLast(datentry, event) om.put(mapDates, eventTime, datentry) return catalog
def Requerimiento1(analyzer, characteristic, min_range, max_range): keys_in_range = om.keys(analyzer[characteristic], min_range, max_range) mapa = om.newMap() events = 0 for i in range(lt.size(keys_in_range)): key = lt.getElement(keys_in_range, i) exist = om.contains(mapa, key) if not exist: value = om.get(analyzer[characteristic], key) value = me.getValue(value) for i in range(lt.size(value)): dicc = lt.getElement(value, i) artist = dicc['artist_id'] om.put(mapa, artist, value) events += 1 return events, om.size(mapa)
def getMusicapara(analyzer, c1, c2, min_c1, max_c1, min_c2, max_c2): """ Retorna las pistas en el sistema de recomendación que cumplen dos características """ map_pista_cumple = om.newMap(omaptype='RBT',comparefunction=compareIds) for pista in lt.iterator(analyzer["eventos"]): if float(pista[c1]) <= max_c1 and float(pista[c1]) >= min_c1: if float(pista[c2]) <= max_c2 and float(pista[c2]) >= min_c2: om.put(map_pista_cumple, pista["track_id"], (pista[c1], pista[c2])) num_unicas = om.size(map_pista_cumple) if num_unicas == 0: return None return (num_unicas, map_pista_cumple)
def update_characteristic_index(map, event, characteristic): if characteristic == 'created_at': hora = event['created_at'] hora = datetime.datetime.strptime(hora, '%Y-%m-%d %H:%M:%S') hora = hora.time() characteristic_value = hora else: characteristic_value = float(event[characteristic]) entry = om.get(map, characteristic_value) if entry is None: entry = new_entry() om.put(map, characteristic_value, entry) else: entry = me.getValue(entry) add_characteristic_index(entry, event) return map
def updateDateIndex(index, event): """ Se toma la fecha del evento y se busca si ya existe en el arbol dicha fecha. Si es así, se adiciona a su lista de eventos. Si no se encuentra creado un nodo para esa fecha en el arbol se crea. """ occurreddate = event['created_at'] eventdate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S') entry = om.get(index, eventdate.time()) if entry is None: eventList = lt.newList("ARRAY_LIST", cmpfunction=compareIds2) om.put(index, eventdate.time(), eventList) else: eventList = me.getValue(entry) lt.addLast(eventList, event)
def actualizaMapa(analyzer, trip): fecha = trip['trip_start_timestamp'] fecha = datetime.datetime.strptime(fecha, '%Y-%m-%dT%H:%M:%S.%f') fecha = fecha.date() entry = om.get(analyzer['mapaTaxi'], fecha) if entry is None: entrada = {'lstidtaxi': None} entrada['lstidtaxi'] = lt.newList('SINGLE_LINKED', compararTaxi) om.put(analyzer['mapaTaxi'], fecha, entrada) else: entrada = me.getValue(entry) actualizataxi(entrada, trip) return analyzer
def updateAccidentInDate(year_RBT,accident): """ Adiciona la fecha de un accidente como llave a su respectivo año de ocurrencia (RBT). Actualiza el entry en el caso de que la fecha ya exista: Se actualiza el mapa de severidades. Se actualiza la lista de accidentes en la fecha. """ ocurred_date = accident['Start_Time'] acc_date = datetime.datetime.strptime(ocurred_date, '%Y-%m-%d %H:%M:%S') entry = om.get(year_RBT,acc_date.date()) if entry is None: date_entry = newEntry() om.put(year_RBT,acc_date.date(),date_entry) else: date_entry = me.getValue(entry) addSeverityToEntry(date_entry,accident)
def updateEnergyDanceabilityInstrumentalnessTempoIndex( map, EnergyDanceabilityInstrumentalnessTempo, event): """ Se toma el ID del artista y revisa si ya se encuentra dentro del arbol como llave, en caso de que no sea así crea una entrada nueva y lo agrega """ option = float(event[EnergyDanceabilityInstrumentalnessTempo]) entry = om.get(map, option) if entry is None: optionentry = newDataEntry(event) om.put(map, option, optionentry) else: optionentry = me.getValue(entry) lt.addLast(optionentry, event) return map
def updateTimeIndex(map, EachAccident): """Si no se encuentra creado un nodo para esa Tiempos Hora Minuto en el arbol se crea y se actualiza el indice de tipos de accidentes """ occurreddate = EachAccident['Start_Time'] AccidentTime = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S') AccidentTime = AccidentTime.replace(second=0) AccidentTime = compareTime(AccidentTime) entry = om.get(map, AccidentTime.time()) if entry is None: datentry = newDataEntrySevetiry(EachAccident, AccidentTime) om.put(map, AccidentTime.time(), datentry) else: datentry = me.getValue(entry) addTime(datentry, EachAccident) return map
def addTime(analyzer, event): """ Adiciona un evento a la lista de eventos de una hora de creación específica, las horas de creación se guardan en un árbol tipo 'RBT' """ map = analyzer['time'] date = event['created_at'] time = datetime.datetime.strptime(date, '%Y-%m-%d %H:%M:%S').time() existtime = om.contains(map, time) if existtime: entry = om.get(map, time) value = me.getValue(entry) else: value = newValue(time) om.put(map, time, value) lt.addLast(value['events'], event)
def addRep_a_mapaReq1(catalog, caracteristica, rep): mapa = catalog['RepsPor_{}'.format(caracteristica)] llave = rep[caracteristica] if not om.contains(mapa, llave): nueva_lista = lt.newList(datastructure='ARRAY_LIST') agregar = {'id': rep['id'], 'artist_id': rep['artist_id']} # esto se hace por req2 if caracteristica == 'danceability': agregar = { 'id': rep['id'], 'artist_id': rep['artist_id'], 'danceability': rep['danceability'], 'energy': rep['energy'], 'track_id': rep['track_id'] } #esto se hace por req3 if caracteristica == "instrumentalness": agregar = { 'id': rep['id'], 'artist_id': rep['artist_id'], 'instrumentalness': rep['instrumentalness'], 'tempo': rep['tempo'], 'track_id': rep['track_id'] } lt.addLast(nueva_lista, agregar) om.put(mapa, llave, nueva_lista) else: lista_existente = me.getValue(om.get(mapa, llave)) agregar = {'id': rep['id'], 'artist_id': rep['artist_id']} if caracteristica == 'danceability': agregar = { 'id': rep['id'], 'artist_id': rep['artist_id'], 'danceability': rep['danceability'], 'energy': rep['energy'], 'track_id': rep['track_id'] } if caracteristica == "instrumentalness": agregar = { 'id': rep['id'], 'artist_id': rep['artist_id'], 'instrumentalness': rep['instrumentalness'], 'tempo': rep['tempo'], 'track_id': rep['track_id'] } lt.addLast(lista_existente, agregar)
def updateIdIndex(maps, event): """ Se toma El track_id de cada evento y se adiciona al map. Si el track_id del evento ya esta en el arbol, se adiciona a su lista respectiva y se actualiza el index. Si no se encuentra creado un nodo para ese id en el arbol se crea y se actualiza el indice del id de las pistas. """ eventId = event['track_id'] entry = om.get(maps, eventId) if entry is None: datantry = newDataEntry(event) om.put(maps, eventId, datantry) else: datantry = me.getValue(entry) addEntry(datantry, event) return maps
def requerimiento3(catalog, menor1, mayor1, menor2, mayor2): """ Devuelve el total de canciones únicas y un mapa con 5 canciones aleatorias que cumplen con dos rangos de características """ # Mapa donde se guardan las canciones que cumplen con el rango # de tempo, el valor es una tupla con el instrumentalness y el # energy de la canción mapa_tempo = om.newMap('BST') # Lista de listas de eventos que cumplen con el rango de tempo lista_rango = om.values(catalog['tempo'], menor2, mayor2) for lista_instrumentalness in lt.iterator(lista_rango): for e in lt.iterator(lista_instrumentalness): om.put(mapa_tempo, e['track_id'], (e['instrumentalness'], e['tempo'])) # Lista de las canciones que cumplen con el tempo canciones = om.keySet(mapa_tempo) # Se recorre la lista de canciones que cumple con tempo y # se revisa cuáles de esas no cumplen con el rango de # instrumentalness y se eliminan del mapa for cancion in lt.iterator(canciones): instrumental = (me.getValue(om.get(mapa_tempo, cancion)))[0] tempo = (me.getValue(om.get(mapa_tempo, cancion)))[1] if not (instrumental <= mayor1 and instrumental >= menor1): om.remove(mapa_tempo, cancion) # Se obtiene el tamaño del mapa tamaño = om.size(mapa_tempo) # Se crea un mapa para guardar las 5 llaves aleatorias y sus valores mapa_aleatorias = om.newMap('RBT') # Se obtiene una lista con cinco números aleatorios no repetidos # que estén dentro del rango del tamaño lista_cinco_aleatorios = random.sample(range(tamaño), 5) for i in lista_cinco_aleatorios: llave_aleatoria = om.select(mapa_tempo, i) valor = me.getValue(om.get(mapa_tempo, llave_aleatoria)) om.put(mapa_aleatorias, llave_aleatoria, valor) return tamaño, mapa_aleatorias
def requerimiento2(catalog, menor1, mayor1, menor2, mayor2): """ Devuelve el total de canciones únicas y un mapa con 5 canciones aleatorias que cumplen con dos rangos de características """ # Mapa donde se guardan las canciones que cumplen con el rango # de danceability, el valor es una tupla con el energy y el # danceability de la canción mapa_dance = om.newMap('BST') # Lista de listas de eventos que cumplen con el rango de danceability lista_rango = om.values(catalog['danceability'], menor2, mayor2) for lista_energy in lt.iterator(lista_rango): for e in lt.iterator(lista_energy): om.put(mapa_dance, e['track_id'], (e['energy'], e['danceability'])) # Lista de las canciones que cumplen con el danceability canciones = om.keySet(mapa_dance) # Se recorre la lista de canciones que cumple con danceability y # se revisa cuáles de esas no cumplen con el rango de energy y # se eliminan del mapa for cancion in lt.iterator(canciones): energy = (me.getValue(om.get(mapa_dance, cancion)))[0] dance = (me.getValue(om.get(mapa_dance, cancion)))[1] if not (energy <= mayor1 and energy >= menor1): om.remove(mapa_dance, cancion) # Se obtiene el tamaño del mapa tamaño = om.size(mapa_dance) # Se crea un mapa para guardar las llaves aleatorias y sus valores mapa_aleatorias = om.newMap('RBT') # Se obtiene una lista con cinco números aleatorios no repetidos # que estén dentro del rango del tamaño lista_cinco_aleatorios = random.sample(range(tamaño), 5) for i in lista_cinco_aleatorios: llave_aleatoria = om.select(mapa_dance, i) valor = me.getValue(om.get(mapa_dance, llave_aleatoria)) om.put(mapa_aleatorias, llave_aleatoria, valor) return tamaño, mapa_aleatorias
def addtomap2(mapa, event, tupla, caract): llave = float(event[caract]) if caract == 'danceability': val = (event['energy'], event['danceability']) elif caract == 'tempo': val = (event['instrumentalness'], event['tempo']) else: val = None if om.contains(mapa, llave): pareja = om.get(mapa, llave) entry = pareja["value"] mp.put(entry["events"], tupla, None) mp.put(entry["artists"], event["artist_id"], None) mp.put(entry["tracks"], event['track_id'], val) else: entry = entrada(llave, tupla, event, caract, val) om.put(mapa, llave, entry)
def addEventOnOrderedRBTMap(analyzer, int_input, event, map_key): """ La función de addEventOnOrderedRBTMap() adiciona el video al árbol tipo RBT que se ha seleccionado. Args: analyzer: Analizador de eventos int_input: Llave a analizar video: Video a añadir map_key: Especifica cuál mapa """ selected_map = analyzer[map_key] entry = om.get(selected_map, int_input) if entry is not None: value = me.getValue(entry) else: value = newDataEntry() om.put(selected_map, int_input, value) lt.addLast(value['events'], event)
def updateIndex(map, track, characteristic): """ Se toma el valor de la característica de la pista y se busca si ya existe en el arbol dicho valor. Si es asi, se adiciona a su lista de pistas y se actualiza el indice de tipos de pistas. Si no se encuentra creado un nodo para ese valor en el arbol se crea y se actualiza el indice de tipos de pistas """ characteristic_value = track[characteristic] entry = om.get(map, characteristic_value) if entry is None: datentry = newDataEntry(track) om.put(map, characteristic_value, datentry) else: datentry = me.getValue(entry) addArtistIndex(datentry, track) return map
def addFecha(diccio, song2): fecha = datetime.datetime.strptime(song2["created_at"], "%Y-%m-%d %H:%M:%S") quita = fecha.time() if om.contains(diccio["fecha"], quita): jef = om.get(diccio["fecha"], quita) lis = me.getValue(jef) lt.addLast(lis, song2) else: lis = lt.newList() om.put(diccio["fecha"], quita, lis) lt.addLast(lis, song2) return diccio
def uptadeAccidentInDate(year_map, accident): """ Se busca si existe la fecha del accidente, de no hacerlo la crea """ ocurred_date = accident["Start_Time"] accident_date = datetime.datetime.strptime(ocurred_date, "%Y-%m-%d %H:%M:%S") entry = om.get(year_map, accident_date.date()) if entry is None: date_entry = newDateEntry() om.put(year_map, accident_date.date(), date_entry) else: date_entry = me.getValue(entry) addSeverityToDateEntry(date_entry, accident) return year_map
def updateDateIndex(map, line): """ Se toma la fecha del accidente y se busca si ya existe en el arbol dicha fecha. Si es asi, se adiciona al árbol. Si no se encuentra creado un nodo para esa fecha en el arbol se crea. """ occurreddate = line['trip_start_timestamp'] linedate = datetime.datetime.strptime(occurreddate, '%Y-%m-%dT%H:%M:%S.%f') entry = om.get(map, linedate.date()) if entry is None: datentry = {} om.put(map, linedate.date(), datentry) else: datentry = me.getValue(entry) calculatePoints(datentry, line) #addDateIndex(datentry, line, pointdic) return map
def updateIndex(map, music, name): """ Se toma la fecha del crimen y se busca si ya existe en el arbol dicha fecha. Si es asi, se adiciona a su lista de crimenes y se actualiza el indice de tipos de crimenes. Si no se encuentra creado un nodo para esa fecha en el arbol se crea y se actualiza el indice de tipos de crimenes """ num = music[name] entry = om.get(map, num) if entry is None: datentry = newDataEntry(music) om.put(map, num, datentry) else: datentry = me.getValue(entry) addIndex(datentry, music) return map
def addplaylist(catalog, reproduccion): big_map = catalog["context"] lt.addLast(catalog["list"], reproduccion) characteristics = mp.keySet(catalog["context"]) authors = unique_authors(catalog, reproduccion) for element in lt.iterator(characteristics): almost = mp.get(big_map, element) answer = me.getValue(almost) key = float(reproduccion[element]) if om.contains(answer, key): addtolist = om.get(answer, key) listadd = me.getValue(addtolist) lt.addLast(listadd, reproduccion) else: value = lt.newList("SINGLE_LINKED") lt.addLast(value, reproduccion) om.put(answer, key, value) return catalog
def updateDateIndex(map, accident): """ Se toma la fecha del accidente y se busca si ya existe en el arbol dicha fecha. Si es asi, se adiciona a su lista de crimenes y se actualiza el indice de severidad y estados de accidentes. Si no se encuentra creado un nodo para esa fecha en el arbol se crea y se actualiza eel indice de severidad y estados de accidentes. """ occurreddate = accident['Start_Time'] accidentdate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S') entry = om.get(map, accidentdate.date()) if entry is None: datentry = newDataEntry(accident) om.put(map, accidentdate.date(), datentry) else: datentry = me.getValue(entry) addDateIndex(datentry, accident) return map
def addCompanias(analyzer, carrera): compania = carrera['company'] entry = om.get(analyzer['companias'], compania) if entry is None: entrada_compania = newDataEntry(analyzer, carrera) om.put(analyzer['companias'], compania, entrada_compania) else: entrada_compania = me.getValue(entry) # addCompania(analyzer,carrera) if not lt.isPresent(entrada_compania['taxis_afiliados'], carrera["taxi_id"]): lt.addLast(entrada_compania['taxis_afiliados'], carrera['taxi_id']) lt.addLast(entrada_compania['servicios'], carrera['trip_id']) return analyzer
def lpInterconexion(catalog): mapa_grande = catalog['landing_points'] rbt_nuevo = om.newMap(omaptype='RBT', comparefunction=CompareIntegersOM) # total = 0 for lp in lt.iterator(mp.valueSet(mapa_grande)): lista_vertices = lp['lista_vertices'] cant_vertices = lt.size(lista_vertices) # total = total + cant_vertices if not om.contains(rbt_nuevo, cant_vertices): lista_lps = lt.newList(datastructure='ARRAY_LIST') lt.addLast(lista_lps, (lp, lista_vertices)) om.put(rbt_nuevo, cant_vertices, lista_lps) else: lista_lps = me.getValue(om.get(rbt_nuevo, cant_vertices)) lt.addLast(lista_lps, (lp, lista_vertices)) return rbt_nuevo
def tercera_consulta(citibike): tree = om.newMap(omaptype='RBT', comparefunction=compareroutes) diccionario = {} list_vertext = gr.vertices(citibike["graph"]) ite = it.newIterator(list_vertext) while it.hasNext(ite): vertex = it.next(ite) arrive = gr.indegree(citibike["graph"], vertex) if arrive > 0: om.put(tree, arrive, vertex) l = [] number = om.size(tree) resta = abs(number - 3) less = om.select(tree, resta) greater = om.maxKey(tree) ran = om.values(tree, less, greater) i = it.newIterator(ran) while it.hasNext(i): name = it.next(i) l.append(name) diccionario["llegadas"] = l tree_1 = om.newMap(omaptype='RBT', comparefunction=compareroutes) list_vertext_1 = gr.vertices(citibike["graph"]) ite_1 = it.newIterator(list_vertext_1) while it.hasNext(ite_1): vertex_1 = it.next(ite_1) arrive_1 = gr.outdegree(citibike["graph"], vertex_1) if arrive_1 > 0: om.put(tree_1, arrive_1, vertex_1) print((citibike["graph"])) l_1 = [] number_1 = om.size(tree_1) resta_1 = abs(number_1 - 3) less_1 = om.select(tree_1, resta_1) greater_1 = om.maxKey(tree_1) ran_1 = om.values(tree_1, less_1, greater_1) iterar = it.newIterator(ran_1) while it.hasNext(iterar): name_1 = it.next(iterar) l_1.append(name_1) diccionario["salidas"] = l_1 return diccionario
def taxisPointsByDate(analyzer, N, fecha): taxis = om.keySet(analyzer["taxisPoints"]) #pointsLists = om.valueSet(analyzer["taxisPoints"]) rankingFechas = om.newMap(omaptype="BST", comparefunction=cmpTaxiId) 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] if tupla[0] > puntosLlave and tupla[1] == fecha: puntosLlave = tupla[0] puntosFecha = tupla[1] if puntosFecha == fecha and om.contains(rankingFechas, puntosLlave) == False: taxiList = lt.newList("ARRAY_LIST", None) lt.addLast(taxiList, taxi) om.put(rankingFechas, puntosLlave, taxiList) elif puntosFecha == fecha and 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(N): k = tam - i puntos = om.select(rankingFechas, k) pareja = om.get(rankingFechas, puntos) lista = pareja["value"] taxisN = lista["elements"] info = str(tam - k + 1) + ". Taxi ID: " + str( taxisN) + ", Puntos: " + str(puntos) print(info)