def mostTrendingVideo(catalog, attribute, indicator):
lista_trabajo = lt.newList('SINGLE_LINKED', cmpVideos)
if indicator == 0:
for video in lt.iterator(catalog['videos']):
if lt.isPresent(lista_trabajo, video) != 0:
pos = lt.isPresent(lista_trabajo, video)
lt.getElement(lista_trabajo, pos)['trending_days'] += 1
elif video['country'] == attribute:
lt.addFirst(lista_trabajo, video)
lt.firstElement(lista_trabajo)['trending_days'] = 1
else:
for video in lt.iterator(catalog['videos']):
if lt.isPresent(lista_trabajo, video) != 0:
pos = lt.isPresent(lista_trabajo, video)
lt.getElement(lista_trabajo, pos)['trending_days'] += 1
elif video['category_id'] == attribute:
lt.addFirst(lista_trabajo, video)
lt.firstElement(lista_trabajo)['trending_days'] = 1
sorted_list = mg.sort(lista_trabajo, cmpVideosByTrend)
return lt.firstElement(sorted_list)
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 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 loadConnections(analyzer, landingPointsFile, connectionsFile,
countriesFile):
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
landingPointsList = lt.newList('ARRAY_LIST')
landingPointsFile = cf.data_dir + landingPointsFile
lpFile = csv.DictReader(open(landingPointsFile, encoding="utf-8"),
delimiter=",")
for lp in lpFile:
lt.addLast(landingPointsList, lp)
# Por cada landing point en el archivo de entrada, se llama a la función en el modelo
model.addLandingPoint(analyzer, lp)
model.addCountriesCodes(analyzer, lp)
countriesList = lt.newList('ARRAY_LIST')
countriesFile = cf.data_dir + countriesFile
cntFile = csv.DictReader(open(countriesFile, encoding="utf-8"),
delimiter=",")
for ctry in cntFile:
lt.addLast(countriesList, ctry)
# Por cada país en el archivo de entrada, se llama a la función en el modelo
model.loadCountry(analyzer, ctry)
connectionsFile = cf.data_dir + connectionsFile
cnnFile = csv.DictReader(open(connectionsFile, encoding="utf-8-sig"),
delimiter=",")
for cnn in cnnFile:
# Por cada conexión en el archivo de entrada, se llama a la función en el modelo
model.addConnection(analyzer, cnn)
model.addArchConnections(analyzer, cnn)
# Se crean las conexiónes entre los vertices de cada landing point y entre estos y el vertice de la capital
model.addPointConnections(analyzer)
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return analyzer, lt.firstElement(landingPointsList), lt.firstElement(
countriesList), delta_time, delta_memory
def getcity(catalog,pais):
info_pais=m.get(catalog["info_countries"],pais)
if info_pais==None:
return None
else:
elemento=lt.firstElement(info_pais["value"]["song"])
return elemento["CapitalName"]
def pais(catalog,service):#PARA ENCONTRAR EL PAÍS
if m.contains(catalog["landing_point_id"],service)==True:
lista=m.get(catalog["landing_point_id"],service)
elemnto=lt.getElement(lista["value"]["song"],1)
city=elemnto["name"].split(", ")
if len(city)==4:
ciudad_name=city[3]
elif len(city)==3:
ciudad_name=city[2]
elif len(city)==2:
ciudad_name=city[1]
else:
ciudad_name=city[0]
elementosss=m.get(catalog["info_countries"],ciudad_name)
if elementosss==None:
print(ciudad_name)
return "No Country"
else:
especifico=lt.firstElement(elementosss["value"]["song"])
ciudad_name=especifico["CapitalName"]
else:
ciudad_name="No Country"
return ciudad_name
def requerimiento4(catalog):
pri = prim.PrimMST(catalog['connections'])
peso = prim.weightMST(catalog['connections'], pri)
mst = prim.edgesMST(catalog['connections'], pri)['mst']
m = folium.Map(location=[4.6, -74.083333], tiles="Stamen Terrain")
for st in lt.iterator(mst):
cv = st['vertexA'].split("-", 1)
ce = st['vertexB'].split("-", 1)
infov = mp.get(catalog['points'], cv[0])['value']
infoe = mp.get(catalog['points'], ce[0])['value']
addPointConneMst(catalog, st['vertexA'], st['vertexB'], st['weight'])
folium.PolyLine(locations=[(float(infov['latitude']), float(infov['longitude'])), (float(infoe['latitude']), float(infoe['longitude']))], tooltip=str(cv[1])).add_to(m)
folium.Marker([float(infov['latitude']), float(infov['longitude'])], popup=str(infov['name'])).add_to(m)
folium.Marker([float(infoe['latitude']), float(infoe['longitude'])], popup=str(infoe['name'])).add_to(m)
m.save('mapa_req4.html')
gramst = catalog['mst']
vert = gr.vertices(gramst)
num = lt.size(vert)
primero = lt.firstElement(vert)
mayor = 0
camino = None
dijta = djk.Dijkstra(catalog['mst'], primero)
for v in lt.iterator(vert):
ruta = djk.pathTo(dijta, v)
x = lt.size(ruta)
if x > mayor:
mayor = x
camino = ruta
return num, peso, camino
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 requerimiento5(analyzer, landingpoint):
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
landingpoints = mp.keySet(analyzer['landingpoints'])
capitals = mp.keySet(analyzer['countrypoints'])
capital = False
for key in lt.iterator(capitals):
if landingpoint in key:
vertex = key
capital = True
if not capital:
for key in lt.iterator(landingpoints):
dataentry = mp.get(analyzer['landingpoints'], key)
entry = me.getValue(dataentry)
if landingpoint in entry['data']['name']:
key = lt.firstElement(entry['points'])
vertex = key
edges = model.afectedCountries(analyzer, vertex)
model.createMap(analyzer, edges[0])
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return (edges[1], (delta_time, delta_memory))
def requerimiento_3(catalog):
"""Función encargada de invocar las funciones del controller necesarias para ejecutar
el requerimiento 3."""
filter_category = " " + filterCategory(catalog)
filtered_catalog = controller.filterCatalog(catalog=catalog,
column_1="category_name",
value_1=filter_category)
max_videos = lt.newList()
unique_catalog = controller.initUniqueCatalog(filtered_catalog["videos"])
top_days = sortVideos(unique_catalog, lt.size(unique_catalog),
"sortByDays")
if lt.size(top_days[1]) != 0:
first_video = lt.firstElement(top_days[1])
max_days = first_video[0]
pos = 1
while lt.getElement(top_days[1], pos)[0] == max_days:
lt.addLast(max_videos, lt.getElement(top_days[1], pos)[2])
pos += 1
printResultsReq3(max_videos, str(max_days))
else:
print("No existen videos de la categoría ingresada en tendencias.")
def requerimiento_2(catalog):
"""Función encargada de invocar las funciones del controller necesarias para ejecutar
el requerimiento 2."""
filter_country = filterCountry(catalog)
filtered_catalog = controller.filterCatalog(catalog=catalog,
column_1="country",
value_1=filter_country)
max_videos = lt.newList()
unique_catalog = controller.initUniqueCatalog(filtered_catalog["videos"])
top_days = sortVideos(unique_catalog, lt.size(unique_catalog),
"sortByDays")
first_video = lt.firstElement(top_days[1])
max_days = first_video[0]
pos = 1
while lt.getElement(top_days[1], pos)[0] == max_days:
lt.addLast(max_videos, lt.getElement(top_days[1], pos)[2])
pos += 1
printResultsReq2(max_videos, str(max_days))
def ruta_circula(graph, ref_table, tiempo, id_estacion):
vertices = gr.vertices(graph)
it_vertices = it.newIterator(vertices)
list_station = []
while it.hasNext(it_vertices):
actual_vertex = it.next(it_vertices)
if id_estacion == actual_vertex:
confirmador = gr.adjacents(graph, id_estacion)
it_confirmador = it.newIterator(confirmador)
while it.hasNext(it_confirmador):
ad_vertex = it.next(it_confirmador)
pt1 = Camino_corto(graph, ad_vertex, id_estacion)
if pt1:
if not lt.isEmpty(pt1):
estacion_final = lt.firstElement(pt1)
final = conversor_id_nombre(estacion_final["vertexA"],
ref_table)
final2 = conversor_id_nombre(estacion_final["vertexB"],
ref_table)
peso = estacion_final["weight"]
list_station.append((final, final2, peso))
for i in list_station:
if i[2] > tiempo:
list_station.remove(i)
return list_station
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 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
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 print1stelement(videos, tipo):
primero = lt.firstElement(videos)
print(
"Title: {} Channel: {} Trending Date: {} Country: {} Views: {} Likes: {} Dislikes: {} "
.format(primero['title'], primero["channel_title"],
primero["trending_date"], primero["country"], primero["views"],
primero["likes"], primero["dislikes"]))
def show_categories(catalog):
"""Función netamente de la view que imprime una lista con
todas las categorias al momento de cargar los datos."""
a = "Id"
b = "Nombre de Categoría"
formato = "|{}|{}|\n".format(a.center(6), b.center(26)) + ("-" * 36) + "\n"
texto = ("-" * 36) + "\n" + formato
actual_node = lt.firstElement(catalog["categories"])
for i in range(1, lt.size(catalog["categories"])):
actual_node_id = actual_node["category_id"]
actual_node_name = actual_node["name"]
formato = "|{}|{}|\n".format(
actual_node_id.center(6),
actual_node_name.center(26)) + ("-" * 36) + "\n"
texto += formato
actual_node = lt.getElement(catalog["categories"], i + 1)
print(texto)
def landing_paises(catalog,lista,vertice):
newlist=lt.newList(datastructure="ARRAY_LIST")
lst_element=[]
for element in lt.iterator(lista):
distancia=gr.getEdge(catalog["connections"],element,vertice)
ciudad=des_vertice(element)
lista_grande=m.get(catalog["ciudad_id"],ciudad)
if lista_grande!=None:
dato=lt.firstElement(lista_grande["value"]["song"])
pais=dato["name"].split(",")
if len(pais)>2:
if pais[2] not in lst_element:
info={"Pais":str(pais[2]),"Distancia": str(round(float(distancia["weight"]),2))}
lt.addLast(newlist,info)
lst_element.append(pais[2])
elif len(pais)==2:
if pais[1] not in lst_element:
info={"Pais":str(pais[1]),"Distancia": str(round(float(distancia["weight"]),2))}
lt.addLast(newlist,info)
lst_element.append(pais[1])
else:
if pais[0] not in lst_element:
info={"Pais":str(pais[0]),"Distancia": str(round(float(distancia["weight"]),2))}
lt.addLast(newlist,info)
lst_element.append(pais[0])
return newlist
def getTendencia3 (sorted_list):
mayor = lt.firstElement(sorted_list)
conteo = 1
sig = None
conteo_sig = 1
for x in lt.iterator(sorted_list):
if x['video_id'] == mayor["video_id"]:
if x['trending_date'] != mayor["trending_date"]:
conteo += 1
elif sig == None:
sig = x
conteo_sig += 1
elif x['video_id'] == sig["video_id"]:
if x['trending_date'] != sig["trending_date"]:
conteo_sig += 1
else:
if conteo_sig > conteo:
mayor = sig
conteo = conteo_sig
sig = x
conteo_sig = 1
return mayor, conteo
def req2(analizer,limiteinf,limite,verticei):
grafo=analizer['connections']
sc = scc.KosarajuSCC(grafo)
componente_inicio=m.get(sc['idscc'],verticei)['value']
iterator=it.newIterator(m.keySet(sc['idscc']))
verticesfc=lt.newList(cmpfunction=compareroutes)
while it.hasNext(iterator):
proximo=it.next(iterator)
c_proximo=m.get(sc['idscc'],proximo)['value']
if c_proximo == componente_inicio: #Que el componente sea el mismo
lt.addLast(verticesfc,proximo)
adyacentes=gr.adjacents(grafo,verticei)
iterator=it.newIterator(verticesfc)
rutasposibles=[]
while it.hasNext(iterator):
proximo=it.next(iterator)
if lt.isPresent(adyacentes,proximo):
dfs3 = dfs.DepthFirstSearchSCC(grafo,proximo,verticesfc)
if dfs.pathTowithLimiter(dfs3,verticei,grafo,limite) != None:
rutachikita,tiempo=dfs.pathTowithLimiter(dfs3,verticei,grafo,limite)
lt.removeLast(rutachikita)
if limiteinf<tiempo<limite:
rutasposibles.append({"First":m.get(analizer['nameverteces'],lt.firstElement(rutachikita))['value'],"Last":m.get(analizer['nameverteces'],lt.lastElement(rutachikita))['value'],"Duracion":tiempo/60})
return rutasposibles
def FindMostLikedByTag(catalog, tag, country, elements):
entry = mp.get(catalog["country"], country.strip().lower())
dos = me.getValue(entry)
reduced_list = dos["videos"]
print(lt.size(reduced_list))
tag_list = lt.newList("ARRAY_LIST")
for element in range(1, lt.size(reduced_list) + 1):
video = lt.getElement(reduced_list, element)
yes = video["tags"].split("|")
for sub_element in yes:
if sub_element.lower().find(tag) != -1:
lt.addLast(tag_list, video)
print(lt.size(tag_list))
final_list = merg.sort(tag_list, cmpVideosByLikes)
user_list = lt.newList("ARRAY_LIST", comparador_ascendente)
lt.addFirst(user_list, lt.firstElement(final_list))
iterator = 1
while lt.size(user_list) < int(elements) + 1 and iterator != lt.size(
final_list):
video = lt.getElement(final_list, iterator)
if lt.isPresent(user_list, video) == 0:
lt.addLast(user_list, video)
iterator += 1
else:
iterator += 1
return user_list
def findPopularsAdd(analyzer):
"""
Compara los vertices para buscar los más
populares segun su categoria en edad
que cumplen los requerimientos para
tener publicidad
"""
mayLst = analyzer["publicity"]["BestPublicity"]
catLst = analyzer["publicity"]["ByAges"]
for pos in range(1, 8):
total = 0
mayCatLst = lt.getElement(mayLst, pos)
mayTup = lt.firstElement(mayCatLst)
routesMap = lt.getElement(catLst, pos)
routesLst = m.keySet(routesMap)
routeIterator = it.newIterator(routesLst)
while it.hasNext(routeIterator):
vert = it.next(routeIterator)
routeEntry = m.get(routesMap, vert)
timesRoute = me.getValue(routeEntry)
total += timesRoute
routeTuple = (timesRoute, vert)
mayTimes, name = mayTup
if mayTimes < timesRoute:
size = lt.size(mayCatLst)
if size > 1:
for i in range(0, size - 1):
lt.deleteElement(mayCatLst, 1)
lt.changeInfo(mayCatLst, 1, routeTuple)
mayTup = routeTuple
elif timesRoute == mayTimes:
lt.addLast(mayCatLst, routeTuple)
lt.addLast(mayCatLst, total)
return analyzer
def secondReq(catalog, country):
"""
Completa el requerimiento #2
"""
new_map = mp.newMap(50000, 50007, 'PROBING', 0.80, None)
for videos in catalog["videos"]["table"]["elements"]:
if videos["key"] != None:
for video in lt.iterator(videos["value"]["videos"]):
if str(video["country"]).lower() == str(country).lower():
value = {
"title": video["title"],
"channel": video["channel_title"],
"count": "1"
}
key = video["title"]
exists = mp.contains(new_map, key)
if not exists:
mp.put(new_map, key, value)
else:
new_value = mp.get(new_map, key)
new_value["value"]["count"] = str(
int(new_value["value"]["count"]) + 1)
mp.put(new_map, key, new_value["value"])
new_list = lt.newList('ARRAY_LIST', cmpfunction=cmpVideosByTrendingdays)
for element in new_map["table"]["elements"]:
if element["key"] != None:
lt.addLast(new_list, element["value"])
sorted_list = quick.sort(new_list, cmpVideosByTrendingdays)
result = lt.firstElement(sorted_list)
result["country"] = country
return result
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 MejorHora(Taxis, límite_Inferior, límite_Superior, vertexA, vertexB):
Mejor = 200000
lstHours = lt.newList("SINGLE_LINKED")
for i in Taxis["lst"]:
timeHash = datetime.datetime.strptime(i, "%H:%M")
if (timeHash.hour > límite_Inferior.hour) and (timeHash.hour <
límite_Superior.hour):
lt.addLast(lstHours, timeHash)
if (timeHash.hour == límite_Inferior.hour
and timeHash.minute >= límite_Inferior.minute):
lt.addLast(lstHours, timeHash)
if (timeHash.hour == límite_Superior
and timeHash.minute <= límite_Superior.minute):
lt.addLast(lstHours, timeHash)
listiterator = it.newIterator(lstHours)
while it.hasNext(listiterator):
start_time = it.next(listiterator)
Graph = me.getValue(m.get(Taxis["Hash"], start_time.time()))
dijsktra = djk.Dijkstra(Graph, vertexA)
if djk.hasPathTo(dijsktra, vertexB):
path = djk.pathTo(dijsktra, vertexB)
path = lt.firstElement(path)
if path["weight"] < Mejor:
Mejor = path["weight"]
Tiempo = start_time.time()
return (Tiempo, Mejor)
def recomendarRutas(analyzer, agerange):
ageGraph = crearGrafoEdad(analyzer, agerange)
mayorsalida = majorStart(ageGraph["grafo"])
mayordestino = majorDestiny(ageGraph["grafo"])
if mayorsalida == None or mayordestino == None:
return "No existen rutas para este rango de edad"
else:
pesos = lt.newList(datastructure="ARRAY_LIST")
pathiterator = it.newIterator(ageGraph["lista"])
while it.hasNext(pathiterator):
viaje = it.next(pathiterator)
if viaje["start station id"] == mayorsalida and viaje["end station id"] == mayordestino:
lt.addLast(pesos, viaje["tripduration"])
if lt.isEmpty(pesos):
econ = None
else:
mrg.mergesort(pesos, lessfunction)
econ = lt.firstElement(pesos)
sal = m.get(analyzer["nameIndex"], mayorsalida)
salnombre = me.getValue(sal)
dest = m.get(analyzer["nameIndex"], mayordestino)
destnombre = me.getValue(dest)
W = {"salida":salnombre,
"destino":destnombre,
"tiempo":econ}
return W
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 fallas(analyzer, name):
LPid = me.getValue(mp.get(analyzer['LPnames'], name))#id del LP.
afectados = gr.adjacents(analyzer['cables'], LPid)
paises = mp.newMap(37,comparefunction=LPids)
paisesSet = set()
ltSort = lt.newList('ARRAY_LIST', cmpfunction=LPids)
try:
for vertex in lt.iterator(afectados):
pais = me.getValue(mp.get(analyzer['landingPoints'], vertex))[2]
pais = pais.split(',')[1].strip() #Saca el país, quita la ciudad.
paisesSet.add(pais)
arc = gr.getEdge(analyzer['cables'], LPid, vertex)
if mp.contains(paises, pais):
lt.addLast(me.getValue(mp.get(paises, pais)), arc)
if not mp.contains(paises, pais):
mp.put(paises, pais, lt.newList('ARRAY_LIST', cmpfunction=LPids))
lt.addLast(me.getValue(mp.get(paises, pais)), arc)
for pais in paisesSet:
ltP = me.getValue(mp.get(paises, pais))
ltPO = sortMaster(ltP, cmpArcW)
mp.put(paises, pais, ltPO)#Pone la lista en orden.
primero = lt.firstElement(ltPO)#solo compara el cable más largo de ese país.
lt.addLast(ltSort, (pais, primero))
ltFinal = sortMaster(ltSort, cmpWtuple)
return len(list(paisesSet)), ltFinal
except Exception as exp:
error.reraise(exp, 'model:Fallas')
def vertices_buscables(catalog,v):
elemento=m.get(catalog["ciudad_id"],v)
if elemento==None:
return v
else:
info=lt.firstElement(elemento["value"]["song"])
return v+"-"+str(info["landing_point_id"])
def firstVertex(analyzer):
"""
Retorna la informacion del primer vértice cargado
"""
listaVertices = mp.keySet(analyzer['landing_points'])
primerPoint = lt.firstElement(listaVertices)
infoPoint = mp.get(analyzer['landing_points'], primerPoint)['value']
return infoPoint
