def Req3(analyzer, minIn, maxIn, minTe, maxTe):
feat = analyzer['features']
rangoIn = om.values(feat["instrumentalness"], minIn, maxIn)
rangoTe = om.values(feat["tempo"], minTe, maxTe)
da = lt.newList('ARRAY_LIST', cmpfunction=compareNames)
en = lt.newList('ARRAY_LIST', cmpfunction=compareNames)
mew = lt.newList('ARRAY_LIST', cmpfunction=compareNames)
da = oneList(rangoIn)
en = oneList(rangoTe)
b = lit.newIterator(da)
while lit.hasNext(b):
objeto = lit.next(b)
a = lt.isPresent(en, objeto)
c = lt.isPresent(mew, objeto)
if a != 0 and c == 0:
lt.addLast(mew, objeto)
size = lt.size(mew)
seed(1)
num = lt.newList('ARRAY_LIST')
for a in range(1, 6):
value = randint(1, size)
track = lt.getElement(mew, value)
entry = mp.get(analyzer['contextContent'], track)
newL = me.getValue(entry)
d = (newL['first']['info']['instrumentalness'])
e = (newL['first']['info']['tempo'])
trackr = "track{0}:{1} with tempo of {2} and instrumentalness of {3}.".format(
a, track, e, d)
lt.addLast(num, trackr)
return (size, num)
def musicFest(analyzer, mine, maxe, mind, maxd):
feat = analyzer['features']
rangod = om.values(feat["danceability"], mind, maxd)
rangoe = om.values(feat["energy"], mine, maxe)
da = lt.newList('ARRAY_LIST', cmpfunction=compareNames)
en = lt.newList('ARRAY_LIST', cmpfunction=compareNames)
mew = lt.newList('ARRAY_LIST', cmpfunction=compareNames)
da = oneList(rangod)
en = oneList(rangoe)
b = lit.newIterator(da)
while lit.hasNext(b):
objeto = lit.next(b)
a = lt.isPresent(en, objeto)
c = lt.isPresent(mew, objeto)
if a != 0 and c == 0:
lt.addLast(mew, objeto)
size = lt.size(mew)
seed(1)
num = lt.newList('ARRAY_LIST')
for a in range(1, 6):
value = randint(1, size)
track = lt.getElement(mew, value)
entry = mp.get(analyzer['contextContent'], track)
newL = me.getValue(entry)
d = (newL['first']['info']['danceability'])
e = (newL['first']['info']['energy'])
trackr = "track{0}:{1} with energy of {2} and danceability of {3}.".format(
a, track, e, d)
lt.addLast(num, trackr)
return (size, num)
def consulta_req2(analyzer, inf_e, sup_e, inf_d, sup_d):
"""
Ejecuta la consulta sobre los datos para responder al requerimiento 2
"""
mapa_trabajo = mp.newMap(numelements=20, maptype='PROBING')
lista_entregable = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareIds)
mapa_caracs = analyzer['EvByCaracteristics']
entry_1 = mp.get(mapa_caracs, 'energy')
entry_2 = mp.get(mapa_caracs, 'danceability')
arbol_energy = me.getValue(entry_1)
arbol_dance = me.getValue(entry_2)
#Vamos primero con energy
estructuras = om.values(arbol_energy, inf_e, sup_e)
for estructura in lt.iterator(estructuras):
mapa = estructura['mapa_unicos']
tracks = mp.keySet(mapa)
for track in lt.iterator(tracks):
mp.put(mapa_trabajo, track, 1)
#Ahora vamos con danceability
estructuras = om.values(arbol_dance, inf_d, sup_d)
suma = 0
for estructura in lt.iterator(estructuras):
mapa = estructura['mapa_unicos']
tracks = mp.keySet(mapa)
for track in lt.iterator(tracks):
entry = mp.get(mapa_trabajo, track)
if entry is not None:
entry_auxiliar = mp.get(analyzer['tracks'], track)
track = me.getValue(entry_auxiliar)
lt.addLast(lista_entregable, track)
suma += 1
retorno = lt.subList(lista_entregable, 1, 5)
return retorno, suma
def musicaFestejar(analyzer, energyMin, energyMax, danceabilityMin,
danceabilityMax):
"""
Requerimiento 2: Encontrar musica para festejar
"""
entry = mp.get(analyzer['content'], 'energy')
arbolEnergy = me.getValue(entry)
valoresEnergy = om.values(arbolEnergy, energyMin, energyMax)
arbolDance = om.newMap(omaptype='RBT', comparefunction=compareValues)
for valor in lt.iterator(valoresEnergy):
for evento in lt.iterator(valor):
dance = float(evento['danceability'])
existe = om.get(arbolDance, dance)
if existe is None:
eventList = lt.newList('ARRAY_LIST', cmpfunction=compareValues)
om.put(arbolDance, dance, eventList)
else:
eventList = me.getValue(existe)
lt.addLast(eventList, evento)
valoresDance = om.values(arbolDance, danceabilityMin, danceabilityMax)
tracks_unicas = mp.newMap(maptype='PROBING')
for lista in lt.iterator(valoresDance):
for evento in lt.iterator(lista):
mp.put(tracks_unicas, evento['track_id'], evento)
listaUnicas = mp.valueSet(tracks_unicas)
num_tracks = lt.size(listaUnicas)
res = [random.randrange(1, num_tracks, 1) for i in range(5)]
random_tracks = lt.newList('ARRAY_LIST')
for numero in res:
chosen_track = lt.getElement(listaUnicas, numero)
lt.addLast(random_tracks, chosen_track)
return num_tracks, random_tracks
def getPartyMusic(analyzer, energyMin, energyMax, danceMin, danceMax):
tracks = lt.newList('SINGLE_LINKED', compareTracks)
lstEnergy = om.values(analyzer["energy"], energyMin, energyMax)
lstDance = om.values(analyzer["danceability"], danceMin, danceMax)
lstResult = lt.newList('SINGLE_LINKED', compareTracks)
for energyValue in lt.iterator(lstEnergy):
trackIndex1 = energyValue["trackIndex"]
for track in lt.iterator(mp.keySet(trackIndex1)):
for danceValue in lt.iterator(lstDance):
trackIndex2 = danceValue["trackIndex"]
if mp.contains(trackIndex2, track):
lt.addLast(lstResult,
me.getValue(mp.get(trackIndex1, track)))
break
tottracks = lt.size(lstResult)
for i in range(5):
pos = random.randint(1, lt.size(lstResult))
lt.addLast(tracks, lt.getElement(lstResult, pos))
lt.deleteElement(lstResult, pos)
return [tottracks, tracks]
def req2(catalog, min_en, max_en, min_dan, max_dan):
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
listadeentries1 = om.values(catalog["energy"], min_en, max_en)
mapa1 = model.mapaeventos(listadeentries1)
listadeentries2 = om.values(catalog["danceability"], min_dan, max_dan)
tracksencomun = model.tracksencomun(mapa1, listadeentries2)
print('\nEnergy is between ' + str(min_en) + ' and ' + str(max_en))
print('Danceability is between ' + str(min_dan) + ' and ' + str(max_dan))
print('Total of unique tracks in events: ' + str(tracksencomun[0]))
print('\n--- Unique track_id ---')
lista = tracksencomun[1]
i = it.newIterator(lista)
x = 1
while it.hasNext(i):
tupla = it.next(i)
features = tupla[1]
print('Track ' + str(x) + ': ' + tupla[0] + ' with energy of ' +
str(features[0]) + ' and danceability of ' + str(features[1]))
x += 1
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return delta_time, delta_memory
def Req3(analyzer, limInf1, limSup1, limInf2, limSup2):
try:
entry = mp.get(analyzer['content'], "instrumentalness")
arbolInstr = me.getValue(entry)
valoresInstr = om.values(arbolInstr, limInf1, limSup1)
arbol_Tempo = om.newMap(omaptype="RBT", comparefunction=compareValues)
for lista in lt.iterator(valoresInstr):
for evento in lt.iterator(lista):
tempo = float(evento["tempo"])
existe = om.get(arbol_Tempo, tempo)
if existe is None:
eventList = lt.newList("ARRAY_LIST",
cmpfunction=compareValues)
om.put(arbol_Tempo, evento["tempo"], eventList)
else:
eventList = me.getValue(existe)
lt.addLast(eventList, evento)
valoresTempo = om.values(arbol_Tempo, limInf2, limSup2)
unique_tracks = mp.newMap(maptype="PROBING")
for lista in lt.iterator(valoresTempo):
for evento in lt.iterator(lista):
mp.put(unique_tracks, evento["track_id"], evento)
total_tracks = mp.valueSet(unique_tracks)
num_tracks = lt.size(total_tracks)
random5Tracks = lt.subList(total_tracks,
random.randint(1, num_tracks - 5), 5)
return num_tracks, random5Tracks
except Exception:
return None
def getTrcForTwoCriteria(analyzer, criteria1range, str1, criteria2range, str2):
'''
Retorna los varias características de los
eventos dado dos criterios y rangos en el mismo,
buscándolos en ambos árboles. El retorno son los eventos
que cumplen con ambas características
Args:
analyzer: Analizador de eventos
criteria1range: Rango del criterio 1
str1: Llave del analyzer del criterio 1
criteria2range: Rango del criterio 2
str2: Llave del analyzer del criterio 2
'''
criteria1 = om.values(analyzer[str1], criteria1range[0], criteria1range[1])
submap = {'events': None}
submap[str2] = om.newMap(omaptype='RBT')
for eventO in lt.iterator(criteria1):
for event0 in lt.iterator(eventO['events']):
addEventOnOrderedRBTMap(submap, float(event0[str2]), event0, str2)
result = om.values(submap[str2], criteria2range[0], criteria2range[1])
artists = mp.newMap(maptype='PROBING')
tracks = mp.newMap(maptype='PROBING')
for event1 in lt.iterator(result):
for eventi in lt.iterator(event1['events']):
mp.put(artists, eventi['artist_id'], 1)
mp.put(tracks, eventi['track_id'], (eventi[str1], eventi[str2]))
return (mp.size(artists), mp.size(tracks), tracks)
def requerimiento3(catalog, minTem,maxTem,minInstru,maxInstru):
listener = om.values(catalog['tempo'],minTem,maxTem)
listdanc = om.values(catalog['instrumentalness'],minInstru,maxInstru)
total = 0
listeven=lt.newList("ARRAY_LIST",compareIds)
listeven2=lt.newList("ARRAY_LIST",compareIds)
final=lt.newList("ARRAY_LIST",compareIds)
for dato in lt.iterator(listener):
for evento in lt.iterator(dato):
esta=lt.isPresent(listeven,evento)
if esta == 0:
lt.addLast(listeven,evento)
for dato2 in lt.iterator(listdanc):
for evento2 in lt.iterator(dato2):
esta2=lt.isPresent(listeven,evento2)
esta3=lt.isPresent(listeven2,evento2)
if esta2 != 0 and esta3 == 0:
lt.addLast(listeven2,evento2)
total +=1
siz = lt.size(listeven2)
for i in range(0,5):
n=rd.randint(1,siz)
lt.addLast(final,lt.getElement(listeven2,n))
return total,final
def getAccidentsByHour(analyzer, initialhour, finalhour):
lst = om.values(analyzer['dateIndex'])
occurreddate = lst['Start_Time']
accidentdate = datetime.datetime.strptime(occurreddate, '%H:%M:%S')
map_horas = om.newMap(omaptype='BST', comparefunction=compareHours)
om.put(map_horas, accidentdate.hour(), lst)
return om.values(map_horas, initialhour, finalhour)
def analisis_por_hora(catalog, tmin, tmax):
mindate = datetime.datetime.strptime(tmin, '%H:%M:%S')
maxdate = datetime.datetime.strptime(tmax, '%H:%M:%S')
mintime = mindate.time()
maxtime = maxdate.time()
map_hora = mp.get(catalog['index_caracteristica'], 'created_at')
arbol_hora = me.getValue(map_hora)
eventos_rango = om.values(arbol_hora, mintime, maxtime)
total_rep = lt.size(eventos_rango)
arbol = llenar_mapa_tempo(eventos_rango)
genero_mas = None
genero_nombre = None
tamaño_genero = 0
lista_generos = lt.newList(datastructure='ARRAY_LIST')
for genero in lt.iterator(mp.keySet(catalog['genero-rango'])):
rango = cambiar_genero_rango(catalog, genero)
valores_rango = om.values(arbol, float(rango[0]), float(rango[1]))
total = lt.size(valores_rango)
tupla = (genero, valores_rango, total)
lt.addLast(lista_generos, tupla)
ordenada_por_genero = sa.sort(lista_generos, cmpgeneros)
genero_mas = lt.getElement(ordenada_por_genero, 1)
promedio = promedio_vader(catalog, genero_mas[1])
lista_unica = mp.valueSet(pistas_unicas(promedio))
ordenada_hashtag = sa.sort(lista_unica, cmphashtags)
return (ordenada_por_genero, genero_mas, promedio, ordenada_hashtag,
total_rep)
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 consulta_req3(analyzer, mini_vali, max_vali, mini_valt, max_valt):
entry_1 = mp.get(analyzer['EvByCaracteristics'], 'instrumentalness')
entry_2 = mp.get(analyzer['EvByCaracteristics'], 'tempo')
arbol_inst = me.getValue(entry_1)
arbol_temp = me.getValue(entry_2)
estructuras_inst = om.values(arbol_inst, mini_vali, max_vali)
estructuras_temp = om.values(arbol_temp, mini_valt, max_valt)
mapa_trabajo = mp.newMap(numelements=20, maptype='PROBING')
lista = lt.newList('ARRAY_LIST', cmpfunction=compareIds)
unique_tracks = 0
for estruc in lt.iterator(estructuras_inst):
tracks = mp.keySet(estruc['mapa_unicos'])
for track in lt.iterator(tracks):
entry = mp.get(analyzer['tracks'], track)
value = me.getValue(entry)
mp.put(mapa_trabajo, track, value)
for estruc in lt.iterator(estructuras_temp):
tracks = mp.keySet(estruc['mapa_unicos'])
for track in lt.iterator(tracks):
entry = mp.get(mapa_trabajo, track)
if entry is not None:
unique_tracks += 1
value = me.getValue(entry)
lt.addLast(lista, value)
lista_final = lt.subList(lista, 1, 5)
return unique_tracks, lista_final
def req3(cont,minimoI,maximoI,minimoT,maximoT): #Cont es el catalogo
tempo=om.values(cont['tempo'],minimoT,maximoT)
instr=om.values(cont['instrumentalness'],minimoI,maximoI)
new=it.newIterator(tempo)
lst=lt.newList("SINGLE_LINKED")
paaa=lt.newList("SINGLE_LINKED")
while it.hasNext(new):
l=it.next(new)
nuevo=it.newIterator(l)
while it.hasNext(nuevo):
pedazo=it.next(nuevo) #Esto devuelve un mapa de la lista iterando (mapa de la lista(cada elemento))
ax=mp.get(pedazo,'instrumentalness')
nex=mp.get(pedazo,'track_id')#Devuelve la llave danceability y el valor respectivo del mapa en forma de diccionario
tax=me.getValue(ax)#Devuelve el valor de danceability del track sacado en el mapa de it.next(video)
fex=me.getValue(nex)
if float(tax)>=float(minimoI) and float(tax)<=float(maximoI):
if lt.isPresent(lst,fex)==0:
lt.addLast(paaa,pedazo)
lt.addLast(lst,fex)
new=it.newIterator(instr)
while it.hasNext(new):
l=it.next(new)
nuevo=it.newIterator(l)
while it.hasNext(nuevo):
pedazo=it.next(nuevo) #Esto devuelve un mapa de la lista iterando (mapa de la lista(cada elemento))
ax=mp.get(pedazo,'tempo') #Devuelve la llave energy y el valor respectivo del mapa en forma de diccionario
tax=me.getValue(ax)#Devuelve el valor de energy del track sacado en el mapa de it.next(video)
yex=mp.get(pedazo,'track_id')
tex=me.getValue(yex)
if float(tax)>=float(minimoT) and float(tax)<=float(maximoT):
if lt.isPresent(lst,tex)==0:
lt.addLast(paaa,pedazo)
lt.addLast(lst,tex)
return paaa
def requerimiento2(catalog, minEner,maxEner,minDanc,maxDanc):
listener = om.values(catalog['energy'],minEner,maxEner)
listdanc = om.values(catalog['danceability'],minDanc,maxDanc)
total = 0
listeven=lt.newList("ARRAY_LIST",compareIds)
listeven2=lt.newList("ARRAY_LIST",compareIds)
final=lt.newList("ARRAY_LIST",compareIds)
for dato in lt.iterator(listener):
for evento in lt.iterator(dato):
esta=lt.isPresent(listeven,evento)
if esta == 0:
lt.addLast(listeven,evento)
for dato2 in lt.iterator(listdanc):
for evento2 in lt.iterator(dato2):
esta2=lt.isPresent(listeven,evento2)
esta3=lt.isPresent(listeven2,evento2)
if esta2 != 0 and esta3 == 0:
lt.addLast(listeven2,evento2)
total +=1
siz = lt.size(listeven2)
for i in range(0,5):
n=rd.randint(1,siz)
lt.addLast(final,lt.getElement(listeven2,n))
return total,final
def getAccidentsInRange(catalog, initial_date, final_date):
"""
Reto3 - Req3
Retorna el número de accidentes ocurridos en un rango de fechas
"""
initial_year = str(initial_date.year)
final_year = str(final_date.year)
if initial_date == None and final_date == None:
print("La fecha ingresada es errónea")
else:
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.values(catalog[initial_year], keylow, keyhigh)
else:
keymax = om.maxKey(catalog[initial_year])
dates_initial_year = om.values(catalog[initial_year], initial_date,
keymax)
keymin = om.minKey(catalog[final_year])
dates_final_year = om.values(catalog[final_year], final_date,
keymin)
return 1, dates_initial_year, dates_final_year
return None
def findreproductions(maptracks, genre, RBTT, listg, newg, minT, maxT):
Totalrp = 0
for element in listg:
a = int((genre[element][0]))
b = int((genre[element][1]))
lstT = om.values(RBTT, a,
b) #obtener los valores en cada genero recibido
for event in lt.iterator(
lstT): #diccionario con la informacion {list, hasht}
Totalrp += lt.size(event['tracks'])
for event in lt.iterator(event['tracks']):
for element in listg:
a = int((genre[element][0]))
b = int((genre[element][1]))
if (float(a) <= float(event['tempo']) <= float(b)):
countreproductions(maptracks, element,
event['artist_id'], a, b)
if (newg != 'none'):
lstT = om.values(RBTT, minT, maxT)
for event in lt.iterator(lstT):
Totalrp += lt.size(event['tracks'])
for event in lt.iterator(event['tracks']):
for element in listg:
a = int((genre[element][0]))
b = int((genre[element][1]))
if (float(a) <= float(event['tempo']) <=
float(b)): # element es el genero
countreproductions(maptracks, element,
event['artist_id'], a, b)
return Totalrp
def getValuesReq2and3(tree, bajo1, alto1, bajo2, alto2, numReq):
"""Retorna un mapa con los tracks en un rango que depende del requerimiento seleccionado.
Args:
tree (dict, mapa): Árbol según Energy. Defaults to None.
bajo1 (float): Rango inferior de la primera carcterística de contenido.
alto1 (float): Rango superior de la primera carcterística de contenido.
bajo2 (float): Rango inferior de la segunda carcterística de contenido.
alto2 (float): Rango superior de la segunda carcterística de contenido.
Returns:
dict: Mapa (PROBING) de los tracks en los rangos elegidos
"""
if tree is not None: # Si el árbol no es None
mapa = mp.newMap(maptype="PROBING", loadfactor=0.5, numelements=8000)
if numReq == 2:
energy = om.values(tree, bajo1, alto1)
for node in lt.iterator(energy):
for event in lt.iterator(
node): # Cada evento contiene info del csv context
if (event["danceability"] >=
bajo2) and (event["danceability"] <= alto2):
audio = event["track_id"]
existe = mp.contains(mapa, audio)
if (not existe
): # se usa un mapa para no repetir tracks
mp.put(mapa, audio, event)
elif numReq == 3:
instrumental = om.values(tree, bajo1, alto1)
for node in lt.iterator(instrumental):
for event in lt.iterator(
node): # Cada evento contiene info del csv context
if (event["tempo"] >= bajo2) and (event["tempo"] <= alto2):
audio = event["track_id"]
existe = mp.contains(mapa, audio)
if (not existe
): # se usa un mapa para no repetir tracks
mp.put(mapa, audio, event)
return mapa
else:
return None
def req3(catalog, mini, maxi, mint, maxt):
tree_ins = catalog['contentValues']['instrumentalness']
tree_tem = catalog['contentValues']['tempo']
ins = om.values(tree_ins, mini, maxi)
tem = om.values(tree_tem, mint, maxt)
ins_it = lt.iterator(ins)
lst = []
for i in ins_it:
for a in i:
if lt.isPresent(tem, a) != 0 and a not in lst:
lst.append(a)
return lst
def req2y3(analyzer, valorminimoenergy, valormaximoenergy, valorminimodance,
valormaximodance):
listaEnergy = om.values(analyzer['energy'], valorminimoenergy,
valormaximoenergy)
listaDance = om.values(analyzer['danceability'], valorminimodance,
valormaximodance)
listadefinitiva = lt.newList("ARRAY_LIST")
idenergy = []
iddance = []
iteradorenergy = it.newIterator(listaEnergy)
while it.hasNext(iteradorenergy):
elemento = it.next(iteradorenergy)
iteradorelemento = it.newIterator(elemento)
while it.hasNext(iteradorelemento):
diccionarioevento = it.next(iteradorelemento)
cancion = diccionarioevento['id']
idenergy.append(cancion)
iteradordance = it.newIterator(listaDance)
while it.hasNext(iteradordance):
elementodance = it.next(iteradordance)
iteradordanceelement = it.newIterator(elementodance)
while it.hasNext(iteradordanceelement):
diccionarioporeventodance = it.next(iteradordanceelement)
iddance.append(diccionarioporeventodance['id'])
lista_final = []
for i in idenergy:
if (i not in lista_final) and (i in iddance):
lista_final.append(i)
print(len(lista_final))
veces = 1
while veces <= 5:
random = randrange(len(lista_final))
idaleatorio = lista_final[random]
iteradorids = it.newIterator(analyzer['ids'])
while it.hasNext(iteradorids):
elementoid = it.next(iteradorids)
if idaleatorio == elementoid['id']:
print('Track', veces, ':', idaleatorio, 'with energy of',
elementoid['energy'], ' and danceability of',
elementoid['danceability'])
veces = veces + 1
'''
def musica_festejar(catalog, dance_inf, dance_sup, temp_inf, temp_sup):
map_dance = mp.get(catalog['index_caracteristica'], 'danceability')
map_temp = mp.get(catalog['index_caracteristica'], 'energy')
arbol_dance = me.getValue(map_dance)
arbol_temp = me.getValue(map_temp)
valores_dance = om.values(arbol_dance, dance_inf, dance_sup)
valores_temp = om.values(arbol_temp, temp_inf, temp_sup)
mapa_dance = lista_en_hash(valores_dance)
lista_musica = lt.newList('ARRAY_LIST')
for evento in lt.iterator(valores_temp):
if mp.contains(mapa_dance, evento['track_id']):
lt.addLast(lista_musica, evento)
lista_unica = mp.valueSet(pistas_unicas(lista_musica))
return lista_unica
def musica_estudiar(catalog, inst_inf, inst_sup, BPM_inf, BPM_sup):
map_inst = mp.get(catalog['index_caracteristica'], 'instrumentalness')
map_BPM = mp.get(catalog['index_caracteristica'], 'tempo')
arbol_inst = me.getValue(map_inst)
arbol_BPM = me.getValue(map_BPM)
valores_inst = om.values(arbol_inst, inst_inf, inst_sup)
valores_BPM = om.values(arbol_BPM, BPM_inf, BPM_sup)
mapa_inst = lista_en_hash(valores_inst)
lista_musica = lt.newList('ARRAY_LIST')
for evento in lt.iterator(valores_BPM):
if mp.contains(mapa_inst, evento['track_id']):
lt.addLast(lista_musica, evento)
lista_unica = mp.valueSet(pistas_unicas(lista_musica))
return lista_unica
def getaccidentrange(analyzer,minkey,maxkey):
accidentsdate=analyzer['dateIndex']
dates= om.values(accidentsdate,minkey,maxkey)
categoria=lt.newList()
categoriamax=None
lt.addLast(categoria,0)
lt.addLast(categoria,0)
lt.addLast(categoria,0)
lt.addLast(categoria,0)
cantidad=0
for i in range(1,lt.size(dates)+1):
fecha=lt.getElement(dates,i)
for a in range(1,lt.size(fecha)+1):
cantidad += 1
accidente=lt.getElement(fecha,a)
severidad=int(accidente['Severity'])
value=lt.getElement(categoria,severidad)
lt.insertElement(categoria, value+1,severidad)
if cantidad==1:
categoriamax=severidad
elif value+1>lt.getElement(categoria,categoriamax):
categoriamax=severidad
return categoria,cantidad,categoriamax
def getAccidentsSeverityByRange(analyzer, initialDate, finalDate):
lst = om.values(analyzer['fechas'], initialDate, finalDate)
tamanio = lt.size(lst)
a1=0
a2=0
a3=0
a4=0
for i in range(1, tamanio + 1):
lista = lt.getElement(lst, i)
medida = lt.size(lista)
for j in range(1, medida + 1):
accidente = lt.getElement(lista,j)
if accidente['severity'] == '1':
a1 += 1
elif accidente['severity'] == '2':
a2 += 1
elif accidente['severity'] == '3':
a3 += 1
elif accidente['severity'] == '4':
a4 += 1
maximo = max(a1,a2,a3,a4)
if maximo == a1:
maximo_return = '1'
if maximo == a2:
maximo_return = '2'
if maximo == a3:
maximo_return = '3'
if maximo == a4:
maximo_return = '4'
return maximo_return
def pistasPorGenero(index, genero, minTempo, maxTempo):
if genero in [
"Reggae", "Down-tempo", "Chill-out", "Hip-hop", "Jazz and Funk",
"Pop", "R&B", "Rock", "Metal"
]:
if genero == "Reggae":
minTempo = 60
maxTempo = 90
elif genero == "Down-tempo":
minTempo = 70
maxTempo = 100
elif genero == "Chill-out":
minTempo = 90
maxTempo = 120
elif genero == "Hip-hop":
minTempo = 85
maxTempo = 115
elif genero == "Jazz and Funk":
minTempo = 120
maxTempo = 125
elif genero == "Pop":
minTempo = 100
maxTempo = 130
elif genero == "R&B":
minTempo = 60
maxTempo = 80
elif genero == "Rock":
minTempo = 110
maxTempo = 140
elif genero == "Metal":
minTempo = 100
maxTempo = 160
pistas = om.values(index, minTempo, maxTempo)
return pistas, minTempo, maxTempo
def R_4(analyzer, genero, num, min_value, max_value):
artist_10 = lt.newList('ARRAY_LIST')
unique_artists = mp.newMap(numelements=65,
maptype='PROBING',
loadfactor=0.3)
total_songs, artists, total_artists = 0, 0, 0
if num == 1:
total_artists = mp.size(analyzer[genero])
for songs in lt.iterator(mp.valueSet(analyzer[genero])):
total_songs += lt.size(songs['lstContent'])
artists += 1
if artists <= 10:
artist_id = lt.getElement(songs['lstContent'], 1)
lt.addLast(artist_10, artist_id['artist_id'])
else:
lst = om.values(analyzer['generos'], min_value, max_value)
for artists_lst in lt.iterator(lst):
total_songs += lt.size(artists_lst['lstContent'])
artists += 1
for elements in lt.iterator(artists_lst['lstContent']):
if mp.get(unique_artists, elements['artist_id']) is None:
mp.put(unique_artists, elements['artist_id'], 0)
if artists <= 10:
artist_id = lt.getElement(artists_lst['lstContent'], 1)
lt.addLast(artist_10, artist_id['artist_id'])
total_artists = lt.size(unique_artists)
return total_artists, total_songs, artist_10
def getBestTime(database: DataBase, area1: str, area2: str, time1,
time2) -> dict:
route = database.getRoute(area1, area2).getRoute()
route = orderedmap.values(route, time1, time2)
sort.mergesort(route, cmp.trip)
trip = list.removeFirst(route)
return (trip.seconds, trip.time)
def musicToStudy(catalog, minI, maxI, minT, maxT):
countReproductions(catalog, 'Instrumentalness', 'req3')
lst = om.values(catalog['req3'], float(minI), float(maxI))
songs = lt.newList('ARRAY_LIST')
tracks = lt.newList('ARRAY_LIST')
size = lt.size(lst)
i = 0
while i < size:
val = lt.getElement(lst, i)
size2 = lt.size(val['lstsongs'])
j = 0
while j < size2:
sub = lt.getElement(val['lstsongs'], j)
so = sub['tempo']
id = sub['track_id']
pos = lt.isPresent(tracks, id)
if ((pos == 0) and (float(so) >= float(minT))
and (float(so) <= float(maxT))):
lt.addLast(songs, sub)
lt.addLast(tracks, id)
j += 1
i += 1
num_songs = lt.size(songs)
return (songs, num_songs)
def musicToCelebrate(catalog, minE, maxE, minD, maxD):
countReproductions(catalog, 'Energy', 'req2')
lst = om.values(catalog['req2'], float(minE), float(maxE))
songs = lt.newList('ARRAY_LIST')
tracks = lt.newList('ARRAY_LIST')
size = lt.size(lst)
i = 0
while i < size:
val = lt.getElement(lst, i)
size2 = lt.size(val['lstsongs'])
j = 0
while j < size2:
sub = lt.getElement(val['lstsongs'], j)
so = sub['danceability']
id = sub['track_id']
pos = lt.isPresent(tracks, id)
if ((pos == 0) and (float(so) >= float(minD))
and (float(so) <= float(maxD))):
lt.addLast(songs, sub)
lt.addLast(tracks, id)
j += 1
i += 1
num_songs = lt.size(songs)
return (songs, num_songs)
def getRankByCarac(map, keylo, keyhi):
lst = om.values(map, keylo, keyhi)
size = lt.size(lst)
i = 0
artist = lt.newList('ARRAY_LIST')
songs = 0
while i < size:
val = lt.getElement(lst, i)
size2 = lt.size(val['lstsongs'])
songs += size2
j = 0
while j < size2:
sub = lt.getElement(val['lstsongs'], j)
art = sub['artist_id']
pos = lt.isPresent(artist, art)
if pos == 0:
lt.addLast(artist, art)
j += 1
i += 1
num_artist = lt.size(artist)
return (songs, num_artist, artist)
