Ejemplo n.º 1
0
def generate_route(trip):
    ''' Build a path using the Mapzen's Valhalla API. '''
    mode = trip['mode']
    points = trip['points']
    base = 'http://valhalla.mapzen.com/'
    key = tools.read_json('config/keys.json')['valhalla']
    request = json.dumps({
        'locations': points,
        # 'costing': mode,
        # For some reasons the biking costing is not close to reality
        'costing': 'pedestrian',
        'directions_options': {
            'units': 'kilometers'
        }
    })
    url = '{0}route?json={1}&api_key={2}'.format(base, request, key)
    # No whitespace allowed
    url = url.replace(' ', '')
    data = get_route(url)
    path = tools.load_json(data)
    return {
        'mode': mode,
        'polyline': path['trip']['legs'][0]['shape'],
        'maneuvers': path['trip']['legs'][0]['maneuvers'],
        'distance': path['trip']['legs'][0]['summary']['length']
    }
Ejemplo n.º 2
0
def apirouting(mode, city, departure, arrival, time, people):
    '''
    Return a list of routes in polyline format.
    String adresses are not supported because they
    won't be needed for the mobile apps. Indeed the
    departure will be the same as the arrival because
    the mobile apps do not include full trips.

    Example URL:

        /routing/mode=takeBike&city=Toulouse&
        departure=[43.5639677,1.4655774]&
        arrival=[43.6044328,1.443463]&
        time=[1442935490355]&people=1

    Don't forget to remove all the spaces.
    '''
    if key == tools.read_json('config/keys.json')['routing']:
        situation = {
            'city': city,
            'departure': eval(departure),
            'arrival': eval(arrival),
            'time': eval(time),
            'people': int(people)
        }
        if mode == 'fullTrip':
            routes = routing.full_trip(situation)
        elif mode == 'takeBike':
            routes = routing.take_bike(situation)
        elif mode == 'dropBike':
            routes = routing.drop_bike(situation)
        return jsonify({'routes': routes})
    else:
        return jsonify({'error': 'Wrong API key.'})
Ejemplo n.º 3
0
def stations(city):
    base = 'https://api.jcdecaux.com/vls/v1/'
    key = tools.read_json('config/keys.json')['jcdecaux']
    url = '{0}stations/?contract={1}&apiKey={2}'.format(base, city, key)
    data = tools.query_API(url)
    stations = tools.load_json(data)
    return normalize(stations)
Ejemplo n.º 4
0
def add_altitudes(stations, size=50):
    ''' Use the Google Maps Elevation API. '''
    base = 'https://maps.googleapis.com/maps/api/elevation/json?'
    key = tools.read_json('config/keys.json')['google-elevation']
    locationsList = ''
    packages = []
    counter = 1
    for station in stations:
        locationsList += '{lat},{lon}|'.format(lat=station['lat'],
                                               lon=station['lon'])
        # The API only allows a certain amount of locations per request
        counter += 1
        if counter > size:
            locationsList += ';'
            counter = 1
    for locations in locationsList.split(';'):
        locations = locations[:-1]
        url = base + 'locations={0}&key={1}'.format(locations, key)
        request = tools.query_API(url)
        data = tools.load_json(request)
        packages.append(data['results'])
    # Melt the packages into one list
    altitudes = []
    for package in packages:
        altitudes.extend(package)
    # Tidy everything up for database insertion
    data = []
    for station in zip(stations, altitudes):
        data.append({
            'name': station[0]['name'],
            'lat': station[0]['lat'],
            'lon': station[0]['lon'],
            'alt': station[1]['elevation']
        })
    return data
Ejemplo n.º 5
0
def add_altitudes(stations, size=50):
    ''' Use the Google Maps Elevation API. '''
    base = 'https://maps.googleapis.com/maps/api/elevation/json?'
    key = tools.read_json('config/keys.json')['google-elevation']
    locationsList = ''
    packages = []
    counter = 1
    for station in stations:
        locationsList += '{lat},{lon}|'.format(lat=station['lat'],
                                               lon=station['lon'])
        # The API only allows a certain amount of locations per request
        counter += 1
        if counter > size:
            locationsList += ';'
            counter = 1
    for locations in locationsList.split(';'):
        locations = locations[:-1]
        url = base + 'locations={0}&key={1}'.format(locations, key)
        request = tools.query_API(url)
        data = tools.load_json(request)
        packages.append(data['results'])
    # Melt the packages into one list
    altitudes = []
    for package in packages:
        altitudes.extend(package)
    # Tidy everything up for database insertion
    data = []
    for station in zip(stations, altitudes):
        data.append({
            'name': station[0]['name'],
            'lat': station[0]['lat'],
            'lon': station[0]['lon'],
            'alt': station[1]['elevation']
        })
    return data
