def musica_req3(valor_minTempo, valor_maxTempo, valor_minInstrumentalness,
valor_maxInstrumentalness, catalog):
"""
Retorna una lista con las canciones
"""
tracksUnicos = lt.newList('ARRAY_LIST')
canciones = lt.newList('ARRAY_LIST')
artistasRepetidos = lt.newList('ARRAY_LIST')
MapInstrumentalness = mp.get(catalog['caraContenido'], 'instrumentalness')
RBTInstrumentalness = me.getValue(MapInstrumentalness)
lista_listas_Instrumentalness = om.values(RBTInstrumentalness,
valor_minInstrumentalness,
valor_maxInstrumentalness)
lista_Instrumentalness = it.newIterator(lista_listas_Instrumentalness)
while it.hasNext(lista_Instrumentalness):
listas_musica = it.next(lista_Instrumentalness)
musicas = it.newIterator(listas_musica)
while it.hasNext(musicas):
musica = it.next(musicas)
if (musica['tempo'] >= valor_minTempo
and musica['tempo'] <= valor_maxTempo):
if int(lt.isPresent(tracksUnicos, musica['track_id'])) == 0:
lt.addLast(tracksUnicos, musica['track_id'])
if int(
lt.isPresent(
artistasRepetidos,
(musica['created_at'] + musica['user_id'] +
musica['track_id']))) == 0:
lt.addLast(artistasRepetidos,
(musica['created_at'] + musica['user_id'] +
musica['track_id']))
lt.addLast(canciones, musica)
else:
if int(
lt.isPresent(
artistasRepetidos,
(musica['created_at'] + musica['user_id'] +
musica['track_id']))) == 0:
lt.addLast(artistasRepetidos,
(musica['created_at'] + musica['user_id'] +
musica['track_id']))
lt.addLast(canciones, musica)
return canciones, tracksUnicos
def top_servcios(catalogo):
llaves=m.keySet(catalogo["lista_compañias"])
ite=it.newIterator(llaves)
lista=lt.newList(datastructure='SINGLE_LINKED', cmpfunction=None)
while it.hasNext(ite):
llave=it.next(ite)
pareja=m.get(catalogo["lista_compañias"],llave)
lt.addLast(lista,pareja)
mer.mergesort(lista,comparar_data_servicios)
return lista
def printElementData(element):
"""
Imprime los datos de un elemento determinado
"""
print('Promedio: ' + str(round(element['average_rating'], 2)))
print('Total de películas: ' + str(lt.size(element['movies'])))
iterator = it.newIterator(element['movies'])
while it.hasNext(iterator):
movie = it.next(iterator)
print('Película: ' + movie['title'])
def printReq3(resp):
print("\n")
print("TOP 3 ESTACIONES DE SALIDA")
itresp = it.newIterator(resp["salidas"])
while it.hasNext(itresp):
M = it.next(itresp)
print("- " + M)
print("\n")
print("TOP 3 ESTACIONES DE DESTINO")
itresp2 = it.newIterator(resp["llegadas"])
while it.hasNext(itresp2):
F = it.next(itresp2)
print("- " + F)
print("\n")
print("TOP 3 ESTACIONES MENOS USADAS")
itresp3 = it.newIterator(resp["usadas"])
while it.hasNext(itresp3):
R = it.next(itresp3)
print("- " + R)
def imprimirActores(result):
print("\nPelículas de:", actor)
iterator = it.newIterator(result[0])
while it.hasNext(iterator):
pelicula = it.next(iterator)
print("{:<50}{:<20}{:}".format(pelicula[0], pelicula[1], pelicula[2]))
print("\nLa cantidad de películas del actor es:", result[1])
print("El promedio de la cantidad de votos de las películas del actor:",
round(result[2], 2))
print("El nombre del director con el que mas ha colaborado es:", result[3])
def imprimirGeneros(result):
print("\nPelículas de:", genero)
iterator = it.newIterator(result[0])
while it.hasNext(iterator):
pelicula = it.next(iterator)
print("{:<50}{:<5}{:<10}".format(pelicula[0], pelicula[1],
pelicula[2]))
print("\nLa cantidad de películas del género es:", result[1])
print("El promedio de la cantidad de votos del género es:",
round(result[2], 2))
def show_country_data(country):
"""
Imprime las películas de una productara.
"""
if country:
print('País de producción de cine encontrada: ' + country['name'])
print('Promedio: ' + str(country['average_rating']))
print('Total de películas: ' + str(lt.size(country['movies'])))
iterator = it.newIterator(country['movies'])
iterator_2 = it.newIterator(country['director'])
while it.hasNext(iterator):
movie = it.next(iterator)
while it.hasNext(iterator_2):
director = it.next(iterator_2)
print('Título: ' + movie['title'] + ' | Relase Date: ' +
movie['release_date'] + '| Director: ' +
director['director_name'])
else:
print('No se encontró el país')
def Requerimiento2(analyzer):
vertic = gr.vertices(analyzer['connections'])
listaR = lt.newList('SINGLE_LINKED')
iterator = it.newIterator(vertic)
while it.hasNext(iterator):
posi = it.next(iterator)
vert_adya = gr.degree(analyzer['connections'], posi)
lt.addLast(listaR, (posi, vert_adya))
res = sorting2(listaR, 10, cmpfunction_merge)
return res
def optionFour():
print("Requerimiento 2")
print("Se desea conocer las rutas circulares que se pueden realizar en un estimado espacio de tiempo")
time1=int(input('Escriba el tiempo minimo que estima para su visita de la ciudad: '))*60
time2=int(input('Escriba el tiempo maximo que tiene para visitar la ciudad: '))*60
start=int(input('Escriba el id de la estación de la que desea empezar su recorrido: '))
result=controller.FindCycles(cont,start,time1,time2)
cycles=it.newIterator(result)
print("hay ",lt.size(result),"rutas circulares que se pueden visitar en el tiempo dado \n Estos son: \n")
while it.hasNext(cycles):
print("-----------------------------")
cycle=it.next(cycles)
cycleit= it.newIterator(cycle)
while it.hasNext(cycleit):
edge=it.next(cycleit)
if edge!=None:
print("salida",edge["vertexA"],"llegada",edge["vertexB"],"tiempo estimado",round(edge["weight"]/60,2),"min\n")
def printMoviesByGenre(catalog, genreName):
moviesByGenre = controller.getMoviesByGenre(catalog, genreName)
iterator = it.newIterator(moviesByGenre["movies"])
while it.hasNext(iterator):
movie = it.next(iterator)
print(movie["title"])
size = controller.genreMoviesSize(catalog, genreName)
promedio = controller.averageByGenre(catalog, genreName)
print("\nSe encontraron "+ str(size) +" películas")
print("El promedio de votos de las películas del género "+genreName+" es: "+str(round(promedio,1)))
def printMoviesByCountry(catalog, countryName):
moviesByCountry = controller.getMoviesByCountry(catalog, countryName)
iterator = it.newIterator(moviesByCountry["movies"])
while it.hasNext(iterator):
movie = it.next(iterator)
casting = controller.linkIdToMovieCasting(catalog, movie["id"])
director = casting["director_name"]
split = movie["release_date"].split("/")
año = split[2]
print("Título:", movie["title"]," ", "Año:", año," ","Director:", director)
def printMoviesByProductionCompany(catalog, companyName):
moviesByProductionCompany = controller.getMoviesByProductionCompany(catalog, companyName)
iterator = it.newIterator(moviesByProductionCompany["movies"])
while it.hasNext(iterator):
movie = it.next(iterator)
print(movie["title"])
size = controller.companyMoviesSize(catalog, companyName)
promedio = controller.averageByProductionCompany(catalog, companyName)
print("\nSe encontraron "+ str(size) +" películas")
print("El promedio de calificación de las películas producidas por "+companyName+" es: "+str(round(promedio,1)))
def printBooksbyYear(books):
"""
Imprime los libros que han sido publicados en un
año
"""
print('Se encontraron: ' + str(lt.size(books)) + ' Libros')
iterator = it.newIterator(books)
while it.hasNext(iterator):
book = it.next(iterator)
print(book['title'])
def printBooksbyTag(books):
"""
Imprime los libros que han sido clasificados con
una etiqueta
"""
print('Se encontraron: ' + str(lt.size(books)) + ' Libros')
iterator = it.newIterator(books)
while it.hasNext(iterator):
book = it.next(iterator)
print(book['title'])
def loadData(catalog, Detailsfile, Castingfile):
"""
Carga los datos de los archivos en el modelo
"""
list_unida = lt.newList("ARRAY_LIST", None)
list_details = loadDetails(catalog, Detailsfile)
list_casting = loadCasting(catalog, Castingfile)
it1 = it.newIterator(list_details)
while it.hasNext(it1):
movie = it.next(it1)
model.addMovie(catalog, movie)
it2 = it.newIterator(list_casting)
while it.hasNext(it2):
peli = it.next(it2)
if movie["id"] == peli["id"]:
union = {**movie, **peli}
lt.addLast(list_unida, union)
break
return list_unida
def bfsVertex(search, graph, source, maxtime):
"""
Funcion auxiliar para calcular un recorrido BFS
Args:
search: Estructura para almacenar el recorrido
vertex: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
adjsqueue = queue.newQueue()
queue.enqueue(adjsqueue, source)
while not queue.isEmpty(adjsqueue):
vertex = queue.dequeue(adjsqueue)
visited_v = map.get(search['visited'], vertex)['value']
adjslst = g.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjslst)
if not (it.hasNext(adjslstiter)):
visited_v["final"] = True
c = 0
while (it.hasNext(adjslstiter)):
if c == 1 and vertex != source:
break
total_time = 0
w = it.next(adjslstiter)
if not (it.hasNext(adjslstiter)) and c == 0:
visited_v["final"] = True
edge = g.getEdge(graph, vertex, w)
time = edge['weight'] / 60
visited_w = map.get(search['visited'], w)
if visited_w is None:
if visited_v["final"] == False:
dist_to_w = visited_v['distTo'] + time
total_time = dist_to_w
if total_time <= maxtime:
visited_w = {
'marked': True,
'edgeTo': vertex,
"distTo": dist_to_w,
"final": False
}
map.put(search['visited'], w, visited_w)
queue.enqueue(adjsqueue, w)
c = 1
return search
except Exception as exp:
error.reraise(exp, 'bfs:bfsVertex')
def mejorHorario(analyzer): # Req. 3
hora_inicio = ''
hora_fin = ''
area1 = input('Digita el area comunitaria de inicio: ')
area2 = input('Digita el area comunitaria final: ')
inicio_H = int(
input('Digita las horas de la hora inicial en formato HH: '))
inicio_M = int(
input('Digita los minutos de la hora inicial en formato MM: '))
fin_H = int(input('Digita las horas de la hora final en formato HH: '))
fin_M = int(input('Digita los minutos de la hora final en formato MM: '))
if inicio_M > 60 or inicio_H > 24 or fin_M > 60 or fin_H > 24:
print('¡¡ KELLY, UNA HORA TIENE 60 MINUTOS Y UN DÍA 24 HORAS !!')
else:
if inicio_M > 0 and inicio_M <= 15:
inicio_M = '15'
hora_inicio = str(inicio_H) + ':' + inicio_M
elif inicio_M == 0:
inicio_M = '00'
hora_inicio = str(inicio_H) + ':' + inicio_M
elif inicio_M > 15 and inicio_M <= 30:
inicio_M = '30'
hora_inicio = str(inicio_H) + ':' + inicio_M
elif inicio_M > 30 and inicio_M <= 45:
inicio_M = '45'
hora_inicio = str(inicio_H) + ':' + inicio_M
elif inicio_M > 45 and inicio_M <= 60:
inicio_M = '00'
inicio_H += 1
hora_inicio = str(inicio_H) + ':' + inicio_M
if fin_M > 0 and fin_M <= 15:
fin_M = '15'
hora_fin = str(fin_H) + ':' + fin_M
elif fin_M > 15 and fin_M <= 30:
fin_M = '30'
hora_fin = str(fin_H) + ':' + fin_M
elif fin_M > 30 and fin_M <= 45:
fin_M = '45'
hora_fin = str(fin_H) + ':' + fin_M
elif fin_M > 45 and fin_M <= 60:
fin_M = '00'
fin_H += 1
hora_fin = str(fin_H) + ':' + fin_M
data = ctrl.parteC(analyzer, area1, area2, hora_inicio, hora_fin)
print('El mejor horario de ', area1, ' a ', area2, ' es de ',
str(data[1][1]), ' a ', str(data[2][1]),
' con una duracion promedio de ', data[0], 'segundos.')
iterator = it.newIterator(data[3])
string = []
while it.hasNext(iterator):
current = it.next(iterator)
string.append('Community Area ' + str(current['vertexA'][0]) +
' -> Community Area ' + str(current['vertexB'][0]))
string = ", ".join(string)
print('Haciendo el siguiente recorrido: ', string)
def sortVideosCountryTrending(catalog, country):
tracemalloc.start()
delta_time = -1.0
delta_memory = -1.0
start_time = getTime()
start_memory = getMemory()
sublistcountries = mp.get(catalog["countries_sorted"], country)["value"]
sorted_list_titles = merge.sort(sublistcountries, compVideoByTitle)
video_id = ""
days = 0
days_max = 0
video_id_max = ""
channel = ""
channel_max = ""
title = ""
title_max = ""
iterator2 = it.newIterator(sorted_list_titles)
while it.hasNext(iterator2):
element = it.next(iterator2)
idNumber = element["video_id"]
if video_id != "#NAME":
if video_id == idNumber:
days += 1
else:
if days > days_max:
days_max = days
video_id_max = video_id
channel_max = channel
title_max = title
video_id = element["video_id"]
channel = element["channel_title"]
title = element["title"]
days = 1
result = ("Titulo: " + str(title_max) + ", Nombre del canal: " +
str(channel_max) + ", País: " + str(country) + ", Días: " +
str(days_max))
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, result
def getdates(cont):
date = input(print('Ingrese la fecha:'))
n = int(input(print('Ingrese el numero de taxis:')))
date = datetime.datetime.strptime(date, '%Y-%m-%d')
date = date.date()
crimedate = om.get(cont, date)
a = me.getValue(crimedate)['taxiIndex']
b = map.keySet(a)
i = it.newIterator(b)
puntajes = {}
while it.hasNext(i):
c = it.next(i)
millas = 0
servicios = 0
dinero = 0
taxi = map.get(a, c)
taxi = me.getValue(taxi)
taxi = taxi['lsttrips']
x = it.newIterator(taxi)
while it.hasNext(x):
w = it.next(x)
if float(w['trip_total']) > 0:
milla = float(w['trip_miles'])
millas += milla
money = float(w['trip_total'])
dinero += money
servicios += 1
if dinero > 0:
puntaje = (millas / dinero) * servicios
puntajes[c] = puntaje
puntajes_ord = sorted(puntajes.items(),
key=operator.itemgetter(1),
reverse=True)
num = 1
cent = 0
while n >= 0:
print(
str(num) + '.' + puntajes_ord[cent][0] + ' con un total de' + ' ' +
str(puntajes_ord[cent][1]))
num += 1
cent += 1
n -= 1
def maxDateinRange(mindate, maxdate, analyzer):
date = None
max_acc = 0
values = valuesinRange(mindate, maxdate, analyzer)
iterator = it.newIterator(values)
while it.hasNext(iterator):
elemento = it.next(iterator)
if lt.size(elemento['AccidentList']) > max_acc:
max_acc = lt.size(elemento['AccidentList'])
date = elemento['Date']
return (date, max_acc)
def tags(catalog, lista, tag):
"""
Dada una lista de videos retorna otra con los videos que tienen un tag dado
"""
final = lt.newList(datastructure='ARRAY_LIST')
i = it.newIterator(lista)
while it.hasNext(i):
vid = it.next(i)
if tag in vid['tags']:
lt.addLast(final, vid)
return final
def optionSix():
initialStation = input("Escriba la estacion de inicio del trayecto: ")
limite = input("Escriba la duracion deseada del trayecto: ")
lstpaths = it.newIterator(
controller.rutasPorResistencia(cont, initialStation, int(limite)))
while it.hasNext(lstpaths):
eachPath = it.next(lstpaths)
print(
"Estacion de partida {} ---- Estacion de llegada {} ----- Duracion {} "
.format(eachPath["Initial Station"], eachPath["Final Station"],
eachPath["Time"]))
def addRouteConnections(citibike):
"""
Por cada vertice (cada estacion) se recorre la lista
de rutas servidas en dicha estación y se crean
arcos entre ellas para representar el cambio de ruta
que se puede realizar en una estación.
"""
lststops = m.keySet(citibike['stops'])
stopsiterator = it.newIterator(lststops)
while it.hasNext(stopsiterator):
key = it.next(stopsiterator)
lstroutes = m.get(citibike['stops'], key)['value']
prevrout = None
routeiterator = it.newIterator(lstroutes)
while it.hasNext(routeiterator):
route = key + '-' + it.next(routeiterator)
if prevrout is not None:
addConnection(citibike, prevrout, route, 0)
addConnection(citibike, route, prevrout, 0)
prevrout = route
def getAccidentsByRange(analyzer, initialDate, finalDate):
"""
Retorna el numero de crimenes en un rago de fechas.
"""
lst = om.values(analyzer['fechas'], initialDate, finalDate)
lstiterator = it.newIterator(lst)
totcrimes = 0
while (it.hasNext(lstiterator)):
lstdate = it.next(lstiterator)
totcrimes += lt.size(lstdate['accidentes'])
return totcrimes
def rango_accidentes_severidad(accidentes, initialDate, finalDate):
lst = om.values(accidentes['Fechas'], initialDate.date(), finalDate)
lstiterator = it.newIterator(lst)
totacc = 0
lista = {}
while (it.hasNext(lstiterator)):
lstdate = it.next(lstiterator)
lista[lstdate['Accidentes']["first"]["info"]['Start_Time']] = lt.size(
lstdate['Accidentes'])
totacc += lt.size(lstdate['Accidentes'])
return totacc, lista
def stationNear(mapa, lat1, lon1):
keys = m.keySet(mapa)
values = m.valueSet(mapa)
small = m.get(mapa, 72)
valorilt = small['value'][0]
valorilo = small['value'][1]
Thedis = distance(valorilt, lat1, valorilo, lon1)
itv = it.newIterator(values)
itk = it.newIterator(keys)
while it.hasNext(itv):
value = it.next(itv)
key = it.next(itk)
lat = value[0]
lon = value[1]
dist = distance(lat1, lat, lon1, lon)
if dist < Thedis:
Thedis = dist
station = key
return station
def optionThree():
parte1 = controller.totalTaxis(cont)
print("Se tienen: " + str(parte1) + " " + "Taxis en total")
parte2 = controller.totalCompanies(cont)
print("Se tienen: " + str(parte2) + " " + "empresas en total")
num = int(input("¿Cuántas compañías se revisarán (top taxis)? \n"))
num2 = int(input("¿Cuántas compañías se revisarán (top servicios)? \n"))
info = controller.companiesByTaxis(cont, num)
infoIterator = it.newIterator(info)
print('Compañia:\tNúmero de taxis afiliado:\n')
while it.hasNext(infoIterator):
elem = it.next(infoIterator)
print(elem['company'], '\t', elem['taxis'])
info2 = controller.companiesByServices(cont, num2)
infoIterator2 = it.newIterator(info2)
print('Compañia:\tNúmero de servicios afiliado:\n')
while it.hasNext(infoIterator2):
elem = it.next(infoIterator2)
print(elem['company'], '\t', elem['servicios'])
def addTaxisServices (analyzer):
iterator=it.newIterator(analyzer["companies"]["taxis"])
while it.hasNext(iterator):
company=it.next(iterator)
mp.insert(analyzer["companies"]["total_taxis"],(lt.size(company["taxis_id"])*-1),company["company"])
mp.insert(analyzer["companies"]["total_services"],(company["services"])*-1,company["company"])
analyzer["NumTaxis"]+=lt.size(company["taxis_id"])
for i in range(0,mp.size(analyzer["companies"]["total_taxis"])):
analyzer["companies"]["diccio"]["top_taxis"].append(mp.delMin(analyzer["companies"]["total_taxis"]))
for j in range (0,mp.size(analyzer["companies"]["total_services"])):
analyzer["companies"]["diccio"]["top_services"].append(mp.delMin(analyzer["companies"]["total_services"]))
def relacionar_id_categorias(category, catalog):
nombre = ""
iterador = it.newIterator(catalog['categories'])
while it.hasNext(iterador):
elemento = it.next(iterador)
if category == elemento['id']:
nombre = elemento['name']
break
return nombre
"""
def parteA2(analyzer):
answer = 0
companies = m.keySet(analyzer['companyByTaxis'])
iterator = it.newIterator(companies)
while it.hasNext(iterator):
company = it.next(iterator)
value = m.get(analyzer['companyByTaxis'], company)['value']
size = m.size(value)
if size > 0:
answer += 1
return answer
