stadiamaps 4.0.0__py3-none-any.whl → 6.0.0__py3-none-any.whl

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/models/pelias_response_geocoding.py

@@ -1,89 +0,0 @@
-# coding: utf-8
-
-"""
-    Stadia Maps Geospatial APIs
-
-    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.  # noqa: E501
-
-    The version of the OpenAPI document: 5.0.6
-    Contact: support@stadiamaps.com
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-
-from typing import Any, Dict, List, Optional
-from pydantic import BaseModel, Field, StrictStr, conlist
-
-class PeliasResponseGeocoding(BaseModel):
-    """
-    PeliasResponseGeocoding
-    """
-    attribution: Optional[StrictStr] = Field(None, description="A URL containing attribution information. If you are not using Stadia Maps and our standard attribution already for your basemaps, you must include this attribution link somewhere in your website/app.")
-    query: Optional[Dict[str, Any]] = Field(None, description="Technical details of the query. This is most useful for debugging during development. See the full example for the list of properties; these should be self-explanatory, so we don't enumerate them in the spec.")
-    warnings: Optional[conlist(StrictStr)] = Field(None, description="An array of non-critical warnings. This is normally for informational/debugging purposes and not a serious problem.")
-    errors: Optional[conlist(StrictStr)] = Field(None, description="An array of more serious errors (for example, omitting a required parameter). Don’t ignore these.")
-    additional_properties: Dict[str, Any] = {}
-    __properties = ["attribution", "query", "warnings", "errors"]
-
-    class Config:
-        """Pydantic configuration"""
-        allow_population_by_field_name = True
-        validate_assignment = True
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.dict(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> PeliasResponseGeocoding:
-        """Create an instance of PeliasResponseGeocoding from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self):
-        """Returns the dictionary representation of the model using alias"""
-        _dict = self.dict(by_alias=True,
-                          exclude={
-                            "additional_properties"
-                          },
-                          exclude_none=True)
-        # puts key-value pairs in additional_properties in the top level
-        if self.additional_properties is not None:
-            for _key, _value in self.additional_properties.items():
-                _dict[_key] = _value
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: dict) -> PeliasResponseGeocoding:
-        """Create an instance of PeliasResponseGeocoding from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return PeliasResponseGeocoding.parse_obj(obj)
-
-        _obj = PeliasResponseGeocoding.parse_obj({
-            "attribution": obj.get("attribution"),
-            "query": obj.get("query"),
-            "warnings": obj.get("warnings"),
-            "errors": obj.get("errors")
-        })
-        # store additional fields in additional_properties
-        for _key in obj.keys():
-            if _key not in cls.__properties:
-                _obj.additional_properties[_key] = obj.get(_key)
-
-        return _obj
-

stadiamaps/models/route_response_trip.py

@@ -1,117 +0,0 @@
-# coding: utf-8
-
-"""
-    Stadia Maps Geospatial APIs
-
-    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.  # noqa: E501
-
-    The version of the OpenAPI document: 5.0.6
-    Contact: support@stadiamaps.com
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-
-from typing import List
-from pydantic import BaseModel, Field, StrictInt, StrictStr, conlist
-from stadiamaps.models.route_leg import RouteLeg
-from stadiamaps.models.route_summary import RouteSummary
-from stadiamaps.models.routing_response_waypoint import RoutingResponseWaypoint
-from stadiamaps.models.valhalla_languages import ValhallaLanguages
-from stadiamaps.models.valhalla_long_units import ValhallaLongUnits
-
-class RouteResponseTrip(BaseModel):
-    """
-    RouteResponseTrip
-    """
-    status: StrictInt = Field(..., description="The response status code")
-    status_message: StrictStr = Field(..., description="The response status message")
-    units: ValhallaLongUnits = Field(...)
-    language: ValhallaLanguages = Field(...)
-    locations: conlist(RoutingResponseWaypoint) = Field(...)
-    legs: conlist(RouteLeg) = Field(...)
-    summary: RouteSummary = Field(...)
-    additional_properties: Dict[str, Any] = {}
-    __properties = ["status", "status_message", "units", "language", "locations", "legs", "summary"]
-
-    class Config:
-        """Pydantic configuration"""
-        allow_population_by_field_name = True
-        validate_assignment = True
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.dict(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> RouteResponseTrip:
-        """Create an instance of RouteResponseTrip from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self):
-        """Returns the dictionary representation of the model using alias"""
-        _dict = self.dict(by_alias=True,
-                          exclude={
-                            "additional_properties"
-                          },
-                          exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of each item in locations (list)
-        _items = []
-        if self.locations:
-            for _item in self.locations:
-                if _item:
-                    _items.append(_item.to_dict())
-            _dict['locations'] = _items
-        # override the default output from pydantic by calling `to_dict()` of each item in legs (list)
-        _items = []
-        if self.legs:
-            for _item in self.legs:
-                if _item:
-                    _items.append(_item.to_dict())
-            _dict['legs'] = _items
-        # override the default output from pydantic by calling `to_dict()` of summary
-        if self.summary:
-            _dict['summary'] = self.summary.to_dict()
-        # puts key-value pairs in additional_properties in the top level
-        if self.additional_properties is not None:
-            for _key, _value in self.additional_properties.items():
-                _dict[_key] = _value
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: dict) -> RouteResponseTrip:
-        """Create an instance of RouteResponseTrip from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return RouteResponseTrip.parse_obj(obj)
-
-        _obj = RouteResponseTrip.parse_obj({
-            "status": obj.get("status"),
-            "status_message": obj.get("status_message"),
-            "units": obj.get("units"),
-            "language": obj.get("language"),
-            "locations": [RoutingResponseWaypoint.from_dict(_item) for _item in obj.get("locations")] if obj.get("locations") is not None else None,
-            "legs": [RouteLeg.from_dict(_item) for _item in obj.get("legs")] if obj.get("legs") is not None else None,
-            "summary": RouteSummary.from_dict(obj.get("summary")) if obj.get("summary") is not None else None
-        })
-        # store additional fields in additional_properties
-        for _key in obj.keys():
-            if _key not in cls.__properties:
-                _obj.additional_properties[_key] = obj.get(_key)
-
-        return _obj
-

stadiamaps/models/trace_attributes_response_all_of.py

@@ -1,96 +0,0 @@
-# coding: utf-8
-
-"""
-    Stadia Maps Geospatial APIs
-
-    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.  # noqa: E501
-
-    The version of the OpenAPI document: 5.0.6
-    Contact: support@stadiamaps.com
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-
-from typing import List, Optional
-from pydantic import BaseModel, Field, StrictStr, conlist
-from stadiamaps.models.trace_attributes_base_response import TraceAttributesBaseResponse
-from stadiamaps.models.valhalla_long_units import ValhallaLongUnits
-
-class TraceAttributesResponseAllOf(BaseModel):
-    """
-    TraceAttributesResponseAllOf
-    """
-    id: Optional[StrictStr] = Field(None, description="An identifier to disambiguate requests (echoed by the server).")
-    units: Optional[ValhallaLongUnits] = None
-    alternate_paths: Optional[conlist(TraceAttributesBaseResponse)] = Field(None, description="Alternate paths, if any, that were not classified as the best match.")
-    additional_properties: Dict[str, Any] = {}
-    __properties = ["id", "units", "alternate_paths"]
-
-    class Config:
-        """Pydantic configuration"""
-        allow_population_by_field_name = True
-        validate_assignment = True
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.dict(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> TraceAttributesResponseAllOf:
-        """Create an instance of TraceAttributesResponseAllOf from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self):
-        """Returns the dictionary representation of the model using alias"""
-        _dict = self.dict(by_alias=True,
-                          exclude={
-                            "additional_properties"
-                          },
-                          exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of each item in alternate_paths (list)
-        _items = []
-        if self.alternate_paths:
-            for _item in self.alternate_paths:
-                if _item:
-                    _items.append(_item.to_dict())
-            _dict['alternate_paths'] = _items
-        # puts key-value pairs in additional_properties in the top level
-        if self.additional_properties is not None:
-            for _key, _value in self.additional_properties.items():
-                _dict[_key] = _value
-
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: dict) -> TraceAttributesResponseAllOf:
-        """Create an instance of TraceAttributesResponseAllOf from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return TraceAttributesResponseAllOf.parse_obj(obj)
-
-        _obj = TraceAttributesResponseAllOf.parse_obj({
-            "id": obj.get("id"),
-            "units": obj.get("units"),
-            "alternate_paths": [TraceAttributesBaseResponse.from_dict(_item) for _item in obj.get("alternate_paths")] if obj.get("alternate_paths") is not None else None
-        })
-        # store additional fields in additional_properties
-        for _key in obj.keys():
-            if _key not in cls.__properties:
-                _obj.additional_properties[_key] = obj.get(_key)
-
-        return _obj
-

stadiamaps-4.0.0.dist-info/METADATA

@@ -1,79 +0,0 @@
-Metadata-Version: 2.1
-Name: stadiamaps
-Version: 4.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 <2.1.0,>=1.25.3
-Requires-Dist: python-dateutil
-Requires-Dist: pydantic >=2
-Requires-Dist: typing-extensions >=4.7.1
-
-
-# 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)
-```
-