Ejemplo n.º 6
0
def stations(city):
    # The city parameter is necessary so that everything works
    base = 'http://data.keolis-rennes.com/json/?version=1.0&'
    key = tools.read_json('config/keys.json')['keolis']
    url = '{0}key={1}&cmd=getstation'.format(base, key)
    data = tools.query_API(url)
    stations = tools.load_json(data)
    return normalize(stations)
Ejemplo n.º 7
0
def stations(city):
    # The city parameter is necessary so that everything works
    base = 'http://data.keolis-rennes.com/json/?version=1.0&'
    key = tools.read_json('config/keys.json')['keolis']
    url = '{0}key={1}&cmd=getstation'.format(base, key)
    data = tools.query_API(url)
    stations = tools.load_json(data)
    return normalize(stations)
Ejemplo n.º 8
0
def stations(city):
    # The city parameter is necessary so that everything works
    key = tools.read_json('config/keys.json')['lacub']
    url = 'http://data.lacub.fr/wfs?key={}' \
          '&SERVICE=WFS&VERSION=1.1.0&' \
          'REQUEST=GetFeature' \
          '&TYPENAME=CI_VCUB_P&SRSNAME=EPSG:4326'
    print(url)
    data = tools.query_API(url)
    stations = tools.load_xml(data)
    print(stations)
    return normalize(stations)
Ejemplo n.º 9
0
def stations(city):
    # The city parameter is necessary so that everything works
    key = tools.read_json('config/keys.json')['lacub']
    url = 'http://data.lacub.fr/wfs?key={}' \
          '&SERVICE=WFS&VERSION=1.1.0&' \
          'REQUEST=GetFeature' \
          '&TYPENAME=CI_VCUB_P&SRSNAME=EPSG:4326'
    print(url)
    data = tools.query_API(url)
    stations = tools.load_xml(data)
    print(stations)
    return normalize(stations)
Ejemplo n.º 10
0
def compute_distances(departure, stations, mode):
    ''' Using the Mapbox Distance API. '''
    # Interrogate the API to get the distance to each station
    base = 'https://api.mapbox.com/distances/v1/mapbox/'
    key = tools.read_json('config/keys.json')['mapbox-distance']
    coordinates = {
        'coordinates': [departure] + [station['p'] for station in stations]
    }
    print(coordinates)
    url = '{0}{1}?access_token={2}'.format(base, mode, key)
    data = tools.query_API(url)
    distances = tools.load_json(data)['rows'][0]['elements']
    candidates = []
    for station in zip(stations, distances):
        candidate = {}
        for information in station:
            candidate.update(information)
        candidates.append(candidate)
    return candidates
Ejemplo n.º 11
0
def compute_distances(departure, stations, mode):
    ''' Using the Mapbox Distance API. '''
    # Interrogate the API to get the distance to each station
    base = 'https://api.mapbox.com/distances/v1/mapbox/'
    key = tools.read_json('config/keys.json')['mapbox-distance']
    coordinates = {
        'coordinates': [
            departure
        ] + [station['p'] for station in stations]
    }
    print(coordinates)
    url = '{0}{1}?access_token={2}'.format(base, mode, key)
    data = tools.query_API(url)
    distances = tools.load_json(data)['rows'][0]['elements']
    candidates = []
    for station in zip(stations, distances):
        candidate = {}
        for information in station:
            candidate.update(information)
        candidates.append(candidate)
    return candidates
