def _add_station(self, station):
is_error = False
try:
start_time = time.time()
stations = self.DICTIONARY.keys()
if station not in stations:
self.DICTIONARY[station] = {}
print(
str(time.time() - start_time) + " Dictionary add station")
return True
else:
is_error = True
return ERRORS.get("duplicate")
except KeyError:
is_error = True
return ERRORS.get("key_error")
except Exception:
is_error = True
return ERRORS.get("error")
finally:
pass
if is_error == False:
try:
self.db._insert_station_data(station)
except psycopg2.Error:
return ERRORS.get("database")
def _update_station_connector(self, station, next_station, distance):
is_error = False
try:
start_time = time.time()
if self.DICTIONARY[station][next_station] != None:
self.DICTIONARY[station][next_station] = int(distance)
print(
str(time.time() - start_time) +
" Dictionary update station connection")
return True
else:
return ERRORS.get("not_exist")
except KeyError:
is_error = True
return ERRORS.get("key_error")
except Exception:
is_error = True
return ERRORS.get("error")
finally:
if is_error == False:
try:
self.db._update_connected_station_data(
station, next_station, distance)
except psycopg2.Error:
return ERRORS.get("database")
def _add_station_connector(self, station, next_station, distance):
is_error = False
try:
try:
start_time = time.time()
self.DICTIONARY[station][next_station]
is_error = True
return ERRORS.get("duplicate")
except KeyError:
self.DICTIONARY[station][next_station] = int(distance)
print(
str(time.time() - start_time) +
" Dictionary add station connection")
return True
except KeyError:
is_error = True
return ERRORS.get("key_error")
except Exception:
is_error = True
return ERRORS.get("error")
finally:
if is_error == False:
try:
self.db._insert_connected_station_data(
station, next_station, int(distance))
except psycopg2.Error:
return ERRORS.get("database")
def _update_station(self, key, station_name):
is_error = False
try:
start_time = time.time()
target_data = self.DICTIONARY[key]
self.DICTIONARY[station_name] = target_data
self.DICTIONARY.pop(key)
matched_stations = []
for station in self.DICTIONARY:
for connector in self.DICTIONARY[station]:
if connector == key:
matched_stations.append(station)
for station in matched_stations:
target_data = self.DICTIONARY[station][key]
self.DICTIONARY.pop(station)
self.DICTIONARY[station] = {}
self.DICTIONARY[station][station_name] = target_data
print(str(time.time() - start_time) + " Dictionary update station")
return True
except KeyError:
is_error = True
return ERRORS.get("key_error")
except Exception:
is_error = True
return ERRORS.get("error")
finally:
if is_error == False:
try:
self.db._update_station_data(key, station_name)
except psycopg2.Error:
return ERRORS.get("database")
def _update_station_distance(self,
src,
dest=None,
station_name=None,
distance=None):
try:
if src is not None:
index = self.stations.index(src)
if index is not None:
if station_name is None:
node_list = self.stations_arr[index]
result = node_list._update(dest, None, distance)
if result == True:
return True
else:
return result
if dest is None:
for station in self.stations_arr:
station._update(src, station_name)
self.stations[index] = station_name
return True
else:
return ERRORS.get("not_exist")
else:
return ERRORS.get("null_error")
except Exception:
return ERRORS.get("error")
def _delete(self, key):
is_error = False
try:
start_time = time.time()
self.DICTIONARY.pop(key)
matched_stations = []
for station in self.DICTIONARY:
for connector in self.DICTIONARY[station]:
if connector == key:
matched_stations.append(station)
for station in matched_stations:
self.DICTIONARY[station].pop(key)
print(str(time.time() - start_time) + " Dictionary delete station")
return True
except KeyError:
is_error = True
return ERRORS.get("key_error")
except Exception:
is_error = True
return ERRORS.get("error")
finally:
if is_error == False:
try:
self.db._delete_station_data(key)
except psycopg2.Error:
return ERRORS.get("database")
def _build(self):
connected_station_data_set = self.db._get_all_connected_stations()
station_data_set = self.db._get_all_stations()
try:
if connected_station_data_set[
'status'] and station_data_set['status'] is True:
for data in station_data_set['data']:
station = data[1]
self.DICTIONARY[station] = {}
for data in connected_station_data_set['data']:
station = data[0]
next_station = data[1]
distance = int(data[2])
target_data = self.DICTIONARY.get(station)
if target_data is not None:
self.DICTIONARY[station][next_station] = distance
else:
self.DICTIONARY[station] = {next_station: distance}
else:
return ERRORS.get("database")
except KeyError:
return ERRORS.get("key_error")
except IndexError:
return ERRORS.get("index")
except Exception:
return ERRORS.get("error")
def _add_station_connector(self, station, next_stations, distance):
is_error = False
try:
start_time = time.time()
all_connections = self._get_all_connections()
for connection in all_connections['data']:
station_name = connection["station_name"]
next_station = connection["next_station"]
if station_name == station and next_station == next_stations:
return ERRORS.get("duplicate")
result = self.LINKEDLIST._add(station, next_stations,
int(distance))
print(
str(time.time() - start_time) +
" Linkedlist add station connection")
if result is True:
return True
else:
is_error = True
return result
except Exception:
is_error = True
return ERRORS.get("error")
finally:
if is_error == False:
try:
print(
self.db._insert_connected_station_data(
station, next_stations, str(distance)))
except psycopg2.Error:
return ERRORS.get("database")
def _get(self, key):
try:
if key is not None:
index = self.stations.index(key)
if index is not None:
node_list = self.stations_arr[index]
return node_list._get_all()
else:
return ERRORS.get("null_error")
except Exception:
return ERRORS.get("error")
def _update_station(self,key,data):
try:
if key in self.stations:
index = self.stations.index(key)
self.stations[index]=data
return True
else:
return ERRORS.get('not_exist')
except KeyError:
return ERRORS.get('key_error')
except Exception:
return ERRORS.get('error')
def _print(self):
try:
current_station = self.head
while current_station != None:
print(
str(current_station.station_name) + ":" +
str(current_station.distance))
current_station = current_station.next_station
except ArithmeticError:
return ERRORS.get('data_type')
except Exception:
return ERRORS.get("error")
def _add_station(self, key):
try:
if key is not None:
if key not in self.stations:
self.stations_arr.append(SinglyLinkedList())
self.stations.append(key)
return True
else:
return ERRORS.get("duplicate")
else:
return ERRORS.get('null_error')
except Exception:
return ERRORS.get("error")
def _add(self, src, dest, distance):
try:
if src and dest and distance is not None:
if src in self.stations:
index = self.stations.index(src)
self.stations_arr[index]._add(dest, None, distance)
return True
else:
return ERRORS.get("not_exist")
else:
return ERRORS.get("null_error")
except Exception:
return ERRORS.get("error")
def _pop(self, key):
try:
if key is not None and key in self.stations:
index = self.stations.index(key)
if index is not None:
self.stations_arr.pop(index)
self.stations.pop(index)
for station in self.stations_arr:
station._pop(key)
return True
else:
return ERRORS.get("not_exist")
except Exception:
return ERRORS.get("error")
def _pop_station_connection(self, key, next_station):
try:
if key is not None and key in self.stations:
index = self.stations.index(key)
if index is not None:
target = self.stations_arr[index]._pop(next_station)
if target == True:
return True
else:
return ERRORS.get('not_exist')
else:
return ERRORS.get("not_exist")
except Exception:
return ERRORS.get("error")
def _pop(self,key):
try:
if key in self.stations:
index = self.stations.index(key)
self.stations.pop(index)
self.adjacency_matrix.pop(index)
for stations in self.adjacency_matrix:
stations.pop(index)
return True
else:
return ERRORS.get('not_exist')
except KeyError:
return ERRORS.get('key_error')
except Exception:
return ERRORS.get('error')
def _add_station(self,station):
try:
if station is not None:
self.stations_count+=1
self.stations.append(station)
for station in self.adjacency_matrix:
station.append(0)
self.adjacency_matrix.append([0 for i in range(self.stations_count)])
return True
else:
return ERRORS.get('null_error')
except KeyError:
return ERRORS.get('key_error')
except Exception:
return ERRORS.get('error')
def _get(self,key):
try:
if key is not None and key in self.stations:
index = self.stations.index(key)
vertex_list=[]
for i in range(0,self.stations_count):
if not i==index and not self.adjacency_matrix[index][i] ==0:
vertex_list.insert(0,{self.stations_copy[i]:self.adjacency_matrix[index][i]})
return vertex_list
else:
return ERRORS.get('null_error')
except KeyError:
return ERRORS.get('key_error')
except Exception:
return ERRORS.get('error')
def _get(self, key):
try:
target_node = None
temp = self.head
while temp != None:
if temp.station_name == key:
target_node = temp
break
temp = temp.next_station
if target_node is not None:
return target_node
else:
return ERRORS.get("not_exist")
except Exception:
return ERRORS.get("error")
def _make_undirected_graph(self, graph):
all_connections = graph._get_all_connections()
if all_connections['status'] is True:
for connection in all_connections['data']:
station_name = connection["station_name"]
next_station = connection["next_station"]
distance = connection["distance"]
if station_name not in self._undirected_graph.keys():
self._undirected_graph[station_name] = {}
self._undirected_graph[station_name][
next_station] = distance
else:
self._undirected_graph[station_name][
next_station] = distance
for connection in all_connections['data']:
station_name = connection["station_name"]
next_station = connection["next_station"]
distance = connection["distance"]
if next_station not in self._undirected_graph.keys():
self._undirected_graph[next_station] = {}
self._undirected_graph[next_station][
station_name] = distance
else:
self._undirected_graph[next_station][
station_name] = distance
else:
return ERRORS.get("error")
def _update_station_distance(self,src,dest,distance):
try:
if src and dest in self.stations:
index_src = self.stations.index(src)
index_dest = self.stations.index(dest)
if(self.adjacency_matrix[index_src][index_dest]!=0):
self.adjacency_matrix[index_src][index_dest]=distance
return True
else:
return ERRORS.get('not_exist')
else:
return ERRORS.get('not_exist')
except KeyError:
return ERRORS.get('key_error')
except Exception:
return ERRORS.get('error')
def _pop_station_connection(self,key,next_station):
try:
if key and next_station in self.stations:
indexKey = self.stations.index(key)
indexNextStation= self.stations.index(next_station)
if(self.adjacency_matrix[indexKey][indexNextStation]!=0):
self.adjacency_matrix[indexKey][indexNextStation]=0
return True
else:
return ERRORS.get('not_exist')
else:
return ERRORS.get('not_exist')
except KeyError:
return ERRORS.get('key_error')
except Exception:
return ERRORS.get('error')
def _update(self, key, station_name=None, distance=None):
try:
target_station = self._get(key)
if type(target_station
) == dict and target_station['status'] == False:
return ERRORS.get("not_exist")
else:
if station_name is None:
target_station.distance = distance
elif distance is None:
target_station.station_name = station_name
elif station_name and distance is not None:
target_station.distance = distance
target_station.station_name = station_name
return True
except Exception:
return ERRORS.get("error")
def _get_all_connections(self):
try:
start_time = time.time()
result = self.LINKEDLIST._get_all()
print(
str(time.time() - start_time) +
" Linkedlist get all station connections")
return result
except Exception:
return ERRORS.get("error")
def _pop(self, key):
try:
target_node = self.head
target_node_prev = None
while target_node.station_name != key:
target_node_prev = target_node
target_node = target_node.next_station
if target_node is None:
break
if target_node != None:
if target_node_prev != None:
target_node_prev.next_station = target_node.next_station
else:
self.head = target_node.next_station
return True
else:
return ERRORS.get("not_exist")
except Exception:
return ERRORS.get("error")
def _add_station(self, station):
is_error = False
try:
start_time = time.time()
result = self.ADJACENCY._add_station(station)
print(str(time.time() - start_time)+" Adjacency Insert Station")
if result is True:
return True
else:
is_error = True
return result
except Exception:
return ERRORS.get("error")
finally:
if is_error == False:
try:
self.db._insert_station_data(station)
except psycopg2.Error:
return ERRORS.get("database")
def _delete(self, key):
is_error = False
try:
start_time = time.time()
result = self.ADJACENCY._pop(key)
print(str(time.time() - start_time)+" Adjacency Delete Station")
if result is True:
return True
else:
is_error = True
return result
except Exception:
return ERRORS.get("error")
finally:
if is_error == False:
try:
self.db._delete_station_data(key)
except psycopg2.Error:
return ERRORS.get("database")
def _print_graph(self):
try:
for i in range(len(self.stations_arr)):
print(str(self.stations[i]) + "->")
print(self.stations_arr[i]._print())
print(" \n")
if len(self.stations_arr) is 0:
return None
except Exception:
return ERRORS.get("error")
def _get_all(self):
try:
station_list = []
current_station = self.head
while current_station != None:
station_list.append(
{current_station.station_name: current_station.distance})
current_station = current_station.next_station
return station_list
except Exception:
return ERRORS.get("error")
def _delete(self, key):
is_error = False
try:
start_time = time.time()
result = self.LINKEDLIST._pop(key)
print(str(time.time() - start_time) + " Linkedlist delete station")
if result is True:
return True
else:
is_error = True
return result
except Exception:
is_error = True
return ERRORS.get("error")
finally:
if is_error == False:
try:
self.db._delete_station_data(key)
except psycopg2.Error:
return ERRORS.get("database")