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