def mail(self, name=0, **kwargs):
name = str(name)
cfg = Config.smtp
Logger.debug("sending mail %s%s from %s to %s", name, str(kwargs),
cfg['from'], cfg['to'])
usr = cfg.get('user')
pswd = cfg.get('password')
msg = self.buildMsg(name, kwargs)
dump = kwargs.get("dump")
if dump:
with open(dump, "w") as f:
f.write(msg)
Logger.info("Message %s saved to %s", name, dump)
return
cli = smtplib.SMTP(cfg['host'])
if cfg.get('ssl') == True:
cli.starttls()
if usr and pswd:
cli.ehlo()
cli.login(usr, pswd)
else:
cli.helo()
cli.sendmail(cfg['from'], kwargs.get('to') or cfg['to'], msg)
cli.quit()
Logger.info("Message %s sent", name)
def buildMsg(self, name, params):
pth = mypath("mails")
fname = os.path.join(pth, "mail_" + name + ".txt")
params = self.buildParams(name, params)
Logger.debug("preparing mail %s w params %s", fname, str(params))
if not os.path.exists(fname):
raise Mailer.MailNotFoundError(name)
body = None
with open(fname, "r") as f:
body = f.read()
params = self.buildFiles(body, params, pth)
return body.format(m=params)
def readFile(self, fname, enc):
Logger.debug("Adding file %s %s", fname, enc)
data = None
with open(fname, 'rb') as f:
data = f.read()
if enc is None:
return data
if enc == 'base64':
data = base64.encodestring(data)
elif enc == 'base64l':
data = base64.encodestring(data).replace("\r",
"").replace("\n", "")
else:
raise Exception("Unknown file encoding: " + enc)
return data
class Configuration():
@property
def edges(self):
return self._edges
@property
def edges_order(self):
return self._edges_order
@property
def edges_with_tl(self):
return self._edges_with_tl
@property
def tls(self):
return [self._edges[edge]['tl']['name'] for edge in self._edges_with_tl]
def set_staticdynamic(self):
self.staticdynamic = True
def __init__(self, ev, folder):
self._folder = folder
self._ev = ev
self._logger = Logger(self.__class__.__name__).get()
self._net_file = xml.etree.ElementTree.parse(self._folder+'/osm.net.xml').getroot()
self._edges_order = []
self._edges_with_tl = []
self.edges_to_reroute = []
self.compute_adj = False
self.staticdynamic = False
#self.compute_values()
def update_values(self):
old = np.array(self._edges_order)
new = np.array(traci.vehicle.getRoute(self._ev))
if not np.array_equiv(old,new):
if self.staticdynamic:
routes_xml = xml.etree.ElementTree.parse(self._folder+'/osm.passenger.rou.xml').getroot()
new_route_el = routes_xml.find('./vehicle[@id="{}"]/route'.format(self._ev))
if new_route_el != None:
new_route = new_route_el.get('edges').split(' ')
traci.vehicle.setRoute(self._ev,new_route)
new = np.array(traci.vehicle.getRoute(self._ev))
self._logger.debug('old')
self._logger.debug(old)
self._logger.debug('new')
self._logger.debug(new)
self._edges_order = traci.vehicle.getRoute(self._ev)
self.compute_values()
return True
return False
def compute_values(self):
self.edges_to_reroute = [ e.get('id') for e in self._net_file.findall('./edge[@type="highway.motorway"]') + \
self._net_file.findall('./edge[@type="highway.primary"]') + \
self._net_file.findall('./edge[@type="highway.secondary"]') + \
self._net_file.findall('./edge[@type="highway.tertiary"]') ]
self._edges_with_tl = []
self._edges = {}
self._tls = set()
self._logger.debug(self._edges_order)
tls_already_used = {}
index = traci.vehicle.getRouteIndex(self._ev)
my_type = traci.vehicle.getTypeID(self._ev)
for i in range(index,len(self._edges_order)):
edge_name = self._edges_order[i]
self._edges[edge_name] = {}
current_edge = self._edges[edge_name]
lane = edge_name+'_0'
current_edge['vmax'] = traci.lane.getMaxSpeed(lane)
current_edge['length'] = traci.lane.getLength(lane)
self._logger.debug(str(edge_name) + ' ' + str(current_edge['vmax']) + ' ' + str(current_edge['length']))
j=i+1
path = './connection[@from="'+ str(edge_name) + '"]'
if j < len(self._edges_order):
path += '[@to="'+ str(self._edges_order[j]) + '"]'
self._logger.debug(path)
connections = self._net_file.findall(path)
tl = None
link_index = -1
lane_in = None
lane_out = None
input_links_edge = []
for connection in connections:
if tl is not None:
break
tls = connection.get('tl')
if tls and j < len(self._edges_order):
controlled_links = traci.trafficlight.getControlledLinks(tls)
for li in range(len(controlled_links)):
link_tuple = controlled_links[li]
if edge_name in link_tuple[0][0]:
input_links_edge.append(li)
if edge_name in link_tuple[0][0] and self._edges_order[j] in link_tuple[0][1] and \
my_type.split('_')[1] in traci.lane.getAllowed(link_tuple[0][0]):
tl = tls
link_index = li
lane_in = link_tuple[0][0]
lane_out = link_tuple[0][1]
if tl != None:
if tl in tls_already_used:
edge_in_use = [ edge for edge in self._edges if 'tl' in self._edges[edge] and self._edges[edge]['tl']['name'] == tl ][0]
self._edges[edge_in_use]['tl']['cluster'] = True
controlled_links = traci.trafficlight.getControlledLinks(tl)
for li in range(len(controlled_links)):
link_tuple = controlled_links[li]
if edge_name in link_tuple[0][0] and self._edges_order[j] in link_tuple[0][1]:
if my_type.split('_')[1] in traci.lane.getAllowed(link_tuple[0][0]):
self._edges[edge_in_use]['tl']['other_link_indeces'].append(li)
all_indeces = self._edges[edge_in_use]['tl']['other_link_indeces']
g_index = self._edges[edge_in_use]['tl']['g']['index']
all_programs = traci.trafficlight.getCompleteRedYellowGreenDefinition(tl)
my_program = [ program for program in all_programs if program.programID == current_program ][0]
lights = my_program.phases[g_index].state
if lights[li].upper() == 'G':
break
else:
for p in range(0,len(my_program.phases)):
state = my_program.phases[p].state.upper()
all_green = True
for x in all_indeces:
if state[x] != 'G':
all_green = False
break
if all_green:
self._edges[edge_in_use]['tl']['g']['index'] = p
self._edges[edge_in_use]['tl']['g']['duration'] = my_program.phases[p].duration
break
continue
tls_already_used[tl] = edge_name
self._edges_with_tl.append(edge_name)
self._tls.add(tl)
current_edge['tl'] = {}
current_edge['tl']['name'] = tl
current_edge['tl']['cluster'] = False
current_edge['tl']['lane_in'] = lane_in
current_edge['tl']['lane_out'] = lane_out
current_edge['tl']['link_index'] = link_index
current_edge['tl']['other_link_indeces'] = []
current_edge['tl']['other_link_indeces'].append(link_index)
current_edge['tl']['adjs'] = {}
current_program = traci.trafficlight.getProgram(tl)
all_programs = traci.trafficlight.getCompleteRedYellowGreenDefinition(tl)
my_program = [ program for program in all_programs if program.programID == current_program ][0]
self._logger.debug(my_program.phases[0].duration)
right_index = int(link_index)
lights_sequence = list(map((lambda ls: ls.state[right_index].upper()), my_program.phases))
green_phase_index = lights_sequence.index('G')
count_g = my_program.phases[green_phase_index].state.upper().count('G')
edge_g = 0
for l_index in range(len(lights_sequence)):
count_edge_g = 0
for x in input_links_edge:
if my_program.phases[l_index].state[x].upper() == 'G':
count_edge_g = count_edge_g + 1
if (lights_sequence[l_index].upper() == 'G' and count_edge_g > edge_g) or \
(count_edge_g == edge_g and my_program.phases[l_index].state.upper().count('G') > count_g):
#and my_program.phases[l_index].state.upper().count('G') > count_g:
count_g = my_program.phases[l_index].state.upper().count('G')
edge_g = count_edge_g
green_phase_index = l_index
self.define_parameters(green_phase_index, lights_sequence, current_edge['tl'], current_edge, my_program)
if self.compute_adj:
self._logger.debug(self.tls)
for edge in self._edges_with_tl:
if edge != self._edges_with_tl[-1]:
tl_info = self._edges[edge]['tl']
tl_name = tl_info['name']
self._logger.debug(tl_name)
controlled_links = traci.trafficlight.getControlledLinks(tl_name)
tls = self.get_recursive_adj(controlled_links, edge, 0, tl_name)
self._logger.debug(tls)
self.add_adj(tls, tl_info)
#stack_edges.append(edge_out)
#while len(stack_edges) > 0:
# curr_edge = stack_edges.pop()
# if curr_edge in checked_edges:
# continue
# path = './connection[@to="'+ str(curr_edge) + '"]'
# connections = self._net_file.findall(path)
#check all connections recursively
# should_break = False
# for connection in connections:
# tl = connection.get('tl')
# if tl is not None and tl not in self._tls and tl not in tl_info['adjs']:
# self.add_adj(tl, tl_info)
# should_break = True
# elif tl is None:
# new_edge = connection.get('from')
# if new_edge not in stack_edges:
# stack_edges.append(new_edge)
# checked_edges.add(curr_edge)
# if should_break:
# break
def is_not_car_allowed(self,alloweds):
not_cars = ['tram', 'rail_urban', 'rail', 'rail_electric', 'ship']
return len([a for a in not_cars if a in alloweds]) > 0
def get_recursive_adj(self, controlled_links, curr_edge, level, curr_tl):
tls = set()
if controlled_links is not None:
unique_links_in = set()
for link in controlled_links:
alloweds = traci.lane.getAllowed(link[0][0])
if not self.is_not_car_allowed(alloweds):
splitted_name = link[0][0].split('_')
edge_name = '_'.join(splitted_name[0:len(splitted_name)-1])
if ':' not in edge_name and edge_name != curr_edge:
unique_links_in.add(edge_name)
for link in unique_links_in:
tls.update(self.get_recursive_adj(None, link, level+1, curr_tl))
else:
if level >= 5:
return tls
path = './connection[@to="'+ str(curr_edge) + '"]'
connections = self._net_file.findall(path)
unique_edges = set()
unique_connections = set()
for c in connections:
from_conn = c.get('from')
if ':' not in from_conn and from_conn not in unique_edges:
unique_edges.add(from_conn)
unique_connections.add(c)
for connection in unique_connections:
edge_from = connection.get('from')
tl = connection.get('tl')
self._logger.debug('tl: {} from: {} to: {} tl: {} level: {}'.format(curr_tl,edge_from,curr_edge,tl,level))
#if len(unique_connections) > 1 and tl is None:
# break
if tl != curr_tl:
if tl is not None and tl not in self._tls:
cl_of_tl = traci.trafficlight.getControlledLinks(tl)
edges_input_of_tl_splitted = [link[0][0].split('_') for link in cl_of_tl]
edges_input = ['_'.join(link[0:len(link)-1]) for link in edges_input_of_tl_splitted]
edges_out_of_route = [edge for edge in edges_input if edge in self.edges_order]
if len(edges_out_of_route) <= 0:
tls.add(tl)
break
else:
new_edge = connection.get('from')
if new_edge is not None and new_edge not in self._edges:
new_tls = self.get_recursive_adj(None, new_edge, level+1, curr_tl)
if len(new_tls) > 0:
tls.update(new_tls)
break
return tls
def add_adj(self, tls, tl_info):
for tl in tls:
all_programs = traci.trafficlight.getCompleteRedYellowGreenDefinition(tl)
current_program = traci.trafficlight.getProgram(tl)
my_program = [ program for program in all_programs if program.programID == current_program ][0]
tl_adj = {}
self.define_durations(tl_adj,my_program)
tl_info['adjs'][tl] = tl_adj
def define_parameters(self, green_phase_index, lights_sequence, tl_info, current_edge, my_program):
safe_phase_index = (green_phase_index - 2) % len(lights_sequence)
red_phase_index = (green_phase_index - 1) % len(lights_sequence)
self._logger.debug(str(green_phase_index)+' '+str(safe_phase_index)+' '+str(red_phase_index))
tl_info['g'] = {}
tl_info['g']['index'] = green_phase_index
tl_info['g']['duration'] = my_program.phases[green_phase_index].duration
tl_info['y'] = {}
tl_info['y']['index'] = safe_phase_index
tl_info['y']['duration'] = my_program.phases[safe_phase_index].duration
tl_info['r'] = {}
tl_info['r']['index'] = red_phase_index
tl_info['r']['duration'] = my_program.phases[red_phase_index].duration
self.define_durations(tl_info, my_program)
tl_time = tl_info['y']['duration'] + tl_info['r']['duration'] + tl_info['g']['duration']
self._logger.debug(current_edge['vmax'])
self._logger.debug(tl_time)
tl_info['s_detection'] = float(current_edge['vmax'])*float(tl_time)
tl_info['vmax'] = current_edge['vmax']
tl_info['length'] = current_edge['length']
self._logger.debug(current_edge['tl'])
def define_durations(self, tl_info, my_program):
tl_info['ps_duration'] = []
tl_info['phases'] = []
tl_info['durations'] = []
for t in range(len(my_program.phases)):
tl_info['phases'].append(my_program.phases[t].state)
tl_info['durations'].append(my_program.phases[t].duration)
if t == 0:
tl_info['ps_duration'].append(my_program.phases[t].duration)
else:
tl_info['ps_duration'].append(tl_info['ps_duration'][t-1] + my_program.phases[t].duration)
def receive(self):
Logger.debug("Sending and receiveing outlook mail")
self.mapi.SendAndReceive(False)