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"
