stadiamaps 0.4.0__tar.gz → 0.5.0__tar.gz

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stadiamaps
-Version: 0.4.0
+Version: 0.5.0
 Summary: Stadia Maps Geospatial APIs
 Home-page: https://docs.stadiamaps.com/
 Author: Stadia Maps Support

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/README.md

@@ -35,8 +35,8 @@ from stadiamaps.rest import ApiException
 from pprint import pprint
 
 # Defining the host is optional and defaults to https://api.stadiamaps.com
-# You can also use our EU endpoint to keep traffic within the EU by setting
-# host to https://api-eu.stadiamaps.com.
+# You can also use our EU endpoint to keep traffic within the EU like sq:
+# configuration = stadiamaps.Configuration(host="https://api-eu.stadiamaps.com")
 # See configuration.py for a list of all supported configuration parameters.
 configuration = stadiamaps.Configuration()
 

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "stadiamaps"
-version = "0.4.0"
+version = "0.5.0"
 description = "Stadia Maps Geospatial APIs"
 authors = ["Stadia Maps Support <support@stadiamaps.com>"]
 license = "BSD-3-Clause"

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/setup.py

@@ -22,7 +22,7 @@ from setuptools import setup, find_packages  # noqa: H301
 # prerequisite: setuptools
 # http://pypi.python.org/pypi/setuptools
 NAME = "stadiamaps"
