def __init__(self, fallback_string, user, date=None):
self.user = user
# the date of this route, so we know which identifiers to look for
self.date = date
if not fallback_string: #return empty route
self.route = Route()
self.route.save()
return None
route = Route(fallback_string=fallback_string, p2p=False)
route.save()
is_p2p, routebases = self.make_routebases_from_fallback_string(route)
route.p2p = is_p2p
for routebase in routebases:
routebase.route = route
routebase.save()
route.easy_render()
self.route = route
def account(request, email):
user = None
if email:
user = get_object_or_404(User, username=email)
if request.method == 'POST':
email = request.POST['email']
mobile_num = to_e164(request.POST['mobile_num'])
password = request.POST['password']
if not user:
if password == request.POST['confirm']:
user = User.objects.create(username=email, email=email)
user.set_password(password)
user.save()
UserProfile.objects.create(user=user).save()
send_confirmation_text(user, mobile_num)
user = auth.authenticate(username=user.username,
password=password)
auth.login(request, user)
try:
route_json = request.session['route_json']
except IndexError:
pass
else:
r = Route(user=request.user,
json=route_json,
start_time=request.POST['start_time'])
r.save()
profile_data = {'mobile_num': mobile_num}
UserProfile.objects.filter(user=user).update(**profile_data)
return redirect('myroutes')
profile = user.get_profile() if user else None
return render(request, 'account.html', {'user': user, 'profile': profile})
def create_route(payload):
body = request.get_json()
print(body)
new_route_name = body['route_name']
new_route_description = body['route_description']
new_route_difficulty = body['route_difficulty']
new_map_link = body['map_link']
new_length = body['length']
new_area = body['area']
try:
route = Route(
route_name=new_route_name,
area=new_area,
route_description=new_route_description,
route_difficulty=new_route_difficulty,
map_link=new_map_link,
length=new_length
)
print(route)
route.insert()
routes = list(map(Route.format,
Route.query.order_by(Route.route_name).all()))
'''current_questions = paginate_questions(request, selection)'''
return jsonify({
'success': True,
'routes': routes
})
except Exception as e:
print(e)
abort(422)
async def post(self):
try:
args = RouteInputSchema().load(
escape.json_decode(self.request.body))
except ValidationError as e:
raise web.HTTPError(400, escape.json_encode(e.messages),
e.messages)
route_id = uuid.uuid4()
data = args.data
new_route = Route(
id=str(route_id),
origin=func.ST_GeomFromGeoJSON(escape.json_encode(data['origin'])),
origin_name=data['origin_name'],
destination=func.ST_GeomFromGeoJSON(
escape.json_encode(data['destination'])),
destination_name=data['destination_name'],
polyline=func.ST_GeomFromGeoJSON(escape.json_encode(data['polyline'])),
bounds=data.get('bounds'),
created=data.get('created') or datetime.utcnow()
)
self.db.add(new_route)
self.db.commit()
new_route_from_db = self._route_query().filter(
Route.id == str(route_id)).one()
schema = RouteOutputSchema()
output = schema.dumps(row_to_dict(new_route_from_db))
self.finish(output.data)
def save_new_route(session, auth_type, route_view_method, route, route_name):
new_route = Route(
auth_type=auth_type,
route_view_method=route_view_method,
route=route,
route_name=route_name,
)
session.add(new_route)
def setUp(self):
self.maxDiff = None
db.session.remove()
db.drop_all()
db.create_all()
# adding users
user = User('adriangohjw', encrypt('password'), 'Adrian Goh')
db.session.add(user)
# add points
point_1 = Point(30.0, 40.0)
db.session.add(point_1)
point_2 = Point(50.0, 60.0)
db.session.add(point_2)
# add routes
route_1 = Route(
user_id=1,
distance=10,
polyline=
'evfGin%7CwR%5Cf@%60@Zh@Vb@JfBP%60CJtHd@LgBNiCF%7D@YCXBNe@PUr@i@p@c@lDsBj@c@DKJW@Yi@cA%7B@yBg@wAa@aAWaAg@qAoCaH%5BaAWs@k@OOEO?%5DDuEpBoInDo@TMVGREVRhBPbBH~AAzEAdD?XX@nAH~AJ@UAT_BKcCMHcGAcEUkC%5D%7DCEMPGbCaA%60MuFlDaB%60CuAdJuFnAy@r@a@pDuBtEuC%60CqARIZc@%5E%7B@Py@uB%7BH%7BF_TyAcFbAFbCJnD?@GtAWrCy@jAg@xAe@lDwA%7C@i@HSBe@wBuDNGVOfCsAtAs@%60@K@u@ES%7B@wAi@d@o@%5EXh@LLFFBH?ROZGHm@%5CiAh@e@IIKKQIWAW?WGEMGGGESA%5BFg@J%5DZe@TQNGH?%5CBJEMWMU%7B@b@%5BXSXQb@Kp@@l@Pz@j@jARZbAjBx@tAVL%5EFP?vAaAlD_CrCoBzAgAl@_@l@YvBaAbD%7BAnBs@VKlAS@GtAAfCDbAHtAP~Bh@%60A%5E%60Bz@zC~ApBqD%5EaAFo@EqGImG@%7DACWU_AY_AcBj@e@Ls@N_BTw@HaBDkAC%7DJ%5Dk%5Da@cBBa@DmAXeAXsCjAuG~CiCvAi@%60@q@v@U%5EgAxBU%60@SROLWLg@L_AFkA@g@AYCs@Oq@Ye@UcAYo@C%7D@?SZQXIXPtA%60@dBrGfVtBbHhAhEfDjMd@%7CAVv@tApFx@pCsAb@mA%60@wAr@_DpBu@Xs@d@kDpBy@h@aAl@%7DFzDsDhBSl@Kf@G%7C@jA%7CCz@%60CxAdDeBbA_FpCkBhAGHMPKXI~AUdE',
purpose='Casual',
calories=100,
ascent=1,
descent=2,
startPos_id=1,
endPos_id=2)
db.session.add(route_1)
route_2 = Route(
user_id=1,
distance=10,
polyline=
'evfGin%7CwR%5Cf@%60@Zh@Vb@JfBP%60CJtHd@LgBNiCF%7D@YCXBNe@PUr@i@p@c@lDsBj@c@DKJW@Yi@cA%7B@yBg@wAa@aAWaAg@qAoCaH%5BaAWs@k@OOEO?%5DDuEpBoInDo@TMVGREVRhBPbBH~AAzEAdD?XX@nAH~AJ@UAT_BKcCMHcGAcEUkC%5D%7DCEMPGbCaA%60MuFlDaB%60CuAdJuFnAy@r@a@pDuBtEuC%60CqARIZc@%5E%7B@Py@uB%7BH%7BF_TyAcFbAFbCJnD?@GtAWrCy@jAg@xAe@lDwA%7C@i@HSBe@wBuDNGVOfCsAtAs@%60@K@u@ES%7B@wAi@d@o@%5EXh@LLFFBH?ROZGHm@%5CiAh@e@IIKKQIWAW?WGEMGGGESA%5BFg@J%5DZe@TQNGH?%5CBJEMWMU%7B@b@%5BXSXQb@Kp@@l@Pz@j@jARZbAjBx@tAVL%5EFP?vAaAlD_CrCoBzAgAl@_@l@YvBaAbD%7BAnBs@VKlAS@GtAAfCDbAHtAP~Bh@%60A%5E%60Bz@zC~ApBqD%5EaAFo@EqGImG@%7DACWU_AY_AcBj@e@Ls@N_BTw@HaBDkAC%7DJ%5Dk%5Da@cBBa@DmAXeAXsCjAuG~CiCvAi@%60@q@v@U%5EgAxBU%60@SROLWLg@L_AFkA@g@AYCs@Oq@Ye@UcAYo@C%7D@?SZQXIXPtA%60@dBrGfVtBbHhAhEfDjMd@%7CAVv@tApFx@pCsAb@mA%60@wAr@_DpBu@Xs@d@kDpBy@h@aAl@%7DFzDsDhBSl@Kf@G%7C@jA%7CCz@%60CxAdDeBbA_FpCkBhAGHMPKXI~AUdE',
purpose='Casual',
calories=200,
ascent=1,
descent=2,
startPos_id=1,
endPos_id=2)
db.session.add(route_2)
db.session.commit()
def test_routeRead(self):
self.assertIsNone(routeRead(1))
route = Route(1, 10, 'test', 'casual', 200, 20, 30, 1, 2)
db.session.add(route)
db.session.commit()
self.assertEqual(routeRead(1).distance, 10)
def test_routeCreate(self):
self.assertEqual(len(Route.query.all()), 0)
route = Route(1, 10, 'test', 'casual', 200, 20, 30, 1, 2)
# record successfully created
self.assertTrue(routeCreate(route))
self.assertEqual(len(Route.query.all()), 1)
def test_routeUpdate(self):
route = Route(1, 10, 'test', 'casual', 200, 20, 30, 1, 2)
db.session.add(route)
db.session.commit()
route.distance = 100
routeUpdate()
self.assertEqual(Route.query.filter_by(id=1).first().distance, 100)
def test_routeDelete(self):
route = Route(1, 10, 'test', 'casual', 200, 20, 30, 1, 2)
db.session.add(route)
db.session.commit()
self.assertEqual(len(Route.query.all()), 1)
routeDelete(1)
self.assertEqual(len(Route.query.all()), 0)
def insert_route(route_id, route_short_name, route_long_name):
"""
insert a new route
:param route_id: str, route id
:param route_short_name: str, short name for route
:param route_long_name: str, long name for route
:return:
"""
d = Route(route_id=route_id,
route_short_name=route_short_name,
route_long_name=route_long_name)
d.save()
def load_routes():
session = Session()
routes = parse_routes()
rx = []
for r in routes:
rx.append(Route(r['rid'], r['name'], r['description'], r['color']))
session.add_all(rx)
session.commit()
def bind(self, uuid):
"""Bind ``uuid`` resource to a service. """
services = Service.objects.annotate(
num_routes=Count('routes')).order_by('num_routes')
if not services:
raise NoServicesAvailable
service = services[0]
route = Route(uuid=uuid, service=service)
route.save()
return service
def route(request, id):
if request.method == 'POST':
if request.user.is_authenticated():
# store the route in the database for the user
r = Route(user=request.user, json=request.POST['route_json'])
r.save()
return redirect('myroutes')
else:
# store the route in session
# will store route in database for the user after
# we create the user
request.session['route_json'] = request.POST['route_json']
return redirect('account')
else:
return redirect('home')
def getRoutesAndSave(o, d):
data = json.load(open(data_prefix+'/data/%s_%s.json' % (o, d)))
for route_index, route in enumerate(data['routes']):
gpolyline = route['overview_polyline']['points']
linestring = google_lines.decode_line(gpolyline)
linestring.set_srid(canonical_projection)
linestring_dist = linestring.clone()
linestring_dist.transform(google_projection)
route_object = Route(geom=linestring, geom_dist=linestring_dist, \
summary=route['summary'], origin_taz=taz_lookup[o], \
destination_taz=taz_lookup[d], \
travel_time=compute_route_time(route), \
od_route_index=route_index, \
json_contents=json.dumps(route))
route_object.save()
async def post(self, routeid):
data = json.loads(self.request.body)
dron = await Dron.query.where(
Dron.id == data['dron_id']
).gino.first()
print('routehandler async post dron', dron)
if dron:
data['start_timestamp'] = datetime.now()
route = Route(**data)
print(data, route)
await route.create()
print('routehandler async post route', route)
self.write({'created': route.id})
else:
self.set_status(404, 'dron not created')
def update_page_route(page):
"""
Add or update the page to the routing system.
"""
print '[ROUTER] update_page_route'
r = Route.query(Route.page_key == page.key).get() or Route()
r.searchable_page_names = []
r.all_lurls = page.get_all_lurls().values()
r.page_key = page.key
r.template_id = page.p_template_id
r.root_page = page.parent_section is None
for lang in page.get_languages():
r.set_page_name(page.get_name(lang), lang)
r.set_page_url(page.get_url(lang), lang)
r.put()
def create_route():
result = ''
error = ''
try:
route = Route(
request.json['routeId'],
request.json['busId'],
request.json['stopId']
)
route.save()
print('Added route: ', route)
result = 'Added route: {0}'.format(route.serialize())
except Exception as err:
print('Unexpected error:', err)
error = 'Error: {0}'.format(err)
return jsonify({'result': result, 'error': error})
def fell_asleep_early(config, log):
def alter(ls_start, ls_end):
print("? You fell asleep early by")
new_dt = ls_start.alter_time_by_td('__sub__')
print("You fell asleep", new_dt)
if get_confirmation():
ls_start.time = new_dt
return ls_start, ls_end
log.alter_last_session(alter)
log.sync()
return Route(Level(2), message = "You can also tune the time when you woke up")
def save_route(code, sign, direction, main_to_sec, sec_to_main, type_route):
try:
route = Route.objects.get(code=code)
route.sign = sign
route.direction = direction
route.main_to_sec = main_to_sec
route.sec_to_main = sec_to_main
route.type_route = type_route
except Route.DoesNotExist:
route = Route(code=code,
sign=sign,
direction=direction,
main_to_sec=main_to_sec,
sec_to_main=sec_to_main,
type_route=type_route)
route.save()
return route
def clean_route(self):
'''Translate number from autocomplete to object.
If not number, just create a new route with the text given as name
'''
data = self.cleaned_data['route']
try:
data = Route.objects.get(pk=data)
except ValueError: # not int, means name
if data: # Check that string i set, if not, leave it to exercise.save() to create autoroute
r = Route()
r.name = data
r.single_serving = True
r.save()
data = r
else:
return None
return data
def overslept(config, log):
def alter(ls_start, ls_end):
print("? You overslept by")
new_dt = ls_end.alter_time_by_td('__add__')
print("You awoke at", new_dt)
if get_confirmation():
ls_end.time = new_dt
return ls_start, ls_end
log.alter_last_session(alter)
log.sync()
return Route(Level(2), message = "You can also tune the time when you fell asleep")
def invoke(self, context: ConversationContext):
context.route = Route()
context.data = {}
text = context.request['inputs'][0]["rawInputs"][0].get("query",'')
context.route.intent = context.request["inputs"][0]["intent"]
context.data['is_main'] = context.route.intent == "actions.intent.MAIN"
nlu_response = self.nlu.parse_nlu(text,context.user.lang)
intent = nlu_response['intent']['name']
if intent:
context.route.intent = intent
context.data = {item['entity']: item['value']
for item in nlu_response['entities']}
elif context.user.lastSeen is None and context.route.intent == "actions.intent.MAIN":
context.route.intent = "actions.intent.INIT"
return context
def get_stored_historic_score(origin,destination,startTime,endTime,sinceDate,beforeDate,alpha):
score = None
scores = None
calculatedScore = -1
today = datetime.now()
today = datetime(2015,05,07,15,00)
# If the route already exists, get from database, else save new instance.
route = Route.get_or_none(origin=origin,destination=destination)
if route is None:
route = Route(origin=origin,destination=destination)
route.save()
# If both extremes of the date range are not none, then the scores of
# the tweets from that time range are retrived.
if sinceDate is not None and beforeDate is not None:
scores = HistoricScore.get_scores_between_dates(route_id=route.id,
lower_timestamp=sinceDate,higher_timestamp=beforeDate)
else:
if sinceDate is None:
scores = HistoricScore.get_scores_until_date(route_id=route.id,timestamp=beforeDate)
if beforeDate is None:
scores = HistoricScore.get_scores_from_date(route_id=route.id,timestamp=sinceDate)
#If previous scores don't exist, then a score is calculated and saved to the database.
if scores is None or not scores:
# Verifies if a score was already calculated for the route with today's date.
score = HistoricScore.get_or_none(route_id=route.id,timestamp=today)
if score is None:
calculatedScore = get_score(related_tweets_time(origin, destination, startTime, endTime,
sinceDate, beforeDate))
score = HistoricScore(route_id=route.id,timestamp=today,score=calculatedScore)
score.save()
else:
calculatedScore = score.score
else:
calculatedScore = exponential_smoothing(scores,alpha)
return calculatedScore
def handler(args):
# loaddata
if args.loaddata:
route_handler = RouteParser()
stop_point = route_handler.parse_routing_points(args.loaddata)
print(stop_point)
with session_scope() as session:
route = Route()
session.add(route)
session.flush()
sp_obj = []
for i in stop_point:
routing_point = RoutingPoint(start_point=i[0],
end_point=i[1],
base_route=route.id)
sp_obj.append(routing_point)
session.add_all(sp_obj)
# landmark func
elif args.landmark:
dr_data, error = LandmarkSerializer().load({
'coordinate':
args.landmark[0],
'name':
args.landmark[1]
})
if error:
print(error)
sys.exit(0)
with session_scope() as session:
landmark = Landmark(**dr_data)
session.add(landmark)
# robot
elif args.run:
print('<<START>>')
loop = asyncio.get_event_loop()
loop.run_until_complete(processor())
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
print('<<END>>')
loop.close()
def load_routes():
route_names = []
with open('routes.csv', 'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',', quotechar='|')
for row in reader:
route_names.append(row[1])
route_names = route_names[1:]
db_routes = session.query(Route, Route.name).all()
db_route_names = []
for route in db_routes:
db_route_names.append(route.name)
for name in route_names:
if name not in db_route_names:
session.add(Route(name, 0))
else:
print '%s already in the database' % name
session.commit()
def request(port, path, body):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect((HOST, port))
except:
print("ERR: Unable to connect to", port)
exit()
data = Route(path, body)
data = encrypt(data.serialize())
status = sock.sendall(data)
if status == None:
response = sock.recv(1024)
response = decrypt(response)
response = json.loads(response)
return response
else:
print("Could not send the request")
exit()
def get_route(cnx, node1, node2):
import networkx as nx
# Arguments:
# cnx - database connection object
# node1 - a Node object
# node2 - a Node object
# Returns - a list of Node objects representing the shortest route between node1 and node2
G = db.get_graph(cnx)
nodes = nx.astar_path(G, node1.id, node2.id)
route = Route()
route.length = nx.astar_path_length(G, node1.id, node2.id)
for node in nodes:
route.nodes.append(db.get_node_details(cnx, node))
return route
def insert_flight_plan():
JSON = request.json
flight_num = JSON.get('flight_num')
origin = JSON.get('origin')
dest = JSON.get('dest')
cancelled = False
carrier = JSON.get('carrier')
departure_date = JSON.get('dep_date').split('/')
departure_time = JSON.get('dep_time').split(':')
dep_time = datetime.datetime(int(departure_date[0]), int(departure_date[1]), int(departure_date[2]), int(departure_time[0]), int(departure_time[1]))
arrival_date = JSON.get('arr_date').split('/')
arrival_time = JSON.get('arr_time').split(':')
arr_time = datetime.datetime(int(arrival_date[0]), int(arrival_date[1]), int(arrival_date[2]), int(arrival_time[0]), int(arrival_time[1]))
route = JSON.get('current_route')
current_route = []
for waypoint in route:
current_route.append(ndb.GeoPt(waypoint[0], waypoint[1]))
flight_plan = FlightPlan(flight_num=flight_num, origin=origin, dest=dest, dep_time=dep_time,
arr_time=arr_time, cancelled=cancelled, carrier=carrier, current_route=Route(waypoints=current_route))
return flight_plan.put().urlsafe()
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
print("Connecting with KDC on PORT:", KDC_PORT, "...")
try:
sock.connect((HOST, KDC_PORT))
except:
print("ERR: Unable to connect with KDC.")
exit()
try:
files = os.listdir(PATH)
except:
print("Not a valid path provided")
exit()
print("Registering FS node with KDC ...")
data = Route("init", {'port': PORT, 'files': files})
data = encrypt(data.serialize())
# Connect to server and send data
sock.sendall(data)
# Receive data from the server and shut down
received = sock.recv(1024)
received = decrypt(received)
received = json.loads(received)
id = received['id']
key = bytes.fromhex(received['key'])
print("Node successfully registered with id:", id)
last_nonce = 0
