def test_error_dequeue(queue, books):
"""
Este test busca comprobar que es imposible eliminar un objeto de
una cola vacia
"""
with pytest.raises(Exception):
q.dequeue(queue)
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_error_dequeue():
"""
Este test busca comprobar que es imposible eliminar un objeto de
una cola vacia
"""
queue = q.newQueue(list_type)
assert (q.size(queue) == 0)
assert(q.isEmpty(queue))
with pytest.raises(Exception):
q.dequeue(queue)
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_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 optionFour():
verticeCentral = input(
"Ingrese la estación para la cual desea realizar la consulta (Ejemplo 3661, 477): "
)
LimiteInferior = (int(
input("Ingrese el limite inferior del rango a consultar (Ej 120): "))
) * 60
LimiteSuperior = (int(
input("Ingrese el limite superior del rango a consultar (Ej 240): "))
) * 60
listaAdyacentes = controller.ListaAdyacentes(cont, verticeCentral,
LimiteInferior,
LimiteSuperior)
print("\nSe encontraron en total {} rutas cíclicas:\n ".format(
listaAdyacentes[0]))
while (not stack.isEmpty(listaAdyacentes[1])):
stop = stack.pop(listaAdyacentes[1])
print(
"Esta ruta tarda en total {} minutos, tiene {} estaciones, teniendo en cuenta un tiempo de 20 minutos por estacion. "
.format(
(round((stop["PesoPorRuta"] / 60), 2)),
str(queue.size(stop)),
))
while stop and (not queue.isEmpty(stop)):
stopDOS = queue.dequeue(stop)
print(
"-> Parte de la estacion {}, hasta la estación {} y tarda {} minutos en el trayecto. "
.format(stopDOS['vertexA'], stopDOS['vertexB'],
round((stopDOS['weight'] / 60), 2)))
print("\n")
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 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 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 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 ImprimirEnConsola(cola, DatosAdicionales=None):
if qe.isEmpty(cola)==False:
Centinela = True
print("-"*100)
while Centinela==True:
print("", end=" "*10)
print("•" + qe.dequeue(cola))
if qe.isEmpty(cola)==True: Centinela=False
print("-"*100)
else: print("No se ha encontrado información para el criterio")
if DatosAdicionales!=None:
if qe.isEmpty(DatosAdicionales)==False:
CentinelaAdicionales = True
while CentinelaAdicionales==True:
dato = qe.dequeue(DatosAdicionales)
print(str(dato[0])+str(dato[1]))
if qe.isEmpty(DatosAdicionales)==True: CentinelaAdicionales=False
def test_prim2(graph2):
search = prim.PrimMST(graph2)
weight = prim.weightMST(graph2, search)
print('\n')
path = search['mst']
while not q.isEmpty(path):
edge = q.dequeue(path)
print(edge['vertexA'] + "-->" + edge['vertexB'] + " costo: " +
str(edge['weight']))
print(str(weight))
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 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 convertQueueToStr(queue):
"""
Toma la cola con la ruta más corta
y la convierte a un string
"""
size = qu.size(queue)
strRoute = ""
for i in range(0, size):
stat = qu.dequeue(queue)
strRoute = strRoute + str(stat['vertexA']) + " - "
strRoute = strRoute + stat['vertexB']
return strRoute
def loadData(DataBase) -> bool:
files = getFiles()
dialect = csv.excel()
dialect.delimiter = ','
while not (queue.isEmpty(files)):
with open(queue.dequeue(files), encoding="utf-8") as csvfile:
buffer = csv.DictReader(csvfile, dialect=dialect)
cont = 0
for element in buffer:
cont += 1
Add.addTrip(element, DataBase)
if cont == Const.SIZE:
print(cont)
return True
print(cont)
return True
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_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 getBestRoute(analyzer, originArea, destinArea, initPos, endPos):
"""
Busca la mejor ruta entre dos estaciones
"""
lst = analyzer["hours"]
menorTime = float("inf")
menorRoute = ""
hour = 0
for i in range(initPos,(endPos+1)):
dict = lt.getElement(lst, i)
if (gr.containsVertex(dict["grafo"], originArea)) and (gr.containsVertex(dict["grafo"], destinArea)):
if destinArea == originArea:
edge = gr.getEdge(dict["grafo"],originArea,destinArea)
if edge is not None:
time = edge['weight']
if time < menorTime:
menorTime = time
menorRoute = originArea+"-"+destinArea
hour = dict["hora"]
else:
search = djk.Dijkstra(dict["grafo"],originArea)
queuePath = djk.pathTo(search, destinArea)
size = -1
if queuePath is not None:
size = qu.size(queuePath)
strRoute = ""
time = 0
for i in range(0,size):
stat = qu.dequeue(queuePath)
strRoute = strRoute + str(stat['vertexA'])+ " - "
time += stat['weight']
strRoute = strRoute + stat['vertexB']
if (time < menorTime) and (queuePath is not None):
menorTime = time
menorRoute = strRoute
hour = dict["hora"]
return (menorTime,menorRoute,hour)
respuesta = 'SI'
print(
'Estos dos landing points {} estan fuertemente conectados.'.format(
respuesta))
elif int(inputs[0]) == 3:
# -------------------------------------------------- REQ 2 -------------------------------------------------- #
print("Cargando información de los landing points...")
cola_lp, cant_cables_tot = controller.lpInterconexion(catalog)
print(
"---------------------- Lista primeros 10 landing points con más puntos de interconexión a cables ----------------------"
)
contador = 0
while not qu.isEmpty(cola_lp):
lp, listavertices = qu.dequeue(cola_lp)
cant_cables = lt.size(listavertices)
contador = contador + 1
print("TOP {}:".format(contador))
print("Nombre: {}".format(lp['name']))
print("País: {}".format(lp['country']))
print("Identificador: {}".format(lp['landing_point_id']))
print('Con {} cables distintos.'.format(cant_cables))
print(
'--------------------------------------------------------------------------------------------------'
)
print(
'La cantidad total de cables distintos conectados a estos 10 landing points es: {}.'
.format(cant_cables_tot))