-VERSION = "0.4.0"
+VERSION = "0.5.0"
 PYTHON_REQUIRES = ">=3.7"
 REQUIRES = [
     "urllib3 >= 1.25.3",

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/stadiamaps/__init__.py

@@ -15,7 +15,7 @@
 """
 
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 
 # import apis into sdk package
 from stadiamaps.api.geocoding_api import GeocodingApi

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/stadiamaps/api_client.py

@@ -77,7 +77,7 @@ class ApiClient(object):
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/0.4.0/python'
+        self.user_agent = 'OpenAPI-Generator/0.5.0/python'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/stadiamaps/configuration.py

@@ -398,7 +398,7 @@ conf = stadiamaps.Configuration(
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: 5.0.1\n"\
-               "SDK Package Version: 0.4.0".\
+               "SDK Package Version: 0.5.0".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self):

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/stadiamaps/models/isochrone_feature.py

@@ -39,8 +39,8 @@ class IsochroneFeature(BaseModel):
         if value is None:
             return value
 
-        if value not in ('LineString', 'Polygon'):
-            raise ValueError("must be one of enum values ('LineString', 'Polygon')")
+        if value not in ('Feature'):
+            raise ValueError("must be one of enum values ('Feature')")
         return value
 
     class Config:

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/stadiamaps/models/matrix_response.py

@@ -110,9 +110,9 @@ class MatrixResponse(BaseModel):
 
         _obj = MatrixResponse.parse_obj({
             "id": obj.get("id"),
-            "sources": [List[Coordinate].from_dict(_item) for _item in obj.get("sources")] if obj.get("sources") is not None else None,
-            "targets": [List[Coordinate].from_dict(_item) for _item in obj.get("targets")] if obj.get("targets") is not None else None,
-            "sources_to_targets": [List[MatrixDistance].from_dict(_item) for _item in obj.get("sources_to_targets")] if obj.get("sources_to_targets") is not None else None,
+            "sources": [[Coordinate.from_dict(_item) for _item in _items] for _items in obj.get("sources")] if obj.get("sources") is not None else None,
+            "targets": [[Coordinate.from_dict(_item) for _item in _items] for _items in obj.get("targets")] if obj.get("targets") is not None else None,
+            "sources_to_targets": [[MatrixDistance.from_dict(_item) for _item in _items] for _items in obj.get("sources_to_targets")] if obj.get("sources_to_targets") is not None else None,
             "warnings": [Warning.from_dict(_item) for _item in obj.get("warnings")] if obj.get("warnings") is not None else None,
             "units": obj.get("units")
         })

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/stadiamaps/models/pelias_layer.py

@@ -24,7 +24,7 @@ from aenum import Enum, no_arg
 
 class PeliasLayer(str, Enum):
     """
-    Our database is organized into several layers (in the GIS sense of the term) as follows:  - `venue`: Points of interest, businesses, and things with walls - `address`: Places with a street address - `street`: Streets, roads, highways - `county`: Places that issue passports, nations, nation-states - `macroregion`: A related group of regions (mostly in Europe) - `region`: The first administrative division within a country (usually states and provinces) - `macrocounty`: A related group of counties (mostly in Europe) - `county`: Official governmental areas; usually bigger than a locality, but almost always smaller than a region - `locality`: Towns, hamlets, cities, etc. - `localadmin`: Local administrative boundaries - `borough`: Local administrative boundaries within cities (not widely used, but present in places such as NYC and Mexico City) - `neighbourhood`: Social communities and neighborhoods (note the British spelling in the API!) - `postalcode`: Postal codes used by mail services (note: not used for reverse geocoding) - `coarse`: An alias for simultaneously using all administrative layers (everything except `venue` and `address`) 
+    Our database is organized into several layers (in the GIS sense of the term) as follows:  - `venue`: Points of interest, businesses, and things with walls - `address`: Places with a street address - `street`: Streets, roads, highways - `county`: Places that issue passports, nations, nation-states - `macroregion`: A related group of regions (mostly in Europe) - `region`: The first administrative division within a country (usually states and provinces) - `macrocounty`: A related group of counties (mostly in Europe) - `county`: Official governmental areas; usually bigger than a locality, but almost always smaller than a region - `locality`: Towns, hamlets, cities, etc. - `localadmin`: Local administrative boundaries - `borough`: Local administrative boundaries within cities (not widely used, but present in places such as NYC and Mexico City) - `neighbourhood`: Social communities and neighborhoods (note the British spelling in the API!) - `postalcode`: Postal codes used by mail services (note: not used for reverse geocoding) - `coarse`: An alias for simultaneously using all administrative layers (everything except `venue` and `address`) - `marinearea`: Places with fishes and boats. - `ocean`: A really big marine area. 
     """
 
     """
@@ -44,6 +44,13 @@ class PeliasLayer(str, Enum):
     NEIGHBOURHOOD = 'neighbourhood'
     POSTALCODE = 'postalcode'
     COARSE = 'coarse'
+    DEPENDENCY = 'dependency'
+    MACROHOOD = 'macrohood'
+    MARINEAREA = 'marinearea'
+    DISPUTED = 'disputed'
+    EMPIRE = 'empire'
+    CONTINENT = 'continent'
+    OCEAN = 'ocean'
 
     @classmethod
     def from_json(cls, json_str: str) -> PeliasLayer:

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/stadiamaps.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stadiamaps
-Version: 0.4.0
+Version: 0.5.0
 Summary: Stadia Maps Geospatial APIs
 Home-page: https://docs.stadiamaps.com/
 Author: Stadia Maps Support

{stadiamaps-0.4.0 → stadiamaps-0.5.0}/stadiamaps.egg-info/SOURCES.txt

@@ -241,4 +241,7 @@ test/test_valhalla_languages.py
 test/test_valhalla_long_units.py
 test/test_warning.py
 test/integration/__init__.py
-test/integration/test_gecoding.py
+test/integration/test_eu_endpoint.py
+test/integration/test_gecoding.py
+test/integration/test_geospatial.py
+test/integration/test_routing.py

stadiamaps-0.5.0/test/integration/test_eu_endpoint.py

@@ -0,0 +1,21 @@
+import os
+import unittest
+
+import stadiamaps
+
+
+class TestEUEndpoint(unittest.TestCase):
+    def setUp(self):
+        self.configuration = stadiamaps.Configuration(host="https://api-eu.stadiamaps.com")
+        self.configuration.api_key['ApiKeyAuth'] = os.environ["STADIA_API_KEY"]
+
+    def tearDown(self):
+        pass
+
+    def testAutocomplete(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.autocomplete("Põhja pst 27a")
+            self.assertEqual("Estonia", res.features[0].properties.country)
+            self.assertEqual("address", res.features[0].properties.layer)

stadiamaps-0.5.0/test/integration/test_gecoding.py

@@ -0,0 +1,64 @@
+import os
+import unittest
+
+import stadiamaps
+
+address = "Põhja pst 27a"
+
+
+class TestGeocoding(unittest.TestCase):
+    def setUp(self):
+        self.configuration = stadiamaps.Configuration()
+        self.configuration.api_key['ApiKeyAuth'] = os.environ["STADIA_API_KEY"]
+
+    def tearDown(self):
+        pass
+
+    def testAutocomplete(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.autocomplete(address)
+            self.assertEqual("Estonia", res.features[0].properties.country)
+            self.assertEqual("address", res.features[0].properties.layer)
+
+    def testSearch(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.search(address)
+            self.assertEqual("Estonia", res.features[0].properties.country)
+            self.assertEqual("address", res.features[0].properties.layer)
+
+    def testStructuredSearch(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.search_structured(address, country="Estonia")
+            self.assertEqual("Estonia", res.features[0].properties.country)
+            self.assertEqual("address", res.features[0].properties.layer)
+
+    def testReverse(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.reverse(59.444351, 24.750645)
+            self.assertEqual("Estonia", res.features[0].properties.country)
+            self.assertEqual("address", res.features[0].properties.layer)
+
+    def testReverseUncommonLayer(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            # Middle of the Gulf of Oman
+            res = api_instance.reverse(24.750645, 59.444351)
+            self.assertEqual("marinearea", res.features[0].properties.layer)
+
+    def testPlace(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.place(["openstreetmap:address:way/109867749"])
+            self.assertEqual(1, len(res.features))
+            self.assertEqual("Estonia", res.features[0].properties.country)
+            self.assertEqual("address", res.features[0].properties.layer)

stadiamaps-0.5.0/test/integration/test_geospatial.py

@@ -0,0 +1,31 @@
+import os
+import unittest
+
+import stadiamaps
+
+
+class TestGeospatial(unittest.TestCase):
+    def setUp(self):
+        self.configuration = stadiamaps.Configuration()
+        self.configuration.api_key['ApiKeyAuth'] = os.environ["STADIA_API_KEY"]
+
+    def tearDown(self):
+        pass
+
+    def testTZLookup(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeospatialApi(api_client)
+
+            res = api_instance.tz_lookup(37.56, 126.99)
+            self.assertEqual("Asia/Seoul", res.tz_id)
+
+    def testElevation(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeospatialApi(api_client)
+
+            req = stadiamaps.HeightRequest(id="Seoul", shape=[stadiamaps.Coordinate(lat=37.56, lon=126.99)])
+            res = api_instance.elevation(req)
+            self.assertEqual(req.id, res.id)
+            self.assertGreaterEqual(len(res.height), 1)
+            self.assertGreaterEqual(res.height[0], 1)
+            self.assertEqual(res.shape, req.shape)

stadiamaps-0.5.0/test/integration/test_routing.py

@@ -0,0 +1,146 @@
+import os
+import unittest
+
+import stadiamaps
+
+location_a = {"lat": 40.042072, "lon": -76.306572}
+location_b = {"lat": 39.992115, "lon": -76.781559}
+location_c = {"lat": 39.984519, "lon": -76.6956}
+
+
+class TestRouting(unittest.TestCase):
+    def setUp(self):
+        self.configuration = stadiamaps.Configuration()
+        self.configuration.api_key['ApiKeyAuth'] = os.environ["STADIA_API_KEY"]
+
+    def tearDown(self):
+        pass
+
+    def testRoute(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.RoutingApi(api_client)
+
+            req = stadiamaps.RouteRequest(
+                id="route",
+                locations=[
+                    stadiamaps.RoutingWaypoint.from_dict(location_a),
+                    stadiamaps.RoutingWaypoint.from_dict(location_b)
+                ],
+                costing=stadiamaps.CostingModel.AUTO,
+                costing_options=stadiamaps.CostingOptions(auto=stadiamaps.AutoCostingOptions(use_tolls=1)),
+                directions_options=stadiamaps.DirectionsOptions(units=stadiamaps.DistanceUnit.MI)
+            )
+
+            res = api_instance.route(req)
+            self.assertEqual(req.id, res.id)
+            self.assertEqual(0, res.trip.status)
+            self.assertEqual("miles", res.trip.units)
+            self.assertEqual(len(res.trip.legs), 1)
+
+    def testOptimizedRoute(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.RoutingApi(api_client)
+
+            req = stadiamaps.OptimizedRouteRequest(
+                id="optimized_route",
+                locations=[
+                    stadiamaps.Coordinate.from_dict(location_a),
+                    stadiamaps.Coordinate.from_dict(location_b),
+                    stadiamaps.Coordinate.from_dict(location_c)
+                ],
+                costing=stadiamaps.CostingModel.AUTO,
+                costing_options=stadiamaps.CostingOptions(auto=stadiamaps.AutoCostingOptions(use_tolls=1)),
+                directions_options=stadiamaps.DirectionsOptions(units=stadiamaps.DistanceUnit.MI)
+            )
+
+            res = api_instance.optimized_route(req)
+            self.assertEqual(req.id, res.id)
+            self.assertEqual(0, res.trip.status)
+            self.assertEqual("miles", res.trip.units)
+            self.assertGreater(len(res.trip.legs), 1)
+
+    def testTimeDistanceMatrix(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.RoutingApi(api_client)
+
+            req = stadiamaps.MatrixRequest(
+                id="matrix",
+                sources=[
+                    stadiamaps.Coordinate.from_dict(location_a),
+                ],
+                targets=[
+                    stadiamaps.Coordinate.from_dict(location_b),
+                    stadiamaps.Coordinate.from_dict(location_c),
+                ],
+                costing=stadiamaps.MatrixCostingModel.PEDESTRIAN,
+            )
+
+            res = api_instance.time_distance_matrix(req)
+            self.assertEqual(req.id, res.id)
+            self.assertEqual([req.sources], res.sources)
+            self.assertEqual([req.targets], res.targets)
+            self.assertGreaterEqual(len(res.sources_to_targets), 1)
+            self.assertEqual("kilometers", res.units)
+
+    def testNearestRoads(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.RoutingApi(api_client)
+
+            req = stadiamaps.NearestRoadsRequest(
+                locations=[location_a]
+            )
+            res = api_instance.nearest_roads(req)
+            self.assertGreaterEqual(len(res), 1)
+            self.assertGreaterEqual(len(res[0].edges), 1)
+
+    def testIsochrone(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.RoutingApi(api_client)
+
+            req = stadiamaps.IsochroneRequest(
+                id="isochrone",
+                locations=[location_a],
+                costing=stadiamaps.IsochroneCostingModel.PEDESTRIAN,
+                contours=[
+                    stadiamaps.Contour(time=5, color="aabbcc")
+                ],
+                polygons=True,
+            )
+            res = api_instance.isochrone(req)
+            self.assertEqual(req.id, res.id)
+            self.assertGreaterEqual(len(res.features), 1)
+
+    def testMapMatch(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.RoutingApi(api_client)
+
+            req = stadiamaps.MapMatchRequest(
+                id="map_match",
+                encoded_polyline="_grbgAh~{nhF?lBAzBFvBHxBEtBKdB?fB@dBZdBb@hBh@jBb@x@\\|@x@pB\\x@v@hBl@nBPbCXtBn@|@z@ZbAEbAa@~@q@z@QhA]pAUpAVhAPlAWtASpAAdA[dASdAQhAIlARjANnAZhAf@n@`A?lB^nCRbA\\xB`@vBf@tBTbCFbARzBZvBThBRnBNrBP`CHbCF`CNdCb@vBX`ARlAJfADhA@dAFdAP`AR`Ah@hBd@bBl@rBV|B?vB]tBCvBBhAF`CFnBXtAVxAVpAVtAb@|AZ`Bd@~BJfA@fAHdADhADhABjAGzAInAAjAB|BNbCR|BTjBZtB`@lBh@lB\\|Bl@rBXtBN`Al@g@t@?nAA~AKvACvAAlAMdAU`Ac@hAShAI`AJ`AIdAi@bAu@|@k@p@]p@a@bAc@z@g@~@Ot@Bz@f@X`BFtBXdCLbAf@zBh@fBb@xAb@nATjAKjAW`BI|AEpAHjAPdAAfAGdAFjAv@p@XlAVnA?~A?jAInAPtAVxAXnAf@tBDpBJpBXhBJfBDpAZ|Ax@pAz@h@~@lA|@bAnAd@hAj@tAR~AKxAc@xAShA]hAIdAAjA]~A[v@BhB?dBSv@Ct@CvAI~@Oz@Pv@dAz@lAj@~A^`B^|AXvAVpAXdBh@~Ap@fCh@hB\\zBN`Aj@xBFdA@jALbAPbAJdAHdAJbAHbAHfAJhALbA\\lBTvBAdC@bC@jCKjASbC?`CM`CDpB\\xAj@tB\\fA\\bAVfAJdAJbAXz@L|BO`AOdCDdA@~B\\z@l@v@l@v@l@r@j@t@b@x@b@r@z@jBVfCJdAJdANbCPfCF|BRhBS~BS`AYbAe@~BQdA",
+                costing=stadiamaps.MapMatchCostingModel.PEDESTRIAN,
+                directions_options=stadiamaps.DirectionsOptions(units=stadiamaps.DistanceUnit.MI),
+                linear_references=True,
+            )
+            res = api_instance.map_match(req)
+            self.assertEqual(req.id, res.id)
+            self.assertEqual(0, res.trip.status)
+            self.assertEqual("miles", res.trip.units)
+            self.assertEqual(len(res.trip.legs), 1)
+
+    def testTraceAttributes(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.RoutingApi(api_client)
+
+            req = stadiamaps.TraceAttributesRequest(
+                id="trace",
+                encoded_polyline="_grbgAh~{nhF?lBAzBFvBHxBEtBKdB?fB@dBZdBb@hBh@jBb@x@\\|@x@pB\\x@v@hBl@nBPbCXtBn@|@z@ZbAEbAa@~@q@z@QhA]pAUpAVhAPlAWtASpAAdA[dASdAQhAIlARjANnAZhAf@n@`A?lB^nCRbA\\xB`@vBf@tBTbCFbARzBZvBThBRnBNrBP`CHbCF`CNdCb@vBX`ARlAJfADhA@dAFdAP`AR`Ah@hBd@bBl@rBV|B?vB]tBCvBBhAF`CFnBXtAVxAVpAVtAb@|AZ`Bd@~BJfA@fAHdADhADhABjAGzAInAAjAB|BNbCR|BTjBZtB`@lBh@lB\\|Bl@rBXtBN`Al@g@t@?nAA~AKvACvAAlAMdAU`Ac@hAShAI`AJ`AIdAi@bAu@|@k@p@]p@a@bAc@z@g@~@Ot@Bz@f@X`BFtBXdCLbAf@zBh@fBb@xAb@nATjAKjAW`BI|AEpAHjAPdAAfAGdAFjAv@p@XlAVnA?~A?jAInAPtAVxAXnAf@tBDpBJpBXhBJfBDpAZ|Ax@pAz@h@~@lA|@bAnAd@hAj@tAR~AKxAc@xAShA]hAIdAAjA]~A[v@BhB?dBSv@Ct@CvAI~@Oz@Pv@dAz@lAj@~A^`B^|AXvAVpAXdBh@~Ap@fCh@hB\\zBN`Aj@xBFdA@jALbAPbAJdAHdAJbAHbAHfAJhALbA\\lBTvBAdC@bC@jCKjASbC?`CM`CDpB\\xAj@tB\\fA\\bAVfAJdAJbAXz@L|BO`AOdCDdA@~B\\z@l@v@l@v@l@r@j@t@b@x@b@r@z@jBVfCJdAJdANbCPfCF|BRhBS~BS`AYbAe@~BQdA",
+                costing=stadiamaps.MapMatchCostingModel.PEDESTRIAN,
+                directions_options=stadiamaps.DirectionsOptions(units=stadiamaps.DistanceUnit.MI),
+            )
+            res = api_instance.trace_attributes(req)
+            self.assertEqual(req.id, res.id)
+            self.assertEqual("miles", res.units)
+            self.assertGreaterEqual(len(res.admins), 1)
+            self.assertGreater(len(res.edges), 1)
+            self.assertGreater(len(res.matched_points), 1)
+            self.assertGreater(len(res.shape), 1)

stadiamaps-0.4.0/test/integration/test_gecoding.py

@@ -1,23 +0,0 @@
-import os
-import unittest
-
-import stadiamaps
-
-
-class TestGeocoding(unittest.TestCase):
-    def setUp(self):
-        self.configuration = stadiamaps.Configuration()
-        self.configuration.api_key['ApiKeyAuth'] = os.environ["STADIA_API_KEY"]
-
-    def tearDown(self):
-        pass
-
-    def testAutocomplete(self):
-        with stadiamaps.ApiClient(self.configuration) as api_client:
-            # Create an instance of the API class
-            api_instance = stadiamaps.GeocodingApi(api_client)
-            text = 'Põhja pst 27a'  # str | The place name (address, venue name, etc.) to search for.
-
-            # Search and geocode quickly based on partial input.
-            api_response = api_instance.autocomplete(text)
-            self.assertEqual("Estonia", api_response.features[0].properties.country)