def f6(cont, s1, tMAX): cola = qe.newQueue() listaDeListasDeTuplas = model.buscarEstacionesBFS(cont,s1,tMAX) for i in listaDeListasDeTuplas: for j in i: qe.enqueue(cola, s1 + "-->" + str(j[0]) + ". La duración esperada de esta ruta es " + str(j[1]) + " minutos") return cola
def bfsVertex(search, graph, source): """ 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) while (it.hasNext(adjslstiter)): w = it.next(adjslstiter) visited_w = map.get(search['visited'], w) if visited_w is None: dist_to_w = visited_v['distTo'] + 1 visited_w = { 'marked': True, 'edgeTo': vertex, "distTo": dist_to_w } map.put(search['visited'], w, visited_w) queue.enqueue(adjsqueue, w) return search except Exception as exp: error.reraise(exp, 'bfs:bfsVertex')
def dfsVertex(graph, search, vertex): """ Genera un recorrido DFS sobre el grafo graph Args: graph: El grafo a recorrer source: Vertice de inicio del recorrido. Returns: Una estructura para determinar los vertices conectados a source Raises: Exception """ try: queue.enqueue(search['pre'], vertex) map.put(search['marked'], vertex, True) lstadjacents = g.adjacents(graph, vertex) adjiterator = it.newIterator(lstadjacents) while it.hasNext(adjiterator): adjvert = it.next(adjiterator) if not map.contains(search['marked'], adjvert): dfsVertex(graph, search, adjvert, ) queue.enqueue(search['post'], vertex) stack.push(search['reversepost'], vertex) return search except Exception as exp: error.reraise(exp, 'dfo:dfsVertex')
def RutaMinima(catalog, paisA, paisB): mapaLP = catalog['landing_points'] mapaCountries = catalog['countries'] mapaCountries2 = catalog['countries2'] grafo = catalog['grafo'] capitalA = me.getValue(mp.get(mapaCountries, paisA))['CapitalName'] capitalB = me.getValue(mp.get(mapaCountries, paisB))['CapitalName'] dijkstra = djk.Dijkstra(grafo, capitalA) distancia_total = djk.distTo(dijkstra, capitalB) ruta_cruda = djk.pathTo(dijkstra, capitalB) ruta = qu.newQueue('ARRAY_LIST') previo = None while not stk.isEmpty(ruta_cruda): punto = stk.pop(ruta_cruda)['vertexB'] dist = djk.distTo(dijkstra, punto) if not mp.contains(mapaCountries2, punto): punto = 'Landing point ' + punto.split('-')[0] print(dist) print(punto) p_d = (punto, dist) if not previo == punto: qu.enqueue(ruta, p_d) previo = punto return ruta, distancia_total
def relax(graph, search, v): """ Relaja el peso de los arcos del grafo Args: search: La estructura de busqueda v: Vertice desde donde se relajan los pesos Returns: El grafo con los arcos relajados Raises: Exception """ try: edges = g.adjacentEdges(graph, v) if edges is not None: for edge in lt.iterator(edges): v = e.either(edge) w = e.other(edge) distv = map.get(search['distTo'], v)['value'] distw = map.get(search['distTo'], w)['value'] distweight = distv + e.weight(edge) if (distw > distweight): map.put(search['distTo'], w, distweight) map.put(search['edgeTo'], w, edge) if (not map.get(search['onQ'], w)['value']): q.enqueue(search['qvertex'], w) map.put(search['onQ'], w, True) cost = search['cost'] if ((cost % g.numVertices(graph)) == 0): findneg = findNegativeCycle(graph, search) if (hasNegativecycle(findneg)): return search['cost'] = cost + 1 return search except Exception as exp: error.reraise(exp, 'bellman:relax')
def BellmanFord(graph, source): """ Implementa el algoritmo de Bellman-Ford Args: graph: El grafo de busqueda source: El vertice de inicio Returns: La estructura search con los caminos de peso mínimos Raises: Exception """ try: search = initSearch(graph, source) map.put(search['distTo'], source, 0.0) q.enqueue(search['qvertex'], source) map.put(search['onQ'], source, True) while (not q.isEmpty(search['qvertex']) and (not hasNegativecycle(search))): v = q.dequeue(search['qvertex']) map.put(search['onQ'], v, False) relax(graph, search, v) return search except Exception as exp: error.reraise(exp, 'bf:BellmanFord')
def f9(cont,age): cola = qe.newQueue() qe.enqueue(cola,"Las estaciones adyacentes que más utilizan las personas de este grupo de edad, con suscripción de 3 días son: ") retorno = model.idEstPublicidad(cont,age) for i in retorno: qe.enqueue(cola,i) return cola
def efe12(productora, PsXComDePro, LlavesCriteriosAdicionales): n = 0 ColaPeliculas = qe.newQueue() ColaAdicionales = qe.newQueue() Puntajes = [] Centinela = True while Centinela == True: if mp.contains(PsXComDePro, productora + str(n)): pelicula = mp.get(PsXComDePro, productora + str(n))["value"] qe.enqueue( ColaPeliculas, pelicula["title"] + " (" + pelicula["release_date"][-4:] + ")") Puntajes.append(float(pelicula["vote_average"])) n = n + 1 else: Centinela = False if len(Puntajes) != 0: qe.enqueue(ColaAdicionales, [LlavesCriteriosAdicionales[0], qe.size(ColaPeliculas)]) qe.enqueue( ColaAdicionales, [LlavesCriteriosAdicionales[1], sum(Puntajes) / len(Puntajes)]) return (ColaPeliculas, ColaAdicionales) else: qe.enqueue(ColaAdicionales, qe.size(ColaPeliculas)) qe.enqueue(ColaAdicionales, 0) return (ColaPeliculas, ColaAdicionales)
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 nearbyStations(database, longitude, latitude): aspir = queue.newQueue() queue.enqueue( aspir, orderedmap.ceiling(database['position']['latitude'], latitude)) queue.enqueue( aspir, orderedmap.ceiling(database['position']['longitude'], longitude)) queue.enqueue( aspir, orderedmap.floor(database['position']['longitude'], longitude)) queue.enqueue(aspir, orderedmap.floor(database['position']['latitude'], latitude)) val = None wID = None while not queue.isEmpty(aspir): id = queue.dequeue(aspir) id = mapentry.getValue(id) element = map.get(database['station'], id) element = mapentry.getValue(element) dist = abs( Calc.distance(element['latitude'], latitude, element['longitude'], longitude)) if val is None: val = dist wID = id if dist < val: val = dist wID = id return wID
def efe5(país, PsXPais____): n = 0 ColaPeliculas = qe.newQueue() Centinela = True while Centinela == True: if mp.contains(PsXPais____, país + str(n)): pelicula = mp.get(PsXPais____, país + str(n))["value"] qe.enqueue( ColaPeliculas, pelicula["title"] + " (" + pelicula["release_date"][-4:] + ") " + "Dirigida por: " + pelicula["director_name"]) n = n + 1 else: Centinela = False return (ColaPeliculas, None)
def edgesMST(graph, search): """ Args: search: La estructura de busqueda vertex: El vertice de destino Returns: Una pila con el camino entre source y vertex Raises: Exception """ try: vertices = g.vertices(graph) for vert in lt.iterator(vertices): e = map.get(search['edgeTo'], vert) if (e is not None): q.enqueue(search['mst'], e['value']) return search except Exception as exp: error.reraise(exp, 'bellman:pathto')
def lpInterconexion(catalog): rbt = model.lpInterconexion(catalog) lista_listas_LandingPoints = om.valueSet(rbt) cola_retornar = qu.newQueue() total_cables_resultado = mp.newMap(loadfactor=4.0) contador = 0 for lista in lt.iterator(lista_listas_LandingPoints): for tupla_lp_listavertices in lt.iterator(lista): if contador > 9: break else: lista_vertices = tupla_lp_listavertices[1] for vertice in lt.iterator(lista_vertices): # cable = vertice.split('-')[2] mp.put(total_cables_resultado, vertice, vertice) qu.enqueue(cola_retornar, tupla_lp_listavertices) contador = contador + 1 total_cables_resultado = mp.size(total_cables_resultado) return cola_retornar, total_cables_resultado
def f3(analyzer,s1,s2): cola = qe.newQueue() qe.enqueue(cola, "Hay " + str(model.numSCC(analyzer)) + " clústeres en el grafo") if model.sameCC(analyzer,s1,s2)==False: qe.enqueue(cola, "Las dos estaciones NO pertenecen al mismo clúster") else: qe.enqueue(cola, "Las dos estaciones SI pertenecen al mismo clúster") return cola
def f5(cont): cola = qe.newQueue() Top3Salida = model.Top3Salida(cont) Top3Llegada = model.Top3Llegada(cont) Top3Total = model.Top3Total(cont) qe.enqueue(cola, "Las 3 estaciones principales de llegada (en orden) son: " + Top3Llegada[0] + " " + Top3Llegada[1] + " " + Top3Llegada[2]) qe.enqueue(cola, "Las 3 estaciones principales de salida (en orden) son: " + Top3Salida[0] + " " + Top3Salida[1] + " " + Top3Salida[2]) qe.enqueue(cola, "Las 3 estaciones menos usadas en total (en orden) son: " + Top3Total[1] + " " + Top3Total[2] + " " + Top3Total[3]) return cola
def f4(cont,s1,tMIN,tMAX): cola = qe.newQueue() qe.enqueue(cola,"Nota: se parte del supuesto de que un turista toma 20 minutos conociendo los alrededores en cada parada.") listaCand = model.CandidatasCirculares(cont,s1) if lt.isEmpty(listaCand): qe.enqueue(cola,"No se encontraron rutas.") return cola listaFinal = model.buscarEstaciónesFinales(cont,s1,listaCand) if lt.isEmpty(listaFinal): qe.enqueue(cola,"No se encontraron rutas.") return cola qe.enqueue(cola,"Se encontraron las siguientes rutas: ") iterador = it.newIterator(listaFinal) C = True while C: dixx = it.next(iterador) llave = list(dixx.keys())[0] valor = list(dixx.values())[0] tupla = model.CostoMinimoCircular(cont,s1,llave,valor) if (tMIN*60)<tupla[1]<(tMAX*60): qe.enqueue(cola,(tupla[0] + " , duración esperada en minutos: " + str(round(tupla[1]/60)) )) if not it.hasNext(iterador): C = False return cola
def test_infoElements(queue, books): """ Este test busca confirmar que los datos se almacenen de forma correcta y que sean los valores correctos en el orden apropiado de la estructura. """ q.enqueue(queue, books[5]) q.enqueue(queue, books[6]) q.enqueue(queue, books[3]) q.enqueue(queue, books[10]) q.enqueue(queue, books[1]) q.enqueue(queue, books[2]) q.enqueue(queue, books[8]) q.enqueue(queue, books[4]) q.enqueue(queue, books[7]) elem = q.peek(queue) assert (elem == books[5]) elem = q.dequeue(queue) assert (elem == books[5]) elem = q.dequeue(queue) assert (q.size(queue) == 7) assert (elem == books[6]) elem = q.peek(queue) assert (q.size(queue) == 7) assert (elem == books[3]) q.enqueue(queue, books[9]) assert (q.size(queue) == 8) elem = q.peek(queue) assert (elem == books[3])
def test_sizeQueue(queue, books): """ Se prueba la creacion de una cola y la relacion con el tamaño al ingresar datos """ assert (q.size(queue) == 0) assert (q.isEmpty(queue)) q.enqueue(queue, books[5]) q.enqueue(queue, books[6]) q.enqueue(queue, books[3]) q.enqueue(queue, books[10]) q.enqueue(queue, books[1]) q.enqueue(queue, books[2]) q.enqueue(queue, books[8]) q.enqueue(queue, books[4]) q.enqueue(queue, books[7]) assert q.size(queue) == 9
def test_queueElements(queue, books): """ Se prueba la creacion de una nueva cola, se agregan todos los datos creados por sistema y se imprime su valor """ q.enqueue(queue, books[5]) q.enqueue(queue, books[6]) q.enqueue(queue, books[3]) q.enqueue(queue, books[10]) q.enqueue(queue, books[1]) q.enqueue(queue, books[2]) q.enqueue(queue, books[8]) q.enqueue(queue, books[4]) q.enqueue(queue, books[7]) q.enqueue(queue, books[9]) while not q.isEmpty(queue): element = q.dequeue(queue) result = ("".join( str(key) + ": " + str(value) + ", " for key, value in element.items())) print(result)
def test_enqueue_dequeue(queue, books): """ Este test prueba que la cola pueda manejar inserciones y eliminaciones de forma correcta siguiendo un orden establecido, y que no quede referencia al objeto sacado despues de haberlo removido de la cola """ q.enqueue(queue, books[5]) assert (q.size(queue) == 1) assert (q.peek(queue) == q.dequeue(queue)) assert (q.size(queue) == 0) q.enqueue(queue, books[6]) assert (q.size(queue) == 1) assert (q.peek(queue) == q.dequeue(queue)) assert (q.size(queue) == 0) q.enqueue(queue, books[3]) assert (q.size(queue) == 1) assert (q.peek(queue) == q.dequeue(queue)) assert (q.size(queue) == 0) q.enqueue(queue, books[10]) assert (q.size(queue) == 1) assert (q.peek(queue) == q.dequeue(queue)) assert (q.size(queue) == 0) q.enqueue(queue, books[1]) assert (q.size(queue) == 1) assert (q.peek(queue) == q.dequeue(queue)) assert (q.size(queue) == 0) q.enqueue(queue, books[2]) assert (q.size(queue) == 1) assert (q.peek(queue) == q.dequeue(queue)) assert (q.size(queue) == 0) q.enqueue(queue, books[8]) q.enqueue(queue, books[4]) q.enqueue(queue, books[7]) q.enqueue(queue, books[9]) assert (q.size(queue) == 4) assert books[8] == q.dequeue(queue) assert books[4] == q.dequeue(queue) assert books[7] == q.dequeue(queue) assert books[9] == q.dequeue(queue) assert (q.size(queue) == 0)
def test_peek_dequeue(queue, books): """ Este test prueba la creacion de una cola y que el orden de salida sea el correcto para la estructura en cuestion, y que el tamaño se reduzca para cada salida de objeto """ q.enqueue(queue, books[5]) q.enqueue(queue, books[6]) q.enqueue(queue, books[3]) q.enqueue(queue, books[10]) q.enqueue(queue, books[1]) q.enqueue(queue, books[2]) q.enqueue(queue, books[8]) q.enqueue(queue, books[4]) q.enqueue(queue, books[7]) total = q.size(queue) while not (q.isEmpty(queue)): peek = q.peek(queue) assert (q.dequeue(queue) == peek) total -= 1 assert (total == q.size(queue))
def greater(key1, key2): if key1['t'] == key2['t']: return 0 elif key1['t'] < key2['t']: return -1 else: return 1 cola_de_espera = queue.newQueue() minpq = pq.newMinPQ(greater) pq.insert(minpq, {'t': 0, 'evento': 'llegada'}) pq.insert(minpq, {'t': 5, 'evento': 'fin'}) iters = 0 while not pq.isEmpty(minpq) and iters < 100: p = pq.delMin(minpq) if p['evento'] == 'llegada': queue.enqueue(cola_de_espera, 1) pq.insert(minpq, {'t': p['t'] + 1, 'evento': 'llegada'}) print('llegada') if p['evento'] == 'fin': break iters = iters + 1 print(queue.size(cola_de_espera))
def ConsultaRutasCirculares(bikes, vertice, inferior, superior): ListaCompleta = ListaAdyacentes(bikes, vertice) lstiterator = it.newIterator(ListaCompleta) conteoCaminos = 0 stackfinal = stack.newStack() CadaRuta = queue.newQueue() ConteoDeRutas = 0 while it.hasNext(lstiterator): eachaStation = it.next(lstiterator) primerRecorrido = getEdge(bikes['grafo'], vertice, eachaStation) search = minimumCostPaths(bikes, eachaStation) colados = minimumCostPath(bikes, vertice) if colados and ((stack.size(colados)) * 60 * 20) < superior: pesoporestaciones = (stack.size(colados)) * 60 * 20 pesocamino = 0 pesoTOTALdos = pesoporestaciones + pesocamino + primerRecorrido[ 'weight'] CadaRuta = queue.newQueue() queue.enqueue(CadaRuta, primerRecorrido) while (not stack.isEmpty(colados)) and (pesoTOTALdos < superior): stopDOS = stack.pop(colados) pesoTOTALdos += stopDOS['weight'] queue.enqueue(CadaRuta, stopDOS) if inferior < pesoTOTALdos < superior and CadaRuta: CadaRuta["PesoPorRuta"] = pesoTOTALdos ConteoDeRutas += 1 stack.push(stackfinal, CadaRuta) return ConteoDeRutas, stackfinal #NO BORRAR LO COMENTADO ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ #NO BORRAR LO COMENTADO ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ #NO BORRAR LO COMENTADO ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ """ #Req 2 funcionando #Req 2 funcionando #Req 2 funcionando ListaCompleta = ListaAdyacentes(bikes, vertice) lstiterator=it.newIterator(ListaCompleta) conteoCaminos = 0 stackfinal = stack.newStack() while it.hasNext(lstiterator): eachaStation=it.next(lstiterator) primero = minimumCostPaths(bikes, vertice) primerpeso = distTo(primero, eachaStation) FirsPath = minimumCostPath(primero, eachaStation) Firststop = stack.pop(FirsPath) segundo = minimumCostPaths(bikes, eachaStation) SecondPath = minimumCostPath(bikes, vertice) if SecondPath: pesoconjunto = (distTo(segundo, vertice)) + primerpeso stack.push(SecondPath, Firststop) pathlen = stack.size(SecondPath) pesofinal = pesoconjunto + (pathlen*20*60) if inferior < pesofinal < superior: conteoCaminos += 1 SecondPath["PesoTotal"]=pesofinal stack.push(stackfinal, SecondPath) return conteoCaminos, stackfinal """ """
def test_sizeQueue(): """ Se prueba la creacion de una cola y la relacion con el tamaño al ingresar datos """ queue = q.newQueue(list_type) assert (q.size(queue) == 0) assert (q.isEmpty(queue)) queue = q.newQueue(list_type) q.enqueue(queue, book5) q.enqueue(queue, book6) q.enqueue(queue, book3) q.enqueue(queue, book10) q.enqueue(queue, book1) q.enqueue(queue, book2) q.enqueue(queue, book8) q.enqueue(queue, book4) q.enqueue(queue, book7) q.enqueue(queue, book9) assert q.size(queue) == 10
def test_infoElements(): """ Este test busca confirmar que los datos se almacenen de forma correcta y que sean los valores correctos en el orden apropiado de la estructura. """ queue = q.newQueue(list_type) assert (q.size(queue) == 0) assert (q.isEmpty(queue)) queue = q.newQueue(list_type) q.enqueue(queue, book5) q.enqueue(queue, book6) q.enqueue(queue, book3) q.enqueue(queue, book10) q.enqueue(queue, book1) q.enqueue(queue, book2) q.enqueue(queue, book8) q.enqueue(queue, book4) q.enqueue(queue, book7) q.enqueue(queue, book9) elem = q.peek(queue) assert (q.size(queue) == 10) assert (elem == book5) elem = q.dequeue(queue) assert (q.size(queue) == 9) assert (elem == book5) elem = q.dequeue(queue) assert (q.size(queue) == 8) assert (elem == book6) elem = q.peek(queue) assert (q.size(queue) == 8) assert (elem == book3) q.enqueue(queue, book9) assert (q.size(queue) == 9) elem = q.peek(queue) assert (elem == book3)
def test_queueElements(): """ Se prueba la creacion de una nueva cola, se agregan todos los datos creados por sistema y se imprime su valor """ queue = q.newQueue(list_type) q.enqueue(queue, book5) q.enqueue(queue, book6) q.enqueue(queue, book3) q.enqueue(queue, book10) q.enqueue(queue, book1) q.enqueue(queue, book2) q.enqueue(queue, book8) q.enqueue(queue, book4) q.enqueue(queue, book7) q.enqueue(queue, book9) iterator = it.newIterator(queue) while it.hasNext(iterator): element = it.next(iterator) result = ("".join(str(key) + ": " + str(value) + ", " for key, value in element.items())) print(result)
def test_enqueue_dequeue(): """ Este test prueba que la cola pueda manejar inserciones y eliminaciones de forma correcta siguiendo un orden establecido, y que no quede referencia al objeto sacado despues de haberlo removido de la cola """ queue = q.newQueue(list_type) assert (q.size(queue) == 0) assert (q.isEmpty(queue)) q.enqueue(queue, book5) assert(q.size(queue) == 1) assert(q.peek(queue) == q.dequeue(queue)) assert(q.size(queue) == 0) q.enqueue(queue, book6) assert(q.size(queue) == 1) assert(q.peek(queue) == q.dequeue(queue)) assert(q.size(queue) == 0) q.enqueue(queue, book3) assert(q.size(queue) == 1) assert(q.peek(queue) == q.dequeue(queue)) assert(q.size(queue) == 0) q.enqueue(queue, book10) assert(q.size(queue) == 1) assert(q.peek(queue) == q.dequeue(queue)) assert(q.size(queue) == 0) q.enqueue(queue, book1) assert(q.size(queue) == 1) assert(q.peek(queue) == q.dequeue(queue)) assert(q.size(queue) == 0) q.enqueue(queue, book2) assert(q.size(queue) == 1) assert(q.peek(queue) == q.dequeue(queue)) assert(q.size(queue) == 0) q.enqueue(queue, book8) q.enqueue(queue, book4) q.enqueue(queue, book7) q.enqueue(queue, book9) assert (q.size(queue) == 4) assert book8 == q.dequeue(queue) assert book4 == q.dequeue(queue) assert book7 == q.dequeue(queue) assert book9 == q.dequeue(queue) assert (q.size(queue) == 0)
def test_peek_dequeue(): """ Este test prueba la creacion de una cola y que el orden de salida sea el correcto para la estructura en cuestion, y que el tamaño se reduzca para cada salida de objeto """ queue = q.newQueue(list_type) assert q.size(queue) == 0 assert q.isEmpty(queue) queue = q.newQueue(list_type) q.enqueue(queue, book5) q.enqueue(queue, book6) q.enqueue(queue, book3) q.enqueue(queue, book10) q.enqueue(queue, book1) q.enqueue(queue, book2) q.enqueue(queue, book8) q.enqueue(queue, book4) q.enqueue(queue, book7) q.enqueue(queue, book9) total = q.size(queue) while not (q.isEmpty(queue)): peek = q.peek(queue) assert(q.dequeue(queue) == peek) total -= 1 assert (total == q.size(queue))
def f7(cont,age): cola = qe.newQueue() qe.enqueue(cola,model.RutaEdad(cont,age)) return cola
def f8(cont,lat1,lon1,lat2,lon2): cola = qe.newQueue() lista = model.RutaTuristica(cont,lat1,lon1,lat2,lon2) for i in lista: qe.enqueue(cola,i) return cola