mkpoly

#!/usr/bin/env python3

import json
import copy
import datetime
import pickle
import sys
from argparse import ArgumentParser
from collections import namedtuple

import requests
from requests.compat import urljoin

formats = 'nodelist', 'ffmap'
Position = namedtuple('Position', ['lat', 'lng'])

geojson_area = {
    'type': 'Feature',
    'properties': {},
    'geometry': {
        'type': 'Polygon',
        'coordinates': []
    }
}
geojson_frame = {
    'type': 'FeatureCollection',
    'features': []
}
state = {
    'last_modified': '1970-01-01 00:00',
    'nodes': 0
}

def fetch(url, maptype):
    """
    fetch node information
    :param url: data location
    :param maptype: data format
    :return:
    """
    response = requests.get(url)
    document = response.json()

    if maptype == 'ffmap':
        return {node['id']: Position(lat=node['geo'][0], lng=node['geo'][1])
                for node in document['nodes']
                if node['geo']}
    elif maptype == 'nodelist':
        return {node['id']: Position(lat=node['position']['lat'], lng=node['position']['long'])
                for node in document['nodes']
                if 'position' in node}


def query_administrative_areas(position):
    """
    fetch administrative area information for a position
    :param position: namedtuple containg latitude and longitude
    :return: areas
    """
    if position in cache['point']:
        return cache['point'][position]

    baseurl = 'http://global.mapit.mysociety.org'
    endpoint = '/point/{SRID}/{lng},{lat}'.format(SRID=4326, lat=position.lat, lng=position.lng)

    response = requests.get(urljoin(baseurl, endpoint))
    document = response.json()

    cache['point'][position] = document

    return document


def query_area_geojson(area_id):
    """
    fetch geojson information for area
    :param area_id: key
    :return: geojson
    """
    if area_id in cache['area']:
        return cache['area'][area_id]

    baseurl = 'http://global.mapit.mysociety.org'
    endpoint = '/area/{id}.geojson'.format(id=area_id)

    response = requests.get(urljoin(baseurl, endpoint))
    document = response.json()

    cache['area'][area_id] = document

    return document


def get_municipal_area(areas):
    """
    return the most local municipal area
    :param areas: candidate administrative areas
    :return most local area key
    """

    def is_municipal(area):
        k, v = area
        return v['type'] in ('O06', 'O07', 'O08')

    def get_type(area):
        k, v = area
        return int(v['type'][1:])

    filtered_list = [area for area in areas.items() if is_municipal(area)]

    if filtered_list:
        return max(filtered_list, key=get_type)[1]
    else:
        print('Could not find a municipal area for the location!', file=sys.stderr)
        return None


def main(url, fmt):
    # get node information
    nodes = fetch(url, fmt)
    node_count = 0

    distribution = {}
    for node, position in nodes.items():
        # get administrative area information
        areas = query_administrative_areas(position)

        # find the most local administrative area
        try:
            local = get_municipal_area(areas)

            if not local:
                raise KeyError("No valid areas found.")

            if local['id'] in distribution:
                distribution[local['id']]['count'] += 1
            else:
                distribution[local['id']] = {'name': local['name'], 'count': 1}
        except TypeError:
            print('No appropriate administrative layer found for {}: {}'.format(node, position), file=sys.stderr)

    areas = []
    for area, data in distribution.items():
        # get geojson for area to copy polygon coordinates
        polygon = query_area_geojson(area)

        # deepcopy template, reference polygon information
        instance = copy.deepcopy(geojson_area)
        instance['properties']['name'] = data['name']
        instance['properties']['count'] = data['count']
        node_count = node_count + int(data['count'])

        instance['geometry']['type'] = polygon['type']
        instance['geometry']['coordinates'] = polygon['coordinates']

        areas.append(instance)

    with open('nodes.geojson', 'w') as handle:
        frame = geojson_frame
        frame['features'] = areas
        handle.write(json.dumps(frame))

    with open('state.json', 'w') as handle_state:
        state['last_modified'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
        state['nodes'] = node_count
        handle_state.write(json.dumps(state))


if __name__ == '__main__':
    parser = ArgumentParser()

    parser.add_argument('-f', '--format', choices=formats, default=formats[0])
    parser.add_argument('url', metavar='URL')

    args = parser.parse_args()

    # ensure FileNotFoundError is defined for python2.7 compatibility
    try:
        FileNotFoundError
    except NameError:
        FileNotFoundError = IOError

    try:
        with open('app.cache', 'rb') as handle:
            cache = pickle.load(handle)
    except FileNotFoundError:
        cache = {'point': {}, 'area': {}}

    main(args.url, args.format)

    with open('app.cache', 'wb+') as handle:
        pickle.dump(cache, handle)