def test_point_str_deg(self):
"""
Point() str degrees, minutes &c
"""
point = Point(u("UT: N 39\xb020' 0'' / W 74\xb035' 0''"))
self.assertEqual(point.latitude, 39.333333333333336)
self.assertEqual(point.longitude, -74.58333333333333)
self.assertEqual(point.altitude, 0)
def test_reverse_point(self):
"""
YahooPlaceFinder.reverse Point
"""
self.reverse_run(
{"query": Point(40.75376406311989, -73.98489005863667)},
{"latitude": 40.75376406311989, "longitude": -73.98489005863667}
)
def test_point_is_picklable(self):
point = Point(self.lat, self.lon, self.alt)
# https://docs.python.org/2/library/pickle.html#data-stream-format
for protocol in (0, 1, 2, -1):
pickled = pickle.dumps(point, protocol=protocol)
point_unp = pickle.loads(pickled)
self.assertEqual(point, point_unp)
self.assertEqual(self.coords, point_unp)
def test_reverse_point(self):
"""
Bing.reverse using point
"""
self.reverse_run(
{"query": Point(40.753898, -73.985071)},
{"latitude": 40.753, "longitude": -73.984},
)
async def test_reverse_point_radius_1000_float(self):
# needs more testing
res = await self.reverse_run(
{"query": Point(40.753898, -73.985071), "radius": 1000.12,
"exactly_one": False},
{"latitude": 40.753898, "longitude": -73.985071}
)
assert len(res) > 5
def test_viewbox(self):
res = self.geocode_run(
{"query": "Maple Street"},
{},
)
self.assertFalse(50 <= res.latitude <= 52)
self.assertFalse(-0.15 <= res.longitude <= -0.11)
for viewbox in [
((52, -0.11), (50, -0.15)),
[Point(52, -0.11), Point(50, -0.15)],
(("52", "-0.11"), ("50", "-0.15"))
]:
self.geocode_run(
{"query": "Maple Street", "viewbox": viewbox},
{"latitude": 51.5223513, "longitude": -0.1382104}
)
def test_point_comparison_with_empty_values(self):
empty_values = (None, '', [], (), {}) # Django validators
point_nonempty = Point(self.lat, self.lon, self.alt)
point_empty = Point() # actually Point(0, 0, 0), which is not "empty"
self.assertFalse(point_nonempty in empty_values)
self.assertTrue(point_nonempty)
# Point() == (0, 0, 0).
self.assertEqual(Point(), (0, 0, 0))
# Currently Point can't distinguish between zero and unset coordinate
# values, so we cannot tell if `point_empty` is really "empty"
# (i.e. unset, like `Point()`) or is just a point at the center
# (which is obviously not "empty"). That's why on the next line
# we assume that `point_empty` is not in the `empty_values` list.
self.assertFalse(point_empty in empty_values)
# bool(Point(0, 0, 0)) should also be true
self.assertTrue(point_empty)
async def test_reverse_point(self):
await self.reverse_run(
{"query": Point(40.753898, -73.985071)},
{
"latitude": 40.753,
"longitude": -73.984
},
)
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_point_comparison_does_not_raise_exceptions(self):
point = Point(self.lat, self.lon, self.alt)
number = 1
not_iterable = object()
self.assertFalse(point == number)
self.assertTrue(point != number)
self.assertFalse(point == not_iterable)
self.assertTrue(point != not_iterable)
def test_point_float(self):
"""
Point() floats
"""
point = Point(self.lat, self.lon, self.alt)
self.assertEqual(point.longitude, self.lon)
self.assertEqual(point.latitude, self.lat)
self.assertEqual(point.altitude, self.alt)
def test_point_getitem(self):
"""
Point.__getitem__
"""
point = Point(self.lat, self.lon, self.alt)
self.assertEqual(point[0], self.lat)
self.assertEqual(point[1], self.lon)
self.assertEqual(point[2], self.alt)
def midpoint(self, destination, start=None):
if start:
A = Point(start[0], start[1])
else:
A = self.pos
B = Point(destination[0], destination[1])
if A.x == B.x: return Point(A.x, (A.y + B.y) / 2)
if A.y == B.y: return Point((A.x + B.x) / 2, A.y)
lon1, lat1 = radians(A.x), radians(A.y)
lon2, lat2 = radians(B.x), radians(B.y)
dLon = lon2 - lon1
Bx = cos(lat2) * cos(dLon)
By = cos(lat2) * sin(dLon)
lat3 = atan2(
sin(lat1) + sin(lat2),
sqrt((cos(lat1) + Bx) * (cos(lat1) + Bx) + By * By))
lon3 = lon1 + atan2(By, cos(lat1) + Bx)
return Point(degrees(lon3), degrees(lat3))
def measure(self, a, b):
a, b = Point(a), Point(b)
lat1, lng1 = radians(degrees=a.latitude), radians(degrees=a.longitude)
lat2, lng2 = radians(degrees=b.latitude), radians(degrees=b.longitude)
sin_lat1, cos_lat1 = sin(lat1), cos(lat1)
sin_lat2, cos_lat2 = sin(lat2), cos(lat2)
delta_lng = lng2 - lng1
cos_delta_lng, sin_delta_lng = cos(delta_lng), sin(delta_lng)
d = atan2(sqrt((cos_lat2 * sin_delta_lng) ** 2 +
(cos_lat1 * sin_lat2 -
sin_lat1 * cos_lat2 * cos_delta_lng) ** 2),
sin_lat1 * sin_lat2 + cos_lat1 * cos_lat2 * cos_delta_lng)
return self.RADIUS * d
async def test_reverse_with_include_country_code(self):
res = await self.reverse_run(
{
"query": Point(40.753898, -73.985071),
"include_country_code": True
},
{},
)
assert res.raw["address"].get("countryRegionIso2", 'missing') == 'US'
async def test_reverse_with_culture_en(self):
res = await self.reverse_run(
{
"query": Point(40.753898, -73.985071),
"culture": "EN"
},
{},
)
assert "United States" in res.address
async def test_reverse_with_culture_de(self):
res = await self.reverse_run(
{
"query": Point(40.753898, -73.985071),
"culture": "DE"
},
{},
)
assert "Vereinigte Staaten von Amerika" in res.address
def test_get_geolocation_address(self, mock_googlemaps):
client = mock_googlemaps.Client.return_value
client.geocode.return_value = [
{"geometry": {"location": {"lat": 45, "lng": -75}}}
]
location = Geocoding().get_from_address(ADDRESS)
self.assertEqual(location, Point(45.0, -75.0))
client.geocode.assert_called_once_with(address=ADDRESS)
def test_reverse_with_mode_areas(self):
"""
Here.reverse using mode parameter 'retrieveAreas'.
"""
res = self.reverse_run(
{"query": Point(40.753898, -73.985071), "mode": "retrieveAreas"},
{}
)
self.assertIn("Theater District-Times Square", res.address)
def test_reverse_with_culture_en(self):
"""
Bing.reverse using point and culture parameter to get an english response
"""
res = self.reverse_run(
{"query": Point(40.753898, -73.985071), "culture": "EN"},
{},
)
self.assertIn("United States", res.address)
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())
async def test_reverse_point(self):
location = await self.reverse_run(
{"query": Point(40.753898, -73.985071)},
{
"latitude": 40.75376406311989,
"longitude": -73.98489005863667
},
)
assert 'New York' in location.address
def test_reverse_point(self):
self.reverse_run(
{"query": Point(39.983615544507, 116.32295155093)},
{
"latitude": 39.983615544507,
"longitude": 116.32295155093
},
)
self.reverse_run(
{
"query": Point(39.983615544507, 116.32295155093),
"exactly_one": False
},
{
"latitude": 39.983615544507,
"longitude": 116.32295155093
},
)
def test_reverse_point(self):
"""
PickPoint.reverse Point
"""
location = self.reverse_run(
{"query": Point(40.75376406311989, -73.98489005863667)},
{"latitude": 40.75376406311989, "longitude": -73.98489005863667}
)
self.assertIn("New York", location.address)
def test_reverse_point(self):
"""
ArcGIS.reverse using point
"""
location = self.reverse_run(
{"query": Point(40.753898, -73.985071)},
{"latitude": 40.75376406311989, "longitude": -73.98489005863667},
)
self.assertIn('New York', location.address)
def test_reverse_with_language_en(self):
"""
Here.reverse using point and language parameter to get an English response
"""
res = self.reverse_run(
{"query": Point(40.753898, -73.985071), "language": "en-US"},
{}
)
self.assertIn("United States", res.address)
def test_reverse_point(self):
"""
Photon.reverse Point
"""
result = self.reverse_run({"query": Point(45.7733105, 4.8869339)}, {
"latitude": 45.7733105,
"longitude": 4.8869339
})
self.assertIn("France", result.address)
def test_reverse(self):
known_addr = '1067 6th Ave, New York, NY 10018, United States'
known_coords = (40.75376406311989, -73.98489005863667)
result = self.geocoder.reverse(Point(40.753898, -73.985071))
addr, coords = result
self.assertTrue(result.raw is not None)
self.assertEqual(str_coerce(addr), known_addr)
self.assertAlmostEqual(coords[0], known_coords[0], delta=self.delta_exact)
self.assertAlmostEqual(coords[1], known_coords[1], delta=self.delta_exact)
def test_point_str_simple(self):
"""
Point() str
"""
for each in ("%s,%s", "%s %s", "%s;%s"):
point = Point(each % (self.lat, self.lon))
self.assertEqual(point.longitude, self.lon)
self.assertEqual(point.latitude, self.lat)
self.assertEqual(point.altitude, 0)
def test_reverse_with_culture_de(self):
"""
Bing.reverse using point and culture parameter to get a non english response
"""
res = self.reverse_run(
{"query": Point(40.753898, -73.985071), "culture": "DE"},
{},
)
self.assertIn("Vereinigte Staaten von Amerika", res.address)
