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)
