def test_direction_params():
params = "&alternatives=false&geometries=polyline&overview=false&steps=false" \
"&continue_straight=false&annotations=distance%2Cspeed&language=en" \
"&radiuses=10%3Bunlimited"
responses.add(
responses.GET,
'https://api.mapbox.com/directions/v5/mapbox/driving/'
'-87.337875%2C36.539157%3B-88.247681%2C36.922175.json?access_token=pk.test'
+ params,
match_querystring=True,
body="not important, only testing URI templating",
status=200,
content_type='application/json')
res = mapbox.Directions(access_token='pk.test').directions(
points,
alternatives=False,
geometries='polyline',
overview=False,
continue_straight=True,
annotations=['distance', 'speed'],
language='en',
waypoint_snapping=[10, 'unlimited'],
steps=False)
assert res.status_code == 200
def directions(ctx, features, geojson, profile, alternatives,
instructions, geometry, steps, output):
"""Calculate optimal route with turn-by-turn directions
between up to 25 waypoints.
$ mapbox directions "[-122.681032, 45.528334]" "[-122.71679, 45.525135]"
An access token is required, see `mapbox --help`.
"""
stdout = click.open_file(output, 'w')
access_token = (ctx.obj and ctx.obj.get('access_token')) or None
if geojson:
geometry = 'geojson'
service = mapbox.Directions(access_token=access_token)
try:
res = service.directions(
features,
steps=steps,
alternatives=alternatives,
instructions=instructions,
geometry=geometry,
profile=profile)
except mapbox.errors.ValidationError as exc:
raise click.BadParameter(str(exc))
if res.status_code == 200:
if geojson:
click.echo(json.dumps(res.geojson()), file=stdout)
else:
click.echo(res.text, file=stdout)
else:
raise MapboxCLIException(res.text.strip())
def directions(ctx, features, profile, alternatives,
geometries, overview, steps, continue_straight,
waypoint_snapping, annotations, language, output):
"""The Mapbox Directions API will show you how to get
where you're going.
mapbox directions "[0, 0]" "[1, 1]"
An access token is required. See "mapbox --help".
"""
access_token = (ctx.obj and ctx.obj.get("access_token")) or None
service = mapbox.Directions(access_token=access_token)
# The Directions SDK expects False to be
# a bool, not a str.
if overview == "False":
overview = False
# When using waypoint snapping, the
# Directions SDK expects features to be
# a list, not a generator.
if waypoint_snapping is not None:
features = list(features)
if annotations:
annotations = annotations.split(",")
stdout = click.open_file(output, "w")
try:
res = service.directions(
features,
profile=profile,
alternatives=alternatives,
geometries=geometries,
overview=overview,
steps=steps,
continue_straight=continue_straight,
waypoint_snapping=waypoint_snapping,
annotations=annotations,
language=language
)
except mapbox.errors.ValidationError as exc:
raise click.BadParameter(str(exc))
if res.status_code == 200:
if geometries == "geojson":
click.echo(json.dumps(res.geojson()), file=stdout)
else:
click.echo(res.text, file=stdout)
else:
raise MapboxCLIException(res.text.strip())
def trip(df):
token = config.plotly_key
directions_api = mapbox.Directions(access_token=token)
df_tour['Winery'] = df_tour.index
feat = df_to_geojson(df_tour, properties=['Winery'])
feat['features'].append({
'geometry': {
'coordinates': [-121.945778, 37.281630],
'type': 'Point'
},
'properties': {
'Winery': 'Home'
},
'type': 'Feature'
})
res = directions_api.directions(feat['features'])
data = Data([
Scattermapbox(
lat=[
item_x[1] for item_x in res.geojson()['features'][0]
['geometry']['coordinates']
],
lon=[
item_y[0] for item_y in res.geojson()['features'][0]
['geometry']['coordinates']
],
mode='markers+lines',
marker=Marker(size=3),
),
(Scattermapbox(lon=df_tour['Lon'],
lat=df_tour['Lat'],
mode='markers',
hoverinfo='text',
marker=Marker(color='purple', size=12),
text=df_tour['Winery'],
name='Stops'))
])
layout = Layout(
margin=dict(t=0, b=0, r=0, l=0),
autosize=True,
hovermode='closest',
showlegend=False,
mapbox=dict(accesstoken=token,
bearing=0,
center=dict(lat=37, lon=-122),
pitch=0,
zoom=8,
style='outdoors'),
)
fig = dict(data=data, layout=layout)
py_off.plot(fig, filename='tour.html')
def test_direction_bearings_none():
responses.add(
responses.GET, 'https://api.mapbox.com/directions/v5/mapbox/driving/'
'-87.337875%2C36.539157%3B-88.247681%2C36.922175.json?access_token=pk.test'
'&radiuses=10%3B20&bearings=%3B315%2C90',
match_querystring=True,
body="not important, only testing URI templating",
status=200,
content_type='application/json')
res = mapbox.Directions(access_token='pk.test').directions(
points, waypoint_snapping=[10, (20, 315, 90)])
assert res.status_code == 200
def test_directions(cache):
with open('tests/moors.json') as fh:
body = fh.read()
responses.add(
responses.GET,
'https://api.mapbox.com/v4/directions/mapbox.driving/-87.337875%2C36.539157%3B-88.247681%2C36.922175.json?access_token=pk.test',
match_querystring=True,
body=body, status=200,
content_type='application/json')
res = mapbox.Directions(access_token='pk.test', cache=cache).directions(points)
assert res.status_code == 200
assert sorted(res.json()['routes'][0].keys()) == ['distance', 'duration', 'geometry', 'steps', 'summary']
assert sorted(res.json().keys()) == ['destination', 'origin', 'routes', 'waypoints']
def test_directions_geojson():
with open('tests/moors.json') as fh:
body = fh.read()
responses.add(
responses.GET, 'https://api.mapbox.com/directions/v5/mapbox/driving/'
'-87.337875%2C36.539157%3B-88.247681%2C36.922175.json?access_token=pk.test',
match_querystring=True,
body=body,
status=200,
content_type='application/json')
res = mapbox.Directions(access_token='pk.test').directions(points)
fc = res.geojson()
assert fc['type'] == 'FeatureCollection'
assert fc['features'][0]['geometry']['type'] == 'LineString'
def test_directions(cache):
with open('tests/moors.json') as fh:
body = fh.read()
responses.add(
responses.GET,
'https://api.mapbox.com/directions/v5/mapbox/driving/' +
'-87.337875%2C36.539157%3B-88.247681%2C36.922175.json?access_token=pk.test',
match_querystring=True,
body=body,
status=200,
content_type='application/json')
res = mapbox.Directions(access_token='pk.test',
cache=cache).directions(points)
assert res.status_code == 200
assert 'distance' in res.json()['routes'][0].keys()
def test_direction_params():
params = "&alternatives=false&instructions=html&geometry=polyline&steps=false"
responses.add(
responses.GET,
'https://api.mapbox.com/v4/directions/mapbox.driving/-87.337875%2C36.539157%3B-88.247681%2C36.922175.json?access_token=pk.test' + params,
match_querystring=True,
body="not important, only testing URI templating", status=200,
content_type='application/json')
res = mapbox.Directions(access_token='pk.test').directions(
points,
alternatives=False,
instructions='html',
geometry='polyline',
steps=False)
assert res.status_code == 200
def distanca(mesto):
destination = str(mesto) + ', Serbia'
map = mapbox.Geocoder(
access_token=
"pk.eyJ1IjoiZHVoaXpqYW1lIiwiYSI6ImNrZHhzdGxvbDM0aGkyd21xNHVleTByajUifQ.esMht2IXyPcuICHLA9vl2Q"
)
d_code = map.forward(destination)
dest = d_code.json()
for z in dest['features']:
print(z)
print("============================================")
beograd = map.forward("Belgrade, Serbia")
bg_json = beograd.json()
destination = {
'type': 'Feature',
'properties': {
'name': destination
},
'geometry': {
'type': 'Point',
'coordinates': dest['features'][0]['center']
}
}
service = mapbox.Directions(
access_token=
"pk.eyJ1IjoiZHVoaXpqYW1lIiwiYSI6ImNrZHhzdGxvbDM0aGkyd21xNHVleTByajUifQ.esMht2IXyPcuICHLA9vl2Q"
)
origin = {
'type': 'Feature',
'properties': {
'name': "Belgrade, Serbia"
},
'geometry': {
'type': 'Point',
'coordinates': bg_json['features'][0]['center']
}
}
directions = service.directions([origin, destination])
dir_json = directions.json()
distance = dir_json['routes'][0]['legs'][0]['distance'] / 1000
print(distance)
def test_direction_backwards_compat():
"""Ensure old calls to directions method work against v5 API
"""
responses.add(
responses.GET, 'https://api.mapbox.com/directions/v5/mapbox/cycling/'
'-87.337875%2C36.539157%3B-88.247681%2C36.922175.json?access_token=pk.test'
'&geometries=polyline',
match_querystring=True,
body="not important, only testing URI templating",
status=200,
content_type='application/json')
res = mapbox.Directions(access_token='pk.test').directions(
points,
geometry='polyline', # plural in v5
profile='mapbox.cycling', # '/' delimited in v5
)
# TODO instructions parameter removed in v5
assert res.status_code == 200
def test_invalid_bearing_tuple():
service = mapbox.Directions(access_token='pk.test')
with pytest.raises(mapbox.errors.InvalidParameterError) as e:
service._validate_snapping([(270, 45, 'extra'), (315, )], points)
assert 'bearing tuple' in str(e)
def distanca(mesto):
destination = str(mesto).replace('đ','dj') + ', Serbia'
db = sqlite3.connect("placesDB.db")
map = mapbox.Geocoder(access_token="pk.eyJ1IjoiZHVoaXpqYW1lIiwiYSI6ImNrZHhzdGxvbDM0aGkyd21xNHVleTByajUifQ.esMht2IXyPcuICHLA9vl2Q")
d_code = map.forward(destination)
dest = d_code.json()
y = 0
nasao = False
while(dest['features'][int(y)]['place_type']!=["place"] or dest['features'][int(y)]['place_type']!=["region"] or dest['features'][int(y)]['text']=="Serbia"):
for i,z in enumerate(dest['features']):
if (z['place_type']==['place'] or z['place_type']==['region']) and z['text']!="Serbia":
# print(z)
y = i
nasao = True
break
if nasao == True:
break
x = str(mesto).replace('đ','dj').replace('š','s').replace('ž','z').replace('č','c').replace('ć','c').replace('Đ','Dj').replace('Š','S').replace('Ž','Z').replace('Č','C').replace('Ć','C')
execution = f"SELECT * from mesto where nazivMesta = \"{x}\""
cursor = db.execute(execution)
res = cursor.fetchone()
if res is None:
print("Can't find place in database.")
return
zipCode = res[0]
while(zipCode % 100 !=0 ):
zipCode = zipCode - 1
cursor = db.execute(f"SELECT * from mesto where idMesta = {zipCode}")
mesto = cursor.fetchone()
if mesto is None:
continue
d_code = map.forward(str(mesto) + ', Serbia')
dest = d_code.json()
print(dest['features'][y]['text'])
if (dest['features'][y]['place_type']==["place"] or dest['features'][int(y)]['place_type']==["region"]) and dest['features'][y]['text']!="Serbia":
break
beograd = map.forward("Belgrade, Serbia")
novi_sad = map.forward("Novi Sad, Serbia")
lazarevac = map.forward("Lazarevac, Serbia")
bg_json = beograd.json()
la_json = lazarevac.json()
ns_json = novi_sad.json()
origins = []
origins.append((bg_json['features'][0]['text'],bg_json['features'][0]['center']))
origins.append((la_json['features'][0]['text'],la_json['features'][0]['center']))
origins.append((ns_json['features'][0]['text'],ns_json['features'][0]['center']))
destinations = {
'type': 'Feature',
'properties': {'name': dest['features'][y]['text']},
'geometry': {
'type': 'Point',
'coordinates': dest['features'][y]['center']
}
}
service = mapbox.Directions(access_token="pk.eyJ1IjoiZHVoaXpqYW1lIiwiYSI6ImNrZHhzdGxvbDM0aGkyd21xNHVleTByajUifQ.esMht2IXyPcuICHLA9vl2Q")
for place in origins:
origin = {
'type': 'Feature',
'properties': {'name': place[0]},
'geometry': {
'type': 'Point',
'coordinates': place[1]
}
}
directions = service.directions([origin,destinations])
dir_json = directions.json()
distance = dir_json['routes'][0]['legs'][0]['distance']/1000
if int(distance) <= 165 and (str(place[0]).lower() == 'Belgrade'.lower() or str(place[0]).lower() == "Beograd".lower()):
return True
elif int(distance) <= 60 and str(place[0]).lower() == 'Novi Sad'.lower():
return True
elif int(distance) <= 80 and str(place[0]).lower() == 'Lazarevac'.lower():
return True
return False
def test_invalid_geom_encoding():
service = mapbox.Directions(access_token='pk.test')
with pytest.raises(mapbox.errors.ValidationError):
service._validate_geom_encoding('wkb')
def test_invalid_profile():
with pytest.raises(ValueError):
mapbox.Directions(access_token='pk.test').directions(points,
profile='bogus')
def test_bearings_without_radius():
with pytest.raises(TypeError):
mapbox.Directions(access_token='pk.test').directions(
waypoint_snapping=[(270, 45), (270, 45)])
def test_v4_profile_aliases():
service = mapbox.Directions(access_token='pk.test')
assert 'mapbox/cycling' == service._validate_profile('mapbox.cycling')
def test_validate_radius_invalid():
service = mapbox.Directions(access_token='pk.test')
with pytest.raises(mapbox.errors.InvalidParameterError) as e:
service._validate_radius(-1)
def test_invalid_bearing_domain():
service = mapbox.Directions(access_token='pk.test')
with pytest.raises(mapbox.errors.InvalidParameterError) as e:
service._validate_snapping([(-1, 90), (315, 90)], points)
assert 'between 0 and 360' in str(e)
def test_invalid_annotations():
service = mapbox.Directions(access_token='pk.test')
with pytest.raises(mapbox.errors.InvalidParameterError):
service._validate_annotations(['awesomeness'])
def test_validate_radius_none():
service = mapbox.Directions(access_token='pk.test')
assert service._validate_radius(None) is None
def post(self):
lookup = json.loads(request.data)['address']
geocoder = mapbox.Geocoder()
features = json.loads(geocoder.forward(lookup).content.decode('utf-8'))['features']
selected_feature = None
for feature in features:
if 'address' in feature:
selected_feature = feature
break
if not selected_feature:
return 'The is no such place on mapbox!', 400
# print lookup
# print selected_feature['place_name'], '@@@@@@@@'
# print selected_feature['relevance']
query_set = AddressEntry.query.filter(AddressEntry.user_id==g.user_id, AddressEntry.is_dest==True, AddressEntry.is_avail==True)
if query_set.count() == 0:
address_entry = AddressEntry()
address_entry.user_id = g.user_id
address_entry.is_dest = True
address_entry.is_avail = True
else:
address_entry = query_set.first()
address_entry.name = json.loads(request.data)['spot_name']
address_entry.longitude = selected_feature['center'][0]
address_entry.latitude = selected_feature['center'][1]
address_entry.street_number = selected_feature['address']
address_entry.street_name = selected_feature['text']
address_entry.mapbox_place_name = selected_feature['place_name']
# Generate a dict from
for feature in selected_feature['context']:
if feature['id'].startswith('place'):
address_entry.county = feature['text']
if feature['id'].startswith('postcode'):
address_entry.postal_code = feature['text']
if feature['id'].startswith('region'):
address_entry.state = feature['text']
if feature['id'].startswith('country'):
address_entry.country = feature['text']
if feature['id'].startswith('neighborhood'):
address_entry.neighborhood = feature['text']
db_session = db.session()
db_session.add(address_entry)
db_session.commit()
origin = {
'type': 'Feature',
'properties': {'name': address_entry.name},
'geometry': {
'type': 'Point',
'coordinates': [float(address_entry.longitude), float(address_entry.latitude)]
}
}
# just for the parking spots within the threshold (20Km), create/update the distance from the destination
for sub_address in AddressEntry.query.filter(AddressEntry.is_dest==False, AddressEntry.is_avail==True):
distance = get_straight_distance(float(address_entry.latitude), float(address_entry.longitude), float(sub_address.latitude), float(sub_address.longitude))
if distance > 20000:
continue
query_set = AddressDistance.query.filter(AddressDistance.address_a_id==address_entry.id, AddressDistance.address_b_id==sub_address.id)
if query_set.count() == 0:
address_distance = AddressDistance()
else:
address_distance = query_set.first()
destination = {
'type': 'Feature',
'properties': {'name': sub_address.name},
'geometry': {
'type': 'Point',
'coordinates': [float(sub_address.longitude), float(sub_address.latitude)],
}
}
content = mapbox.Directions().directions([origin, destination],'mapbox.driving').geojson()
address_distance.address_a_id = address_entry.id
address_distance.address_b_id = sub_address.id
address_distance.mapbox_response = json.dumps(content)
address_distance.speed_scala = sum([feature['properties']['distance'] for feature in content['features']])
db_session = db.session()
db_session.add(address_distance)
db_session.commit()
return {
'waypoints': AddressDistance.get_direction_pois(address_entry.id),
'origin': address_entry.as_geojson(True),
}
def sell_parking():
if request.method == 'GET':
spots = AddressEntry.query.filter(AddressEntry.user_id==current_user.id, AddressEntry.is_dest==False)
return render_template('users/sell_parking.html', spots=spots)
else:
address_entry_form = AddressEntryForm()
if address_entry_form.validate_on_submit():
# Join the address fields into a single field.
# 'address city state postal_code'
lookup = ' '.join([address_entry_form.data['address'],
address_entry_form.data['city'],
address_entry_form.data['state']])
geocoder = mapbox.Geocoder()
features = json.loads(geocoder.forward(lookup).content.decode('utf-8'))['features']
features = [ feature for feature in features if ('address' in feature) ]
# Storage Convenience
session['_price'] = address_entry_form.data.get('price', None)
if address_entry_form.data.get('form_state', None) == 'validation':
# Store the features in the session based off feature['id'].
session['_geocoded_values'] = json.dumps({feature['id']:feature for feature in features })
return jsonify({'features': features})
else:
abort(400) # Probably trying to do something nasty.
address_entry_form = None
# Frame Three Logic
address_entry_commit_form = AddressEntryCommitForm()
if address_entry_commit_form.validate_on_submit():
address_entry = AddressEntry()
if address_entry_commit_form.data.get('form_state', None) == 'commit':
address_entry.user_id = current_user.id
address_entry.is_dest = False
address_entry.is_avail = True
address_entry.price = session['_price']
del session['_price']
selected_feature = json.loads(session['_geocoded_values'])[address_entry_commit_form.data['picked']]
del session['_geocoded_values'] # Clean up the session
address_entry.longitude = selected_feature['center'][0]
address_entry.latitude = selected_feature['center'][1]
address_entry.street_number = selected_feature['address']
address_entry.street_name = selected_feature['text']
address_entry.mapbox_place_name = selected_feature['place_name']
# address_entry.name = data.get('name')
# Generate a dict from
for feature in selected_feature['context']:
if feature['id'].startswith('place'):
address_entry.county = feature['text']
if feature['id'].startswith('postcode'):
address_entry.postal_code = feature['text']
if feature['id'].startswith('region'):
address_entry.state = feature['text']
if feature['id'].startswith('country'):
address_entry.country = feature['text']
if feature['id'].startswith('neighborhood'):
address_entry.neighborhood = feature['text']
db_session = db.session()
db_session.add(address_entry)
db_session.commit()
origin = {
'type': 'Feature',
'properties': {'name': address_entry.street_name},
'geometry': {
'type': 'Point',
'coordinates': [float(address_entry.longitude), float(address_entry.latitude)]
}
}
# just for the destinations within the threshold (20Km), create the distance from the new spot
for sub_address in AddressEntry.query.filter(AddressEntry.is_dest==True, AddressEntry.is_avail==True):
distance = get_straight_distance(float(address_entry.latitude), float(address_entry.longitude), float(sub_address.latitude), float(sub_address.longitude))
if distance > 20000:
continue
address_distance = AddressDistance()
destination = {
'type': 'Feature',
'properties': {'name': sub_address.street_name},
'geometry': {
'type': 'Point',
'coordinates': [float(sub_address.longitude), float(sub_address.latitude)],
}
}
content = mapbox.Directions().directions([origin, destination],'mapbox.driving').geojson()
address_distance.address_a_id = sub_address.id # destination
address_distance.address_b_id = address_entry.id # parking spot
address_distance.mapbox_response = json.dumps(content)
address_distance.speed_scala = sum([feature['properties']['distance'] for feature in content['features']])
db_session = db.session()
db_session.add(address_distance)
db_session.commit()
return 'success'
def test_invalid_number_of_bearings():
service = mapbox.Directions(access_token='pk.test')
with pytest.raises(mapbox.errors.InvalidParameterError) as e:
service._validate_snapping([1, 2, 3], points)
assert 'exactly one' in str(e)
def test_invalid_radiuses():
service = mapbox.Directions(access_token='pk.test')
with pytest.raises(mapbox.errors.InvalidParameterError) as e:
service._validate_radius('forever')
assert 'not a valid radius' in str(e)
def test_invalid_geom_overview():
service = mapbox.Directions(access_token='pk.test')
with pytest.raises(mapbox.errors.InvalidParameterError):
service._validate_geom_overview('infinite')
def _update_users_address():
# Frame Two Logic
address_entry_form = AddressEntryForm()
if address_entry_form.validate_on_submit():
# Join the address fields into a single field.
# 'address city state postal_code'
lookup = ','.join([address_entry_form.data['address'],
address_entry_form.data['city'],
address_entry_form.data['state'],
address_entry_form.data['postal_code']])
geocoder = mapbox.Geocoder()
features = json.loads(geocoder.forward(lookup).content.decode('utf-8'))['features']
features = [ feature for feature in features if ('address' in feature) ]
# Storage Convenience
session['_phone'] = address_entry_form.data.get('phone', None)
session['_building_name'] = address_entry_form.data.get('building_name', None)
if address_entry_form.data.get('form_state', None) == 'validation':
# Store the features in the session based off feature['id'].
session['_geocoded_values'] = json.dumps({feature['id']:feature for feature in features })
return jsonify({'features': features})
else:
abort(400) # Probably trying to do something nasty.
address_entry_form = None
# Frame Three Logic
address_entry_commit_form = AddressEntryCommitForm()
if address_entry_commit_form.validate_on_submit():
query_set = AddressEntry.query.filter(AddressEntry.user_id==current_user.id)
if query_set.count() == 0:
address_entry = AddressEntry()
else:
address_entry = query_set.first()
if address_entry_commit_form.data.get('form_state', None) == 'commit':
address_entry.user_id = current_user.id
address_entry.is_dest = True
address_entry.is_avail = True
address_entry.name = session['_building_name']
address_entry.phone = session['_phone']
del session['_building_name'] # Cleanup the session
del session['_phone'] # Cleanup the session
# https://www.mapbox.com/help/define-lat-lon/
# Sometimes mapbox returns long/lat or lat/long. With the Geocoding API, it seems
# long/lat is the format.
# With that, make sure you double check the projections. Google will return a long in the
# positive specturm while mapbox will return a long in the negative spectrum. Not a problem technically,
# but this very question breeds hours of googling to understand the contextual differences between map
# providers.
# https://en.wikipedia.org/wiki/Map_projection
# https://www.mapbox.com/tilemill/docs/manual/basics/
# There is even some drama with the Google projections. epsg3857 and 900913 should be the same thing;
# but are very different when it comes to the specification. It's fun to read about. :)
# http://gis.stackexchange.com/questions/50347/which-is-correct-projection-in-arcgis-server-for-epsg3857-900913
selected_feature = json.loads(session['_geocoded_values'])[address_entry_commit_form.data['picked']]
del session['_geocoded_values'] # Clean up the session
address_entry.longitude = selected_feature['center'][0]
address_entry.latitude = selected_feature['center'][1]
address_entry.street_number = selected_feature['address']
address_entry.street_name = selected_feature['text']
address_entry.mapbox_place_name = selected_feature['place_name']
# address_entry.name = data.get('name')
# Generate a dict from
for feature in selected_feature['context']:
if feature['id'].startswith('place'):
address_entry.county = feature['text']
if feature['id'].startswith('postcode'):
address_entry.postal_code = feature['text']
if feature['id'].startswith('region'):
address_entry.state = feature['text']
if feature['id'].startswith('country'):
address_entry.country = feature['text']
if feature['id'].startswith('neighborhood'):
address_entry.neighborhood = feature['text']
db_session = db.session()
db_session.add(address_entry)
db_session.commit()
origin = {
'type': 'Feature',
'properties': {'name': address_entry.name},
'geometry': {
'type': 'Point',
'coordinates': [float(address_entry.longitude), float(address_entry.latitude)]
}
}
# just for the parking spots within the threshold (20Km), create/update the distance from the destination
for sub_address in AddressEntry.query.filter(AddressEntry.is_dest==False, AddressEntry.is_avail==True):
distance = get_straight_distance(float(address_entry.latitude), float(address_entry.longitude), float(sub_address.latitude), float(sub_address.longitude))
if distance > 20000:
continue
query_set = AddressDistance.query.filter(AddressDistance.address_a_id==address_entry.id, AddressDistance.address_b_id==sub_address.id)
if query_set.count() == 0:
address_distance = AddressDistance()
else:
address_distance = query_set.first()
destination = {
'type': 'Feature',
'properties': {'name': sub_address.name},
'geometry': {
'type': 'Point',
'coordinates': [float(sub_address.longitude), float(sub_address.latitude)],
}
}
content = mapbox.Directions().directions([origin, destination],'mapbox.driving').geojson()
address_distance.address_a_id = address_entry.id
address_distance.address_b_id = sub_address.id
address_distance.mapbox_response = json.dumps(content)
address_distance.speed_scala = sum([feature['properties']['distance'] for feature in content['features']])
db_session = db.session()
db_session.add(address_distance)
db_session.commit()
return jsonify({
'waypoints': AddressDistance.get_direction_pois(address_entry.id),
'origin': address_entry.as_geojson(),
})
def test_class_attrs():
"""Get expected class attr values"""
serv = mapbox.Directions()
assert serv.api_name == 'directions'
assert serv.api_version == 'v5'
def post(self, action):
spot = json.loads(request.data)
address_entry = AddressEntry()
address_entry.user_id = g.user_id
address_entry.is_dest = False
address_entry.is_avail = True
address_entry.price = spot['price']
address_entry.photo_url = spot['photo_url']
address_entry.spot_type = spot['spot_type']
address_entry.avail_type = spot['availability_type']
# update the user's phone number
# spot['phone']
geocoder = mapbox.Geocoder()
features = json.loads(geocoder.forward(spot['address']).content.decode('utf-8'))['features']
selected_feature = None
for feature in features:
if 'address' in feature:
selected_feature = feature
break
if not selected_feature:
return 'The is no such place on mapbox!', 400
address_entry.longitude = selected_feature['center'][0]
address_entry.latitude = selected_feature['center'][1]
address_entry.street_number = selected_feature['address']
address_entry.street_name = selected_feature['text']
address_entry.mapbox_place_name = selected_feature['place_name']
# address_entry.name = data.get('name')
# Generate a dict from
for feature in selected_feature['context']:
if feature['id'].startswith('place'):
address_entry.county = feature['text']
if feature['id'].startswith('postcode'):
address_entry.postal_code = feature['text']
if feature['id'].startswith('region'):
address_entry.state = feature['text']
if feature['id'].startswith('country'):
address_entry.country = feature['text']
if feature['id'].startswith('neighborhood'):
address_entry.neighborhood = feature['text']
db_session = db.session()
db_session.add(address_entry)
db_session.commit()
origin = {
'type': 'Feature',
'properties': {'name': address_entry.street_name},
'geometry': {
'type': 'Point',
'coordinates': [float(address_entry.longitude), float(address_entry.latitude)]
}
}
# just for the destinations within the threshold (20Km), create the distance from the new spot
for sub_address in AddressEntry.query.filter(AddressEntry.is_dest==True, AddressEntry.is_avail==True):
distance = get_straight_distance(float(address_entry.latitude), float(address_entry.longitude), float(sub_address.latitude), float(sub_address.longitude))
if distance > 20000:
continue
address_distance = AddressDistance()
destination = {
'type': 'Feature',
'properties': {'name': sub_address.street_name},
'geometry': {
'type': 'Point',
'coordinates': [float(sub_address.longitude), float(sub_address.latitude)],
}
}
content = mapbox.Directions().directions([origin, destination],'mapbox.driving').geojson()
address_distance.address_a_id = sub_address.id # destination
address_distance.address_b_id = address_entry.id # parking spot
address_distance.mapbox_response = json.dumps(content)
address_distance.speed_scala = sum([feature['properties']['distance'] for feature in content['features']])
db_session = db.session()
db_session.add(address_distance)
db_session.commit()
return 'success'
def test_snapping_radii_none():
service = mapbox.Directions(access_token='pk.test')
bearings, radii = service._validate_snapping([(10, 270, 45), None], points)
assert bearings == [(270, 45), None]
assert radii == [10, None]
