def printReq5 (respuesta, horamin, horamax):
print("\n++++++ Req No. 5 results... ++++++")
print("There is a total of "+str(respuesta[0][1])+" reproductions between "+str(horamin)+" and "+str(horamax))
print("====================== GENRES SORTED REPRODUCTIONS ======================")
for i in range(1,10):
lista_pequeña = lt.getElement(respuesta[0][0], i)
genero = lt.firstElement(lista_pequeña)
eventos = lt.lastElement(lista_pequeña)
print("TOP "+str(i)+": "+str(genero)+" with "+str(eventos)+" reps")
lista_mayor = lt.firstElement(respuesta[0][0])
genero_mayor = lt.firstElement(lista_mayor)
eventos_mayor = lt.lastElement(lista_mayor)
print("\nThe TOP GENRE is "+str(genero_mayor)+" with "+str(eventos_mayor)+" reproductions...\n")
print("========================== "+str(genero_mayor)+" SENTIMENT ANALYSIS =========================")
print(str(genero_mayor)+" has "+str(respuesta[1][1])+" unique tracks...")
print("The first TOP 10 tracks are...\n")
i = 0
for cada_lista in lt.iterator(respuesta[1][0]):
cancion = lt.getElement(cada_lista, 1)
promedio = lt.getElement(cada_lista, 2)
hashtags = lt.getElement(cada_lista, 3)
i += 1
print("TOP "+str(i)+" track: "+str(cancion)+" with hashtags "+str(hashtags)+
" and VADER = "+str(promedio))
def getToStationFromCoordinates(citibike, Lat1, Lon1, Lat2, Lon2):
"""
RETO4 | REQ 6
Dada una latitud y longitud inicial,
se halla la estación de Citibike más cercana.
Dada una coordenada de destino, se halla
la estación de Citibike más cercana.
Se calcula la ruta de menor tiempo entre estas
dos estaciones.
"""
stations_keys = m.keySet(citibike['Edges_Map'])
initialStationSortedByDistance = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareValues)
finalStationSortedByDistance = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=compareValues)
iterator = it.newIterator(stations_keys)
while it.hasNext(iterator):
station = it.next(iterator)
sta = m.get(citibike['Edges_Map'], station)
staLat = float(sta['value']['Latitude'])
staLon = float(sta['value']['Longitude'])
distance_from_initial_point = distanceFromTo(Lat1, staLat, Lon1,
staLon)
distance_from_final_point = distanceFromTo(Lat2, staLat, Lon2, staLon)
sta['value']['Distance_From_Initial_Point'] = round(
distance_from_initial_point, 5)
sta['value']['Distance_From_Final_Point'] = round(
distance_from_final_point, 5)
lt.addLast(initialStationSortedByDistance, sta)
lt.addLast(finalStationSortedByDistance, sta)
mg.mergesort(initialStationSortedByDistance, closerInitialStation)
mg.mergesort(finalStationSortedByDistance, closerFinalStation)
CloserStation1 = lt.lastElement(initialStationSortedByDistance)
CloserStation2 = lt.lastElement(finalStationSortedByDistance)
paths = djk.Dijkstra(citibike['graph'], CloserStation1['key'])
pathTo = djk.pathTo(paths, CloserStation2['key'])
cost = djk.distTo(paths, CloserStation2['key'])
return CloserStation1, CloserStation2, pathTo, cost
def addTaxi(analyzer, trip):
ids = analyzer["taxis"]
newPoints = 0
tripMiles = trip["trip_miles"]
tripTotal = trip["trip_total"]
timeStamp = trip["trip_start_timestamp"]
tripDate = timeStamp[0:10]
if tripTotal != "0.0" and tripTotal != "":
newPoints = float(tripMiles) / float(tripTotal)
else:
newPoints = 0
if trip["taxi_id"] not in ids["elements"]:
lt.addLast(analyzer["taxis"], trip["taxi_id"])
pointsDate = newPoints, tripDate
pointsList = lt.newList("ARRAY_LIST", None)
lt.addLast(pointsList, pointsDate)
om.put(analyzer["taxisPoints"], trip["taxi_id"], pointsList)
else:
info = om.get(analyzer["taxisPoints"], trip["taxi_id"])
pointsList = info["value"]
pointsDate = lt.lastElement(pointsList)
oldPoints = pointsDate[0]
points = oldPoints + newPoints
newPointsDate = points, tripDate
lt.addLast(pointsList, newPointsDate)
om.put(analyzer["taxisPoints"], trip["taxi_id"], pointsList)
return analyzer
def plotMinimumCostPathMap(analyzer, vertexa, vertexb):
"""
Crea un mapa interactivo de la ruta de costo mínimo entre dos
puntos de conexión
"""
lstvertexs = controller.getMinimumCostPathVertexs(analyzer, vertexb)
lstcoordinates = controller.getPathCoordinates(analyzer, lstvertexs)
origincoords = lt.firstElement(lstcoordinates)
destcoords = lt.lastElement(lstcoordinates)
originpos = lt.isPresent(lstcoordinates, origincoords)
destpos = lt.isPresent(lstcoordinates, destcoords)
lt.removeFirst(lstcoordinates)
lt.removeLast(lstcoordinates)
map = folium.Map(origincoords, zoom_start=2.5)
for location in lt.iterator(lstcoordinates):
folium.Marker(location).add_to(map)
lt.insertElement(lstcoordinates, origincoords, originpos)
lt.insertElement(lstcoordinates, destcoords, destpos)
folium.Marker(origincoords,
str(vertexa.replace('-', ', ')),
icon=folium.Icon(icon='flag', color='red')).add_to(map)
folium.Marker(destcoords,
str(vertexb.replace('-', ', ')),
icon=folium.Icon(icon='flag', color='red')).add_to(map)
folium.PolyLine(lstcoordinates['elements'],
color="grey",
weight=2.5,
opacity=0.75).add_to(map)
map.save("map3.html")
def optionOne(cont):
'''
Carga la información en el analizador
'''
controller.loadAnalyzerData(cont)
numedges = controller.totalConnections(cont)
numvertex = controller.totalLandingPoints(cont)
points = cont['points']
pointKeys = m.keySet(points)
numLPoints = lt.size(pointKeys)
primKey = lt.firstElement(pointKeys)
primLPoint = me.getValue(m.get(points, primKey))
primLine = 'El primer Landing Point cargado es {}, identificado con el id {}, de latitud {} y longitud {}'.format\
(primLPoint['name'],primLPoint['landing_point_id'],primLPoint['latitude'],primLPoint['longitude'])
countries = cont['countries']
contKeys = m.keySet(countries)
numCountries = lt.size(contKeys)
lastContKey = lt.lastElement(contKeys)
lastCont = me.getValue(m.get(countries, lastContKey))
secLine = 'El último país cargado es {}, con una población de {} y su número de usuarios de Internet es de {}'.format\
(lastCont['CountryName'],lastCont['Population'],lastCont['Internet users'])
print('Numero de Landing Points ' + str(numLPoints))
print(primLine)
print('Numero de paises ' + str(numCountries))
print(secLine)
print('Numero de vertices: ' + str(numvertex))
print('Numero de arcos: ' + str(numedges))
def getFirstLastMovies(catalog):
"""
Retorna el primer y ultimo libro de la lista.
"""
first_movie=lt.firstElement(catalog)
last_movie=lt.lastElement(catalog)
return (first_movie, last_movie)
def FindTrendVideoByCategory(catalog, category_name):
cat_id = getCategory_ID(catalog, category_name)
entry = mp.get(catalog["categories"], cat_id)
dos = me.getValue(entry)
reduced_list = dos["videos"]
print(lt.size(reduced_list))
sorted_final_list = merg.sort(reduced_list, cmpVideosByVideoID)
final_element = ""
days = 0
contador = 0
for element in range(1, lt.size(sorted_final_list) + 1):
actual = lt.getElement(sorted_final_list, element)
pos = element + 1
if actual == lt.lastElement(sorted_final_list):
if actual["video_id"] == final_element["video_id"]:
days += 1
days += 1
return final_element, days
next_one = lt.getElement(sorted_final_list, pos)
if actual["video_id"] == next_one["video_id"]:
contador += 1
else:
if contador >= days:
days = contador
final_element = lt.getElement(sorted_final_list, element)
contador = 0
return final_element, days
def infoArchivoCsv(lista: list):
num_peliculas = lista['size']
#Primera pelicula
primer_elemento = lt.firstElement(lista)
titulo_primera = primer_elemento['original_title']
fecha_primera = primer_elemento['release_date']
vote_average_primera = primer_elemento['vote_average']
vote_count_primera = primer_elemento['vote_count']
language_primera = primer_elemento['original_language']
primera = [
titulo_primera, fecha_primera, vote_average_primera,
vote_count_primera, language_primera
]
#Ultima pelicula
ultimo_elemento = lt.lastElement(lista)
titulo_ultima = ultimo_elemento['original_title']
fecha_ultima = ultimo_elemento['release_date']
vote_average_ultima = ultimo_elemento['vote_average']
vote_count_ultima = ultimo_elemento['vote_count']
language_ultima = ultimo_elemento['original_language']
ultima = [
titulo_ultima, fecha_ultima, vote_average_ultima, vote_count_ultima,
language_ultima
]
return num_peliculas, primera, ultima
def printMenu():
print("Opciones:")
print("1- Cargar Libros")
print("2- Cargar Tags")
# TO-DO: Modificación de Est-1 en el Lab 2
print("3- Cargar Book-Tags!")
print('Último libro cargado: ' + str(lt.lastElement(books)))
print("0- Salir")
def firstCountry(analyzer):
"""
Retorna la informacion del primer pais cargado
"""
listaPaises = mp.keySet(analyzer['countries'])
ultimoPais = lt.lastElement(listaPaises)
infoPais = mp.get(analyzer['countries'], ultimoPais)['value']
return infoPais
def ObtenerVideosDistintos(tad_lista):
videos_distintos = lt.newList(datastructure='ARRAY_LIST')
primero = lt.firstElement(tad_lista)
primero['repeticiones'] = 1
lt.addLast(videos_distintos, primero)
leidos = 1
for video in lt.iterator(tad_lista):
if leidos > 1:
video_agregar = {}
info_deseada = ['title','video_id', 'category_id', 'views', 'channel_title', \
'country', 'likes', 'dislikes', 'publish_time', 'trending_date', 'tags']
for info in info_deseada:
video_agregar[info] = video[info]
if lt.lastElement(
videos_distintos)['video_id'] == video_agregar['video_id']:
lt.lastElement(
videos_distintos)['repeticiones'] = lt.lastElement(
videos_distintos)['repeticiones'] + 1
lt.lastElement(videos_distintos)['likes'] = max(
int(video_agregar['likes']),
int(lt.lastElement(videos_distintos)['likes']))
lt.lastElement(videos_distintos)['views'] = max(
int(video_agregar['views']),
int(lt.lastElement(videos_distintos)['views']))
else:
video_agregar['repeticiones'] = 1
lt.addLast(videos_distintos, video_agregar)
leidos += 1
return videos_distintos
def cargarPeliculas(empty_catalog, casting, details):
t1_start = process_time() #tiempo inicial
catalog = model.loadMovies(empty_catalog, casting, details)
lista = catalog["movies"]
first = lt.getElement(lista, 1)
last = lt.lastElement(lista)
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", (t1_stop - t1_start), " segundos")
return (catalog, lt.size(lista), first, last)
def last_country(catalog):
"""
"""
list_countries = mp.valueSet(catalog['map_countries'])
last_element = lt.lastElement(list_countries)
print("El nombre del ultimo pais: " + str(last_element['CountryName']))
print("La cantidad de poblacion es: " + str(last_element['Population']))
print("La cantidad de usuario con interent es: " +
str(last_element['Internet users']))
def test_addLast(lst, books):
assert lt.isEmpty(lst) is True
assert lt.size(lst) == 0
lt.addLast(lst, books[1])
assert lt.size(lst) == 1
lt.addLast(lst, books[2])
assert lt.size(lst) == 2
book = lt.firstElement(lst)
assert book == books[1]
book = lt.lastElement(lst)
assert book == books[2]
def loadlst (file):
lst = m.loadCSVFile(file,m.compareRecordIds)
first=lt.firstElement(lst)
last=lt.lastElement(lst)
print("Datos cargados, " + str(lt.size(lst)) + " elementos cargados")
print ("Primera película:\n"+ " "*18 + "Título: " + first["original_title"]+ "\n"+ " "*18 +
"Fecha de estreno: "+ first["release_date"]+"\n"+ " "*18 + "Promedio de votación: "+ first["vote_average"]+
"\n"+ " "*18 + "Número de votos: " +first["vote_count"]+"\n"+ " "*18 + "Idioma: "+ first["original_language"])
print ("última película:\n"+ " "*18 + "Título: " + last["original_title"]+ "\n"+ " "*18 +
"Fecha de estreno: "+ last["release_date"]+"\n"+ " "*18 + "Promedio de votación: "+ last["vote_average"]+
"\n"+ " "*18 + "Número de votos: " + last["vote_count"]+"\n"+ " "*18 + "Idioma: "+ last["original_language"])
return lst
def printLastCountry(analyzer):
"""
Imprime la información del último país cargado al
analizador
"""
map = analyzer['countries']
lstcountries = mp.keySet(map)
key = lt.lastElement(lstcountries)
value = me.getValue(mp.get(map, key))
print("---------- Último país cargado ----------")
print("País: " + str(key) + " Población: " + str(value[1]) +
" Usuarios: " + str(value[2]) + "\n")
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 getLastCountryInfo(analyzer):
'''
Retorna la informacion del ultimo pais cargado
'''
loaded_countries = m.keySet(analyzer['countries'])
last_country = lt.lastElement(loaded_countries)
info_country = m.get(analyzer['countries'], last_country)['value']
res = {
'country': info_country['country_name'],
'population': info_country['population'],
'internet_users': info_country['internet_users']
}
return res
def element_data(lista,orden):
lt_datos= []
if orden== "primera":
datos= lt.firstElement(lista)
elif orden== "ultima":
datos= lt.lastElement(lista)
lt_datos.append(datos["original title"])
'''
lt_datos.append(datos["release_date"])
lt_datos.append(datos["vote_average"])
lt_datos.append(datos["vote_count"])
lt_datos.append(datos["spoken_languages"])
'''
return lt_datos
def addLandingPointConnections(analyzer):
lstpoints = mp.keySet(analyzer['landingpoints'])
for key in lt.iterator(lstpoints):
dataentry = mp.get(analyzer['landingpoints'], key)
lstcables = me.getValue(dataentry)['points']
i = 1
while i < lt.size(lstcables):
origin = lt.getElement(lstcables, i)
destination = lt.getElement(lstcables, (i+1))
addConnection(analyzer, origin, destination, 0)
i += 1
if lt.size(lstcables) >= 2:
origin = lt.lastElement(lstcables)
destination = lt.firstElement(lstcables)
addConnection(analyzer, origin, destination, 0)
def top(stack):
""" Retorna el elemento en tope de la pila, sin eliminarlo de la pila
Args:
stack: La pila a examinar
Returns:
El primer elemento de la pila, sin eliminarlo
Raises:
Exception
"""
try:
return lt.lastElement(stack)
except Exception as exp:
error.reraise(exp, 'TADStack->top: ')
def requerimiento4(time, InitialS, citibike):
time = int(time) #Cambio S-M
listD = gr.vertices(citibike["graph"])
Recorrido = dfs.DepthFirstSearch(citibike["graph"], InitialS)
ListaPilas = lt.newList('SINGLE_LINKED', compareIds)
for i in range(1, lt.size(listD) + 1):
vertice2 = lt.getElement(listD, i)
if dfs.pathTo(Recorrido, vertice2) and InitialS != vertice2:
Pila = dfs.pathTo(Recorrido, vertice2)
lt.addLast(ListaPilas, Pila)
## Se buscan los Vertices que se conecten a Initial S
listadeciclos = lt.newList('SINGLE_LINKED', compareIds)
for r in range(1, lt.size(ListaPilas) + 1):
listanueva = lt.newList('SINGLE_LINKED', compareIds)
pila = lt.getElement(ListaPilas, r)
for j in range(1, stack.size(pila) + 1):
k = stack.pop(pila)
lt.addLast(listanueva, k)
lt.addLast(listadeciclos, listanueva)
listaF = lt.newList('SINGLE_LINKED', compareIds)
for i in range(1, lt.size(listadeciclos) + 1):
EstacionesI = 0
Viaje = lt.newList('SINGLE_LINKED', compareIds)
ciclo = lt.getElement(listadeciclos, i)
peso = 0
for j in range(1, lt.size(ciclo)):
verticeA = lt.getElement(ciclo, j)
Ultimo = lt.lastElement(ciclo)
verticeB = lt.getElement(ciclo, (j + 1))
arco = gr.getEdge(citibike["graph"], verticeA, verticeB)
EstacionesI += 1
peso += int(arco["weight"])
lt.addLast(Viaje, EstacionesI)
lt.addLast(Viaje, Ultimo)
peso = peso / 60
lt.addLast(Viaje, peso)
if peso <= time:
lt.addLast(listaF, Viaje)
if lt.isEmpty(listaF):
return False
else:
return listaF
def InfCrit(analyzer):
inf = pr.PrimMST(analyzer['cables'])
LPs = gr.vertices(analyzer['cables'])
tree = lt.newList('ARRAY_LIST', cmpfunction=LPids)
total = 0
try:
for vertex in lt.iterator(LPs):
distance = bell.distTo(inf, vertex)
if distance != 0: #El algoritmo prim pone 0, asumimos que los que se mantienen en 0 son porque no pertenecen al MST
lt.addLast(tree, (vertex, distance))
total += distance
treeO = sortMaster(tree, cmpDeg)
return lt.size(tree), total, lt.firstElement(treeO), lt.lastElement(treeO)
except Exception as exp:
error.reraise(exp, 'model:InfCrit')
def buscar_estaciones_top_ingreso(graph, reference_table):
""""Funcion para hallar los viajes que llegan a una estacion!"""
estaciones = lt.newList()
vertices = gr.vertices(graph)
it_vertice = it.newIterator(vertices)
while it.hasNext(it_vertice):
vert = it.next(it_vertice)
estacion = gr.indegree(graph, vert)
nombre = conversor_id_nombre(vert, reference_table)
lt.addLast(estaciones, (estacion, nombre))
merge.mergesort(estaciones, lessFunction)
final_top = []
for i in range(3):
top = lt.lastElement(estaciones)
final_top.append(top)
lt.removeLast(estaciones)
return final_top
def lastCountry(analyzer, lista):
"""
Se agrega el último país que se cargó en el analyzer a una lista
Args:
analyzer
lista
Returns:
El último país cargado en el grafo
"""
pais = lt.lastElement(lista)
valores = mp.get(
analyzer['countries'], pais
) # Se obteiene el último país cargado, junto conn su respectiva infromación.
return valores
def findMostLikes(list_by_likes, number):
"""
Requerimiento 1
Crea una lista con los x videos con más likes dentro de una lista que ya esta ordenada.
Si un video ya se encuntra en la lista no lo repite.
"""
pos = lt.size(list_by_likes)
topVideos = lt.newList(datastructure='ARRAY_LIST', cmpfunction=cmpVideoId)
lt.addLast(topVideos, lt.lastElement(list_by_likes))
number -= 1
while number > 0 and pos > 0:
current_element = lt.getElement(list_by_likes, pos)
pos_present = lt.isPresent(topVideos, current_element)
if pos_present == 0:
lt.addLast(topVideos, current_element)
number -= 1
pos -= 1
return topVideos
def optionFive(cont, ini):
country = input('Ingrese el país destino: ')
countries = cont['countries']
final = me.getValue(m.get(countries, country))
path = controller.minimumCostPath(cont, final, ini)
inicial = lt.firstElement(path)['vertexA']
final = lt.lastElement(path)['vertexB']
print('Para llegar desde {} hasta {} hay que tomar el camino:'.format(
inicial, final))
distTotal = 0
for i in range(0, lt.size(path)):
camino = lt.getElement(path, i + 1)
punto = camino['vertexB']
distancia = camino['weight']
distTotal += distancia
linea = '{}: {}km'.format(punto, distancia)
print(linea)
distTotal = round(distTotal, 2)
print('Con una distancia total de {}km'.format(distTotal))
def connectSameCode(analyzer):
rela = analyzer['relatedVertex']
congr = analyzer['connections']
codes = m.keySet(rela)
size = lt.size(codes)
for i in range(0, size):
key = lt.getElement(codes, i)
entry = m.get(rela, key)
codeList = me.getValue(entry)
codeSize = lt.size(codeList)
if codeSize > 1:
for j in range(0, codeSize):
if j + 1 <= codeSize:
vertex = lt.getElement(codeList, j)
nextVertex = lt.getElement(codeList, j + 1)
addConnection(congr, vertex, nextVertex, 0.1)
first = lt.firstElement(codeList)
last = lt.lastElement(codeList)
gr.addEdge(congr, last, first, 0.1)
return analyzer
def mostTrending(sorted_list):
#sorted_list=catalog["videos"]
most = 0
most_vid = None
current = 1
for i in range(1, lt.size(sorted_list) + 1):
current_vid = lt.getElement(sorted_list, i)
if current_vid == lt.lastElement(sorted_list):
next_vid = lt.getElement(sorted_list, i - 1)
else:
next_vid = lt.getElement(sorted_list, i + 1)
if str(current_vid["title"]) == str(next_vid["title"]):
current += 1
else:
current = 1
if current > most:
most = current
most_vid = current_vid
return (most_vid, most)
def optionTwo(analyzer):
print("\nCargando información ....")
controller.loadLanding_Points(analyzer)
controller.loadConnection(analyzer)
controller.loadCountries(analyzer)
numvertex = controller.totalLanding_Points(analyzer)
numarc = controller.totalArcs(analyzer)
vert = controller.vertices(analyzer)
countries = controller.CountrySize(analyzer)
print('\n')
print("********INORMACIÓN CARGADA********")
print('\n')
print('Número de vertices en el grafo: ' + str(numvertex))
print('\n')
print('Número de arcos en el grafo: ' + str(numarc))
print('\n')
print('Número de paises cargados:', countries)
print('\n')
prim_el = lt.firstElement(vert)
mapinfo = controller.vertInfo(analyzer, prim_el)
name = controller.getValue(mapinfo, 'name')
id = controller.getValue(mapinfo, 'id')
latitude = controller.getValue(mapinfo, 'latitude')
longitude = controller.getValue(mapinfo, 'longitude')
print("Información del primer Landing Point cargado:")
print("Nombre:", name)
print("Identificador:", id)
print("Latitude:", latitude)
print("Longitude:", longitude)
print('\n')
country = controller.countries(analyzer)
prim_country = lt.lastElement(country)
country_info = controller.countryInfo(analyzer, prim_country)
population = controller.getValue(country_info, 'Population')
users = controller.getValue(country_info, 'Internet_Users')
print("Información del último país cargado:")
print("Nombre:", prim_country)
print("Población:", population)
print("Usuarios de Internet:", users)
print('\n')
