from CSAir_json import *
from CSAir_helpers import *
import webbrowser
import math
from flask import Markup
def list_locations(graph):
"""
Prints all of the cities stored in the graph.
:param graph: the directed graph
"""
cities = graph.get_nodes()
for city_node in cities:
city_node.get_object().brief_print()
def lookup(graph, code):
"""
Prints data for a specific city.
:param graph: the directed graph
:param code: the airport identifier for the city
:return: True if the city was found, False otherwise
"""
city_node = graph.find_node(code)
if city_node is None:
return "Location, " + code + ", not found.\n"
else:
ret_str = city_node.get_object().get_info()
ret_str += "\nRoutes departing from " + code + ":\n"
edges = graph.get_edges_for_node(city_node)
for edge in edges:
dest_node = edge.get_destination()
ret_str += code + " to " + Markup("<a href=\"?code=" + str(dest_node) + "\">" + str(dest_node) + "</a>") \
+ ", distance: " + edge + Markup(' <button type="button" class="btn btn-primary btn-xs" '
'onclick="window.location.href=\'routes?route=' + code + '-'
+ dest_node + '\'">View route</button>') + '\n'
if len(edges) == 0:
ret_str += "No routes."
return ret_str
def generate_map_url(graph):
"""
Returns a url to display a map at gcmap.com
:param graph: the directed graph
:return: string containing the url
"""
edges = graph.get_edges()
url_string = "http://www.gcmap.com/map?P="
for edge in edges:
url_string += (edge.get_source() + "-" + edge.get_destination() + "%0D%0A")
return url_string + "&MS=wls&MR=1800&MX=720x360&PM=*"
def show_map(url_string):
"""
Launches the default web browser to the specified url.
:param url_string: a string containing a url
"""
print(url_string)
webbrowser.open(url_string)
def print_longest(graph):
"""
Prints the longest flight path
:param graph: the directed graph
"""
edges = graph.get_edges()
longest_edge = 0
longest_int = 0
for edge in edges:
if int(edge) > longest_int:
longest_edge = edge
longest_int = int(edge)
return "Longest flight: " + longest_edge.get_source() + " to " + longest_edge.get_destination() \
+ ". " + longest_edge + "km"
def print_shortest(graph):
"""
Prints the shortest flight path
:param graph: the directed graph
"""
edges = graph.get_edges()
shortest_edge = 0
shortest_int = 0
for edge in edges:
if shortest_int == 0 or int(edge) < shortest_int:
shortest_edge = edge
shortest_int = int(edge)
return "Shortest flight: " + shortest_edge.get_source() + " to " + shortest_edge.get_destination() \
+ ". " + shortest_edge + "km"
def print_average(graph):
"""
Prints the average size of all routes and the total number of routes
:param graph: the directed graph
"""
edges = graph.get_edges()
total = "Total routes: " + str(len(edges)) + "\n"
total_distance = 0
for edge in edges:
total_distance += int(edge)
average = total_distance/len(edges)
return total + "Average distance across all routes: " + str(math.floor(average)) + "km"
def print_smallest_city(graph):
"""
Prints the smallest city
:param graph: the directed graph
"""
nodes = graph.get_nodes()
smallest_pop = 0
for node in nodes:
node_pop = node.get_object().population
if smallest_pop == 0 or node_pop < smallest_pop:
smallest_city = node
smallest_pop = node_pop
ret_str = "Smallest city: " + smallest_city.get_object().get_brief()
ret_str += "Population: " + str(smallest_pop)
return ret_str
def print_largest_city(graph):
"""
Prints the largest city
:param graph: the directed graph
"""
nodes = graph.get_nodes()
largest_pop = 0
for node in nodes:
node_pop = node.get_object().population
if node_pop > largest_pop:
largest_city = node
largest_pop = node_pop
ret_str = "Largest city: " + largest_city.get_object().get_brief()
ret_str += "Population: " + str(largest_pop)
return ret_str
def print_average_city(graph):
"""
Prints the average size of all cities and the total number of cities
:param graph: the directed graph
"""
nodes = graph.get_nodes()
ret_str = "Total cities: " + str(len(nodes)) + "\n"
total_pop = 0
for node in nodes:
node_pop = node.get_object().population
total_pop += node_pop
average = total_pop/len(nodes)
return ret_str + "Average city size: " + str(math.floor(average))
def print_continents(graph):
"""
Prints the continents and cities within them
:param graph: the directed graph
"""
nodes = graph.get_nodes()
continents = [] # continents is a list of continent names.
cities = [] # cities[i] is a list of cities in continent i
for node in nodes:
city = node.get_object()
node_cont = city.continent
if node_cont not in continents:
continents.append(node_cont)
cities.append([])
for i, _ in enumerate(continents):
if continents[i] == node_cont:
cities[i].append(city)
ret_str = ""
for i, _ in enumerate(continents):
ret_str += "\nCities in " + continents[i] + ":\n"
for city in cities[i]:
ret_str += city.get_brief()
return ret_str
def print_hubs(graph):
"""
Prints the cities ordered from largest number of connections to smallest
:param graph: the directed graph
"""
nodes = graph.get_nodes()
num_edges = []
for node in nodes:
edges = graph.get_edges_for_node(node)
num_edges.append(len(edges))
both = zip(num_edges, nodes) # zip both lists into a tuple
both = sorted(both)[::-1] # sort and reverse the tuple
ret_str = ""
for pair in both:
city = pair[1].get_object()
ret_str += str(pair[0]) + " connections from: " + city.get_brief()
return ret_str
def add_city(graph):
"""
Prompts the user to add a new city to the graph.
:return: True on success, false on failure.
"""
print("Enter the new city's information:")
code = input("Code: ").rstrip('\n')
if code in graph.get_nodes():
print("City already exists, can not add. Perhaps you meant to edit the city?")
return False
use_api = input("Do you want to look up this city using the Wunderground API? (y/n)")
if use_api == "y":
return json_api_request(graph, code)
else:
name = input("Name: ").rstrip('\n')
country = input("Country: ").rstrip('\n')
continent = input("Continent: ").rstrip('\n')
timezone = input("Timezone: ").rstrip('\n')
latitude = input("Latitude: ").rstrip('\n')
longitude = input("Longitude: ").rstrip('\n')
population = input("Population: ").rstrip('\n')
region = input("Region: ").rstrip('\n')
add_city_helper(graph, code, name, country, continent, timezone, latitude, longitude, population, region)
return True
def add_route(graph):
"""
Prompts the user to add a new route.
"""
print("Enter the new route's information:")
source = input("Source: ").rstrip('\n')
dest = input("Destination: ").rstrip('\n')
distance = input("Distance: ").rstrip('\n')
direction = input("Add the route in both directions? (y/n): ").rstrip('\n')
add_route_helper(graph, source, dest, distance, direction)
def remove_city(graph):
"""
Prompts the user to remove a city.
"""
print("Enter the code of the city to remove:")
code = input("Code: ").rstrip('\n')
if graph.remove_node(code):
print("City removed.")
else:
print("Unable to remove city. A city with the specified code does not exist.")
def remove_route(graph):
"""
Prompts the user to remove a route.
"""
print("Enter the source and destination codes for the route to remove:")
source = input("Source: ").rstrip('\n')
dest = input("Destination: ").rstrip('\n')
direction = input("Remove the route in both directions? (y/n): ").rstrip('\n')
remove_route_helper(graph, source, dest, direction)
def edit_city(graph, code):
"""
Prompts the user to edit a city.
:param code: The city to edit
:return: True if edited, false otherwise.
"""
node = graph.find_node(code)
if node is None:
print("City not found, can not edit.")
return False
city = node.get_object()
print("Editing " + code + "'s information:"
"\nThe current information will be displayed, then you can enter new information:"
"\nTo keep the current information, leave the section blank.")
code = update_data("Code", city.code)
name = update_data("Name", city.name)
country = update_data("Country", city.country)
continent = update_data("Continent", city.continent)
timezone = update_data("Timezone", str(city.timezone))
latitude = update_data("Latitude", str(city.latitude))
longitude = update_data("Longitude", str(city.longitude))
population = update_data("Population", str(city.population))
region = update_data("Region", str(city.region))
graph.remove_node(node)
if not add_city_helper(graph, code, name, country, continent, timezone, latitude, longitude, population, region):
#if modifying the city failed, add the old one back to the graph.
graph.add_node(node)
return False
#edit current routes to match new information!
update_routes(graph, code, node)
return True
def route_info(graph):
"""
Prompts the user to enter a list of cities, then will display cost, time, and distance for the route.
:return: False on error, True otherwise.
"""
try:
num_cities = int(input("Total number of cities in the route: "))
except ValueError:
print("Error: Number of cities must be an integer.")
return False
if num_cities <= 0:
print("Error: The number of cities in the route must be greater than 0.")
return False
nodes = graph.get_nodes()
print("Enter the city codes for the route. Type cancel to return back to the main prompt.")
route = []
for i in range(num_cities):
code = input(":")
if code == "cancel":
return True
elif code not in nodes:
print("Error: " + code + " is not a city in our current data.")
return False
route.append(code)
return route_helper(graph, route)
def route_shortest(graph):
"""
Uses Dijkstra's algorithm to determine the shortest route between souce city and destination city.
:return: False on error, true otherwise
"""
print("Enter the city codes for the route.")
source = input("Source city: ")
dest = input("Destination city: ")
route = graph.dijkstra(source, dest)
if route is None:
return False
return route_helper(graph, route)
