def parse_result(result):
strip = ", \n"
address = util.get_first_text(result, 'Address', strip)
city = util.get_first_text(result, 'City', strip)
state = util.get_first_text(result, 'State', strip)
zip = util.get_first_text(result, 'Zip', strip)
country = util.get_first_text(result, 'Country', strip)
city_state = util.join_filter(", ", [city, state])
place = util.join_filter(" ", [city_state, zip])
location = util.join_filter(", ", [address, place, country])
latitude = float(util.get_first_text(result, 'Latitude')) or None
longitude = float(util.get_first_text(result, 'Longitude')) or None
# TODO use Point/Location object API in 0.95
#if latitude and longitude:
# point = Point(latitude, longitude)
#else:
# point = Non
#return Location(location, point, {
# 'Address': address,
# 'City': city,
# 'State': state,
# 'Zip': zip,
# 'Country': country
#})
return address, (latitude, longitude)
def parse_resource(resource):
"""
Parse each return object.
"""
stripchars = ", \n"
addr = resource['address']
address = addr.get('addressLine', '').strip(stripchars)
city = addr.get('locality', '').strip(stripchars)
state = addr.get('adminDistrict', '').strip(stripchars)
zipcode = addr.get('postalCode', '').strip(stripchars)
country = addr.get('countryRegion', '').strip(stripchars)
city_state = join_filter(", ", [city, state])
place = join_filter(" ", [city_state, zipcode])
location = join_filter(", ", [address, place, country])
latitude = resource['point']['coordinates'][0] or None
longitude = resource['point']['coordinates'][1] or None
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
entity_type = resource['entityType']
return Location(location, (latitude, longitude), resource)
def parse_result(result):
strip = ", \n"
address = util.get_first_text(result, 'Address', strip)
city = util.get_first_text(result, 'City', strip)
state = util.get_first_text(result, 'State', strip)
zip = util.get_first_text(result, 'Zip', strip)
country = util.get_first_text(result, 'Country', strip)
city_state = util.join_filter(", ", [city, state])
place = util.join_filter(" ", [city_state, zip])
location = util.join_filter(", ", [address, place, country])
latitude = float(util.get_first_text(result, 'Latitude')) or None
longitude = float(util.get_first_text(result, 'Longitude')) or None
# TODO use Point/Location object API in 0.95
#if latitude and longitude:
# point = Point(latitude, longitude)
#else:
# point = Non
#return Location(location, point, {
# 'Address': address,
# 'City': city,
# 'State': state,
# 'Zip': zip,
# 'Country': country
#})
return address, (latitude, longitude)
def _parse_result(result):
"""
Parse individual results. Different, but lazy actually, so... ok.
"""
# turn x=y pairs ("lat=47.6", "long=-117.426")
# into dict key/value pairs:
place = dict([x.split('=') for x in result if len(x.split('=')) > 1])
if 'error' in place:
if "couldn't find" in place['error']:
return None
address = [
place.get('number', None),
place.get('prefix', None),
place.get('street', None),
place.get('type', None),
place.get('suffix', None)
]
city = place.get('city', None)
state = place.get('state', None)
zip_code = place.get('zip', None)
name = join_filter(", ", [
join_filter(" ", address), city,
join_filter(" ", [state, zip_code])
])
latitude = place.get('lat', None)
longitude = place.get('long', None)
if latitude and longitude:
latlon = float(latitude), float(longitude)
else:
return None
return Location(name, latlon, place)
def parse_code(code):
place = util.join_filter(", ", [code.get('placeName'),
code.get('countryCode')])
location = util.join_filter(" ", [place,
code.get('postalCode')]) or None
latitude = code.get('lat')
longitude = code.get('lng')
latitude = latitude and float(latitude)
longitude = longitude and float(longitude)
return (location, (latitude, longitude))
def parse_code(code):
place_name = util.get_first_text(code, 'name')
country_code = util.get_first_text(code, 'countryCode')
postal_code = util.get_first_text(code, 'postalcode')
place = util.join_filter(", ", [place_name, country_code])
location = util.join_filter(" ", [place, postal_code]) or None
latitude = util.get_first_text(code, 'lat') or None
longitude = util.get_first_text(code, 'lng') or None
latitude = latitude and float(latitude)
longitude = longitude and float(longitude)
return (location, (latitude, longitude))
def parse_result(p):
line1, line2, line3, line4 = p.get('line1'), p.get('line2'), p.get('line3'), p.get('line4')
address = util.join_filter(", ", [line1, line2, line3, line4])
city = p.get('city')
state = p.get('state')
country = p.get('country')
location = util.join_filter(", ", [address, city, country])
lat, lng = p.get('latitude'), p.get('longitude')
if lat and lng:
point = Point(lat, lng)
else:
point = None
return (location, (lat, lng))
def parse_result(place):
line1, line2, line3, line4 = place.get("line1"), place.get("line2"), place.get("line3"), place.get("line4")
address = util.join_filter(", ", [line1, line2, line3, line4])
city = place.get("city")
state = place.get("state")
country = place.get("country")
location = util.join_filter(", ", [address, city, country])
lat, lng = place.get("latitude"), place.get("longitude")
# if lat and lng:
# point = Point(floatlat, lng)
# else:
# point = None
return (location, (float(lat), float(lng)))
def parse_result(place):
line1, line2, line3, line4 = place.get('line1'), place.get('line2'), place.get('line3'), place.get('line4')
address = util.join_filter(", ", [line1, line2, line3, line4])
city = place.get('city')
state = place.get('state')
country = place.get('country')
location = util.join_filter(", ", [address, city, country])
lat, lng = place.get('latitude'), place.get('longitude')
#if lat and lng:
# point = Point(floatlat, lng)
#else:
# point = None
return (place, location, (float(lat), float(lng)))
def parse_resource(resource):
"""
Parse record.
"""
if resource["type"] == "3 words":
words = resource["words"]
words = join_filter(".", [words[0], words[1], words[2]])
position = resource["position"]
latitude, longitude = position[0], position[1]
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(words, (latitude, longitude), resource)
elif resource["type"] == "OneWord":
words = resource["words"]
words = join_filter(".", [words[0], words[1], words[2]])
oneword = resource["oneword"]
info = resource["info"]
address = join_filter(
", ",
[
oneword,
words,
info["name"],
info["address1"],
info["address2"],
info["address3"],
info["city"],
info["county"],
info["postcode"],
info["country_id"],
],
)
position = resource["position"]
latitude, longitude = position[0], position[1]
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(address, (latitude, longitude), resource)
else:
raise exc.GeocoderParseError("Error parsing result.")
def _format_name(self, result):
address = [
result.get('number'),
result.get('prefix'),
result.get('street'),
result.get('street_type'),
result.get('suffix')
]
city = result.get('city')
state = result.get('state')
zip_code = result.get('zip')
return util.join_filter(", ", [
util.join_filter(" ", address), city,
util.join_filter(" ", [state, zip_code])
])
def _format_name(self, result):
address = [
result.get('number'),
result.get('prefix'),
result.get('street'),
result.get('street_type'),
result.get('suffix')
]
city = result.get('city')
state = result.get('state')
zip_code = result.get('zip')
return util.join_filter(", ", [
util.join_filter(" ", address),
city,
util.join_filter(" ", [state, zip_code])
])
def parse_resource(resource):
"""
Parse record.
"""
if resource['type'] == '3 words':
words = resource['words']
words = join_filter(".", [words[0], words[1], words[2]])
position = resource['position']
latitude, longitude = position[0], position[1]
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(words, (latitude, longitude), resource)
elif resource['type'] == 'OneWord':
words = resource['words']
words = join_filter(".", [words[0], words[1], words[2]])
oneword = resource['oneword']
info = resource['info']
address = join_filter(", ", [
oneword,
words,
info['name'],
info['address1'],
info['address2'],
info['address3'],
info['city'],
info['county'],
info['postcode'],
info['country_id']
])
position = resource['position']
latitude, longitude = position[0], position[1]
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(address, (latitude, longitude), resource)
else:
raise exc.GeocoderParseError('Error parsing result.')
def parse_resource(resource):
"""
Parse record.
"""
if resource['type'] == '3 words':
words = resource['words']
words = join_filter(".", [words[0], words[1], words[2]])
position = resource['position']
latitude, longitude = position[0], position[1]
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(words, (latitude, longitude), resource)
elif resource['type'] == 'OneWord':
words = resource['words']
words = join_filter(".", [words[0], words[1], words[2]])
oneword = resource['oneword']
info = resource['info']
address = join_filter(", ", [
oneword,
words,
info['name'],
info['address1'],
info['address2'],
info['address3'],
info['city'],
info['county'],
info['postcode'],
info['country_id']
])
position = resource['position']
latitude, longitude = position[0], position[1]
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(address, (latitude, longitude), resource)
else:
raise exc.GeocoderParseError('Error parsing result.')
def _get_address(self, page):
"""
Returns address string from page dictionary
:param page: dict
:return: str
"""
place = page.get('place')
address_city = place.get('city')
address_country_code = place.get('countryCode')
address = join_filter(', ', [address_city, address_country_code])
return address
def parse_resource(resource):
stripchars = ", \n"
a = resource['address']
address = a.get('addressLine', '').strip(stripchars)
city = a.get('locality', '').strip(stripchars)
state = a.get('adminDistrict', '').strip(stripchars)
zipcode = a.get('postalCode', '').strip(stripchars)
country = a.get('countryRegion', '').strip(stripchars)
city_state = join_filter(", ", [city, state])
place = join_filter(" ", [city_state, zipcode])
location = join_filter(", ", [address, place, country])
latitude = resource['point']['coordinates'][0] or None
longitude = resource['point']['coordinates'][1] or None
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return (location, (latitude, longitude))
def parse_resource(resource):
stripchars = ", \n"
a = resource['address']
address = a.get('addressLine', '').strip(stripchars)
city = a.get('locality', '').strip(stripchars)
state = a.get('adminDistrict', '').strip(stripchars)
zipcode = a.get('postalCode', '').strip(stripchars)
country = a.get('countryRegion', '').strip(stripchars)
city_state = join_filter(", ", [city, state])
place = join_filter(" ", [city_state, zip])
location = join_filter(", ", [address, place, country])
latitude = resource['point']['coordinates'][0] or None
longitude = resource['point']['coordinates'][1] or None
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return (location, (latitude, longitude))
def parse_result(result):
strip = ", \n"
line1= util.get_first_text(result, 'line1', strip)
line2 = util.get_first_text(result, 'line2', strip)
line3 = util.get_first_text(result, 'line3', strip)
line4 = util.get_first_text(result, 'line4', strip)
address = util.join_filter(", ", [line1, line2, line3, line4])
city = util.get_first_text(result, 'city', strip)
state = util.get_first_text(result, 'state', strip)
zip = util.get_first_text(result, 'uzip', strip)
country = util.get_first_text(result, 'country', strip)
city_state = util.join_filter(", ", [city, state])
place = util.join_filter(" ", [city_state, zip])
location = util.join_filter(", ", [address, place, country])
latitude = util.get_first_text(result, 'latitude') or None
longitude = util.get_first_text(result, 'longitude') or None
if latitude and longitude:
point = Point(latitude, longitude)
else:
point = None
return (location, (latitude, longitude))
def parse_resource(resource):
words = resource['words']
words = join_filter(".", [words[0], words[1], words[2]])
position = resource['position']
latitude, longitude = position[0], position[1]
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(words, (latitude, longitude), resource)
def parse_resource(resource):
words = resource['words']
words = join_filter(".", [words[0], words[1], words[2]])
position = resource['position']
latitude, longitude = position[0], position[1]
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(words, (latitude, longitude), resource)
def _parse_result(result):
# turn x=y pairs ("lat=47.6", "long=-117.426") into dict key/value pairs:
place = dict(
filter(
lambda x: len(x) >
1, # strip off bits that aren't pairs (i.e. "geocoder modified" status string")
map(lambda x: x.split('=', 1),
result) # split the key=val strings into (key, val) tuples
))
address = [
place.get('number', None),
place.get('prefix', None),
place.get('street', None),
place.get('type', None),
place.get('suffix', None)
]
city = place.get('city', None)
state = place.get('state', None)
zip_code = place.get('zip', None)
name = util.join_filter(", ", [
util.join_filter(" ", address), city,
util.join_filter(" ", [state, zip_code])
])
latitude = place.get('lat', None)
longitude = place.get('long', None)
if latitude and longitude:
latlon = float(latitude), float(longitude)
else:
return None
# TODO use Point/Location object API in 0.95
#if latitude and longitude:
# point = Point(latitude, longitude)
#else:
# point = None
#return Location(name, point, dict(result))
return name, latlon
def parse_resource(resource):
"""
Parse each return object.
"""
stripchars = ", \n"
addr = resource['Location']['Address']
address = addr.get('Label', '').strip(stripchars)
city = addr.get('City', '').strip(stripchars)
state = addr.get('State', '').strip(stripchars)
zipcode = addr.get('PostalCode', '').strip(stripchars)
country = addr.get('Country', '').strip(stripchars)
city_state = join_filter(", ", [city, state])
place = join_filter(" ", [city_state, zipcode])
location = join_filter(", ", [address, place, country])
display_pos = resource['Location']['DisplayPosition']
latitude = float(display_pos['Latitude'])
longitude = float(display_pos['Longitude'])
return Location(location, (latitude, longitude), resource)
def _parse_result(result):
# turn x=y pairs ("lat=47.6", "long=-117.426") into dict key/value pairs:
place = dict(
filter(lambda x: len(x)>1, # strip off bits that aren't pairs (i.e. "geocoder modified" status string")
map(lambda x: x.split('=', 1), result) # split the key=val strings into (key, val) tuples
))
address = [
place.get('number', None),
place.get('prefix', None),
place.get('street', None),
place.get('type', None),
place.get('suffix', None)
]
city = place.get('city', None)
state = place.get('state', None)
zip_code = place.get('zip', None)
name = util.join_filter(", ", [
util.join_filter(" ", address),
city,
util.join_filter(" ", [state, zip_code])
])
latitude = place.get('lat', None)
longitude = place.get('long', None)
if latitude and longitude:
latlon = float(latitude), float(longitude)
else:
return None
# TODO use Point/Location object API in 0.95
#if latitude and longitude:
# point = Point(latitude, longitude)
#else:
# point = None
#return Location(name, point, dict(result))
return name, latlon
def parse_resource(resource):
"""
Parse resource to return Geopy Location object
"""
words = resource["words"]
words = join_filter(".", [words[0], words[1], words[2]])
position = resource["position"]
latitude, longitude = position[0], position[1]
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(words, (latitude, longitude), resource)
def parse_result(result):
strip = ", \n"
address = util.get_first_text(result, 'Address', strip)
city = util.get_first_text(result, 'City', strip)
state = util.get_first_text(result, 'State', strip)
zip = util.get_first_text(result, 'Zip', strip)
country = util.get_first_text(result, 'Country', strip)
city_state = util.join_filter(", ", [city, state])
place = util.join_filter(" ", [city_state, zip])
location = util.join_filter(", ", [address, place, country])
latitude = util.get_first_text(result, 'Latitude') or None
longitude = util.get_first_text(result, 'Longitude') or None
if latitude and longitude:
point = Point(latitude, longitude)
else:
point = Non
return Location(location, point, {
'Address': address,
'City': city,
'State': state,
'Zip': zip,
'Country': country
})
def parse_resource(resource):
city = resource['adminArea5']
county = resource['adminArea4']
state = resource['adminArea3']
country = resource['adminArea1']
latLng = resource['latLng']
latitude, longitude = latLng.get('lat'), latLng.get('lng')
location = join_filter(", ", [city, county, state, country])
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return (location, (latitude, longitude))
def parse_resource(resource):
city = resource['adminArea5']
county = resource['adminArea4']
state = resource['adminArea3']
country = resource['adminArea1']
latLng = resource['latLng']
latitude, longitude = latLng.get('lat'), latLng.get('lng')
location = join_filter(", ", [city, county, state, country])
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return (location, (latitude, longitude))
def parse_result(result):
strip = ", \n"
address = util.get_first_text(result, 'Address', strip)
city = util.get_first_text(result, 'City', strip)
state = util.get_first_text(result, 'State', strip)
zip = util.get_first_text(result, 'Zip', strip)
country = util.get_first_text(result, 'Country', strip)
city_state = util.join_filter(", ", [city, state])
place = util.join_filter(" ", [city_state, zip])
location = util.join_filter(", ", [address, place, country])
latitude = util.get_first_text(result, 'Latitude') or None
longitude = util.get_first_text(result, 'Longitude') or None
if latitude and longitude:
point = Point(latitude, longitude)
else:
point = Non
return Location(location, point, {
'Address': address,
'City': city,
'State': state,
'Zip': zip,
'Country': country
})
def _parse_result(result):
"""
Parse individual results. Different, but lazy actually, so... ok.
"""
# turn x=y pairs ("lat=47.6", "long=-117.426")
# into dict key/value pairs:
place = dict(
[x.split('=') for x in result if len(x.split('=')) > 1]
)
if 'error' in place:
if "couldn't find" in place['error']:
return None
address = [
place.get('number', None),
place.get('prefix', None),
place.get('street', None),
place.get('type', None),
place.get('suffix', None)
]
city = place.get('city', None)
state = place.get('state', None)
zip_code = place.get('zip', None)
name = join_filter(", ", [
join_filter(" ", address),
city,
join_filter(" ", [state, zip_code])
])
latitude = place.get('lat', None)
longitude = place.get('long', None)
if latitude and longitude:
latlon = float(latitude), float(longitude)
else:
return None
return Location(name, latlon, place)
def _parse_result(result):
"""
TODO docs, accept iterable
"""
# turn x=y pairs ("lat=47.6", "long=-117.426") into dict key/value pairs:
place = dict(
# strip off bits that aren't pairs (i.e. "geocoder modified" status string")
filter(lambda x: len(x)>1, # pylint: disable=W0141
# split the key=val strings into (key, val) tuples
map(lambda x: x.split('=', 1), result) # pylint: disable=W0141
))
address = [
place.get('number', None),
place.get('prefix', None),
place.get('street', None),
place.get('type', None),
place.get('suffix', None)
]
city = place.get('city', None)
state = place.get('state', None)
zip_code = place.get('zip', None)
name = join_filter(", ", [
join_filter(" ", address),
city,
join_filter(" ", [state, zip_code])
])
latitude = place.get('lat', None)
longitude = place.get('long', None)
if latitude and longitude:
latlon = float(latitude), float(longitude)
else:
return None
return name, latlon
def _parse_result(result):
"""
TODO docs, accept iterable
"""
# turn x=y pairs ("lat=47.6", "long=-117.426") into dict key/value pairs:
place = dict(
# strip off bits that aren't pairs (i.e. "geocoder modified" status string")
filter(
lambda x: len(x) > 1, # pylint: disable=W0141
# split the key=val strings into (key, val) tuples
map(lambda x: x.split('=', 1), result) # pylint: disable=W0141
))
address = [
place.get('number', None),
place.get('prefix', None),
place.get('street', None),
place.get('type', None),
place.get('suffix', None)
]
city = place.get('city', None)
state = place.get('state', None)
zip_code = place.get('zip', None)
name = join_filter(", ", [
join_filter(" ", address), city,
join_filter(" ", [state, zip_code])
])
latitude = place.get('lat', None)
longitude = place.get('long', None)
if latitude and longitude:
latlon = float(latitude), float(longitude)
else:
return None
return name, latlon
def parse_resource(resource):
"""
Parse each return object.
"""
stripchars = ", \n"
addr = resource["address"]
address = addr.get("addressLine", "").strip(stripchars)
city = addr.get("locality", "").strip(stripchars)
state = addr.get("adminDistrict", "").strip(stripchars)
zipcode = addr.get("postalCode", "").strip(stripchars)
country = addr.get("countryRegion", "").strip(stripchars)
city_state = join_filter(", ", [city, state])
place = join_filter(" ", [city_state, zipcode])
location = join_filter(", ", [address, place, country])
latitude = resource["point"]["coordinates"][0] or None
longitude = resource["point"]["coordinates"][1] or None
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(location, (latitude, longitude), resource)
def parse_resource(resource):
"""
Parse each record.
"""
city = resource["adminArea5"]
county = resource["adminArea4"]
state = resource["adminArea3"]
country = resource["adminArea1"]
latLng = resource["latLng"]
latitude, longitude = latLng.get("lat"), latLng.get("lng")
location = join_filter(", ", [city, county, state, country])
if latitude and longitude:
latitude = float(latitude)
longitude = float(longitude)
return Location(location, (latitude, longitude), resource)
