def getAccidentsHour(analyzer, dayin, dayend):
aDate = om.keys(analyzer['hour'],dayin,dayend)
iterator= it.newIterator(aDate)
sev = m.newMap(numelements=15, maptype='PROBING', comparefunction=compareSeverities)
cuantos=0
while (it.hasNext(iterator)):
info= it.next(iterator)
valor = om.get(analyzer['hour'],info)['value']
cuantos += lt.size(valor['accidents'])
llaves = m.keySet(valor['severities'])
iterator1= it.newIterator(llaves)
while(it.hasNext(iterator1)):
info1= it.next(iterator1)
val = m.get(valor['severities'], info1)['value']['listBySeverity']
entry = m.get(sev, info1)
if(entry is None):
dic={'severity': info1, 'cuantos':lt.size(val)}
m.put(sev,info1,dic)
else:
entry['value']['cuantos']+=lt.size(val)
data=" "
cuan=0
keys= m.keySet(sev)
ite=it.newIterator(keys)
while(it.hasNext(ite)):
inf=it.next(ite)
value = m.get(sev,inf)['value']['cuantos']
if(value>cuan):
cuan= value
data= inf
print("accidentes totales: "+str(cuantos)+", la severidad con mayor \n accidentes es : "+str(data)+ "con : "+str(cuan)+" accidentes.")
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 doSentimentAnalysis(analyzer, tempo_lo, tempo_hi):
lst_events = om.values(analyzer['tempo'], tempo_lo, tempo_hi)
track_map = analyzer['tracks']
hashtag_vader_map = analyzer['hashtag_vader']
tracks = lt.newList()
for lstevents in lt.iterator(lst_events):
for ev_ in lt.iterator(lstevents['events']):
# get id
entry = om.get(track_map, ev_['track_id'])
if entry is not None:
value = me.getValue(entry)
# iterate over hastags
vader_vals = []
for ht_ in lt.iterator(value['hashtags']):
vader_val = mp.get(hashtag_vader_map, ht_)
if vader_val is not None:
vader_val = vader_val['value']
try:
vader_val = float(vader_val)
vader_vals.append(vader_val)
except ValueError:
continue
n_hs = len(vader_vals)
if n_hs == 0:
mean_vader = 0
else:
mean_vader = sum(vader_vals) / n_hs
track_out = TrackOutput(ev_['track_id'], n_hs, mean_vader)
lt.addLast(tracks, track_out)
return tracks, lt.size(tracks)
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 getAccidentsByDate(analyzer, date):
accidentDate = om.get(analyzer['dateIndex'], date)
if accidentDate:
if accidentDate['key'] is not None:
lst = lt.newList('ARRAY_LIST')
severityMap = me.getValue(accidentDate)['severityIndex']
severityNum1 = m.get(severityMap, '1')
severityNum2 = m.get(severityMap, '2')
severityNum3 = m.get(severityMap, '3')
severityNum4 = m.get(severityMap, '4')
if (severityNum1 is not None):
lt.addLast(lst,
(m.size(me.getValue(severityNum1)['lstseverity'])))
else:
lt.addLast(lst, 0)
if (severityNum2 is not None):
lt.addLast(lst,
(m.size(me.getValue(severityNum2)['lstseverity'])))
else:
lt.addLast(lst, 0)
if (severityNum3 is not None):
lt.addLast(lst,
(m.size(me.getValue(severityNum3)['lstseverity'])))
else:
lt.addLast(lst, 0)
if (severityNum4 is not None):
lt.addLast(lst,
(m.size(me.getValue(severityNum4)['lstseverity'])))
else:
lt.addLast(lst, 0)
return (lt.getElement(lst, 1), lt.getElement(lst, 2),
lt.getElement(lst, 3), lt.getElement(lst, 4))
else:
return 0
def updateAccidentInHour(hour_RBT,accident):
"""
RETO3 - REQ5
Adiciona la hora en la que ocurrió un accidente como llave al RBT.
Actualiza el entry en el caso de que la hora ya exista:
Se actualiza el mapa de severidades.
Se actualiza la lista de accidentes ocurridos en esa hora.
"""
ocurred_date = accident['Start_Time']
fifteen_minutes = datetime.timedelta(minutes=15)
acc_date = datetime.datetime.strptime(ocurred_date, '%Y-%m-%d %H:%M:%S')
acc_minutes = datetime.timedelta(minutes=acc_date.minute)
if acc_minutes == 00:
rbt_accident_time = datetime.timedelta(hours=acc_date.hour, minutes = 00)
elif acc_minutes <= fifteen_minutes:
rbt_accident_time = datetime.timedelta(hours=acc_date.hour, minutes = 00)
elif acc_minutes >= fifteen_minutes and acc_minutes <= (fifteen_minutes)*3:
rbt_accident_time = datetime.timedelta(hours=acc_date.hour, minutes = 30)
elif acc_minutes > (fifteen_minutes)*3:
rbt_accident_time = datetime.timedelta(hours=(acc_date.hour + 1 ), minutes = 00)
entry = om.get(hour_RBT,rbt_accident_time)
if entry is None:
hour_entry = newEntry()
om.put(hour_RBT,rbt_accident_time,hour_entry)
else:
hour_entry = me.getValue(entry)
addSeverityToEntry(hour_entry,accident)
def topCabsInDate(catalog, date):
"""
Identifica los N taxis con más puntos para en una fecha determinada.
"""
topPoints = {}
taxiDate = om.get(catalog['dates'], date)
if taxiDate:
if taxiDate[
'key'] is not None: #Se ingresa a la información en la fecha ingresada
taxiMap = me.getValue(taxiDate)['taxiId']
keySet = m.keySet(taxiMap)
iteratorKS = it.newIterator(keySet)
while it.hasNext(
iteratorKS
): #Se recorre cada ID de taxi en la fecha ingresada y se calculan sus respectivos puntos
taxiId = it.next(iteratorKS)
info = m.get(taxiMap, taxiId)
services = (m.size(me.getValue(info)['lstTaxi']))
distance = (me.getValue(info)['distance'])
cash = (me.getValue(info)['cash'])
points = (distance / cash) * services
topPoints[taxiId] = round(points, 3)
pointsSorted = sorted(
topPoints.items(), key=operator.itemgetter(1),
reverse=True) #Se ordenan los taxis de acuerdo a los puntos
return topPoints, pointsSorted
else:
return 0, 1
def getAccidentsByDate(date, analyzer):
try:
cant1 = 0
cant2 = 0
cant3 = 0
cant4 = 0
events = om.get(analyzer["dateIndex"], date)
accidents_date = me.getValue(events)
total = lt.size(accidents_date["crashes"])
sev1 = m.get(accidents_date["accident_type"], "1")
if sev1 != None:
v1 = me.getValue(sev1)
cant1 = lt.size(v1["accidents"])
sev2 = m.get(accidents_date["accident_type"], "2")
if sev2 != None:
v2 = me.getValue(sev2)
cant2 = lt.size(v2["accidents"])
sev3 = m.get(accidents_date["accident_type"], "3")
if sev3 != None:
v3 = me.getValue(sev3)
cant3 = lt.size(v3["accidents"])
sev4 = m.get(accidents_date["accident_type"], "4")
if sev4 != None:
v4 = me.getValue(sev4)
cant4 = lt.size(v4["accidents"])
res = (total, cant1, cant2, cant3, cant4)
except:
res = None
return res
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 getAccidentsByHourRange(analizer, initial_hour, final_hour):
fechas = om.keys(analizer['hourIndex'], initial_hour, final_hour)
cant_fechas = lt.size(fechas)
categorias = m.newMap(numelements=0,
maptype='CHAINING',
loadfactor=0.5,
comparefunction=comparar_categorias)
cant_accidentes = 0
i = 1
while i <= cant_fechas:
llave = lt.getElement(fechas, i)
arbol = om.get(analizer['hourIndex'], llave)
severityIndex = arbol['value']['severityIndex']
llaves_severityIndex = m.keySet(severityIndex)
j = 1
while j <= lt.size(llaves_severityIndex):
categoria = lt.getElement(llaves_severityIndex, j)
cat = m.get(severityIndex, categoria)
accidentes = lt.size(cat['value']['lstofseverities'])
cant_accidentes += accidentes
esta_categoria = m.contains(categorias, categoria)
if not esta_categoria:
m.put(categorias, categoria, 0)
cant = m.get(categorias, categoria)
cant = cant['value']
cant += accidentes
m.put(categorias, categoria, cant)
j += 1
i += 1
return cant_accidentes, categorias
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 updateHourIndex(map, accidente):
"""
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
"""
occurredhour = accidente['Start_Time'][11:]
hora = int(occurredhour[:2])
minutos = int(occurredhour[3:5])
if minutos <= 30:
minutos = 30
elif minutos < 60:
if hora == 23:
hora = int('23')
minutos = 59
else:
hora += 1
minutos = int('00')
segundos = int('00')
accidenthour = datetime.time(hora, minutos, segundos)
entry = om.get(map, accidenthour)
if entry is None:
datentry = newDataEntryHour(accidente)
om.put(map, accidenthour, datentry)
else:
datentry = me.getValue(entry)
addHourIndex(datentry, accidente)
return map
def estados_en_un_rango(analyzer, initialDate, finalDate):
lst = om.keys(analyzer["fechas_accidente"], initialDate, finalDate)
lstiterator = it.newIterator(lst)
estados = {}
fecha = ""
mayor = 0
while (it.hasNext(lstiterator)):
lstdate = it.next(lstiterator)
acc = om.get(analyzer["fechas_accidente"], lstdate)
lda = me.getValue(acc)
size_total = 0
keys = m.keySet(lda["estado_del_accidente"])
itera = it.newIterator(keys)
while (it.hasNext(itera)):
lstk = it.next(itera)
parej = m.get(lda["estado_del_accidente"], lstk)
valu = me.getValue(parej)
size = lt.size(valu["lista_de_accidentes"])
size_total += size
if lstk in estados:
estados[lstk] += size
else:
estados[lstk] = size
if size_total > mayor:
fecha = lstdate
mayor = size_total
estad = mayor_valor(estados)
return (fecha, estad)
def addConnection_directed(analyzer, connection):
origin = connection['\ufefforigin']
destination = connection['destination']
cable_id = connection['cable_name']
cable_lenght = DistanceHaversine(origin, destination, analyzer)
verticeA = "<{}>-<{}>".format(origin, cable_id)
verticeB = "<{}>-<{}>".format(destination, cable_id)
containsA = gr.containsVertex(analyzer['connections_directed'], verticeA)
containsB = gr.containsVertex(analyzer['connections_directed'], verticeB)
if not containsA and not containsB:
gr.insertVertex(analyzer['connections_directed'], verticeA)
gr.insertVertex(analyzer['connections_directed'], verticeB)
listilla = [origin, cable_id, verticeA]
lt.addLast(analyzer['vertices'], listilla)
mapa = analyzer['landing_points']
pareja = om.get(mapa, origin)
valor = me.getValue(pareja)
lista_cables = valor['cables']
lt.addLast(lista_cables, verticeA)
gr.addEdge(analyzer['connections_directed'], verticeA, verticeB,
cable_lenght)
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 addTaxi(analyzer, trip):
ids = analyzer["taxis"]
newPoints = 0
tripMiles = trip["trip_miles"]
tripTotal = trip["trip_total"]
timeStamp = trip["trip_start_timestamp"]
tripDate = timeStamp[0:10]
if tripTotal != "0.0" and tripTotal != "":
newPoints = float(tripMiles) / float(tripTotal)
else:
newPoints = 0
if trip["taxi_id"] not in ids["elements"]:
lt.addLast(analyzer["taxis"], trip["taxi_id"])
pointsDate = newPoints, tripDate
pointsList = lt.newList("ARRAY_LIST", None)
lt.addLast(pointsList, pointsDate)
om.put(analyzer["taxisPoints"], trip["taxi_id"], pointsList)
else:
info = om.get(analyzer["taxisPoints"], trip["taxi_id"])
pointsList = info["value"]
pointsDate = lt.lastElement(pointsList)
oldPoints = pointsDate[0]
points = oldPoints + newPoints
newPointsDate = points, tripDate
lt.addLast(pointsList, newPointsDate)
om.put(analyzer["taxisPoints"], trip["taxi_id"], pointsList)
return analyzer
def getAccidentsBySeverity(analyzer, date):
entry = om.get(analyzer["date_index"], date)
dateEntry = me.getValue(entry)
try:
entryAccidentsBySeverity1 = m.get(dateEntry["severity_index"], "1")
accidentsBySeverity1 = me.getValue(entryAccidentsBySeverity1)
severity1Size = lt.size(accidentsBySeverity1["lstseverities"])
except:
severity1Size = 0
try:
entryAccidentsBySeverity2 = m.get(dateEntry["severity_index"], "2")
accidentsBySeverity2 = me.getValue(entryAccidentsBySeverity2)
severity2Size = lt.size(accidentsBySeverity2["lstseverities"])
except:
severity2Size = 0
try:
entryAccidentsBySeverity3 = m.get(dateEntry["severity_index"], "3")
accidentsBySeverity3 = me.getValue(entryAccidentsBySeverity3)
severity3Size = lt.size(accidentsBySeverity3["lstseverities"])
except:
severity3Size = 0
return severity1Size, severity2Size, severity3Size
def travel_map(Map, tree=False):
lst = om.keySet(Map) if tree else m.keySet(Map)
iter = it.newIterator(lst)
while it.hasNext(iter):
key = it.next(iter)
value = om.get(Map, key) if tree else m.get(Map, key)
yield key, (None if value is None else value["value"])
def getBeforeDate(catalog,search_date):
"""
Función Auxiliar REQ2
Retorna una lista, cada posición tiene
las llaves del RBT de un año.
"""
year_search_date = search_date.year
year_bst = catalog[str(year_search_date)]
year_RBT_Values_Keys_lst = []
date_accidents = om.get(year_bst,search_date)
if date_accidents != None:
yearIterator = int(search_date.year) #Se recorren los años desde el ingresado hasta la primera fecha
while yearIterator > 2015: #registrada en 2016
if yearIterator == int(year_search_date):
year_values = auxiliarYearIterator(catalog,str(yearIterator),2,None,search_date)
else:
year_values = auxiliarYearIterator(catalog,str(yearIterator),1,None,None)
year_RBT_Values_Keys_lst.append(year_values)
yearIterator = yearIterator - 1
return year_RBT_Values_Keys_lst
return None
def getAccidentsByDate(analyzer, date):
"""
Retorna el numero de accidentes en una fecha.
"""
lst = om.get(analyzer['dateIndex'], date)
data = lst['value']['lstaccidents']
return data
def getAccidentsByDate(analyzer, initialDate):
"""
Para una fecha determinada, retorna el numero de accidentes
por severidad .
"""
accidentdate = om.get(analyzer['dateIndex'], initialDate)
return me.getValue(accidentdate)
def addHTinfo(catalog, lista, cancion):
arbol = catalog['date_RBT']
fecha = cancion["created_at"]
entry = om.get(arbol, fecha)
tabla_Gen = me.getValue(entry)
llenado(tabla_Gen['generos'], lista, cancion)
return arbol
def musicInTime(maps, time1, time2):
'''
Funcion que busca los eventos en un rango de tiempo.
retorna la cantidad de eventos de escucha totales y
un mapa con los eventos
'''
init = seconds(time1)
final = seconds(time2)
if init < 0 or final < 0:
return 0
else:
# thelist = lt.newList("ARRAY_LIST")
themap = om.newMap(omaptype='RBT')
eventsq = 0
# Sacamos lo eventos en el rango deseado por el usuario
getusers = om.values(maps['time'], init, final)
# Recorremos la lista de las listas de los eventos
iterator = ite.newIterator(getusers)
while ite.hasNext(iterator):
eventslist = ite.next(iterator)
# Para encontrar el numero total de eventos en el rango
newiterator = ite.newIterator(eventslist['lstevent'])
while ite.hasNext(newiterator):
event = ite.next(newiterator)
eventsq += 1
entry = om.get(themap, float(event['tempo']))
if entry is None:
dataentry = newDataEntry(event)
om.put(themap, float(event['tempo']), dataentry)
else:
dataentry = me.getValue(entry)
addEntry(dataentry, event)
return eventsq, themap
def addSongToTreeEnergy(mapt, cancion):
caracteristica = 'energy'
categoria = cancion["energy"]
entry = om.get(mapt, categoria)
filtrado = {}
filtrado["track_id"] = cancion["track_id"]
filtrado["instrumentalness"] = cancion["instrumentalness"]
filtrado["tempo"] = cancion["tempo"]
filtrado["danceability"] = cancion["danceability"]
filtrado["energy"] = cancion["energy"]
if entry is None:
dataentry = newArtEntry(caracteristica, filtrado)
om.put(mapt, categoria, dataentry)
lt.addLast(dataentry['canciones'], filtrado)
lt.addLast(dataentry['artistas'], cancion["artist_id"])
lt.addLast(dataentry["reproducciones"], cancion["track_id"])
else:
dataentry = me.getValue(entry)
esta_track = lt.isPresent(dataentry['canciones'], filtrado['track_id'])
if esta_track == 0:
lt.addLast(dataentry['canciones'], filtrado)
esta_artista = lt.isPresent(dataentry['artistas'],
cancion['artist_id'])
if esta_artista == 0:
lt.addLast(dataentry['artistas'], cancion["artist_id"])
lt.addLast(dataentry["reproducciones"], cancion["track_id"])
return mapt
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 muestradatos(analyzer):
keys = om.keySet(analyzer['mapaTaxi'])
itera = it.newIterator(keys)
#mapa ordenado
while (it.hasNext(itera)):
key = it.next(itera)
entryMapa = om.get(analyzer['mapaTaxi'], key)
valorMapa = me.getValue(entryMapa)
itera2 = it.newIterator(valorMapa['lstidtaxi'])
while (it.hasNext(itera2)):
valor = it.next(
itera2
) # {'idtaxi': None, 'servicios':None, 'millas':None, 'totalDinero': None, 'puntos': None}
#if valor['totalDinero'] == 0:
if ('7075c4988c577798c58b800dbb9742376dbbb74a84ce6ead178e7d00afcaafa6ac936cd9af7b6685991b9121b629de30650958fa926c5472da0083a63ed285c7'
in valor['idtaxi']):
print(valor['idtaxi'])
print(valor['servicios'])
print(valor['millas'])
print(valor['totalDinero'])
print(valor['puntos'])
print("")
def addtomap(citibike, trip):
fecha = trip["starttime"]
fecha = transformador_fecha(fecha, 1)
existe = om.get(citibike["mapa_fecha"], fecha)
if existe is None:
mapa = structure_map()
llave = trip["bikeid"]
ruta = gr.newGraph(
datastructure="ADJ_LIST",
directed=True,
size=50,
comparefunction=compareStations,
)
addTripV2(ruta, trip)
m.put(mapa, llave, ruta)
om.put(citibike["mapa_fecha"], fecha, mapa)
else:
llave = trip["bikeid"]
existe = me.getValue(existe)
existev2 = m.get(existe, llave)
if existev2 is None:
ruta = gr.newGraph(
datastructure="ADJ_LIST",
directed=True,
size=50,
comparefunction=compareStations,
)
addTripV2(ruta, trip)
m.put(existe, llave, ruta)
else:
grafo = me.getValue(existev2)
addTripV2(grafo, trip)
def plotMostConnectedLandingPointMap(analyzer):
"""
Crea un mapa interactivo de las conexiones del punto de conexión
con mayor número de cables conectados
"""
ordmap = controller.mostConnectedLandingPoint(analyzer)
key = om.minKey(ordmap)
vertex = me.getValue(om.get(ordmap, key))
city = vertex.split('-')[0]
country = vertex.split('-')[1]
landingpoint = city + ', ' + country
vertexcoords = me.getValue(mp.get(analyzer['vertexscoords'], vertex))
lstvertexs = controller.getAdjacentVertexs(analyzer, vertex)
lstcoordinates = controller.getVertexsCoordinates(analyzer, lstvertexs)
map = folium.Map(vertexcoords, zoom_start=2.5)
folium.Marker(vertexcoords,
str(landingpoint),
icon=folium.Icon(icon='flag', color='red')).add_to(map)
for location in lt.iterator(lstcoordinates):
folium.Marker(location).add_to(map)
distance = str(hs.haversine(vertexcoords, location)) + " km"
folium.PolyLine([vertexcoords, location],
color="grey",
weight=3.5,
opacity=0.35,
tooltip=distance).add_to(map)
map.save("map2.html")
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 get_accidents_severity_by_hour_range(analyzer, keylo, keyhi):
entry = om.get(analyzer["hour_index"], "05:30")
hour_range = om.values(analyzer["hour_index"], keylo, keyhi)
iterator = it.newIterator(hour_range)
severity_1 = 0
severity_2 = 0
severity_3 = 0
severity_4 = 0
total = 0
while it.hasNext(iterator):
hour = it.next(iterator)
for severity_number in range(1, 5):
severity_entry = m.get(hour["severity_index"],
str(severity_number))
if severity_entry is not None:
severity = me.getValue(severity_entry)
size = lt.size(severity["lstseverities"])
if severity_number == 1:
severity_1 = severity_1 + size
elif severity_number == 2:
severity_2 = severity_2 + size
elif severity_number == 3:
severity_3 = severity_3 + size
else:
severity_4 = severity_4 + size
total = severity_1 + severity_2 + severity_3 + severity_4
else:
pass
return total, severity_1, severity_2, severity_3, severity_4
