def test_authentication_failure(self):
self.geocoder = GeocodeFarm(api_key="invalid")
with pytest.raises(exc.GeocoderAuthenticationFailure):
self.geocode_run(
{"query": '435 north michigan ave, chicago il 60611'},
{},
expect_failure=True,
)
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
with self.assertRaises(exc.GeocoderAuthenticationFailure):
address = '435 north michigan ave, chicago il 60611'
self.geocoder.geocode(address)
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
try:
with self.assertRaises(exc.GeocoderAuthenticationFailure):
address = '435 north michigan ave, chicago il 60611'
self.geocoder.geocode(address)
except exc.GeocoderTimedOut:
raise unittest.SkipTest("GeocodeFarm timed out")
def setUp(self):
self.address = "Sunnersta" #static address to be found
self.address2 = "Mackenzie" #static address for DataBC only
self.userlocation = (59.8585107, 17.6368508)
self.addrNone = "abcdefghijklmnopqrstuvwxyz zyxwvutsrqponmlkjihgfedcba" #non-existing address
self.scheme = "https"
self.plainscheme = "http"
#set up for geocodeFarm
self.geolocator5 = GeocodeFarm()
self.geourlapi = "https://www.geocode.farm/v3/json/forward/"
def __init__(self):
self.db = NamedEntityMap()
self.tagger = ner.SocketNER(host='localhost', port=2020, output_format='slashTags')
#self.geolocator = GeoNames(username='******')
#self.geolocator = GoogleV3()
self.geolocator = GeocodeFarm(api_key='3ae1656ecc66581156dc23e6bf7a182d1fccdf49')
self.dstk = dstk.DSTK({'apiBase':'http://localhost:8085'})
def setUpClass(cls):
cls.delta = 0.04
cls.geocoder = GeocodeFarm(
# None api_key will use free tier on GeocodeFarm.
api_key=env.get('GEOCODEFARM_KEY'),
timeout=10,
)
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
with self.assertRaises(exc.GeocoderAuthenticationFailure):
address = "435 north michigan ave, chicago il 60611"
self.geocoder.geocode(address)
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
with self.assertRaises(exc.GeocoderAuthenticationFailure):
self.geocode_run(
{"query": '435 north michigan ave, chicago il 60611'},
{},
expect_failure=True,
)
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
try:
with self.assertRaises(exc.GeocoderAuthenticationFailure):
address = '435 north michigan ave, chicago il 60611'
self.geocoder.geocode(address)
except exc.GeocoderTimedOut:
raise unittest.SkipTest("GeocodeFarm timed out")
def __init__(self):
self.geocoders = [
TimedGeocoder(Nominatim()),
TimedGeocoder(GoogleV3()),
TimedGeocoder(Yandex()),
TimedGeocoder(ArcGIS()),
TimedGeocoder(GeocodeFarm()),
TimedGeocoder(Photon())
]
self.next = 0
self.size = len(self.geocoders)
import hashlib
import re
import numpy as np
# The geolocators in geopy that do not expect api_key
from geopy.geocoders import GeocodeFarm, Yandex, ArcGIS
from db import Session
from db import Query
locators = [GeocodeFarm(), ArcGIS()]
def _query(session, hashcode, provider):
return (session.query(Query).filter(Query.hashcode == hashcode,
Query.provider == provider).first())
def cached_query(address, provider):
address = re.sub(r"\s+", " ", address.upper())
session = Session(expire_on_commit=False)
provider_name = provider.__class__.__name__
hashcode = hashlib.md5(bytes(address, encoding="utf-8")).hexdigest()
cached = _query(session, hashcode, provider_name)
if not cached:
try:
response = provider.geocode(address)
except Exception as e:
print(e)
response = None
def setUpClass(cls):
cls.delta = 0.04
cls.geocoder = GeocodeFarm(
api_key=env['GEOCODEFARM_KEY'],
format_string="%s US"
)
class GeocodeFarmTestCase(GeocoderTestBase): # pylint: disable=R0904,C0111
@classmethod
def setUpClass(cls):
cls.delta = 0.04
cls.geocoder = GeocodeFarm(
api_key=env['GEOCODEFARM_KEY'],
format_string="%s US"
)
def test_geocode(self):
"""
OpenCage.geocode
"""
self.geocode_run(
{"query": u"435 north michigan ave, chicago il 60611 usa"},
{"latitude": 41.890, "longitude": -87.624},
)
def test_reverse_string(self):
"""
GeocodeFarm.reverse string
"""
self.reverse_run(
{"query": u"40.75376406311989,-73.98489005863667"},
{"latitude": 40.75376406311989, "longitude": -73.98489005863667},
)
def test_reverse_point(self):
"""
GeocodeFarm.reverse Point
"""
self.reverse_run(
{"query": Point(40.75376406311989, -73.98489005863667)},
{"latitude": 40.75376406311989, "longitude": -73.98489005863667},
)
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
with self.assertRaises(exc.GeocoderAuthenticationFailure):
address = '435 north michigan ave, chicago il 60611'
self.geocoder.geocode(address)
def test_quota_exceeded(self):
"""
GeocodeFarm quota exceeded
"""
def mock_call_geocoder(*args, **kwargs):
"""
Mock API call to return bad response.
"""
return {
"geocoding_results": {
"STATUS": {
"access": "OVER_QUERY_LIMIT",
"status": "FAILED, ACCESS_DENIED"
}
}
}
self.geocoder._call_geocoder = types.MethodType(
mock_call_geocoder,
self.geocoder
)
with self.assertRaises(exc.GeocoderQuotaExceeded):
self.geocoder.geocode(u'435 north michigan ave, chicago il 60611')
def test_unhandled_api_error(self):
"""
GeocodeFarm unhandled error
"""
def mock_call_geocoder(*args, **kwargs):
"""
Mock API call to return bad response.
"""
return {
"geocoding_results": {
"STATUS": {
"access": "BILL_PAST_DUE",
"status": "FAILED, ACCESS_DENIED"
}
}
}
self.geocoder._call_geocoder = types.MethodType(
mock_call_geocoder,
self.geocoder
)
with self.assertRaises(exc.GeocoderServiceError):
self.geocoder.geocode(u'435 north michigan ave, chicago il 60611')
pass
except (KeyboardInterrupt, EOFError):
exit(0)
if __name__ == '__main__':
entry = {}
entry['name'] = input('Name> ')
entry['type'] = choose(
['school', 'company', 'research institute', 'other'], 'Type> ')
address = input('Address> ')
geolocator = GeocodeFarm()
location = geolocator.geocode(address, timeout=15)
if location is None:
print('Geocoder failed')
exit()
entry['lat'] = location.latitude
entry['long'] = location.longitude
if location.longitude < -28: # Recife, Brazil @ -34, Reykjavik, Iceland @ -22 - still not correct for eastern Russia!
datafile = 'america'
else:
datafile = choose(datafiles, 'Chose a datafile> ')
include_address = choose(['yes', 'no'], 'Include address in entry?> ')
if include_address == 'yes':
def test_user_agent_custom(self):
geocoder = GeocodeFarm(user_agent='my_user_agent/1.0')
self.assertEqual(geocoder.headers['User-Agent'], 'my_user_agent/1.0')
def test_user_agent_custom(self):
geocoder = GeocodeFarm(
user_agent='my_user_agent/1.0'
)
assert geocoder.headers['User-Agent'] == 'my_user_agent/1.0'
class NamedEntityTagger(object):
def __init__(self):
self.db = NamedEntityMap()
self.tagger = ner.SocketNER(host='localhost', port=2020, output_format='slashTags')
#self.geolocator = GeoNames(username='******')
#self.geolocator = GoogleV3()
self.geolocator = GeocodeFarm(api_key='3ae1656ecc66581156dc23e6bf7a182d1fccdf49')
self.dstk = dstk.DSTK({'apiBase':'http://localhost:8085'})
def lookup(self, entity):
location = self.db.lookup(entity)
if location:
return location
location = self.geolocate(entity)
if location == None:
return None
address = location.raw['ADDRESS']
print '%s -> %s' % (entity, address['address_returned'])
coordinates = location.raw['COORDINATES']
point = Point(coordinates['latitude'], coordinates['longitude'])
politics = self.dstk.coordinates2politics((point.latitude, point.longitude))[0]['politics']
country = None
if politics:
for c in politics:
if c['type'] == 'admin2':
country = c['code']
if country == None:
return None
return self.db.add(entity, point, country)
def geolocate(self, entity):
timeout = 1
for i in range(30):
try:
location = self.geolocator.geocode(entity)
return location
except (GeocoderServiceError, GeocoderAuthenticationFailure, GeocoderQueryError, GeocoderInsufficientPrivileges):
return None
except (socket.timeout, GeocoderTimedOut):
print 'received timeout, retrying in %d seconds', timeout
time.sleep(timeout)
timeout = timeout * 2
def tag_file(self, in_filename, out_filename):
if os.path.isfile(out_filename):
print 'skipping', in_filename
return
print 'creating features file:', in_filename, '->', out_filename
outfile_data = []
with open(in_filename, 'r') as infile:
for line in infile:
entities = self.tagger.get_entities(line)
countries = []
if 'LOCATION' in entities:
entities = set([s.lower() for s in entities['LOCATION']])
for e in entities:
location = self.lookup(e)
if location == None:
continue
countries.append(location.country)
clist = ['%s=1' % c for c in sorted(set(countries))]
outfile_data.append(' '.join(clist))
with open(out_filename, 'w') as outfile:
for line in outfile_data:
outfile.write(line + '\n')
# save the db
self.db.save()
def make_geocoder(cls, **kwargs):
return GeocodeFarm(
# None api_key will use free tier on GeocodeFarm.
api_key=env.get('GEOCODEFARM_KEY'),
timeout=10,
**kwargs)
class GeocodeFarmTestCase(GeocoderTestBase): # pylint: disable=R0904,C0111
@classmethod
def setUpClass(cls):
cls.delta = 0.04
cls.geocoder = GeocodeFarm(api_key=env["GEOCODEFARM_KEY"], format_string="%s US")
def test_geocode(self):
"""
OpenCage.geocode
"""
self.geocode_run(
{"query": "435 north michigan ave, chicago il 60611 usa"}, {"latitude": 41.890, "longitude": -87.624}
)
def test_reverse_string(self):
"""
GeocodeFarm.reverse string
"""
self.reverse_run(
{"query": "40.75376406311989,-73.98489005863667"},
{"latitude": 40.75376406311989, "longitude": -73.98489005863667},
)
def test_reverse_point(self):
"""
GeocodeFarm.reverse Point
"""
self.reverse_run(
{"query": Point(40.75376406311989, -73.98489005863667)},
{"latitude": 40.75376406311989, "longitude": -73.98489005863667},
)
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
with self.assertRaises(exc.GeocoderAuthenticationFailure):
address = "435 north michigan ave, chicago il 60611"
self.geocoder.geocode(address)
def test_quota_exceeded(self):
"""
GeocodeFarm quota exceeded
"""
def mock_call_geocoder(*args, **kwargs):
"""
Mock API call to return bad response.
"""
return {"geocoding_results": {"STATUS": {"access": "OVER_QUERY_LIMIT", "status": "FAILED, ACCESS_DENIED"}}}
self.geocoder._call_geocoder = types.MethodType(mock_call_geocoder, self.geocoder)
with self.assertRaises(exc.GeocoderQuotaExceeded):
self.geocoder.geocode("435 north michigan ave, chicago il 60611")
def test_unhandled_api_error(self):
"""
GeocodeFarm unhandled error
"""
def mock_call_geocoder(*args, **kwargs):
"""
Mock API call to return bad response.
"""
return {"geocoding_results": {"STATUS": {"access": "BILL_PAST_DUE", "status": "FAILED, ACCESS_DENIED"}}}
self.geocoder._call_geocoder = types.MethodType(mock_call_geocoder, self.geocoder)
with self.assertRaises(exc.GeocoderServiceError):
self.geocoder.geocode("435 north michigan ave, chicago il 60611")
class GeocodeFarmTestCase(GeocoderTestBase): # pylint: disable=R0904,C0111
@classmethod
def setUpClass(cls):
cls.delta = 0.04
cls.geocoder = GeocodeFarm(
api_key=env.get(
'GEOCODEFARM_KEY'
), # None api_key will use free tier on GeocodeFarm
timeout=60,
)
def setUp(self):
# Store the original _call_geocoder in case we replace it with a mock
self._original_call_geocoder = self.geocoder._call_geocoder
def tearDown(self):
# Restore the original _call_geocoder in case we replaced it with a mock
self.geocoder._call_geocoder = self._original_call_geocoder
def test_user_agent_custom(self):
geocoder = GeocodeFarm(user_agent='my_user_agent/1.0')
self.assertEqual(geocoder.headers['User-Agent'], 'my_user_agent/1.0')
def test_geocode(self):
"""
GeocodeFarm.geocode
"""
self.geocode_run(
{"query": "435 north michigan ave, chicago il 60611 usa"},
{
"latitude": 41.890,
"longitude": -87.624
},
)
def test_reverse_string(self):
"""
GeocodeFarm.reverse string
"""
self.reverse_run(
{"query": "40.75376406311989,-73.98489005863667"},
{
"latitude": 40.75376406311989,
"longitude": -73.98489005863667
},
)
def test_reverse_point(self):
"""
GeocodeFarm.reverse Point
"""
self.reverse_run(
{"query": Point(40.75376406311989, -73.98489005863667)},
{
"latitude": 40.75376406311989,
"longitude": -73.98489005863667
},
)
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
try:
with self.assertRaises(exc.GeocoderAuthenticationFailure):
address = '435 north michigan ave, chicago il 60611'
self.geocoder.geocode(address)
except exc.GeocoderTimedOut:
raise unittest.SkipTest("GeocodeFarm timed out")
def test_quota_exceeded(self):
"""
GeocodeFarm quota exceeded
"""
def mock_call_geocoder(*args, **kwargs):
"""
Mock API call to return bad response.
"""
return {
"geocoding_results": {
"STATUS": {
"access": "OVER_QUERY_LIMIT",
"status": "FAILED, ACCESS_DENIED"
}
}
}
self.geocoder._call_geocoder = types.MethodType(
mock_call_geocoder, self.geocoder)
with self.assertRaises(exc.GeocoderQuotaExceeded):
self.geocoder.geocode('435 north michigan ave, chicago il 60611')
def test_unhandled_api_error(self):
"""
GeocodeFarm unhandled error
"""
def mock_call_geocoder(*args, **kwargs):
"""
Mock API call to return bad response.
"""
return {
"geocoding_results": {
"STATUS": {
"access": "BILL_PAST_DUE",
"status": "FAILED, ACCESS_DENIED"
}
}
}
self.geocoder._call_geocoder = types.MethodType(
mock_call_geocoder, self.geocoder)
with self.assertRaises(exc.GeocoderServiceError):
self.geocoder.geocode('435 north michigan ave, chicago il 60611')
#!/usr/bin/env python
# Addresses with ranges, like 202-207 Princes Hwy, are unsupported.
# Keep only the first number in the range when preparing input.
import csv, time, sys, os
from geopy.geocoders import GeocodeFarm
#from getpass import getpass
from datetime import datetime
#user = input("Enter uow proxy usename: ")
#pw = getpass('Enter uow proxy password: '******'GEOCODEFARM_API_KEY']
#intialize geocoder to geocode addresses in only NSW, Australia (addresses will be interpolated to add NSW, Australia)
gc = GeocodeFarm(api_key,"%s, NSW, Australia",1)#,proxies={"http": "http://*****:*****@proxy.domain:8080"})
outstring = ""
for addressfile in sys.argv[1:]:
with open(addressfile, "r") as inputfile:
with open(addressfile[:-4]+"_output.csv", "w") as outputfile:
for address in inputfile:
outstring = address.rstrip()
print datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
try:
location = gc.geocode(address)
outstring = outstring + "\t" + str(location.latitude) + "\t" + str(location.longitude) + "\t" + location.raw["accuracy"] + "\n"
outputfile.write(outstring)
except:
outstring = outstring + "\t" + "address couldn't be geolocated" + "\n"
class GeocodeFarmTestCase(GeocoderTestBase):
@classmethod
def setUpClass(cls):
cls.delta = 0.04
cls.geocoder = GeocodeFarm(
# None api_key will use free tier on GeocodeFarm.
api_key=env.get('GEOCODEFARM_KEY'),
timeout=10,
)
def test_user_agent_custom(self):
geocoder = GeocodeFarm(user_agent='my_user_agent/1.0')
self.assertEqual(geocoder.headers['User-Agent'], 'my_user_agent/1.0')
def test_geocode(self):
"""
GeocodeFarm.geocode
"""
location = self.geocode_run(
{"query": "435 north michigan ave, chicago il 60611 usa"},
{
"latitude": 41.890,
"longitude": -87.624
},
)
self.assertIn("chicago", location.address.lower())
def test_location_address(self):
self.geocode_run({"query": "moscow"}, {
"address": "Moscow, Russia",
"latitude": 55.7558913503453,
"longitude": 37.6172961632184
})
def test_reverse(self):
location = self.reverse_run(
{"query": Point(40.75376406311989, -73.98489005863667)},
{
"latitude": 40.75376406311989,
"longitude": -73.98489005863667
},
)
self.assertIn("new york", location.address.lower())
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
with self.assertRaises(exc.GeocoderAuthenticationFailure):
self.geocode_run(
{"query": '435 north michigan ave, chicago il 60611'},
{},
expect_failure=True,
)
def test_quota_exceeded(self):
"""
GeocodeFarm quota exceeded
"""
def mock_call_geocoder(*args, **kwargs):
return {
"geocoding_results": {
"STATUS": {
"access": "OVER_QUERY_LIMIT",
"status": "FAILED, ACCESS_DENIED"
}
}
}
with patch.object(self.geocoder, '_call_geocoder', mock_call_geocoder), \
self.assertRaises(exc.GeocoderQuotaExceeded):
self.geocoder.geocode('435 north michigan ave, chicago il 60611')
def test_no_results(self):
self.geocode_run({"query": "gibberish kdjhsakdjh skjdhsakjdh"}, {},
expect_failure=True)
def test_unhandled_api_error(self):
"""
GeocodeFarm unhandled error
"""
def mock_call_geocoder(*args, **kwargs):
return {
"geocoding_results": {
"STATUS": {
"access": "BILL_PAST_DUE",
"status": "FAILED, ACCESS_DENIED"
}
}
}
with patch.object(self.geocoder, '_call_geocoder', mock_call_geocoder), \
self.assertRaises(exc.GeocoderServiceError):
self.geocoder.geocode('435 north michigan ave, chicago il 60611')
class GeocodeFarmTestCase(GeocoderTestBase): # pylint: disable=R0904,C0111
@classmethod
def setUpClass(cls):
cls.delta = 0.04
cls.geocoder = GeocodeFarm(
api_key=env.get('GEOCODEFARM_KEY'), # None api_key will use free tier on GeocodeFarm
timeout=60,
)
def setUp(self):
# Store the original _call_geocoder in case we replace it with a mock
self._original_call_geocoder = self.geocoder._call_geocoder
def tearDown(self):
# Restore the original _call_geocoder in case we replaced it with a mock
self.geocoder._call_geocoder = self._original_call_geocoder
def test_geocode(self):
"""
GeocodeFarm.geocode
"""
self.geocode_run(
{"query": "435 north michigan ave, chicago il 60611 usa"},
{"latitude": 41.890, "longitude": -87.624},
)
def test_reverse_string(self):
"""
GeocodeFarm.reverse string
"""
self.reverse_run(
{"query": "40.75376406311989,-73.98489005863667"},
{"latitude": 40.75376406311989, "longitude": -73.98489005863667},
)
def test_reverse_point(self):
"""
GeocodeFarm.reverse Point
"""
self.reverse_run(
{"query": Point(40.75376406311989, -73.98489005863667)},
{"latitude": 40.75376406311989, "longitude": -73.98489005863667},
)
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
try:
with self.assertRaises(exc.GeocoderAuthenticationFailure):
address = '435 north michigan ave, chicago il 60611'
self.geocoder.geocode(address)
except exc.GeocoderTimedOut:
raise unittest.SkipTest("GeocodeFarm timed out")
def test_quota_exceeded(self):
"""
GeocodeFarm quota exceeded
"""
def mock_call_geocoder(*args, **kwargs):
"""
Mock API call to return bad response.
"""
return {
"geocoding_results": {
"STATUS": {
"access": "OVER_QUERY_LIMIT",
"status": "FAILED, ACCESS_DENIED"
}
}
}
self.geocoder._call_geocoder = types.MethodType(
mock_call_geocoder,
self.geocoder
)
with self.assertRaises(exc.GeocoderQuotaExceeded):
self.geocoder.geocode('435 north michigan ave, chicago il 60611')
def test_unhandled_api_error(self):
"""
GeocodeFarm unhandled error
"""
def mock_call_geocoder(*args, **kwargs):
"""
Mock API call to return bad response.
"""
return {
"geocoding_results": {
"STATUS": {
"access": "BILL_PAST_DUE",
"status": "FAILED, ACCESS_DENIED"
}
}
}
self.geocoder._call_geocoder = types.MethodType(
mock_call_geocoder,
self.geocoder
)
with self.assertRaises(exc.GeocoderServiceError):
self.geocoder.geocode('435 north michigan ave, chicago il 60611')
class GeocodeFarmTestCases(unittest.TestCase):
def setUp(self):
self.address = "Sunnersta" #static address to be found
self.address2 = "Mackenzie" #static address for DataBC only
self.userlocation = (59.8585107, 17.6368508)
self.addrNone = "abcdefghijklmnopqrstuvwxyz zyxwvutsrqponmlkjihgfedcba" #non-existing address
self.scheme = "https"
self.plainscheme = "http"
#set up for geocodeFarm
self.geolocator5 = GeocodeFarm()
self.geourlapi = "https://www.geocode.farm/v3/json/forward/"
def testGeocodeFarm(self):
#assert if the object's structure is the same as class Geocode Farm
self.assertIsInstance(
self.geolocator5, GeocodeFarm,
"The object is not an instance of class Geocode Farm")
#assert the url built
self.assertEqual(self.geolocator5.scheme, self.scheme)
self.assertEqual(self.geolocator5.api, self.geourlapi)
def testDataTypeNone(self):
#time.sleep(2)
#without userlocation
location = self.geolocator5.geocode(self.addrNone)
self.assertIsNone(location, "location found! " + str(self.geolocator5))
#with userlocation
location = self.geolocator5.geocode(self.addrNone, self.userlocation)
#print(location)
#print(location.latitude)
self.assertIsNone(location, "location found! " + str(self.geolocator5))
def testDataTypeSingle(self):
#time.sleep(2)
location = self.geolocator5.geocode(self.address)
self.assertIsNotNone(location, "location not found! ")
self.assertIsInstance(
location, Location,
"location is not an instance of class Location! ")
self.assertIsNot(type(location), list, "location is multiple! ")
self.assertIs(type(location), Location,
"location is not of type Location! ")
self.assertIs(type(location.address), unicode,
"address is not of type unicode! ")
self.assertIs(type(location.latitude), float,
"latitude is not of type float! ")
self.assertIs(type(location.longitude), float,
"longitude is not of type float! ")
self.assertIs(type(location.altitude), float,
"altitude is not of type float! ")
self.assertIs(type(location.raw), dict, "raw is not of type dict! ")
#print(location)
def testDataTypeMultiple(self):
#time.sleep(2)
location = self.geolocator5.geocode(self.address, False)
self.assertIsNotNone(location, "location not found! ")
self.assertIs(type(location), list, "location is single! ")
for l in range(len(location)):
self.assertIsInstance(
location[l], Location,
"location is not an instance of class Location! ")
self.assertIs(type(location[l]), Location,
"location is not of type Location! ")
self.assertIs(type(location[l].address), unicode,
"address is not of type unicode! ")
self.assertIs(type(location[l].latitude), float,
"latitude is not of type float! ")
self.assertIs(type(location[l].longitude), float,
"longitude is not of type float! ")
self.assertIs(type(location[l].altitude), float,
"altitude is not of type float! ")
self.assertIs(type(location[l].raw), dict,
"raw is not of type dict! ")
#print(location[l])
def testAddressSingle(self):
#time.sleep(2)
location = self.geolocator5.geocode(self.address)
self.assertIn(self.address, location.raw['formatted_address'])
def testAddressMultiple(self):
#time.sleep(2)
location = self.geolocator5.geocode(self.address, exactly_one=False)
for gl1 in range(len(location)):
self.assertIn(self.address, location[gl1].raw['formatted_address'])
def testAddressSingleChanges(self):
#time.sleep(2)
location = self.geolocator5.geocode(self.address,
userlocation=self.userlocation,
exactly_one=True)
self.assertIn(self.address, location.raw['formatted_address'])
def testAddressMultipleChanges(self):
#time.sleep(2)
location = self.geolocator5.geocode(self.address,
userlocation=self.userlocation,
exactly_one=False)
for gl1 in range(len(location)):
self.assertIn(self.address, location[gl1].raw['formatted_address'])
def testOrderedData(self):
#time.sleep(2)
location = self.geolocator5.geocode(self.address,
userlocation=self.userlocation,
exactly_one=False)
#put all distance in array
distance = []
for l in range(len(location)):
distance.append(
vincenty(self.userlocation,
(location[l].latitude, location[l].longitude)))
#compare all distance with the first distance, the first one should be the smallest
min_distance = distance[0]
for l in range(len(distance)):
self.assertLessEqual(min_distance, distance[l],
"The order of data is wrong")
class GeocodeFarmTestCase(GeocoderTestBase):
@classmethod
def setUpClass(cls):
cls.delta = 0.04
cls.geocoder = GeocodeFarm(
# None api_key will use free tier on GeocodeFarm.
api_key=env.get('GEOCODEFARM_KEY'),
timeout=10,
)
def test_user_agent_custom(self):
geocoder = GeocodeFarm(
user_agent='my_user_agent/1.0'
)
self.assertEqual(geocoder.headers['User-Agent'], 'my_user_agent/1.0')
def test_geocode(self):
"""
GeocodeFarm.geocode
"""
location = self.geocode_run(
{"query": "435 north michigan ave, chicago il 60611 usa"},
{"latitude": 41.890, "longitude": -87.624},
)
self.assertIn("chicago", location.address.lower())
def test_location_address(self):
self.geocode_run(
{"query": "moscow"},
{"address": "Moscow, Russia",
"latitude": 55.7558913503453, "longitude": 37.6172961632184}
)
def test_reverse(self):
location = self.reverse_run(
{"query": Point(40.75376406311989, -73.98489005863667)},
{"latitude": 40.75376406311989, "longitude": -73.98489005863667},
)
self.assertIn("new york", location.address.lower())
def test_authentication_failure(self):
"""
GeocodeFarm authentication failure
"""
self.geocoder = GeocodeFarm(api_key="invalid")
with self.assertRaises(exc.GeocoderAuthenticationFailure):
self.geocode_run(
{"query": '435 north michigan ave, chicago il 60611'},
{},
expect_failure=True,
)
def test_quota_exceeded(self):
"""
GeocodeFarm quota exceeded
"""
def mock_call_geocoder(*args, **kwargs):
return {
"geocoding_results": {
"STATUS": {
"access": "OVER_QUERY_LIMIT",
"status": "FAILED, ACCESS_DENIED"
}
}
}
with patch.object(self.geocoder, '_call_geocoder', mock_call_geocoder), \
self.assertRaises(exc.GeocoderQuotaExceeded):
self.geocoder.geocode('435 north michigan ave, chicago il 60611')
def test_no_results(self):
self.geocode_run(
{"query": "gibberish kdjhsakdjh skjdhsakjdh"},
{},
expect_failure=True
)
def test_unhandled_api_error(self):
"""
GeocodeFarm unhandled error
"""
def mock_call_geocoder(*args, **kwargs):
return {
"geocoding_results": {
"STATUS": {
"access": "BILL_PAST_DUE",
"status": "FAILED, ACCESS_DENIED"
}
}
}
with patch.object(self.geocoder, '_call_geocoder', mock_call_geocoder), \
self.assertRaises(exc.GeocoderServiceError):
self.geocoder.geocode('435 north michigan ave, chicago il 60611')
def setUp(self):
self.address = "Sunnersta" #static address to be found
self.address2 = "Mackenzie" #static address for DataBC only
self.userlocation = (59.8585107, 17.6368508)
self.addrNone = "abcdefghijklmnopqrstuvwxyz zyxwvutsrqponmlkjihgfedcba" #non-existing address
self.scheme = "https"
self.plainscheme = "http"
self.geolocators = []
#set up for Google
self.geolocator1 = GoogleV3()
self.googleurl = "https://maps.googleapis.com/maps/api/geocode/json"
self.googledomain = "maps.googleapis.com"
self.geolocators.append(self.geolocator1)
#set up for ArcGIS
self.geolocator2auth = ArcGIS("asailona", "uppsala00",
"asailona.maps.arcgis.com")
self.geolocator2 = ArcGIS()
self.arcgisurl = "https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/find"
self.arcgisgenerate = "https://www.arcgis.com/sharing/generateToken?username=asailona&password=uppsala00&expiration=3600&f=json&referer=asailona.maps.arcgis.com"
self.geolocators.append(self.geolocator2auth)
self.geolocators.append(self.geolocator2)
#set up for Bing
self.geolocator3auth = Bing(
"AjIo4Ums4724tF5U5V7t91SHwwvjm8GP8wf0b3HZmVJWVQLlGJtSwv04IlwJ6971")
self.bingapikey = "AjIo4Ums4724tF5U5V7t91SHwwvjm8GP8wf0b3HZmVJWVQLlGJtSwv04IlwJ6971"
self.bingurlapi = "https://dev.virtualearth.net/REST/v1/Locations"
self.geolocators.append(self.geolocator3auth)
#set up for Data BC
self.geolocator4 = DataBC()
self.databcurlapi = "https://apps.gov.bc.ca/pub/geocoder/addresses.geojson"
self.geolocators.append(self.geolocator4)
#set up for geocodeFarm
self.geolocator5 = GeocodeFarm()
self.geourlapi = "https://www.geocode.farm/v3/json/forward/"
self.geolocators.append(self.geolocator5)
#set up for GeoNames
self.geolocator6 = GeoNames(None, "asailona")
self.gnameapi = "http://api.geonames.org/searchJSON"
self.geolocators.append(self.geolocator6)
#set up for MapZen
self.geolocator7 = Mapzen("mapzen-yJXCFyc")
self.mapzenapikey = "mapzen-yJXCFyc"
self.mapzenapi = "https://search.mapzen.com/v1/search"
self.geolocators.append(self.geolocator7)
#set up for OpenCage
self.geolocator8 = OpenCage("1aea82c9f55149dc1acc6ae04be7747c")
self.openapikey = "1aea82c9f55149dc1acc6ae04be7747c"
self.opendomain = "api.opencagedata.com"
self.openapi = "https://api.opencagedata.com/geocode/v1/json"
self.geolocators.append(self.geolocator8)
#set up for Open Street Map
self.geolocator9 = Nominatim()
self.osmdomain = "nominatim.openstreetmap.org"
self.osmapi = "https://nominatim.openstreetmap.org/search"
self.geolocators.append(self.geolocator9)
#set up for Photon
self.geolocator10 = Photon()
self.photondomain = "photon.komoot.de"
self.photonapi = "https://photon.komoot.de/api"
self.geolocators.append(self.geolocator10)
#set up for vincenty distance test cases
self.myLocation = Point(59.849904, 17.621000)
self.northPole = Point(90.0, 0.0)
self.southPole = Point(-90.0, 0.0)
self.antiPodal1 = Point(0.0, 0.0)
self.antiPodal2 = Point(0.5, 179.7)
self.earthCircunference = Distance(2 * math.pi * EARTH_RADIUS)
