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 afectedCountries (analyzer, vertex):
adjacentedges = gr.adjacentEdges(analyzer['connections'], vertex)
map = mp.newMap(numelements=100,maptype='PROBING')
lstedges = adjacentedges.copy()
i = 1
while i <= lt.size(lstedges):
edge = lt.getElement(lstedges, i)
pais = edge['vertexB'].split(',')
if len(pais) > 3:
pais = pais[len(pais)-1]
else:
pais = pais[0]
contains = mp.contains(map, pais)
if contains:
entry = mp.get(map, pais)
entry = me.getValue(entry)
if e.weight(edge) < entry[0]:
mp.put(map, pais, (e.weight(edge), i))
lt.deleteElement(lstedges, entry[1])
else:
lt.deleteElement(lstedges, i)
else:
mp.put(map, pais, (e.weight(edge), i))
i += 1
orderededges = mergeSortEdges(lstedges, lt.size(lstedges))[0]
return (adjacentedges, orderededges)
def findPopularsAdd(analyzer):
"""
Compara los vertices para buscar los más
populares segun su categoria en edad
que cumplen los requerimientos para
tener publicidad
"""
mayLst = analyzer["publicity"]["BestPublicity"]
catLst = analyzer["publicity"]["ByAges"]
for pos in range(1, 8):
total = 0
mayCatLst = lt.getElement(mayLst, pos)
mayTup = lt.firstElement(mayCatLst)
routesMap = lt.getElement(catLst, pos)
routesLst = m.keySet(routesMap)
routeIterator = it.newIterator(routesLst)
while it.hasNext(routeIterator):
vert = it.next(routeIterator)
routeEntry = m.get(routesMap, vert)
timesRoute = me.getValue(routeEntry)
total += timesRoute
routeTuple = (timesRoute, vert)
mayTimes, name = mayTup
if mayTimes < timesRoute:
size = lt.size(mayCatLst)
if size > 1:
for i in range(0, size - 1):
lt.deleteElement(mayCatLst, 1)
lt.changeInfo(mayCatLst, 1, routeTuple)
mayTup = routeTuple
elif timesRoute == mayTimes:
lt.addLast(mayCatLst, routeTuple)
lt.addLast(mayCatLst, total)
return analyzer
def quitarCopiasLikes(
ord_videos,
size): # Carlos dijo que no era necesario quitar las copias
"""
Args:
ord_videos: catálogo de videos ordenados.
size: videos que se van a imprimir en el view, ayuda a no recorrer todo ord_videos
Return:
list: Lista donde solo se incluya cada video que aparezca más de unna vez, dejando así el que mas likes tenga.
"""
i = 1
sub_list = lt.subList(ord_videos, 1, lt.size(ord_videos))
sub_list = sub_list.copy()
for video in lt.iterator(ord_videos):
ii = i + 1
while ii <= lt.size(sub_list):
if (ii < lt.size(sub_list)) and video['title'] == lt.getElement(
sub_list, ii)['title']:
lt.deleteElement(sub_list, ii)
ii += 1
if i == size + 1:
return sub_list
i += 1
return sub_list
def buscarTop(pais, categoria, n, categories, videos):
top=lt.newList(datastructure="SINGLE_LINKED")
id=0
for i in range(1, lt.size(categories)):
actual=lt.getElement(categories, i)["id\tname"]
actual=actual.split(" ",1)
if actual[1]==categoria:
id=actual[0]
break
id=int(id)
for i in range(1, lt.size(videos)):
if int(lt.getElement(videos, i)["category_id"])==id and pais==lt.getElement(videos, i)["country"]:
if lt.size(top)<int(n):
lt.addLast(top, lt.getElement(videos, i))
else:
minimo=lt.getElement(top, 0)
posMin=0
for j in range(0, lt.size(top)):
if int(lt.getElement(top, j)["views"])<int(minimo["views"]):
minimo=lt.getElement(top, j)
posMin=j
if int(lt.getElement(top, posMin)["views"])<int(lt.getElement(videos, i)["views"]):
lt.deleteElement(top, posMin)
lt.addLast(top, lt.getElement(videos, i))
return top
def test_deleteElement_array(altbooks, books):
pos = lt.isPresent(altbooks, books[2])
assert pos > 0
book = lt.getElement(altbooks, pos)
assert book == books[2]
lt.deleteElement(altbooks, pos)
assert lt.size(altbooks) == 4
book = lt.getElement(altbooks, pos)
assert book == books[3]
def analizartops(tuplilla, numero):
i = 0
while i < numero:
maxvalue = max(tuplilla[0])
posicion = tuplilla[0].index(maxvalue)
valor = tuplilla[0].pop(posicion)
nombrecompa = lt.getElement(tuplilla[1], posicion + 1)
lt.deleteElement(tuplilla[1], posicion + 1)
print(nombrecompa)
print(str(valor))
i += 1
def req3(catalog, min_instr, max_instr, min_tempo, max_tempo):
"""
Dados un rango de instrumentalness y uno de tempo, devuelve
la cantidad de pistas únicas y la información de 5 de ellas.
Entradas:
- catalog: Estructura donde se almacenan los datos
- min_instr: Valor mínimo para Instrumentalness
- max_instr: Valor máximo para Instrumentalness
- min_tempo: Valor mínimo para Tempo
- max_tempo: Valor máximo para Tempo
Salidas:
- Lista que almacena la cantidad de pistas y la información de 5 de ellas
"""
# Se filtra por Instrumentalness y el rango dado
instr_total = catalog["propiedades"]["instrumentalness"]
instr_filtrado = om.values(instr_total, min_instr, max_instr)
tracks_list = lt.newList(datastructure='ARRAY_LIST')
# Se recorren los datos obtenidos en el filtro
for value in lt.iterator(instr_filtrado):
for event in lt.iterator(value['eventos']):
if ((float(event["tempo"])) >= min_tempo) and (
(float(event["tempo"])) <= max_tempo):
elem = [
event['track_id'], event['instrumentalness'],
event['tempo']
]
contiene = lt.isPresent(tracks_list, elem)
if contiene:
pass
else:
lt.addLast(tracks_list, elem)
# Se seleccionan 5 elementos aleatorios de la lista de tracks
resultado = [(lt.size(tracks_list))]
contador = 1
while contador <= 5:
list_size = lt.size(tracks_list)
pos = random.randint(1, list_size)
elem = lt.getElement(tracks_list, pos)
resultado.append(elem)
lt.deleteElement(tracks_list, pos)
contador += 1
return resultado
def songByUserId(catalog, song):
map = catalog['tracksong']
pista = song['track_id']
song['hashtag'] = lt.newList('ARRAY_LIST', cmpfunction=cmpCharact)
issong = None
exist = mp.contains(map, pista)
if exist:
entry = mp.get(map, pista)
ltpista = me.getValue(entry)
ejecutar = True
i = 1
while i <= lt.size(ltpista) and ejecutar == True:
song1 = lt.getElement(ltpista, i)
issong = newSong(song1, song)
if issong is not None:
lt.deleteElement(ltpista, i)
ejecutar = False
i += 1
return issong
def Resistencia(citibike, StationId, MaxTime):
lista = lt.newList("ARRAY_LIST", compareRoutes)
aux = lt.newList("ARRAY_LIST", compareRoutes)
vertices = gr.vertices(citibike["graph"])
stopiterator = it.newIterator(vertices)
dijk = djk.Dijkstra(citibike["graph"], StationId)
while it.hasNext(stopiterator):
element = it.next(stopiterator)
ruta = djk.pathTo(dijk, element)
iterator = it.newIterator(ruta)
duracion = 0
alarm = False
aux2 = lt.newList("ARRAY_LIST", compareRoutes)
cont = 0
if lt.size(aux) == 0:
tamaño = 1
else:
tamaño = lt.size(aux)
if element != StationId:
while it.hasNext(
iterator) and alarm == False and duracion <= int(MaxTime):
cont += 1
i = it.newIterator(aux)
elem = it.next(iterator)
duracion += int(elem["weight"])
while it.hasNext(i) and alarm == False:
vertex = it.next(i)
if vertex == elem["vertexB"]:
alarm = True
if alarm == False and duracion <= int(MaxTime):
lt.addLast(aux, elem["vertexB"])
lt.addLast(aux2, elem)
else:
if cont != 1:
tamfinal = lt.size(aux)
i = tamaño - cont + 1
while i <= tamfinal:
lt.deleteElement(aux, i)
aux2 = lt.newList("ARRAY_LIST", compareRoutes)
tamfinal = lt.size(aux)
if duracion <= int(MaxTime) and alarm == False and lt.size(aux2) != 0:
lt.addLast(lista, aux2)
return lista
def remove(map, key):
""" Elimina la pareja llave,valor, donde llave == key.
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
Returns:
El map
Raises:
Exception
"""
hash = hashValue(map, key)
bucket = lt.getElement(map['table'], hash)
pos = lt.isPresent(bucket, key)
if pos > 0:
lt.deleteElement(bucket, pos)
map['size'] -= 1
return map
else:
return None
def top_companies_by_services(catalog, top_number):
companies_per_services = catalog["companies"]["companies_per_services"]
key_lst = m.keySet(companies_per_services)
greater = 0
counter = 0
lst = lt.newList(cmpfunction=compare_companies)
while counter < top_number:
iterator = it.newIterator(key_lst)
while it.hasNext(iterator):
company = it.next(iterator)
entry = m.get(companies_per_services, company)
services_number = me.getValue(entry)
if services_number > greater:
greater = services_number
greater_company = company
lt.addLast(lst, (greater_company, greater))
pos = lt.isPresent(key_lst, greater_company)
lt.deleteElement(key_lst, pos)
greater = 0
counter += 1
return lst
def remove(map, key):
""" Elimina la pareja llave,valor, donde llave == key.
Args:
map: El map a donde se guarda la pareja
key: la llave asociada a la pareja
Returns:
El map
Raises:
Exception
"""
try:
hash = hashValue(map, key)
bucket = lt.getElement(map['table'], hash)
if (bucket is not None):
pos = lt.isPresent(bucket, key)
if pos > 0:
lt.deleteElement(bucket, pos)
map['size'] -= 1
return map
except Exception as exp:
error.reraise(exp, 'Chain:remove')
def topTags(tag, pais, n, videos):
top=lt.newList(datastructure="SINGLE_LINKED")
for i in range(1, lt.size(videos)):
if pais==lt.getElement(videos, i)["country"]:
tags=lt.getElement(videos,i)["tags"].split("|")
for j in range(1, len(tags)):
tags[j]=tags[j].replace('"', "")
if tags[j]==tag:
if lt.size(top)<int(n):
lt.addLast(top, lt.getElement(videos,i))
break
else:
menor=lt.firstElement(top)
posMenor=0
for k in range(1, lt.size(top)):
if int(lt.getElement(top, k)["likes"])<int(menor["likes"]):
menor=lt.getElement(top, k)
posMenor=k
if int(menor["likes"])<int(lt.getElement(videos,i)["likes"]):
lt.deleteElement(top, posMenor)
lt.addLast(top, lt.getElement(videos, i))
break
return top
def req5(catalog, minimo, maximo):
"""
Dados un rango de horas, se devuelve el género más escuchado en dicho rango,
y demás información como el promedio de Vader de los hashtags de 10 pistas
aleatorias del mismo.
Entradas:
- catalog: Estructura donde se almacenan los datos
- minimo: Valor mínimo del rango de horas
- maximo: Valor máximo del rango de horas
Salidas:
- Diccionario con el género encontrado, la cantidad de reproducciones del
mismo, y la información de las 10 pistas escogidas
"""
eventos = catalog["fechas-eventos"]
# Se filtra por el rango de horas
eventos_filtrado = om.values(eventos, minimo, maximo)
map_tempo = om.newMap('RBT')
generos = []
# Se pasan los eventos a un mapa nuevo
for value in lt.iterator(eventos_filtrado):
for event in lt.iterator(value['eventos']):
key = str(event['tempo']) + "," + str(
event['user_id']) + "," + str(event['track_id']) + "," + str(
event['created_at'])
om.put(map_tempo, key, 0)
generos_event = determinarGeneros(event, generos)
# Se determina el género que más se repite
genero_moda = stat.mode(generos)
genmod_datos = genero_moda.split(",")
min_tempo = genmod_datos[1]
max_tempo = genmod_datos[2]
# Sabiendo el género, se filtran los eventos por los rangos de tempo
tempo_filtrado = om.keys(map_tempo, min_tempo, max_tempo)
# Se seleccionan 10 tracks aleatorios
generos_top = lt.newList(datastructure='ARRAY_LIST')
contador = 1
while contador <= 10:
list_size = lt.size(tempo_filtrado)
pos = random.randint(1, list_size)
elem = lt.getElement(tempo_filtrado, pos)
# Se determinan sus hashtags
datos_elem = elem.split(",")
track = datos_elem[1:]
map_hashtags = catalog['hashtags-eventos']
events = om.get(map_hashtags, track[1])
datos_event = {
'info': track,
'hashtags': [],
'vader_prom': 0,
'conteo': 0
}
for ev in lt.iterator(events['value']['eventos']):
if (str(ev['user_id']) == str(track[0])) and (str(ev['created_at'])
== str(track[2])):
datos_event['hashtags'].append(ev['hashtag'])
# Se determina el vader promedio de sus hashtags, descartando los que no tengan valor vader_avg
map_sentiments = catalog['sentiments']
promedio = 0
conteo = 0
for hasht in datos_event['hashtags']:
sent_hashtag = om.get(map_sentiments, hasht.lower())
if sent_hashtag != None:
try:
vader = float(sent_hashtag['value']['vader_avg'])
except:
print(sent_hashtag['value']['vader_avg'])
if vader != None:
promedio += vader
conteo += 1
if conteo != 0:
promedio = float(promedio) / float(conteo)
else:
promedio = 0
datos_event['vader_prom'] = promedio
datos_event['conteo'] = conteo
lt.addLast(generos_top, datos_event)
lt.deleteElement(tempo_filtrado, pos)
contador += 1
resultado = {
'genero': genero_moda[0],
'cantidad_genero': lt.size(tempo_filtrado),
'tracks': generos_top
}
return resultado