Ejemplo n.º 12
0
def generate_route(trip):
    ''' Build a path using the Mapzen's Valhalla API. '''
    mode = trip['mode']
    points = trip['points']
    base = 'http://valhalla.mapzen.com/'
    key = tools.read_json('config/keys.json')['valhalla']
    request = json.dumps({
        'locations': points,
        # 'costing': mode,
        # For some reasons the biking costing is not close to reality
        'costing': 'pedestrian',
        'directions_options': {
            'units': 'kilometers'
        }
    })
    url = '{0}route?json={1}&api_key={2}'.format(base, request, key)
    # No whitespace allowed
    url = url.replace(' ', '')
    data = get_route(url)
    path = tools.load_json(data)
    return {'mode': mode, 'polyline': path['trip']['legs'][0]['shape'],
            'maneuvers': path['trip']['legs'][0]['maneuvers'],
            'distance': path['trip']['legs'][0]['summary']['length']}
Ejemplo n.º 13
0
from flask import Flask, render_template, request, \
                  url_for, jsonify, g
from flask.ext.babel import Babel, gettext
from htmlmin import minify
from lib import routing
from lib import tools
import json

app = Flask(__name__)
babel = Babel(app)

cities = tools.read_json('static/cities.json')
names = tools.read_json('static/names.json')
stations = tools.read_json('static/stations.json')
centers = tools.read_json('static/centers.json')
predictions = tools.read_json('static/predictions.json')

# Languages


@app.before_request
def before():
    if request.view_args and 'lang_code' in request.view_args:
        g.current_lang = request.view_args['lang_code']
        request.view_args.pop('lang_code')


@babel.localeselector
def get_locale():
    return g.get('current_lang', 'en')
Ejemplo n.º 14
0
from apscheduler.schedulers.background import BackgroundScheduler
from lib.providers import wrapper
from lib.mongo import timeseries
from lib import tools
from datetime import datetime
import time
import json

providers = tools.read_json('static/providers.json')
centers = tools.read_json('static/centers.json')
predictions = tools.read_json('static/predictions.json')


def update(provider, city, predict):
    # Get the information for the city
    try:
        stations = wrapper.collect(provider, city)
    except:
        return
    # Update the database
    if predict == 'Yes':
        timeseries.update_city(stations, city)
    # Save the data for the map
    geojson = tools.json_to_geojson(stations)
    with open('static/geojson/{0}.geojson'.format(city), 'w') as outfile:
        json.dump(geojson, outfile)
    # Tell the server the city's data was updated
    with open('static/updates/{0}.txt'.format(city), 'w') as outfile:
        outfile.write(datetime.now().isoformat())

Ejemplo n.º 15
0
def apicenters():
    ''' Return the list of names. '''
    centers = tools.read_json('static/centers.json')
    return jsonify(centers)
Ejemplo n.º 16
0
def apiproviders():
    ''' Return the list of providers/cities. '''
    providers = tools.read_json('static/providers.json')
    return jsonify(providers)
Ejemplo n.º 17
0
def apicities():
    ''' Return the list of countries/cities. '''
    cities = tools.read_json('static/cities.json')
    return jsonify(cities)
Ejemplo n.º 18
0
def apicity_stations(city):
    ''' Return the latest geojson file of a city. '''
    stations = tools.read_json('static/geojson/{}.geojson'.format(city))
    return jsonify(stations)
Ejemplo n.º 19
0
def apistations():
    ''' Return the list of countries/cities/stations. '''
    stations = tools.read_json('static/stations.json')
    return jsonify(stations)
Ejemplo n.º 20
0
from apscheduler.schedulers.background import BackgroundScheduler
from lib.providers import wrapper
from lib.mongo import timeseries
from lib import tools
from datetime import datetime
import time
import json

providers = tools.read_json('static/providers.json')
centers = tools.read_json('static/centers.json')
predictions = tools.read_json('static/predictions.json')


def update(provider, city, predict):
    # Get the information for the city
    try:
        stations = wrapper.collect(provider, city)
    except:
        return
    # Update the database
    if predict == 'Yes':
        timeseries.update_city(stations, city)
    # Save the data for the map
    geojson = tools.json_to_geojson(stations)
    with open('static/geojson/{0}.geojson'.format(city), 'w') as outfile:
        json.dump(geojson, outfile)
    # Tell the server the city's data was updated
    with open('static/updates/{0}.txt'.format(city), 'w') as outfile:
        outfile.write(datetime.now().isoformat())

