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)