def weightConnection(catalog, origin, destination):
"""
Se obtiene el peso entre 2 landing_point
"""
# Obtener la tabla de origin
tabla_origin_Entry = mp.get(catalog['map_landing_points'], origin)
tabla_origin = me.getValue(tabla_origin_Entry)
# Obtener la tabla de destination
tabla_destination_Entry = mp.get(catalog['map_landing_points'],
destination)
tabla_destination = me.getValue(tabla_destination_Entry)
# Obtener el elemento de origin
values_origin_list = mp.valueSet(tabla_origin)
# Obtener el elemento de destination
values_destination_list = mp.valueSet(tabla_destination)
# Iterar sobra values origin
values_origin_iterator = it.newIterator(values_origin_list)
element_origin = it.next(values_origin_iterator)
# Iterar sobra values destination
values_destination_iterator = it.newIterator(values_destination_list)
element_destination = it.next(values_destination_iterator)
# Obtener la altitud y longitud de origin
altitud_origin = element_origin['latitude']
longitud_origin = element_origin['longitude']
# Obtener la altitud y longitud de destination
altitud_destination = element_destination['latitude']
longitud_destination = element_destination['longitude']
weight = haversine(float(altitud_origin), float(longitud_origin),
float(altitud_destination), float(longitud_destination))
return weight
def parteA_consulta(inicial, rankingM, rankingN):
orden_compañias = m.valueSet(inicial["compañias"])
compañias_servicios_ordenados = m.valueSet(inicial["compañias"])
mergesort.mergesort(orden_compañias, comparador_de_taxis)
mergesort.mergesort(compañias_servicios_ordenados, comparador_de_servicios)
numero_compañias = m.size(inicial["compañias"])
topM = lt.newList("ARRAY_LIST")
topN = lt.newList("ARRAY_LIST")
cuantas_tengoM = 1
while cuantas_tengoM <= rankingM:
elemento_agregar = lt.getElement(orden_compañias, cuantas_tengoM)
lt.addLast(topM, elemento_agregar)
cuantas_tengoM += 1
cuantas_tengoN = 1
while cuantas_tengoN <= rankingN:
elemento_agregar = lt.getElement(compañias_servicios_ordenados,
cuantas_tengoN)
lt.addLast(topN, elemento_agregar)
cuantas_tengoN += 1
return (topM, topN, numero_compañias, len(inicial["taxis"]))
def consulta2(Inite, fecha_ini, fecha_fin, top2):
fecha_fin = transformador_fecha(fecha_fin)
fecha_ini = transformador_fecha(fecha_ini)
datos_entre_medio = om.values(Inite["mapa_fecha"], fecha_ini, fecha_fin)
mapa_intermedio = m.newMap(maptype="PROBING",
comparefunction=compareStationsv2)
for i in range(1, lt.size(datos_entre_medio) + 1):
lista = lt.getElement(datos_entre_medio, i)
lista = m.valueSet(lista)
for e in range(1, lt.size(lista) + 1):
elemento = lt.getElement(lista, e)
existe = m.get(mapa_intermedio, elemento["taxi"])
if existe is None:
m.put(mapa_intermedio, elemento["taxi"], elemento)
else:
nodo_new = incrementalV3(me.getValue(existe), elemento)
m.put(mapa_intermedio, nodo_new["taxi"], nodo_new)
top_2 = lt.newList("ARRAY_LIST")
mapa_intermedio_ordenado = m.valueSet(mapa_intermedio)
mergesort.mergesort(mapa_intermedio_ordenado,
comparador_ascendente) # SHELLSORT
for i in range(1, lt.size(mapa_intermedio_ordenado) + 1):
elemento = lt.getElement(mapa_intermedio_ordenado, i)
lt.addLast(top_2, elemento)
if i == top2:
break
return top_2
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 req1_return(Inite, ranking1, ranking2):
companies_orden = m.valueSet(Inite["mapa_companies"])
services_orden = m.valueSet(Inite["mapa_companies"])
mergesort.mergesort(services_orden,
comparador_ascendente_services) # SHELLSORT
mergesort.mergesort(companies_orden,
comparador_ascendente_taxis) # SHELLSORT
cantidad_compañias_taxi = m.size(Inite["mapa_companies"])
top1 = lt.newList("ARRAY_LIST")
top2 = lt.newList("ARRAY_LIST")
for i in range(1, lt.size(companies_orden) + 1):
elemento = lt.getElement(companies_orden, i)
lt.addLast(top1, elemento)
if i == ranking1:
break
for i in range(1, lt.size(services_orden) + 1):
elemento = lt.getElement(services_orden, i)
lt.addLast(top2, elemento)
if i == ranking2:
break
return {
"ranking1": top1,
"ranking2": top2,
"compañias taxi": cantidad_compañias_taxi,
"total taxis": len(Inite["Taxis sin repetir"]),
}
def getMinimumSpaningTree(analyzer):
mst = prim.PrimMST(analyzer['connections'])
distance = 0
numberOfElements = lt.size(mp.valueSet(mst['marked']))
for element in lt.iterator(mp.valueSet(mst['distTo'])):
distance = distance + float(element)
print ('La cantidad de elementos es: ' + str(numberOfElements) + ' la distancia total es ' + str(distance))
return mst
def __init__(self, catalog):
super_list = mp.valueSet(catalog.videos)
self.super_iter = lliterator.newIterator(super_list)
country_map = lliterator.next(self.super_iter)
country_list = mp.valueSet(country_map)
self.country_iter = lliterator.newIterator(country_list)
self.category_iter = aliterator.newIterator(
lliterator.next(self.country_iter))
def sacar_info(analyzer):
vertices = gr.numVertices(analyzer['Arcos'])
arcos = gr.numEdges(analyzer['Arcos'])
paises = mp.keySet(analyzer["paises_nombre"])
Num_paises = lt.size(paises)
landings = mp.valueSet(analyzer['landing_points'])
landing = lt.firstElement(landings)
ciudades = mp.valueSet(analyzer['countries'])
ciudad = lt.lastElement(ciudades)
poblacion = ciudad["Population"]
usuarios = ciudad["Internet users"]
return vertices, arcos, Num_paises, landing, poblacion, usuarios
def videosLikesTags(catalogo, numero, tag, pais):
catalog2 = mp.newMap(40, maptype="PROBING")
vids = mp.valueSet(catalogo["videos"])
for i in range(mp.valueSet(catalogo["videos"])["size"]):
video = lt.getElement(vids, i)
if (tag in video["tags"]) and (pais == video["country"]):
mp.put(
catalog2,
str(video["video_id"]) + str(video["trending_date"]) +
str(video["country"]), video)
if mp.valueSet(catalog2)["size"] < numero:
print("Excede el tamaño de la lista, ingrese un valor válido")
else:
lista_ord = ms.sort(mp.valueSet(catalog2), cmpVideosByLikes)
return lista_ord
def videospaiscategoría(numero, pais, categoria, catalogo):
category = sacaridcategoria(catalogo, categoria)
mapacondiciones = mp.newMap(40, maptype="PROBING")
videos = mp.valueSet(catalogo["videos"])
for x in range(mp.valueSet(catalogo["videos"])["size"]):
video = lt.getElement(videos, x)
if (video["country"] == pais) and (int(video["category_id"])
== int(category)):
mp.put(
mapacondiciones,
str(video["video_id"]) + str(video["trending_date"]) +
str(video["country"]), video)
sorteado = ms.sort(mp.valueSet(mapacondiciones), cmpVideosByViews)
listavideos = lt.subList(sorteado, 1, int(numero))
return listavideos
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 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 __init__(self, catalog, category):
self.category = category
super_list = mp.valueSet(catalog.videos)
self.super_iter = lliterator.newIterator(super_list)
country_map = lliterator.next(self.super_iter)
category_list = mp.get(country_map, category)['value']
self.category_iter = aliterator.newIterator(category_list)
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 Requerimiento1(analyzer, landing_point1, landing_point2):
"""
Retorna ...
"""
clusters = scc.KosarajuSCC(analyzer['connections'])
numClusters = scc.connectedComponents(clusters)
mismoCluster = -1
punto1 = None
punto2 = None
listaPuntos = mp.valueSet(analyzer['landing_points'])
for punto in lt.iterator(listaPuntos):
nombre = punto['name'].split(", ")[0]
if nombre == landing_point1.title():
punto1 = punto['landing_point_id']
if nombre == landing_point2.title():
punto2 = punto['landing_point_id']
if punto1 is not None and punto2 is not None:
entry = mp.get(analyzer["points_vertices"], punto1)
if entry is not None:
lstLP1 = me.getValue(entry)
lp1 = lt.firstElement(lstLP1)
entry = mp.get(analyzer["points_vertices"], punto2)
if entry is not None:
lstLP2 = me.getValue(entry)
lp2 = lt.firstElement(lstLP2)
if lp1 != "" and lp2 != "":
mismoCluster = scc.stronglyConnected(clusters, lp1, lp2)
return numClusters, mismoCluster
def addCapitals(analyzer, country):
capital = country['CapitalName'] + "-" + country['CountryName']
addPoint(analyzer, capital)
grado = gr.degree(analyzer['connections'], capital)
if grado == 0:
info = mp.get(analyzer['countries'], country['CountryName'])['value']
latitud = info['CapitalLatitude']
longitud = info['CapitalLongitude']
listaPoints = mp.valueSet(analyzer["landing_points"])
difMasCercana = 100
for point in lt.iterator(listaPoints):
difLat = abs(float(point['latitude']) - float(latitud))
difLon = abs(float(point['longitude']) - float(longitud))
difTot = difLat + difLon
if difTot < difMasCercana:
difMasCercana = difTot
LPmasCercano = point
listaVertices = mp.get(analyzer['points_vertices'],
LPmasCercano['landing_point_id'])['value']
coordOrigen = (float(latitud), float(longitud))
coordDestino = (float(LPmasCercano["latitude"]),
float(LPmasCercano["longitude"]))
distancia = round(hs.haversine(coordOrigen, coordDestino), 2)
for vertice in lt.iterator(listaVertices):
addConnection(analyzer, capital, vertice, distancia)
addConnection(analyzer, vertice, capital, distancia)
def topN(theServices,N):
valores=[]
res={}
i=0
n=0
keys= m.keySet(theServices)
values=m.valueSet(theServices)
itv=it.newIterator(values)
itk=it.newIterator(keys)
orden=mpq.newMinPQ(comparemaxpq)
while it.hasNext(itv):
value=it.next(itv)
key= it.next(itk)
if key!= "Independent Owner":
mpq.insert(orden,value[1])
while i<N:
valor=mpq.min(orden)
valores.append(valor)
res[valor]=[]
mpq.delMin(orden)
i+=1
itval=it.newIterator(values)
itke=it.newIterator(keys)
while it.hasNext(itval):
val=it.next(itval)
ke= it.next(itke)
if ke!= "Independent Owner":
for i in valores:
if i==val[1]:
if ke not in res[i] and n<N:
res[i].append(ke)
n+=1
return res
def Reps_genero_en_horario(catalog, lista_mapas_reps):
mapa_generos = catalog['Generos']
mapa_contadores = mp.newMap(loadfactor=4.0)
reps_totales = 0
for genero in lt.iterator(mp.keySet(mapa_generos)):
cantidad_reps_genero = 0
for mapa_reps in lt.iterator(lista_mapas_reps):
for rep in lt.iterator(mp.valueSet(mapa_reps)):
tempo_rep = rep['tempo']
limites = me.getValue(mp.get(mapa_generos, genero))[0]
lim_inf = limites[0]
lim_sup = limites[1]
if lim_inf <= tempo_rep and tempo_rep <= lim_sup:
cantidad_reps_genero = cantidad_reps_genero + 1
mp.put(mapa_contadores, genero, cantidad_reps_genero)
bst_calculo = om.newMap(omaptype='BST', comparefunction=MAPcompareEnteros)
for genero in lt.iterator(mp.keySet(mapa_contadores)):
cantidad_reps_genero = me.getValue(mp.get(mapa_contadores, genero))
om.put(bst_calculo, cantidad_reps_genero,
(genero, cantidad_reps_genero))
generos_ordenados_por_reps = om.valueSet(bst_calculo)
#esto es una lista de tuplas (genero, cantidad_reps_genero) ORDENADA por cantidad_reps_genero
return generos_ordenados_por_reps
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 getTrendVidByCountry(catalog, country_name):
countries = catalog['countries']
existsCountry = mp.contains(countries, country_name)
if existsCountry:
entry = mp.get(countries, country_name)
videoList = me.getValue(entry)
trendVids = mp.newMap(comparefunction=compareVideoName2)
for video in lt.iterator(videoList):
vidTitle = video['title']
existVid = mp.contains(trendVids, vidTitle)
if existVid:
entry = mp.get(trendVids, vidTitle)
videoUnique = me.getValue(entry)
videoUnique['cuenta'] += 1
else:
mp.put(trendVids, vidTitle, {"info": video, "cuenta": 1})
trendVidList = mp.valueSet(trendVids)
mayorVideo = None
cuentaMayor = 0
for video in lt.iterator(trendVidList):
cuenta = video["cuenta"]
if cuenta > cuentaMayor:
mayorVideo = video["info"]
cuentaMayor = cuenta
return mayorVideo, cuentaMayor
return None
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 Requerimiento2(catalog, country):
videos = mp.get(catalog['videos_by_country'], country)
videos = me.getValue(videos)
retorno = mp.newMap(comparefunction=compareMapVideosIds)
print(lt.size(videos))
for i in range(1, lt.size(videos)):
video = lt.getElement(videos, i)
exists = mp.contains(retorno, video['video_id'])
if not exists:
dic = {}
dic['title'] = video['title']
dic['channel_title'] = video['channel_title']
dic['country'] = video['country'].lower()
dic['trending_days'] = 1
mp.put(retorno, video['video_id'], dic)
else:
key_value = mp.get(retorno, video['video_id'])
value = me.getValue(key_value)
value['trending_days'] += 1
mayor = 0
mayor1 = {}
result = mp.valueSet(retorno)
for i in range(0, lt.size(result)):
video = lt.getElement(result, i)
if video['trending_days'] > mayor:
mayor = video['trending_days']
mayor1 = video
return mayor1
def addPointConnections(analyzer):
# Para cada landing point es necesario realizar dos acciones:
# 1. Crear arcos entre los vertices correspondientes al landing point, con un peso mínimo
# 2. Crear arcos entre los vertices del landing point y el vertice correspondiente a la capital del país
for lp in lt.iterator(mp.valueSet(analyzer['landingPoints'])):
vertices = lp['vertices']
originIndex = lt.size(vertices)
# Se obtiene el vertice de la capital del país
country = me.getValue(mp.get(analyzer['countries'], lp['country']))
countryVertex = country['vertex']
# Se calcula la distancia del landing point a la capital, mediante coordenadas
origin = (float(lp["latitude"]), float(lp["longitude"]))
destination = (float(country['data']["CapitalLatitude"]),
float(country['data']["CapitalLongitude"]))
haversineLength = round(hs.haversine(origin, destination), 2)
# Para cada vertice del landing point, se crean los arcos correspondientes
for vertex in lt.iterator(vertices):
addEdge(analyzer, vertex, countryVertex, haversineLength)
addEdge(analyzer, countryVertex, vertex, haversineLength)
# Si el landing point solo tiene un vertice (solo se conecta a un cable) no es necesario crear más arcos
if originIndex <= 1:
continue
# Si el landing point tiene más de un vertice, se crean arcos entre ellos. La distancia se considera mínima
for i in range(1, lt.size(vertices)):
originVertex = lt.getElement(vertices, originIndex)
destinationVertex = lt.getElement(vertices, i)
addEdge(analyzer, originVertex, destinationVertex, 0.1)
addEdge(analyzer, destinationVertex, originVertex, 0.1)
originIndex = i
def consulta_req4(analyzer, list_gen):
mapa_final = mp.newMap(numelements=10, maptype='PROBING')
entry_2 = mp.get(analyzer['EvByCaracteristics'], 'tempo')
arbol_tempo = me.getValue(entry_2)
tot_eventos = 0
for gender in list_gen:
num_artistas = 0
num_eventos = 0
entry_1 = mp.get(analyzer['Genders'], gender)
rango = me.getValue(entry_1)
estructuras = om.values(arbol_tempo, rango[0], rango[1])
mapa_trabajo = mp.newMap(numelements=80, maptype='PROBING')
for estruc in lt.iterator(estructuras):
for track in lt.iterator(mp.valueSet(estruc['mapa_completo'])):
num_eventos += 1
artista = track['artist_id']
if mp.contains(mapa_trabajo, artista) == False:
mp.put(mapa_trabajo, artista, 1)
num_artistas += 1
tot_eventos += num_eventos
keys = mp.keySet(mapa_trabajo)
top_artistas = lt.subList(keys, 1, 10)
info = (num_eventos, num_artistas, top_artistas)
mp.put(mapa_final, gender, info)
return tot_eventos, mapa_final
def countries_to_landing_point(analyzer, landing_name):
#req 5
landing_id = name_to_id(analyzer, landing_name)
country_origin = m.get(analyzer['landing_points_info'],
landing_id)['value']['country']
lstcables = m.get(analyzer['landing_points_cables'], landing_id)['value']
mapa = m.newMap()
for cable in lt.iterator(lstcables):
vertex = format_vertex(landing_id, cable)
arcos = gr.adjacentEdges(analyzer['connections'], vertex)
for arco in lt.iterator(arcos):
landing_id2 = arco['vertexB'].split('~')[0]
distance = arco['weight']
country = m.get(analyzer['landing_points_info'],
landing_id2)['value']['country']
if country == country_origin:
distance = 0
entry = (country, distance)
if not m.contains(mapa, country):
m.put(mapa, country, entry)
else:
entry2 = m.get(mapa, country)['value']
if distance < entry2[1]:
m.put(mapa, country, entry)
lista = merge.sort(m.valueSet(mapa), compare_entry_req5)
numcountries = lt.size(lista)
return numcountries, lista
def estaciones_criticas(analyzer):
estaciones = m.valueSet(analyzer["trips_age"])
estaciones_inicio = {}
estaciones_final = {}
for i in range(lt.size(estaciones)):
station = lt.getElement(estaciones, i)
estaciones_inicio[station[0][1]] = station[0][0]
estaciones_final[station[1][0]] = station[1][1]
orden_inicio = sorted(estaciones_inicio, reverse=True)
orden_final = sorted(estaciones_final,
key=operator.itemgetter(1),
reverse=True)
if len(orden_inicio) >= 3:
llegada_top = orden_inicio[0], orden_inicio[1], orden_inicio[2]
else:
llegada_top = orden_inicio[0]
if len(orden_final) >= 3:
salida_top = orden_final[0], orden_final[1], orden_final[2]
else:
salida_top = orden_final[0]
orden_inicio = sorted(estaciones_inicio.items(),
key=operator.itemgetter(1))
orden_final = sorted(estaciones_final.items(), key=operator.itemgetter(1))
menos_utilizadas = []
if len(orden_inicio) >= 3 and len(orden_final) >= 3:
menos_utilizadas.append(int(orden_inicio[0][1]) + orden_final[0][1])
menos_utilizadas.append(int(orden_inicio[1][1]) + orden_final[1][1])
menos_utilizadas.append(int(orden_final[2][1]) + orden_final[2][1])
else:
menos_utilizadas.append(
[orden_inicio[0][1] + orden_final[0][1],
int(orden_inicio[0][0])])
mayor = max(menos_utilizadas[0])
menos_utilizadas = mayor
return llegada_top, salida_top, menos_utilizadas
def videos_a_dias_trending(videos):
lst = lt.newList("ARRAY_LIST")
listaids = []
todosvideos = mp.valueSet(videos)
for i in range(mp.valueSet(videos)["size"]):
video = lt.getElement(todosvideos, i)
if not video["video_id"] == "#NAME?":
if not video["video_id"] in listaids:
listaids.append(video["video_id"])
lt.addFirst(lst, {"id": video["video_id"], "apariciones": 1})
else:
for y in lst["elements"]:
if y["id"] == video["video_id"]:
y["apariciones"] += 1
diccionariosorteado = ms.sort(lst, cmpVideosByAppearances)
return diccionariosorteado
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 edges(graph):
"""
Retorna una lista con todos los arcos del grafo graph
Args:
graph: El grafo sobre el que se ejecuta la operacion
Returns:
Una lista con los arcos del grafo
Raises:
Exception
"""
try:
lstmap = map.valueSet(graph['vertices'])
itervertex = it.newIterator(lstmap)
lstresp = lt.newList('SINGLE_LINKED', e.compareedges)
while it.hasNext(itervertex):
lstedge = it.next(itervertex)
iteredge = it.newIterator(lstedge)
while (it.hasNext(iteredge)):
edge = it.next(iteredge)
if (graph['directed']):
lt.addLast(lstresp, edge)
elif (not lt.isPresent(lstresp, edge)):
lt.addLast(lstresp, edge)
return lstresp
except Exception as exp:
error.reraise(exp, 'ajlist:edges')
def generoMasEscuchadoEnTiempo(catalog, hora_min, hora_max):
hora_min = datetime.strptime(hora_min, '%H:%M:%S')
hora_max = datetime.strptime(hora_max, '%H:%M:%S')
#hay que ver en que formato entran las horas para ver si es necesario transformarlas antes de empezar a ejecutar
lista_mapas_reps = om.values(catalog['RepsPor_hora'], hora_min, hora_max)
#esto es una lista de tuplas (genero, cantidad_reps_genero) ORDENADA por cantidad_reps_genero
generos_ordenados_por_reps = model.Reps_genero_en_horario(
catalog, lista_mapas_reps)
max_genero = lt.firstElement(generos_ordenados_por_reps)[0]
unique_tracks = model.unique_tracks(catalog, max_genero, lista_mapas_reps)
model.calculo_vaders_tracks(unique_tracks)
unique_tracks = mp.valueSet(unique_tracks)
#aqui quedan ordenados los tracks por numero de hashtags
model.Ordenar_tracks_por_hashtags(unique_tracks)
'''for track in lt.iterator(unique_tracks):
if track[0]>4:
print(track[0])'''
#esto puede borrarse y pasar la informacion de otra forma
cantidad_track_max_genero = lt.size(unique_tracks)
return generos_ordenados_por_reps, unique_tracks, cantidad_track_max_genero