if __name__ == '__main__':
Ejemplo n.º 21
0
def apipredictions():
    ''' Return the list of predictions. '''
    predictions = tools.read_json('static/predictions.json')
    return jsonify(predictions)
Ejemplo n.º 22
0
from apscheduler.schedulers.background import BackgroundScheduler
from lib.mongo import timeseries
from lib.learning import munging
from lib.learning import forest
from lib import tools
import time

stationsFile = tools.read_json('static/stations.json')


def learn(city):
    for station in stationsFile[city]:
        # Get all the data from the database
        dataframe = timeseries.query_station(city, station)
        # Prepare the dataframe for learning
        dataframe = munging.rename_columns(dataframe)
        dataframe = munging.prepare(dataframe)
        # Apply a regressor
        forest.fit(dataframe, 'bikes', city, station)
        forest.fit(dataframe, 'spaces', city, station)
    # timeseries.delete_city(city)


if __name__ == '__main__':
    scheduler = BackgroundScheduler()
    for city in stationsFile.keys():
        learn(city)
        scheduler.add_job(learn,
                          'interval',
                          weeks=2,
                          args=[city],
Ejemplo n.º 23
0
parser.add_argument('country')
parser.add_argument('countryRealName')
parser.add_argument('predict')

# Parse the command line arguments
parameters = parser.parse_args()
option = parameters.option
provider = parameters.provider
city = parameters.city
cityRealName = parameters.cityRealName
country = parameters.country
countryRealName = parameters.countryRealName
predict = parameters.predict

# Load the files
stationsFile = tools.read_json('static/stations.json')
providersFile = tools.read_json('static/providers.json')
centersFile = tools.read_json('static/centers.json')
citiesFile = tools.read_json('static/cities.json')
namesFile = tools.read_json('static/names.json')
predictionsFile = tools.read_json('static/predictions.json')

if option in ('add', 'insert'):
    geo.add_city(city)
    # Get the current information for a city
    stations = wrapper.collect(provider, city)
    # Add the altitudes of every station
    stations = geography.add_altitudes(stations)
    # Extract latitudes, longitudes and station names
    latitudes = []
    longitudes = []
Ejemplo n.º 24
0
parser.add_argument('country')
parser.add_argument('countryRealName')
parser.add_argument('predict')

# Parse the command line arguments
parameters = parser.parse_args()
option = parameters.option
provider = parameters.provider
city = parameters.city
cityRealName = parameters.cityRealName
country = parameters.country
countryRealName = parameters.countryRealName
predict = parameters.predict

# Load the files
stationsFile = tools.read_json('static/stations.json')
providersFile = tools.read_json('static/providers.json')
centersFile = tools.read_json('static/centers.json')
citiesFile = tools.read_json('static/cities.json')
namesFile = tools.read_json('static/names.json')
predictionsFile = tools.read_json('static/predictions.json')

if option in ('add', 'insert'):
    geo.add_city(city)
    # Get the current information for a city
    stations = wrapper.collect(provider, city)
    # Add the altitudes of every station
    stations = geography.add_altitudes(stations)
    # Extract latitudes, longitudes and station names
    latitudes = []
    longitudes = []
Ejemplo n.º 25
0
from apscheduler.schedulers.background import BackgroundScheduler
from lib.mongo import timeseries
from lib.learning import munging
from lib.learning import forest
from lib import tools
import time

stationsFile = tools.read_json('static/stations.json')


def learn(city):
    for station in stationsFile[city]:
        # Get all the data from the database
        dataframe = timeseries.query_station(city, station)
        # Prepare the dataframe for learning
        dataframe = munging.rename_columns(dataframe)
        dataframe = munging.prepare(dataframe)
        # Apply a regressor
        forest.fit(dataframe, 'bikes', city, station)
        forest.fit(dataframe, 'spaces', city, station)
    # timeseries.delete_city(city)

if __name__ == '__main__':
    scheduler = BackgroundScheduler()
    for city in stationsFile.keys():
        learn(city)
        scheduler.add_job(learn, 'interval', weeks=2, args=[city],
                          misfire_grace_time=60*60*24*7, coalesce=True)
    scheduler.start()
    while True:
        time.sleep(10e-1000000)
Ejemplo n.º 26
0
def apinames():
    ''' Return the list of names. '''
    names = tools.read_json('static/names.json')
    return jsonify(names)