def reque2(main, e, E, d, D):
if float(om.minKey(main)) > e: e == float(om.minKey(main))
if float(om.maxKey(main)) < E: E == float(om.maxKey(main))
nums = get_inter(om.keySet(main), e, E)
ans = {'idlist': {}, 'for_show': lt.newList('SINGLE_LINKED')}
y = 1
while y <= lt.size(nums):
num = lt.getElement(nums, y)
pair = om.get(main, num)
mini = me.getValue(pair)
if float(om.minKey(mini)) > d: d == float(om.minKey(mini))
if float(om.maxKey(mini)) < D: D == float(om.maxKey(mini))
sub_nums = get_inter(om.keySet(mini), d, D)
x = 1
while x <= lt.size(sub_nums):
sub_num = lt.getElement(sub_nums, x)
sub_pair = om.get(mini, sub_num)
events = me.getValue(sub_pair)
z = 1
while z <= lt.size(events):
e = lt.getElement(events, z)
id = e['track_id']
lt.addFirst(ans['for_show'], e)
ans['idlist'][id] = 1
z += 1
x += 1
y += 1
return ans
def count_intervalINF(main, m, M):
ans = {'events': 0, 'idlist': lt.newList('SINGLE_LINKED')}
y = 1
nums = om.keySet(main)
while y <= lt.size(nums):
num = lt.getElement(nums, y)
pair = om.get(main, num)
mini = me.getValue(pair)
if float(om.minKey(mini)) > m: m == float(om.minKey(mini))
if float(om.maxKey(mini)) < M: M == float(om.maxKey(mini))
sub_nums = get_inter(om.keySet(mini), m, M)
x = 1
while x <= lt.size(sub_nums):
sub_num = lt.getElement(sub_nums, x)
sub_pair = om.get(mini, sub_num)
events = me.getValue(sub_pair)
z = 1
while z <= lt.size(events):
e = lt.getElement(events, z)
id = e['artist_id']
ans['events'] += 1
ans['idlist'][id] = 1
z += 1
x += 1
y += 1
return ans
def printReq4 (respuesta):
print('\n++++++ Req No. 4 results... +++++\n'+'Total of reproductions: '+str(respuesta[1]))
for genero in lt.iterator(om.keySet(respuesta[0])):
eventos, tamaño_mapa, mapa, menor, mayor = me.getValue(om.get(mapa_generos, genero))
print("\n========"+" "+genero.upper()+" "+"========")
print("For "+genero+" the tempo is between "+str(menor)+" and "+str(mayor)+" BPM")
print(genero+" reproductions: "+str(eventos)+" with "+str(tamaño_mapa)+" different artists")
print("-----"+" Some artists for "+genero+" "+"-----")
n = 1
for artista in lt.iterator(om.keySet(mapa)):
print('Artist '+str(n)+': '+str(artista))
n += 1
if n == 11:
break
def printMusicapara(respuesta, c1, c2):
print("\nTotal de pistas únicas: " + str(respuesta[0]))
print("\n... Unique track id ...\n")
cont = 0
lst = om.valueSet(respuesta[1])
cod = om.keySet(respuesta[1])
if lt.size(cod) >= 5:
for id in lt.iterator(cod):
datos = om.get(respuesta[1],id)
valor = datos["value"]
cont += 1
print("Track: "+ str(id) + " with " + str(c1) + " of " + str(valor[0]) +
" and " + str(c2) + " of " + str(valor[1]) + "\n")
if cont > 4:
return
else:
for id in lt.iterator(cod):
for pista in lt.iterator(lst):
while cont <= lt.size(lst):
cont += 1
print("Track: "+ str(id) + " with " + str(c1) + " of " + str(pista[0]) +
" and " + str(c2) + " of " + str(pista[1]) + "\n")
def TM(analyzer,M):
rank=oms.newMap('BST',comparefunction=comparerMap)
rankp=oms.newMap('BST',comparefunction=comparerMap)
sancocho=om.valueSet(analyzer["indice"])
for papa in sancocho:
if oms.contains(rank,papa["company"])==True:
new=oms.get(rank,papa["company"])
nueva=lt.newList(new.values())
lt.addLast(nueva,papa["taxi_id"])
oms.put(rank,str(new.keys()),nueva)
if papa["company"]=="" and oms.contains(rank,"Independent Owner")==True:
news=oms.get(rank,"Independent Owner")
nuevas=lt.newList(news.values())
lt.addLast(nuevas,papa["taxi_id"])
oms.put(rank,str(news.keys()),nuevas)
else:
if papa["company"]=="":
oms.put(rank,"Independent Owner",1)
oms.put(rank,papa["company"],1)
for com in list(rank):
oms.put(rankp,lt.size(set(list(com.values()))),str(com.keys()))
ranki=lt.newList()
for puesto in range(M):
p=oms.maxKey(rankp)
lt.addLast(ranki,dict(om.keySet(rank)[om.valueSet(rank).index(p)],p))
oms.deleteMax(rankp)
return ranki
def count_intervalSUP(main, nums):
ans = {'events': 0, 'idlist': {}}
y = 1
while y <= lt.size(nums):
num = lt.getElement(nums, y)
pair = om.get(main, num)
mini = me.getValue(pair)
sub_nums = om.keySet(mini)
x = 1
while x <= lt.size(sub_nums):
sub_num = lt.getElement(sub_nums, x)
sub_pair = om.get(mini, sub_num)
events = me.getValue(sub_pair)
z = 1
while z <= lt.size(events):
e = lt.getElement(events, z)
ans['events'] += 1
id = e['artist_id']
ans['idlist'][id] = 1
z += 1
x += 1
y += 1
return ans
def printConnectedCountries(analyzer, landingpoint):
"""
Imprime los países conectados a un punto de conexión específico
en orden descendente por distancia en km
"""
ordmap = controller.getConnectedCountries(analyzer, landingpoint)
lstcountries = lt.newList('ARRAY_LIST')
keys = om.keySet(ordmap)
values = om.valueSet(ordmap)
size = om.size(ordmap)
index = 1
count = 1
print("\n---------- Países afectados ----------")
while index <= size:
country = lt.getElement(values, index)
distance = lt.getElement(keys, index)
if not lt.isPresent(lstcountries, country):
print(
str(count) + ". " + str(country) + " Distancia: " +
str(distance) + " km")
lt.addLast(lstcountries, country)
index += 1
count += 1
else:
index += 1
print()
print("Total países afectados: " + str(lt.size(lstcountries)) + "\n")
def muestradatos(analyzer):
keys = om.keySet(analyzer['mapaTaxi'])
itera = it.newIterator(keys)
#mapa ordenado
while (it.hasNext(itera)):
key = it.next(itera)
entryMapa = om.get(analyzer['mapaTaxi'], key)
valorMapa = me.getValue(entryMapa)
itera2 = it.newIterator(valorMapa['lstidtaxi'])
while (it.hasNext(itera2)):
valor = it.next(
itera2
) # {'idtaxi': None, 'servicios':None, 'millas':None, 'totalDinero': None, 'puntos': None}
#if valor['totalDinero'] == 0:
if ('7075c4988c577798c58b800dbb9742376dbbb74a84ce6ead178e7d00afcaafa6ac936cd9af7b6685991b9121b629de30650958fa926c5472da0083a63ed285c7'
in valor['idtaxi']):
print(valor['idtaxi'])
print(valor['servicios'])
print(valor['millas'])
print(valor['totalDinero'])
print(valor['puntos'])
print("")
def servicesRanking(analyzer, N):
companies = om.keySet(analyzer["companiesServices"])
services = om.valueSet(analyzer["companiesServices"])
mapaServ = om.newMap(omaptype="BST", comparefunction=cmpCompanies)
for i in range(lt.size(companies)):
empresa = lt.getElement(companies, i)
numserv = lt.getElement(services, i)
if om.contains(mapaServ, numserv) == True:
infoserv = om.get(mapaServ, numserv)
empresas = infoserv["value"]
lt.addLast(empresas, empresa)
om.put(mapaServ, numserv, empresas)
else:
empresas = lt.newList("ARRAY_LIST", None)
lt.addLast(empresas, empresa)
om.put(mapaServ, numserv, empresas)
tam = om.size(mapaServ)
tam = tam - 1
for i in range(N):
k = tam - i
emp = om.select(mapaServ, k)
pareja = om.get(mapaServ, emp)
lista = pareja["value"]
nums = lista["elements"]
info = str(tam - k + 1) + ". " + str(nums[0]) + ": " + str(emp)
print(info)
def travel_map(Map, tree=False):
lst = om.keySet(Map) if tree else m.keySet(Map)
iter = it.newIterator(lst)
while it.hasNext(iter):
key = it.next(iter)
value = om.get(Map, key) if tree else m.get(Map, key)
yield key, (None if value is None else value["value"])
def metal(maps):
'''
Funcion que retorna la cantidad de de reproducciones de
canciones de genero metal, la cantidad de artistas unicos
y 10 id's de artistas al azar
'''
# Aca se agregaran los artistas unicos
metalmap = om.newMap(omaptype='RBT')
reproductions = 0
# Se obtienen los eventos en el rango del genero
metal = om.values(maps["tempo"], 100, 160)
# Recorre el arbol y busca los valores del genero
iterator = ite.newIterator(metal)
while ite.hasNext(iterator):
eventlist = ite.next(iterator)
# agrega la cantidad de videos que hay dentro de cada valor
reproductions += lt.size(eventlist['lstevent'])
newiterator = ite.newIterator(eventlist['lstevent'])
while ite.hasNext(newiterator):
event = ite.next(newiterator)
# Agrega a los artistas a un mapa para saber los unicos
om.put(metalmap, event['artist_id'], event)
# Es una lista con 5 artists_id al azar
lista = om.keySet(metalmap)
size = lt.size(lista)
artistslist = get10artists(metalmap, lista, size)
return reproductions, artistslist, size
def conocerZonaGeografica(cont, radio, longitud, latitud, anio):
"""
cont: analyzer
Radio: En que se encuentran los accidentes
longitud: coordenada
latitud: coordenada
centro=(latitud,longitud)
"""
cantidad = 0
for i in range(2016, 2020):
if cont[str(i)][0] != None:
shaves = om.keySet(cont[str(i)][0]['dateIndex'])
iterator = it.newIterator(shaves)
while it.hasNext(iterator):
date = it.next(iterator)
data = om.get(cont[str(i)][0]['dateIndex'], date)
values = me.getValue(data)['offenseIndex']
accidents = m.keySet(values)
iterator2 = it.newIterator(accidents)
while it.hasNext(iterator2):
actual = m.get(values, it.next(iterator2))
data = me.getValue(actual)['lstoffenses']
siguiente = it.newIterator(data)
while it.hasNext(siguiente):
current = it.next(siguiente)
if inRadio(radio, longitud, latitud, current) == True:
cantidad += 1
return cantidad
def CompaniasConTaxi(analyzer):
lista_companias = lt.newList(datastructure='SINGLE_LINKED',
cmpfunction=None)
cada_compania = om.keySet(analyzer['companias'])
lt.addLast(lista_companias, cada_compania)
return lista_companias
def reque1_SUP(main, m, M):
if (float(om.minKey(main))) > m: m == (float(om.minKey(main)))
if (float(om.maxKey(main))) < M: M == (float(om.maxKey(main)))
nums = get_inter(om.keySet(main), m, M)
dans = count_intervalSUP(main, nums)
k = len(dans['id_list'].keys())
ans = {'t_eve': dans['events'], 't_art': k}
return ans
def getArtistsInList(catalog, posList):
tempArtists = om.newMap(omaptype="BST", comparefunction=cmpArtistId)
for pos in posList:
rep = lt.getElement(catalog["reps"], pos)
existsArtist = om.contains(tempArtists, rep["artist_id"])
if existsArtist == False:
om.put(tempArtists, rep["artist_id"], 0)
artistList = om.keySet(tempArtists)
numArtists = lt.size(artistList)
return (numArtists, artistList)
def consulta_auxiliar(analyzer):
arbol_hora = analyzer['EvByHour']
horas = om.keySet(arbol_hora)
num_reproducciones = 0
num_tracks = 0
for hora in lt.iterator(horas):
entry = om.get(arbol_hora, hora)
arbol_tempo = me.getValue(entry)
tempos = om.keySet(arbol_tempo)
for tempo in lt.iterator(tempos):
entry_tempo = om.get(arbol_tempo, tempo)
estructura = me.getValue(entry_tempo)
eventos = estructura['mapa_completo']
mapa_tracks = estructura['mapa_unicos']
tracks = mp.keySet(mapa_tracks)
num_reproducciones += lt.size(eventos)
num_tracks += lt.size(tracks)
print(f"Reproducciones: {num_reproducciones}\nTracks: {num_tracks}")
return None
def taxisPointsByDateRange(analyzer, M, fecha1, fecha2):
taxis = om.keySet(analyzer["taxisPoints"])
rankingFechas = om.newMap(omaptype="BST", comparefunction=cmpTaxiId)
dia1 = fecha1[8:10]
mes1 = fecha1[5:7]
año1 = fecha1[0:4]
dia2 = fecha1[8:10]
mes2 = fecha1[5:7]
año2 = fecha1[0:4]
for i in range(lt.size(taxis)):
puntosLlave = 0.00000
taxi = lt.getElement(taxis, i)
info = om.get(analyzer["taxisPoints"], taxi)
tuplas = info["value"]
for j in range(lt.size(tuplas)):
tupla = lt.getElement(tuplas, j)
puntosFecha = tupla[1]
dia = puntosFecha[8:10]
mes = puntosFecha[5:7]
año = puntosFecha[0:4]
if (año1 < año and año < año2) or año1 == año or año2 == año:
if (mes1 < mes and mes < mes2) or mes1 == mes or mes2 == mes:
if (dia1 < dia
and dia < dia2) or dia1 == dia or dia2 == dia:
if tupla[0] > puntosLlave:
puntosLlave = tupla[0]
puntosFecha = tupla[1]
if om.contains(rankingFechas, puntosLlave) == False:
taxiList = lt.newList("ARRAY_LIST", None)
lt.addLast(taxiList, taxi)
om.put(rankingFechas, puntosLlave, taxiList)
elif om.contains(rankingFechas, puntosLlave) == True:
info = om.get(rankingFechas, puntosLlave)
taxiList = info["value"]
lt.addLast(taxiList, taxi)
om.put(rankingFechas, puntosLlave, taxiList)
tam = om.size(rankingFechas)
tam = tam - 1
for i in range(M):
k = tam - i
puntos = om.select(rankingFechas, k)
pareja = om.get(rankingFechas, puntos)
lista = pareja["value"]
taxisN = lista["elements"]
x = "x"
info = str(tam - k + 1) + ". Taxi ID: " + str(
taxisN) + ", Puntos: " + str(puntos)
print(info)
def llavesHasta(cont, date):
llaves = {}
for i in range(2016, 2020):
if cont[str(i)][0] != None:
if str(i) not in str(date):
llaves[str(i)] = om.keySet(cont['dateIndex'])
else:
initialDate = om.minKey(cont[str(i)][0]['dateIndex'])
finalDate = om.floor(cont[str(i)][0]['dateIndex'], date)
llaves[str(i)] = om.keys(cont[str(i)][0]['dateIndex'],
initialDate, finalDate)
break
return llaves
def printTopTen(map):
"""
Hace print del top ten generos
"""
pos = 1
size = om.size(map)
keys = om.keySet(map)
print("TOP 9 GENEROS POR REPRODUCCIÓN:")
while pos <= size:
key = lt.getElement(keys, pos)
entry = om.get(map, key)
value = me.getValue(entry)
print("TOP " + str(pos) + ": " + str(value) + " con " + str(key))
pos += 1
def printTotalEvents(events):
"""
Imprime el total de reproducciones para todos los
géneros
"""
index = 1
map = events[0]
genres = controller.getEventsByGenre(map)
keys = om.keySet(genres)
totalevents = 0
while index <= int(om.size(genres)):
tracks = lt.getElement(keys, index)
totalevents += int(tracks)
index += 1
return totalevents
def characterizeReproductions(analyzer, characteristic, minval, maxval):
totevents = 0
artists = 0
for key in lt.iterator(om.keySet(analyzer['artistIndex'])):
charMap = me.getValue(om.get(analyzer['artistIndex'], key))
lst = om.values(charMap[characteristic], minval, maxval)
eventsArtist = 0
for lstevent in lt.iterator(lst):
eventsArtist += lt.size(lstevent['lstevents'])
totevents += eventsArtist
if eventsArtist != 0:
artists += 1
return [totevents, artists]
def topCompanies(analyzer,quantity):
llaves=m.keySet(analyzer["company"])
iterador=it.newIterator(llaves)
orderedmap=om.newMap(omaptype="RBT",comparefunction=CompaniesComparer)
while it.hasNext(iterador):
llave=it.next(iterador)
clave=m.get(analyzer['company'],llave)['value'][0]
compañia={'quantity':clave,'company':llave}
om.put(orderedmap,clave,llave)
llaves=om.keySet(orderedmap)
iterador=it.newIterator(llaves)
retorno=[]
for x in range(lt.size(llaves)-quantity,lt.size(llaves)):
llave=lt.getElement(llaves,x)
retorno.append([om.get(orderedmap,llave)['value'],om.get(orderedmap,llave)['key']])
return retorno
def requerimiento3(catalog, menor1, mayor1, menor2, mayor2):
"""
Devuelve el total de canciones únicas y un mapa con 5 canciones
aleatorias que cumplen con dos rangos de características
"""
# Mapa donde se guardan las canciones que cumplen con el rango
# de tempo, el valor es una tupla con el instrumentalness y el
# energy de la canción
mapa_tempo = om.newMap('BST')
# Lista de listas de eventos que cumplen con el rango de tempo
lista_rango = om.values(catalog['tempo'], menor2, mayor2)
for lista_instrumentalness in lt.iterator(lista_rango):
for e in lt.iterator(lista_instrumentalness):
om.put(mapa_tempo, e['track_id'],
(e['instrumentalness'], e['tempo']))
# Lista de las canciones que cumplen con el tempo
canciones = om.keySet(mapa_tempo)
# Se recorre la lista de canciones que cumple con tempo y
# se revisa cuáles de esas no cumplen con el rango de
# instrumentalness y se eliminan del mapa
for cancion in lt.iterator(canciones):
instrumental = (me.getValue(om.get(mapa_tempo, cancion)))[0]
tempo = (me.getValue(om.get(mapa_tempo, cancion)))[1]
if not (instrumental <= mayor1 and instrumental >= menor1):
om.remove(mapa_tempo, cancion)
# Se obtiene el tamaño del mapa
tamaño = om.size(mapa_tempo)
# Se crea un mapa para guardar las 5 llaves aleatorias y sus valores
mapa_aleatorias = om.newMap('RBT')
# Se obtiene una lista con cinco números aleatorios no repetidos
# que estén dentro del rango del tamaño
lista_cinco_aleatorios = random.sample(range(tamaño), 5)
for i in lista_cinco_aleatorios:
llave_aleatoria = om.select(mapa_tempo, i)
valor = me.getValue(om.get(mapa_tempo, llave_aleatoria))
om.put(mapa_aleatorias, llave_aleatoria, valor)
return tamaño, mapa_aleatorias
def requerimiento2(catalog, menor1, mayor1, menor2, mayor2):
"""
Devuelve el total de canciones únicas y un mapa con 5 canciones
aleatorias que cumplen con dos rangos de características
"""
# Mapa donde se guardan las canciones que cumplen con el rango
# de danceability, el valor es una tupla con el energy y el
# danceability de la canción
mapa_dance = om.newMap('BST')
# Lista de listas de eventos que cumplen con el rango de danceability
lista_rango = om.values(catalog['danceability'], menor2, mayor2)
for lista_energy in lt.iterator(lista_rango):
for e in lt.iterator(lista_energy):
om.put(mapa_dance, e['track_id'], (e['energy'], e['danceability']))
# Lista de las canciones que cumplen con el danceability
canciones = om.keySet(mapa_dance)
# Se recorre la lista de canciones que cumple con danceability y
# se revisa cuáles de esas no cumplen con el rango de energy y
# se eliminan del mapa
for cancion in lt.iterator(canciones):
energy = (me.getValue(om.get(mapa_dance, cancion)))[0]
dance = (me.getValue(om.get(mapa_dance, cancion)))[1]
if not (energy <= mayor1 and energy >= menor1):
om.remove(mapa_dance, cancion)
# Se obtiene el tamaño del mapa
tamaño = om.size(mapa_dance)
# Se crea un mapa para guardar las llaves aleatorias y sus valores
mapa_aleatorias = om.newMap('RBT')
# Se obtiene una lista con cinco números aleatorios no repetidos
# que estén dentro del rango del tamaño
lista_cinco_aleatorios = random.sample(range(tamaño), 5)
for i in lista_cinco_aleatorios:
llave_aleatoria = om.select(mapa_dance, i)
valor = me.getValue(om.get(mapa_dance, llave_aleatoria))
om.put(mapa_aleatorias, llave_aleatoria, valor)
return tamaño, mapa_aleatorias
def Totaltaxis(analyzer):
total_taxis = 0
nombres = om.keySet(analyzer['companias'])
iter = it.newIterator(nombres)
while it.hasNext(iter):
cada_compania = it.next(iter)
nombre_compania = om.get(analyzer['companias'], cada_compania)
if nombre_compania['key'] is not None:
taxis = me.getValue(nombre_compania)['taxis_afiliados']
if taxis is not None:
num_taxis = m.size(taxis)
total_taxis += num_taxis
return (total_taxis)
# print("TOTAL TAXIS: "+ str(total_taxis))
return (taxisXCompania)
def llavesEnRango(cont, initialDate, finalDate, anio):
llaves = {}
if anio['type'] == 0:
llaves[anio['anio']] = om.keys(cont[anio['anio']][0]['dateIndex'],
initialDate, finalDate)
else:
for i in range(int(str(initialDate)[:4]), int(str(finalDate)[:4]) + 1):
if str(i) in str(initialDate):
mayor = om.maxKey(cont[str(i)][0]['dateIndex'])
llaves[str(i)] = om.keys(cont[str(i)][0]['dateIndex'],
initialDate, mayor)
elif str(i) in str(finalDate):
menor = om.minKey(cont[str(i)][0]['dateIndex'])
llaves[str(i)] = om.keys(cont[str(i)][0]['dateIndex'], menor,
finalDate)
else:
llaves[str(i)] = om.keySet(cont[str(i)][0]['dateIndex'])
return llaves
def taxisPointsByDate(analyzer, N, fecha):
taxis = om.keySet(analyzer["taxisPoints"])
#pointsLists = om.valueSet(analyzer["taxisPoints"])
rankingFechas = om.newMap(omaptype="BST", comparefunction=cmpTaxiId)
for i in range(lt.size(taxis)):
puntosLlave = 0.00000
taxi = lt.getElement(taxis, i)
info = om.get(analyzer["taxisPoints"], taxi)
tuplas = info["value"]
for j in range(lt.size(tuplas)):
tupla = lt.getElement(tuplas, j)
puntosFecha = tupla[1]
if tupla[0] > puntosLlave and tupla[1] == fecha:
puntosLlave = tupla[0]
puntosFecha = tupla[1]
if puntosFecha == fecha and om.contains(rankingFechas,
puntosLlave) == False:
taxiList = lt.newList("ARRAY_LIST", None)
lt.addLast(taxiList, taxi)
om.put(rankingFechas, puntosLlave, taxiList)
elif puntosFecha == fecha and om.contains(rankingFechas,
puntosLlave) == True:
info = om.get(rankingFechas, puntosLlave)
taxiList = info["value"]
lt.addLast(taxiList, taxi)
om.put(rankingFechas, puntosLlave, taxiList)
tam = om.size(rankingFechas)
tam = tam - 1
for i in range(N):
k = tam - i
puntos = om.select(rankingFechas, k)
pareja = om.get(rankingFechas, puntos)
lista = pareja["value"]
taxisN = lista["elements"]
info = str(tam - k + 1) + ". Taxi ID: " + str(
taxisN) + ", Puntos: " + str(puntos)
print(info)
def TaxisPorCompania(analyzer):
taxisXCompania = om.newMap(omaptype='RBT', comparefunction=compareIds)
total_taxis = 0
nombres = om.keySet(analyzer['companias'])
iter = it.newIterator(nombres)
while it.hasNext(iter):
cada_compania = it.next(iter)
nombre_compania = om.get(analyzer['companias'], cada_compania)
if nombre_compania['key'] is not None:
taxis = me.getValue(nombre_compania)['taxis_afiliados']
# print(taxis)
if taxis is not None:
num_taxis = m.size(taxis)
total_taxis += num_taxis
om.put(taxisXCompania, num_taxis, cada_compania)
# print(om.valueSet(taxisXCompania))
# print(om.keySet(taxisXCompania))
return (taxisXCompania)
def Req1(analyzer, caracteristica, limInf, limSup):
try:
entry = mp.get(analyzer['content'], caracteristica)
arbol = me.getValue(entry)
if arbol is not None:
totalRepro = 0
valores = om.values(arbol, limInf, limSup)
arbol_artistas = om.newMap(omaptype="RBT")
for lista in lt.iterator(valores):
for evento in lt.iterator(lista):
totalRepro += 1
nombre_artista = evento["artist_id"]
existe = om.get(arbol_artistas, nombre_artista)
if existe is None:
om.put(arbol_artistas, nombre_artista, nombre_artista)
lista_artistas = om.keySet(arbol_artistas)
numArtistas = lt.size(lista_artistas)
return totalRepro, numArtistas
except Exception:
return None
def printMostConnectedLandingPoint(analyzer):
"""
Imprime el punto de conexión con mayor número de
conexiones
"""
ordmap = controller.mostConnectedLandingPoint(analyzer)
keys = om.keySet(ordmap)
index = 1
print("---------- Puntos de conexión críticos ----------")
while index <= 5:
key = lt.getElement(keys, index)
value = me.getValue(om.get(ordmap, key))
name = value.split('-')[0]
country = value.split('-')[1]
print(
str(index) + ". Nombre: " + str(name) + " País: " + str(country) +
" Identificador: " + str(value))
print(" Total cables conectados: " + str(key))
index += 1
print()
