240 lines
6.6 KiB
Python
240 lines
6.6 KiB
Python
# coding: utf-8
|
|
"""
|
|
This module contains basic utility functions, such as pretty printing of JSON
|
|
output, checking that a value is within a given interval etc.
|
|
"""
|
|
from __future__ import (
|
|
absolute_import, division, print_function, unicode_literals
|
|
)
|
|
|
|
import datetime
|
|
import json
|
|
import logging
|
|
import math
|
|
import re
|
|
|
|
import requests
|
|
import unidecode
|
|
|
|
|
|
LOGGER = logging.getLogger(__name__)
|
|
|
|
|
|
def pretty_json(data):
|
|
"""
|
|
Pretty JSON output.
|
|
|
|
:param data: The data to dump as pretty JSON.
|
|
:return: The pretty printed JSON dump.
|
|
|
|
:Example:
|
|
|
|
>>> print(pretty_json({"toto": "ok", "foo": "bar"}))
|
|
{
|
|
"foo": "bar",
|
|
"toto": "ok"
|
|
}
|
|
"""
|
|
return json.dumps(data, indent=4, separators=(',', ': '),
|
|
sort_keys=True)
|
|
|
|
|
|
def is_within_interval(value, min_value=None, max_value=None):
|
|
"""
|
|
Check whether a variable is within a given interval. Assumes the value is
|
|
always ok with respect to a `None` bound. If the `value` is `None`, it is
|
|
always within the bounds.
|
|
|
|
:param value: The value to check. Can be ``None``.
|
|
:param min_value: The lower bound.
|
|
:param max_value: The upper bound.
|
|
:return: ``True`` if the value is ``None``. ``True`` or ``False`` whether
|
|
the value is within the given interval or not.
|
|
|
|
.. note:: A value is always within a ``None`` bound.
|
|
|
|
:Example:
|
|
|
|
>>> is_within_interval(None)
|
|
True
|
|
>>> is_within_interval(None, 0, 10)
|
|
True
|
|
>>> is_within_interval(2, None, None)
|
|
True
|
|
>>> is_within_interval(2, None, 3)
|
|
True
|
|
>>> is_within_interval(2, 1, None)
|
|
True
|
|
>>> is_within_interval(2, 1, 3)
|
|
True
|
|
>>> is_within_interval(2, 4, 7)
|
|
False
|
|
>>> is_within_interval(2, 4, 1)
|
|
False
|
|
"""
|
|
checks = []
|
|
if value and min_value:
|
|
checks.append(value >= min_value)
|
|
if value and max_value:
|
|
checks.append(value <= max_value)
|
|
return all(checks)
|
|
|
|
|
|
def normalize_string(string):
|
|
"""
|
|
Normalize the given string for matching.
|
|
|
|
.. todo :: Convert romanian numerals to decimal
|
|
|
|
:Example:
|
|
|
|
>>> normalize_string("tétéà 14ème-XIV, foobar")
|
|
'tetea 14eme xiv, foobar'
|
|
"""
|
|
# ASCIIfy the string
|
|
string = unidecode.unidecode(string)
|
|
|
|
# Replace any non-alphanumeric character by space
|
|
# Keep some basic punctuation to keep syntaxic units
|
|
string = re.sub(r"[^a-zA-Z0-9,;:]", " ", string)
|
|
|
|
# Convert to lowercase
|
|
string = string.lower()
|
|
|
|
# Collapse multiple spaces, replace tabulations and newlines by space
|
|
string = re.sub(r"\s+", " ", string)
|
|
|
|
return string
|
|
|
|
|
|
def uniqify(some_list):
|
|
"""
|
|
Filter out duplicates from a given list.
|
|
|
|
:Example:
|
|
|
|
>>> uniqify([1, 2, 2, 3])
|
|
[1, 2, 3]
|
|
"""
|
|
return list(set(some_list))
|
|
|
|
|
|
def distance(gps1, gps2):
|
|
"""
|
|
Compute the distance between two tuples of latitude and longitude.
|
|
|
|
:param gps1: First tuple of (latitude, longitude).
|
|
:param gps2: Second tuple of (latitude, longitude).
|
|
:return: The distance in meters.
|
|
|
|
:Example:
|
|
|
|
>>> int(distance([48.86786647303717, 2.19368117495212], \
|
|
[48.95314107920405, 2.3368043817358464]))
|
|
14117
|
|
"""
|
|
lat1 = math.radians(gps1[0])
|
|
long1 = math.radians(gps1[1])
|
|
|
|
lat2 = math.radians(gps2[0])
|
|
long2 = math.radians(gps2[1])
|
|
|
|
# pylint: disable=invalid-name
|
|
a = (
|
|
math.sin((lat2 - lat1) / 2.0)**2 +
|
|
math.cos(lat1) * math.cos(lat2) * math.sin((long2 - long1) / 2.0)**2
|
|
)
|
|
c = 2.0 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
|
|
earth_radius = 6371000
|
|
|
|
return earth_radius * c
|
|
|
|
|
|
def sort_list_of_dicts_by(flats_list, key):
|
|
"""
|
|
Sort a list of dicts according to a given field common to all the dicts.
|
|
|
|
:param flats_list: List of dicts to sort.
|
|
:param key: The key of the dict items to sort on.
|
|
:return: A sorted list.
|
|
|
|
:Example:
|
|
|
|
>>> sort_list_of_dicts_by([{1: 2}, {1: 1}], 1)
|
|
[{1: 1}, {1: 2}]
|
|
"""
|
|
return sorted(flats_list, key=lambda x: x[key])
|
|
|
|
|
|
def merge_dicts(*args):
|
|
"""
|
|
Merge the two flats passed as argument in a single flat dict object.
|
|
"""
|
|
if len(args) == 1:
|
|
return args[0]
|
|
else:
|
|
flat1, flat2 = args[:2]
|
|
merged_flat = {}
|
|
for k, value2 in flat2.items():
|
|
value1 = flat1.get(k, None)
|
|
if value1 is None:
|
|
# flat1 has empty matching field, just keep the flat2 field
|
|
merged_flat[k] = value2
|
|
elif value2 is None:
|
|
# flat2 field is empty, just keep the flat1 field
|
|
merged_flat[k] = value1
|
|
else:
|
|
# Any other case, we should merge
|
|
# TODO: Do the merge
|
|
merged_flat[k] = value1
|
|
return merge_dicts(merged_flat, *args[2:])
|
|
|
|
|
|
def get_travel_time_between(latlng_from, latlng_to, config):
|
|
"""
|
|
Query the Navitia API to get the travel time between two points identified
|
|
by their latitude and longitude.
|
|
|
|
:param latlng_from: A tuple of (latitude, longitude) for the starting
|
|
point.
|
|
:param latlng_to: A tuple of (latitude, longitude) for the destination.
|
|
:return: The travel time in seconds. Returns ``None`` if it could not fetch
|
|
it.
|
|
|
|
.. note :: Uses the Navitia API. Requires a ``navitia_api_key`` field to be
|
|
filled-in in the ``config``.
|
|
"""
|
|
NAVITIA_ENDPOINT = "https://api.navitia.io/v1/coverage/fr-idf/journeys"
|
|
time = None
|
|
|
|
# Check that Navitia API key is available
|
|
if config["navitia_api_key"]:
|
|
payload = {
|
|
"from": "%s;%s" % (latlng_from[1], latlng_from[0]),
|
|
"to": "%s;%s" % (latlng_to[1], latlng_to[0]),
|
|
"datetime": datetime.datetime.now().isoformat(),
|
|
"count": 1
|
|
}
|
|
try:
|
|
# Do the query to Navitia API
|
|
req = requests.get(
|
|
NAVITIA_ENDPOINT, params=payload,
|
|
auth=(config["navitia_api_key"], "")
|
|
)
|
|
req.raise_for_status()
|
|
time = req.json()["journeys"][0]["durations"]["total"]
|
|
except (requests.exceptions.RequestException,
|
|
ValueError, IndexError, KeyError) as e:
|
|
# Ignore any possible exception
|
|
LOGGER.warning(
|
|
"An exception occurred during travel time lookup on "
|
|
"Navitia: %s.",
|
|
str(e)
|
|
)
|
|
else:
|
|
LOGGER.warning(
|
|
"No API key available for travel time lookup. Please provide "
|
|
"a Navitia API key. Skipping travel time lookup."
|
|
)
|
|
return time
|