stadiamaps 5.0.0__py3-none-any.whl → 6.1.0__py3-none-any.whl

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 27")
+            self.assertEqual("Estonia", res.features[0].properties.country)
+            self.assertEqual("address", res.features[0].properties.layer)

test/integration/test_gecoding.py

@@ -0,0 +1,136 @@
+import os
+import unittest
+
+import stadiamaps
+
+address = "Põhja pst 27"
+
+
+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 testAutocompleteV1(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.autocomplete(text=address)
+            self.assertEqual("Estonia", res.features[0].properties.country)
+            self.assertEqual("address", res.features[0].properties.layer)
+
+    def testAutocompleteV2(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.autocomplete_v2(text=address)
+            self.assertEqual(None, res.features[0].properties.context)
+            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=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)
+
+    def testReverseV2(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.reverse_v2(59.444351, 24.750645)
+            self.assertEqual("EST", res.features[0].properties.context.iso_3166_a3)
+
+    def testReverseWithLayerFilter(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.reverse(59.444351, 24.750645,
+                                       layers=[stadiamaps.GeocodingLayer.ADDRESS, stadiamaps.GeocodingLayer.OCEAN])
+            self.assertEqual("Estonia", res.features[0].properties.country)
+            self.assertEqual("address", res.features[0].properties.layer)
+
+    def testReverseWithLayerFilterV2(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.reverse_v2(59.444351, 24.750645,
+                                          layers=[stadiamaps.LayerId.ADDRESS, stadiamaps.LayerId.OCEAN])
+            self.assertEqual("EST", res.features[0].properties.context.iso_3166_a3)
+            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 testReverseUncommonLayerV2(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_v2(24.750645, 59.444351)
+            self.assertEqual("marinearea", res.features[0].properties.layer)
+
+    def testPlaceV1(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.place_details(["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)
+
+    def testPlaceV2(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.place_details_v2(["openstreetmap:address:way/109867749"])
+            self.assertEqual(1, len(res.features))
+            self.assertEqual("Estonia", res.features[0].properties.context.whosonfirst.country.name)
+            self.assertEqual("EST", res.features[0].properties.context.iso_3166_a3)
+            self.assertEqual("address", res.features[0].properties.layer)
+
+    def testBulk(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.GeocodingApi(api_client)
+
+            res = api_instance.search_bulk([
+                stadiamaps.BulkRequest(endpoint="/v1/search",
+                                       query=stadiamaps.BulkRequestQuery(stadiamaps.SearchQuery(text=address))),
+                stadiamaps.BulkRequest(endpoint="/v1/search/structured",
+                                       query=stadiamaps.BulkRequestQuery(stadiamaps.SearchStructuredQuery(
+                                           address=address,
+                                           country="EE",
+                                           layers=[
+                                               stadiamaps.GeocodingLayer.COARSE,
+                                               stadiamaps.GeocodingLayer.ADDRESS]))),
+            ])
+
+            self.assertEqual(2, len(res))
+            for rec in res:
+                self.assertEqual(200, rec.status)
+                self.assertEqual("Estonia", rec.response.features[0].properties.country)
+                self.assertEqual("address", rec.response.features[0].properties.layer)

test/integration/test_geospatial.py

@@ -0,0 +1,43 @@
+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)], range=False)
+            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)
+
+    def testElevationRange(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)], range=True)
+            res = api_instance.elevation(req)
+            self.assertEqual(req.id, res.id)
+            self.assertGreaterEqual(len(res.range_height), 1)
+            self.assertEqual(res.range_height[0][0], 0)  # This is always zero for the first element
+            self.assertGreaterEqual(res.range_height[0][1], 1)
+            self.assertEqual(res.shape, req.shape)

test/integration/test_routing.py

@@ -0,0 +1,282 @@
+import os
+import unittest
+
+import stadiamaps
+from stadiamaps import AnnotationFilters
+
+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=0.7)),
+                units=stadiamaps.DistanceUnit.MI,
+            )
+
+            res = api_instance.route(req).actual_instance
+            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)
+            self.assertEqual(len(res.alternates or []), 0)
+
+    def testNavigationRoute(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=0.7)),
+                units=stadiamaps.DistanceUnit.MI,
+                format="osrm",
+                banner_instructions=True,
+                filters=AnnotationFilters(action="include", attributes=["shape_attributes.speed_limit"])
+            )
+
+            res = api_instance.route(req).actual_instance
+            self.assertEqual("Ok", res.code)
+            self.assertEqual(len(res.routes), 1)
+            has_banner_instructions = False
+            for step in res.routes[0].legs[0].steps:
+                if len(step.banner_instructions) > 0:
+                    has_banner_instructions = True
+
+            self.assertTrue(has_banner_instructions)
+
+    def testRouteWithAlternates(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=0.7)),
+                units=stadiamaps.DistanceUnit.MI,
+                alternates=1,
+            )
+
+            res = api_instance.route(req).actual_instance
+            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)
+            self.assertEqual(len(res.alternates), 1)
+
+    def testRouteWithElevation(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=0.7)),
+                units=stadiamaps.DistanceUnit.MI,
+                elevation_interval=30,
+            )
+
+            res = api_instance.route(req).actual_instance
+            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)
+            self.assertGreater(len(res.trip.legs[0].elevation), 1)
+
+    def testHybridBicycleRoute(self):
+        # Regression test for user-reported issue
+        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.BICYCLE,
+                costing_options=stadiamaps.CostingOptions(
+                    bicycle=stadiamaps.BicycleCostingOptions(bicycle_type='Hybrid', use_roads=0.4, use_hills=0.6)),
+                units=stadiamaps.DistanceUnit.KM,
+            )
+
+            res = api_instance.route(req).actual_instance
+            self.assertEqual(req.id, res.id)
+            self.assertEqual(0, res.trip.status)
+            self.assertEqual("kilometers", 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),
+                    stadiamaps.Coordinate.from_dict(location_a),
+                ],
+                costing=stadiamaps.MatrixCostingModel.AUTO,
+                costing_options=stadiamaps.CostingOptions(auto=stadiamaps.AutoCostingOptions(use_tolls=0.7)),
+                units=stadiamaps.DistanceUnit.MI,
+            )
+
+            res = api_instance.optimized_route(req).actual_instance
+            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.MatrixWaypoint.from_dict(location_a),
+                ],
+                targets=[
+                    stadiamaps.MatrixWaypoint.from_dict(location_b),
+                    stadiamaps.MatrixWaypoint.from_dict(location_c),
+                ],
+                costing=stadiamaps.MatrixCostingModel.PEDESTRIAN,
+            )
+
+            res = api_instance.time_distance_matrix(req)
+            self.assertEqual(req.id, res.id)
+            self.assertEqual(len(req.sources), len(res.sources))
+            self.assertEqual(len(req.targets), len(res.targets))
+            self.assertGreater(len(res.sources_to_targets[0]), 1)
+            self.assertEqual("kilometers", res.units)
+
+    def testTimeDistanceMatrixWithUnroutableLegs(self):
+        with stadiamaps.ApiClient(self.configuration) as api_client:
+            api_instance = stadiamaps.RoutingApi(api_client)
+
+            # At least one of these is not routable; make sure we handle it gracefully
+            req = stadiamaps.MatrixRequest(
+                id="matrix",
+                sources=[
+                    stadiamaps.MatrixWaypoint.from_dict({
+                        "lon": 22.726262,
+                        "lat": 58.891957
+                    }),
+                    stadiamaps.MatrixWaypoint.from_dict({
+                        "lon": 23.762758,
+                        "lat": 59.1558
+                    }),
+                ],
+                targets=[
+                    stadiamaps.MatrixWaypoint.from_dict({
+                        "lon": 23.846605,
+                        "lat": 59.176153
+                    }),
+                    stadiamaps.MatrixWaypoint.from_dict({
+                        "lon": 23.096114,
+                        "lat": 59.562853
+                    }),
+                ],
+                costing=stadiamaps.MatrixCostingModel.BICYCLE,
+            )
+
+            res = api_instance.time_distance_matrix(req)
+            self.assertEqual(req.id, res.id)
+            self.assertEqual(len(req.sources), len(res.sources))
+            self.assertGreater(len(res.sources_to_targets[0]), 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=[stadiamaps.Coordinate.from_dict(loc) for loc in (location_a, location_b, location_c)]
+            )
+            res = api_instance.nearest_roads(req)
+            self.assertEqual(len(res), 3)
+            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=[stadiamaps.Coordinate.from_dict(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,
+                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="ge~jkAbakppC_AJ}_@hEsCZiCXuo@dH{l@pGuaBtPjBr`@`Bt]bDpu@FbDy@fEcAjEgOja@_BfE]zDoIzTaF~MwLtZsDjJwJ~ViF`N_DjI_AzBcDbIsJ~UqIvSqLvYoAzCwJdVmLjY_DzH_FzLuYls@aYhr@Uj@iCpGu@jBmLjYeJ~T_C|FoBzEkGrO}FtNaFxGkHpQeArHcGbOeEfK}D`K}Shi@uWxp@gMv[wBnFiAtCmMl[aB`EoKrW}Mj\\kDlI}K~WeBdEeHxPgF~LiBjE{BnF_EpJsD|I}Rte@sNp]Uj@aQ|b@w^||@_EtJi^`_AaC~F}Qnc@cHlOgA~B}DnIqG~M_NbXeO~X{O~X}\\nl@oFjJyRt\\iJ|NiGxJ{KbPeLtO_HhIyGjI_GbHc]v_@mNnOgWdYcFvFsGtFkBiEWg@cAfAqBnBnCnFaErDiTlSiWdV_O~N{QrOcFrE{IjIaGrC}G|IeEbGwDdGeDfGsDtHmDbIgI~SyEdMaBpEeB|E_BnEsLl\\qLj\\nxAfoA`Lr`ApB|Rz@`Lr@nLp@tJfCzW~Fhi@r@bGv@tF`AnFdA|ErA~EzAxE~BzF|I`SjAxC|@nCl@zB`@lBXtBPhBJ`BDfB@dDCjDGxDqIv}BUrIKpFE|C@|CFhD`@nM`@lJPnDJhAdkA|fMob@i`@gAZfEhgAT|FpDvEnKISjr@pHfe@dHjCvM{F{Lak@q@mZq[bbC~OnAvRvWcHrVzK`GzH}TxGdDoDrKyHlVwG`TvGaTfI|EnBxBZvBGj]AnDAlC\\lB~K~ZtoAlEuExOy@bFi@xHFxF^fEl@rDfBxGbC~GjEdKjQbm@oG|YvBpFrMbV~GlMlGtJtFlHlEjFnGtJzDjGzDvHjBtFrD`IzB`DzD~ClDjBzDjCzChAjD~@?vF^tHx@vGpA~DbB`CpBhArCSrDk@dEkAxB_AbC_BpBkB`@K`B]pFp@fDx@tDh@`BHrCJ~CKd@S`Bk@fAcA`AtP`UxCcAfUsChq@wBSkBSiB[}BiAwMbOvMcO|BhAhBZjBRvBRwC`o@g@vJjBeC~@c@tAz@xF`NnX~p@zAlDtAvA|Bv@xBQ??fo@vsBJhDpc@`aDhBrHzCtHzHtP}Vz_@iFjIiFpIoEbIaJnPzf@d_BuAlQiA~^qd@|dMcCru@G|Cq@|^]z_@LnV^x]RtHd@xP`Bdb@pCbStApIpAjFdCnHlCtFtBlDxDxEdBfBnCnC`~B`yMhA`A|bHvr`@~CxVbF_A~a@yJbS}EvDXdM|AvJ{F{gAjtDgCddC|f@jyDbEtPxuG|scBsDxMahGvkYlXhT`DvCfChC|BjCfBlC|C`GvDdI~_@jbAhJ`Vt|AltGoH~FcTdLqDlA}Af@zhAgl@jEzSnCnNnCjOfBnL~C`XfA~J|@`Kj@hJXtHzAtm@v@xSZrEh@pDdApDfDxFaDxDiA`DG~FpBz^v@tL~@hIt@jDhAdDpYxf@feAbhB{]va@iPuXaBeD`BdDhPtX{JjM~Jz]|@TvPaOjJ~OvNtV|N|Vla@xr@zWjd@fAjBkGlHuUnXqB`CaFgIoK_QmF`HuJcPiFfHo@~BUtBFtA`@zAdA~AfQ|Vb@p@|@rJcCrCxQ|YhmNn`hAk@zECnEbV`x@dBnBlGdAlCX|m@o[tBkDdAoFf@mCdMwGvE~NzGhLzDxE}FtIcC|Bcu@xq@eBzCe@hC~x@t~ElhZpalAln@mSAjKp@pJyKpBqSxHh|KdwX~eMnjv@B_BV_BXeAt@y@fLaChRwBdO]tKXpN~Cz[`N_A`CcArIjC|qAUjHmAnG}BzEyDxDyeAli@hoDxhMpHxEaBdMh@jN~I``@jLpk@v@~D~e@nqE|@`ChBlCRzAP`B|CvHl\\yNlT{HCnGLvBxFn[fBzJ~A|IzAnGpBrGrCvFnOtVfEdIhEvJhBpFiLpH{d@fZiAdE\\hF`tDtzJCFzt@lg@mCpIiDtKhDuKlCqIrD_MbNid@sY}Q{LiJkIqHHaI]wEX{H|AwG`HaNnBzBtLjK`MxIbNrI`e@xYxKjJpIrI~HrKzG`NzErKtDdL~C`OdCtOhFvj@mLdC[F|SxzB~LyBzAxPhChYl@`E`AbExAdDjBxC|BvBtBfBlCpAdDz@nDl@|D^pGf@lSzAxIn@kAxScA|QTvAf@~AdNtSrg@taCfAxGyHfF{KdHiAp@vc@rrBw@hOk@|K~bBh|W~CnHfF`GdMnGpH`AlIm@nh@kL~gAfrOCbMbAbMD`@~@pRMhLNrRaBbB?fLvG`@zC\\|I~@SrOI`FzAfGoKpJqKpJ}@pLjPf\\rFT`H}AhBjA|HXClFyAdHuD~Jm\\oDsUkAwM]eMxrBqLvcCoC|{@e@jk@rBrjD`Ar|CJz{C[l~B[|nA_ExnAgGds@wGxd@}G~f@mDvSkDpTsArIuNd~@cGxi@sHxcAy@bWcAfl@y@|m@aBhz@sAbp@[hNIbDqCncBuDn|CaA~pAEvJn@bnApAtaA`@dZfErr@xDrh@`Du@|EiEp@cEfBcF^|EsAzIaFbFcFnBdEbi@h@~GpFf@n@hA^rCnBb[qALkHj@NdKFhGkAvc@e@fFuB`LiAjG_Phw@q@fDwIrb@Ev@dCdJlBdCnC~@dFDwB~AbCdGfE`J}B~Km@lD?lArAdFcEdHoDzGyFrJpXlw@rCOpCIbA`@dAdA|CrJvBlBtB@~D{AjB]~A^dBdDeAdAuGdFzElOte@b{AhAlF~@hEdQzk@zGpV`BhK|@|HdArGlBhGmAlAiMdH`EfYjInObG|E~K|EfGrB`P~D_IxD_HdBeErBn@pn@KfKPpFl@xAbBjBnC~Vl@pFdG|b@iFbBzNjcApZjiBzd@vmCvL~s@tHiCdFh]pBnKpAlI`S|iAbBzJhIoDpL~r@jXuJvDvKqEzDkBp@pCpKyPlKkHbEyHdFlDtV~DjUbDvRsEpDeBoJeCoN[dQsAfMuDpImH`GiE`Dqf@zv@}a@vq@iDlMib@br@oRvYyIrNi[vg@cC|DqDvPoS~dCgLre@mJ|RkEjHkIpKuJ|HkOfJse@bXg^|Qy^~ZiH`JeC`DeNhYw@~AkGdS{Gt]mGtr@gGbr@wAlh@mBdgAa@vUqD|oA{K~zCcLfxAaBrX`NbEvMlRwMmRaNcEGnA_@dMCnB?hU@fJTfL^bJfFSbC_EcC~DfJa@gJ`@gFR\\|Q^zSR`KYz[Izc@CdJK|[C~Mg@~N_@fN}@bQ}Ktt@aBvKyiFy}JgP|Uqg@ds@mD|D_yAhaByB`GgB|HaAtF[dH?hFH|HjAxGxBxG`CvDnXp^`PaX~HcJrp@_p@",
+                costing=stadiamaps.MapMatchCostingModel.PEDESTRIAN,
+                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-5.0.0.dist-info/METADATA

@@ -1,87 +0,0 @@
-Metadata-Version: 2.2
-Name: stadiamaps
-Version: 5.0.0
-Summary: Stadia Maps Geospatial APIs
-Home-page: https://github.com/stadiamaps/stadiamaps-api-py
-Author: Stadia Maps Support
-Author-email: support@stadiamaps.com
-Keywords: OpenAPI,OpenAPI-Generator,Stadia Maps Geospatial APIs
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: urllib3<3.0.0,>=1.25.3
-Requires-Dist: python-dateutil>=2.8.2
-Requires-Dist: pydantic>=2
-Requires-Dist: typing-extensions>=4.7.1
-Dynamic: author
-Dynamic: author-email
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: requires-dist
-Dynamic: summary
-
-
-# Stadia Maps Python API Client
-
-The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
-
-For more information about the API, please visit [https://docs.stadiamaps.com](https://docs.stadiamaps.com)
-
-## Installation & Usage
-### pip install
-
-```shell
-pip install stadiamaps
-```
-
-### Setuptools
-
-Install via [Setuptools](http://pypi.python.org/pypi/setuptools).
-
-```shell
-python setup.py install --user
-```
-(or `sudo python setup.py install` to install the package for all users)
-
-### Tests
-
-Execute `pytest` to run the tests. These are run automatically via CI.
-
-## Getting Started
-
-Please follow the [installation procedure](#installation--usage) and then run the following:
-
-```python
-import os
-import stadiamaps
-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 like so:
-# configuration = stadiamaps.Configuration(host="https://api-eu.stadiamaps.com")
-# See configuration.py for a list of all supported configuration parameters.
-configuration = stadiamaps.Configuration()
-
-# Configure API key authorization. This example assumes it is injected via an environment
-# variable.
-configuration.api_key['ApiKeyAuth'] = os.environ["API_KEY"]
-
-# Enter a context with an instance of the API client
-with stadiamaps.ApiClient(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.
-
-    try:
-        # Search and geocode quickly based on partial input.
-        api_response = api_instance.autocomplete(text)
-        print("The response of GeocodingApi->autocomplete:
-")
-        pprint(api_response)
-    except ApiException as e:
-        print("Exception when calling GeocodingApi->autocomplete: %s
-" % e)
-```
-