def yearsSize(catalog):
"""
Número de fechas en las que ocurrieron accidentes de todos los años.
"""
y1=om.size(catalog['2016'])
y2=om.size(catalog['2017'])
y3=om.size(catalog['2018'])
y4=om.size(catalog['2019'])
return y1 + y2 + y3 +y4
def yearsSize(catalog):
"""
Reto3 - Req1
Número de fechas en las que ocurrieron accidentes de todos los años.
"""
Año1 = om.size(catalog["2016"])
Año2 = om.size(catalog["2017"])
Año3 = om.size(catalog["2018"])
Año4 = om.size(catalog["2019"])
Año5 = om.size(catalog["2020"])
return Año1 + Año2 + Año3 + Año4, Año5
def YearSize_1(catalog):
"""
Reto3 - Req1
Número de fechas en las que ocurrieron accidentes de
cada año.
"""
Año1 = om.size(catalog["2016"])
Año2 = om.size(catalog["2017"])
Año3 = om.size(catalog["2018"])
Año4 = om.size(catalog["2019"])
Año5 = om.size(catalog["2020"])
return Año1, Año2, Año3, Año4, Año5
def YearHeight_1(catalog):
"""
Reto3 - Req1
Altura del árbol de cada año.
"""
Año1 = om.size(catalog["2016"])
Año2 = om.size(catalog["2017"])
Año3 = om.size(catalog["2018"])
Año4 = om.size(catalog["2019"])
Año5 = om.size(catalog["2020"])
return Año1, Año2, Año3, Año4, Año5
def eachYearSize(catalog):
"""
RETO3 - REQ1
Número de fechas en las que ocurrieron accidentes de
cada año.
"""
y1=om.size(catalog['2016'])
y2=om.size(catalog['2017'])
y3=om.size(catalog['2018'])
y4=om.size(catalog['2019'])
return y1 , y2 , y3 , y4
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 addCategory(catalog, event):
"""Arbol por categorias"""
category_map = catalog['content_cateogries']
keys = mp.keySet(category_map)
if lt.size(keys) <= 0:
fillHashMap(category_map)
keys = mp.keySet(category_map)
for item in lt.iterator(keys):
valor_item = float(event[item])
cate_tree = me.getValue(mp.get(category_map, item))
if cate_tree is None:
cate_tree = createCategTree()
mp.put(category_map, item, cate_tree)
if om.size(cate_tree) == 0:
tree_list = lt.newList(datastructure="ARRAY_LIST")
lt.addLast(tree_list, event)
om.put(cate_tree, valor_item, tree_list)
else:
tree_val = om.get(cate_tree, valor_item)
if tree_val is None:
tree_list = lt.newList(datastructure="ARRAY_LIST")
om.put(cate_tree, valor_item, tree_list)
else:
tree_list = me.getValue(tree_val)
lt.addLast(tree_list, event)
return catalog
def req1(catalog, caracteristica, minimo, maximo):
"""
Dada una característica de contenido y un rango para la misma,
devuelve la cantidad total de eventos de escucha y de artistas únicos.
Entradas:
- catalog: Estructura donde se almacenan los datos
- caracteristica: característica con la que se hará la consulta
- minimo: Valor mínimo para filtrar dentro de la característica
- maximo: Valor máximo para filtrar dentro de la característica
Salidas:
- Lista que almacena el total de eventos, y el total de artistas.
"""
# Se filtra por la característica y el rango dados
carac = caracteristica.lower()
carac_total = catalog["propiedades"][carac]
carac_filtrado = om.values(carac_total, minimo, maximo)
total_events = 0
artists_map = om.newMap('RBT')
# Se recorren los datos obtenidos en el filtro
for value in lt.iterator(carac_filtrado):
for event in lt.iterator(value['eventos']):
total_events += 1
key = event['artist_id']
val = 0
om.put(artists_map, key, val)
total_artists = om.size(artists_map)
return [total_events, total_artists]
def tracksgeneros(catalogo, listabusqueda):
nuevalistabusqueda = lt.newList("ARRAY_LIST")
for x in range(lt.size(listabusqueda)):
genero = lt.getElement(listabusqueda, x)
if not mp.contains(catalogo["mapageneros"], genero):
respuesta = input(
"El género " + genero +
" no está en la lista de géneros, desea añadirlo? (y/n): ")
if respuesta == "y":
minimo = float(input("Ingrese el tempo mínimo: "))
maximo = float(input("Ingrese el tempo máximo: "))
mp.put(catalogo["mapageneros"], genero, (minimo, maximo))
print("Género añadido.")
lt.addLast(nuevalistabusqueda, genero)
else:
lt.addLast(nuevalistabusqueda, genero)
# Creamos otra lista de busqueda para excluir en la búsqueda los géneros no deseados.
listaresultados = lt.newList("ARRAY_LIST")
numerototal = om.size(catalogo["datoscanciones"])
lt.addLast(listaresultados, numerototal)
for x in range(lt.size(nuevalistabusqueda)):
genero = lt.getElement(nuevalistabusqueda, x)
lt.addLast(listaresultados,
(genero,
numerocaracteristicasrango2(
catalogo, "tempo",
mp.get(catalogo["mapageneros"], genero)["value"][0],
mp.get(catalogo["mapageneros"], genero)["value"][1])))
return listaresultados
def genreSearch(analyzer, genres):
videosct = lt.newList("ARRAY_LIST")
for every_genre in genres:
tagg = mp.get(analyzer["musical_genre"], every_genre)
taggg = me.getValue(tagg)
minor = taggg["lower"]
mayor = taggg["upper"]
# filtro 1: por minKey y MaxKey
lst = om.values(analyzer["tempo"], minor, mayor)
totchar = 0 # contador
for lstdate in lt.iterator(lst):
# cuenta el número de tracks y las suma
totchar += lt.size(lstdate['events'])
taggg["totchar"] = totchar
for element in lt.iterator(lstdate["events"]):
if om.contains(taggg["events"], element["artist_id"]) == False:
om.put(taggg["events"], element["artist_id"], None)
different_artist = om.size(taggg["events"])
reproductions = taggg["totchar"]
print("========{}========".format(every_genre))
print("For {} the tempo is between {} and {} BPM".format(
every_genre, minor, mayor))
print("{} reproductions: {} with {} different artists".format(
every_genre, reproductions, different_artist))
print("---- Some artists for {}----".format(every_genre))
for pos in random.sample(range(1, different_artist), 10):
key = om.select(taggg["events"], pos)
print("Artist {}:{}".format(pos, key))
return "-"
def pistasSize(analyzer):
"""
Retorna el numero de elementos en el map de pistas
"""
pistas = analyzer['pistasIds']
return om.size(pistas)
def EstudyMusic(analyzer, min_instru, max_instru, min_tempo, max_tempo):
track_map = om.newMap(omaptype='RBT', comparefunction=compareDates)
videosct = lt.newList("ARRAY_LIST")
track_map = om.newMap(omaptype='RBT', comparefunction=compareDates)
videosct = lt.newList("ARRAY_LIST")
# filtro 1: por minKey y MaxKey de energy
lst = om.values(analyzer["instrumentalness"], min_instru, max_instru)
for lstdate in lt.iterator(lst):
for element in lt.iterator(lstdate["events"]):
if (element["tempo"] > min_tempo) and (element["tempo"] <
max_tempo):
if om.contains(track_map, element["track_id"]) == False:
om.put(
track_map, element["track_id"], {
"instrumentalness": element["instrumentalness"],
"tempo": element["tempo"]
})
size = om.size(track_map)
print("Total of unique track events: ", size)
for pos in random.sample(range(1, size), 5):
key = om.select(track_map, pos)
item = om.get(track_map, key)
value = me.getValue(item)
lt.addLast(
videosct, {
"track_id": key,
"instrumentalness": value["instrumentalness"],
"tempo": value["tempo"]
})
return videosct
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 test_put_deep(tree):
tree = omap.put(tree, 10, 'book10')
tree = omap.put(tree, 7, 'book7')
tree = omap.put(tree, 30, 'book30')
tree = omap.put(tree, 5, 'book5')
tree = omap.put(tree, 4, 'book4')
tree = omap.put(tree, 3, 'book3')
assert omap.size(tree) == 6
def indexSize(analyzer):
"""
Numero de elementos en el indice
"""
respuesta = om.size(analyzer['fechas'])
return (respuesta)
def size_Arbol(accidentes):
size = om.size(accidentes["Fechas"])
return size
lst = om.values(
accidentes['Fechas'],
initialDate,
finalDate,
)
def infAnalyzer(analyzer):
"""
Dado un analizador retorna informacion sobre este.
"""
high = om.height(analyzer['dateIndex'])
nodes = om.size(analyzer['dateIndex'])
min_key = om.minKey(analyzer['dateIndex'])
max_key = om.maxKey(analyzer['dateIndex'])
return (high, nodes, min_key, max_key)
def tercera_consulta(citibike):
tree = om.newMap(omaptype='RBT', comparefunction=compareroutes)
diccionario = {}
list_vertext = gr.vertices(citibike["graph"])
ite = it.newIterator(list_vertext)
while it.hasNext(ite):
vertex = it.next(ite)
arrive = gr.indegree(citibike["graph"], vertex)
if arrive > 0:
om.put(tree, arrive, vertex)
l = []
number = om.size(tree)
resta = abs(number - 3)
less = om.select(tree, resta)
greater = om.maxKey(tree)
ran = om.values(tree, less, greater)
i = it.newIterator(ran)
while it.hasNext(i):
name = it.next(i)
l.append(name)
diccionario["llegadas"] = l
tree_1 = om.newMap(omaptype='RBT', comparefunction=compareroutes)
list_vertext_1 = gr.vertices(citibike["graph"])
ite_1 = it.newIterator(list_vertext_1)
while it.hasNext(ite_1):
vertex_1 = it.next(ite_1)
arrive_1 = gr.outdegree(citibike["graph"], vertex_1)
if arrive_1 > 0:
om.put(tree_1, arrive_1, vertex_1)
print((citibike["graph"]))
l_1 = []
number_1 = om.size(tree_1)
resta_1 = abs(number_1 - 3)
less_1 = om.select(tree_1, resta_1)
greater_1 = om.maxKey(tree_1)
ran_1 = om.values(tree_1, less_1, greater_1)
iterar = it.newIterator(ran_1)
while it.hasNext(iterar):
name_1 = it.next(iterar)
l_1.append(name_1)
diccionario["salidas"] = l_1
return diccionario
def crimesSize(dicci):
"""
Número de crimenes
"""
return om.size(dicci['instrumentalness']), om.size(
dicci['acousticness']), om.size(dicci['liveness']), om.size(
dicci['speechiness']), om.size(dicci['energy']), om.size(
dicci['danceability']), om.size(dicci['valence'])
def rango_caracteristica(catalog, caracteristica, rango_inf, rango_sup):
map = mp.get(catalog['index_caracteristica'], caracteristica)
arbol = me.getValue(map)
valores_rango = om.values(arbol, rango_inf, rango_sup)
cantidad_eventos = lt.size(valores_rango)
lista_autores = autores_unicos(valores_rango)
autores = lt.size(lista_autores)
tamaño = om.size(arbol)
altura = om.height(arbol)
return (tamaño, altura, cantidad_eventos, autores)
def consulta_propiedades_carga(analyzer):
artistas = om.size(analyzer['EvByArtists'])
pistas = om.size(analyzer['EvByPista'])
size_lista = mp.size(analyzer['tracks'])
keys = mp.keySet(analyzer['tracks'])
primeros_5 = lt.subList(keys, 1, 5)
ultimos_5 = lt.subList(keys, size_lista - 4, 5)
lista_1 = lt.newList(datastructure='ARRAY_LIST', cmpfunction=compareIds)
lista_2 = lt.newList(datastructure='ARRAY_LIST', cmpfunction=compareIds)
for key in lt.iterator(primeros_5):
entry = mp.get(analyzer['tracks'], key)
track = me.getValue(entry)
lt.addLast(lista_1, track)
for key in lt.iterator(ultimos_5):
entry = mp.get(analyzer['tracks'], key)
track = me.getValue(entry)
lt.addLast(lista_2, track)
return artistas, pistas, size_lista, lista_1, lista_2
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 consulta_propiedades(analyzer):
mapa = analyzer['EvByCaracteristics']
keys = mp.keySet(mapa)
propiedades = lt.newList('SINGLE_LINKED')
for i in lt.iterator(keys):
entry = mp.get(mapa, i)
arbol = me.getValue(entry)
altura = om.height(arbol)
elementos = om.size(arbol)
lt.addFirst(propiedades, (altura, elementos))
return propiedades
def test_height(tree):
tree = om.put(tree, 23, 'book21')
tree = om.put(tree, 7, 'book7')
tree = om.put(tree, 30, 'book30')
tree = om.put(tree, 5, 'book5')
tree = om.put(tree, 4, 'book4')
tree = om.put(tree, 3, 'book3')
tree = om.put(tree, 20, 'book20')
tree = om.put(tree, 25, 'book25')
tree = om.put(tree, 35, 'book35')
tree = om.put(tree, 29, 'book29')
tree = om.put(tree, 11, 'book11')
tree = om.put(tree, 15, 'book15')
tree = om.put(tree, 10, 'book10')
assert om.size(tree) == 13
assert om.height(tree) == 4
tree = om.put(tree, 37, 'book11')
tree = om.put(tree, 40, 'book15')
tree = om.put(tree, 45, 'book10')
assert om.size(tree) == 16
assert om.height(tree) == 5
def test_get(tree):
tree = omap.put(tree, 10, 'book10')
tree = omap.put(tree, 7, 'book7')
tree = omap.put(tree, 30, 'book30')
tree = omap.put(tree, 5, 'book5')
tree = omap.put(tree, 4, 'book4')
tree = omap.put(tree, 3, 'book3')
assert omap.size(tree) == 6
node = omap.get(tree, 3)
assert node['value'] == 'book3'
node = omap.get(tree, 34)
assert node is None
def Requerimiento4(analyzer, str_generos):
generos_lower = str_generos.lower()
lista_generos = generos_lower.split(',')
final = lt.newList()
for i in range(len(lista_generos)):
lista_genero = lt.newList()
mapa = analyzer['genres']
busqueda_map = om.get(mapa, lista_generos[i])
tupla = me.getValue(busqueda_map)
name = me.getKey(busqueda_map)
minTemp = int(tupla[0])
maxTemp = int(tupla[1])
keys_in_range = om.keys(analyzer['tempo'], minTemp, maxTemp)
events_parciales = lt.size(keys_in_range)
lt.addLast(lista_genero, events_parciales)
mp_artistas = om.newMap()
lt_artistas = lt.newList()
for i in range(lt.size(keys_in_range)):
key = float(lt.getElement(keys_in_range, i))
mapa_tempo = analyzer['tempo']
valores = om.get(mapa_tempo, key)
valores = me.getValue(valores)
for i in range(lt.size(valores)):
valor = lt.getElement(valores, i)
exist = om.contains(mp_artistas, valor['artist_id'])
if not exist:
artist_id = valor['artist_id']
om.put(mp_artistas, artist_id, valor)
while lt.size(lt_artistas) <= 10:
lt.addLast(lt_artistas, artist_id)
artistas_parciales = om.size(mp_artistas)
lt_final_genero = [
name, minTemp, maxTemp, events_parciales, artistas_parciales,
lt_artistas
]
lt.addLast(final, lt_final_genero)
max_eventos = 0
for i in range(lt.size(final)):
listilla = lt.getElement(final, i)
max_eventos += int(listilla[3])
requerimiento_4_print(max_eventos, final)
def test_remove(tree):
tree = om.put(tree, 23, 'book21')
tree = om.put(tree, 7, 'book7')
tree = om.put(tree, 30, 'book30')
tree = om.put(tree, 5, 'book5')
tree = om.put(tree, 4, 'book4')
tree = om.put(tree, 3, 'book3')
tree = om.put(tree, 20, 'book20')
tree = om.put(tree, 25, 'book25')
tree = om.put(tree, 35, 'book35')
tree = om.put(tree, 29, 'book29')
tree = om.put(tree, 11, 'book11')
tree = om.put(tree, 15, 'book15')
tree = om.put(tree, 10, 'book10')
tree = om.put(tree, 37, 'book11')
tree = om.put(tree, 40, 'book15')
tree = om.put(tree, 45, 'book10')
assert om.size(tree) == 16
assert om.contains(tree, 11) is True
tree = om.remove(tree, 11)
assert om.size(tree) == 15
assert om.contains(tree, 11) is False
def req4(catalog, generos):
"""
Dada una lista de géneros existentes y/o nuevos, se devuelve información
de los mismos como los eventos de escucha y algunos de sus artistas.
Entradas:
- catalog: Estructura donde se almacenan los datos
- generos: Lista de géneros dados
Salidas:
- Lista con la información sobre los géneros y sus artistas, y la cantidad
total de eventos.
"""
tempo_total = catalog["propiedades"]["tempo"]
nuevos_generos = lt.newList(datastructure='ARRAY_LIST')
events_map = om.newMap('RBT')
contador = 1
while contador <= lt.size(generos):
artists_list = lt.newList(datastructure='ARRAY_LIST')
total_events = 0
genero = lt.getElement(generos, contador)
# Se filtra el Map de Tempo para cada género dado
tempo_filtrado = om.values(tempo_total, genero[1], genero[2])
for value in lt.iterator(tempo_filtrado):
for event in lt.iterator(value['eventos']):
total_events += 1
val = 0
# Se añaden los eventos a un mapa para contar la cantidad en cada género
om.put(events_map, event['id'], val)
# Se añaden los artistas a un mapa para identificar los artistas "únicos"
elem = event['artist_id']
contiene = lt.isPresent(artists_list, elem)
if contiene:
pass
else:
lt.addLast(artists_list, elem)
total_artists = lt.size(artists_list)
ten_artists = lt.subList(artists_list, 1, 10)
nuevo = {}
nuevo["info"] = genero
nuevo["artistas"] = total_artists
nuevo["eventos"] = total_events
nuevo["10artistas"] = ten_artists
lt.addLast(nuevos_generos, nuevo)
contador += 1
total_tot_eventos = om.size(events_map)
return [nuevos_generos, total_tot_eventos]
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 test_get(tree):
tree = om.put(tree, 10, 'book10')
tree = om.put(tree, 7, 'book7')
tree = om.put(tree, 30, 'book30')
tree = om.put(tree, 5, 'book5')
tree = om.put(tree, 4, 'book4')
tree = om.put(tree, 3, 'book3')
assert om.size(tree) == 6
assert om.contains(tree, 3) is True
node = om.get(tree, 3)
assert node['value'] == 'book3'
node = om.get(tree, 34)
assert om.contains(tree, 34) is False
assert node is None
