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)