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

stadiamaps/models/osrm_route.py

@@ -0,0 +1,119 @@
+# coding: utf-8
+
+"""
+    Stadia Maps Geospatial APIs
+
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
+
+    The version of the OpenAPI document: 7.0.0
+    Contact: support@stadiamaps.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from stadiamaps.models.osrm_route_leg import OsrmRouteLeg
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmRoute(BaseModel):
+    """
+    OsrmRoute
+    """ # noqa: E501
+    distance: Union[StrictFloat, StrictInt] = Field(description="The distance traveled by the route, in meters.")
+    duration: Union[StrictFloat, StrictInt] = Field(description="The estimated travel time, in number of seconds.")
+    geometry: StrictStr = Field(description="An encoded polyline (https://developers.google.com/maps/documentation/utilities/polylinealgorithm).")
+    weight: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The total cost of the route computed by the routing engine.")
+    weight_name: Optional[StrictStr] = Field(default=None, description="The costing model used for the route.")
+    legs: List[OsrmRouteLeg]
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["distance", "duration", "geometry", "weight", "weight_name", "legs"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OsrmRoute from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in legs (list)
+        _items = []
+        if self.legs:
+            for _item_legs in self.legs:
+                if _item_legs:
+                    _items.append(_item_legs.to_dict())
+            _dict['legs'] = _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: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OsrmRoute from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "distance": obj.get("distance"),
+            "duration": obj.get("duration"),
+            "geometry": obj.get("geometry"),
+            "weight": obj.get("weight"),
+            "weight_name": obj.get("weight_name"),
+            "legs": [OsrmRouteLeg.from_dict(_item) for _item in obj["legs"]] if obj.get("legs") 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/osrm_route_leg.py

@@ -0,0 +1,148 @@
+# coding: utf-8
+
+"""
+    Stadia Maps Geospatial APIs
+
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
+
+    The version of the OpenAPI document: 7.0.0
+    Contact: support@stadiamaps.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from stadiamaps.models.osrm_admin import OsrmAdmin
+from stadiamaps.models.osrm_annotation import OsrmAnnotation
+from stadiamaps.models.osrm_route_step import OsrmRouteStep
+from stadiamaps.models.osrm_via_waypoint import OsrmViaWaypoint
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmRouteLeg(BaseModel):
+    """
+    OsrmRouteLeg
+    """ # noqa: E501
+    distance: Union[StrictFloat, StrictInt] = Field(description="The distance traveled by the route, in meters.")
+    duration: Union[StrictFloat, StrictInt] = Field(description="The estimated travel time, in number of seconds.")
+    weight: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The total cost of the leg computed by the routing engine.")
+    summary: Optional[StrictStr] = None
+    steps: List[OsrmRouteStep]
+    annotation: Optional[OsrmAnnotation] = None
+    via_waypoints: Optional[List[OsrmViaWaypoint]] = Field(default=None, description="Indicates which waypoints are passed through rather than creating a new leg.")
+    admins: Optional[List[OsrmAdmin]] = Field(default=None, description="Administrative regions visited along the leg.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["distance", "duration", "weight", "summary", "steps", "annotation", "via_waypoints", "admins"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OsrmRouteLeg from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in steps (list)
+        _items = []
+        if self.steps:
+            for _item_steps in self.steps:
+                if _item_steps:
+                    _items.append(_item_steps.to_dict())
+            _dict['steps'] = _items
+        # override the default output from pydantic by calling `to_dict()` of annotation
+        if self.annotation:
+            _dict['annotation'] = self.annotation.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in via_waypoints (list)
+        _items = []
+        if self.via_waypoints:
+            for _item_via_waypoints in self.via_waypoints:
+                if _item_via_waypoints:
+                    _items.append(_item_via_waypoints.to_dict())
+            _dict['via_waypoints'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in admins (list)
+        _items = []
+        if self.admins:
+            for _item_admins in self.admins:
+                if _item_admins:
+                    _items.append(_item_admins.to_dict())
+            _dict['admins'] = _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
+
+        # set to None if via_waypoints (nullable) is None
+        # and model_fields_set contains the field
+        if self.via_waypoints is None and "via_waypoints" in self.model_fields_set:
+            _dict['via_waypoints'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OsrmRouteLeg from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "distance": obj.get("distance"),
+            "duration": obj.get("duration"),
+            "weight": obj.get("weight"),
+            "summary": obj.get("summary"),
+            "steps": [OsrmRouteStep.from_dict(_item) for _item in obj["steps"]] if obj.get("steps") is not None else None,
+            "annotation": OsrmAnnotation.from_dict(obj["annotation"]) if obj.get("annotation") is not None else None,
+            "via_waypoints": [OsrmViaWaypoint.from_dict(_item) for _item in obj["via_waypoints"]] if obj.get("via_waypoints") is not None else None,
+            "admins": [OsrmAdmin.from_dict(_item) for _item in obj["admins"]] if obj.get("admins") 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/osrm_route_response.py

@@ -0,0 +1,132 @@
+# coding: utf-8
+
+"""
+    Stadia Maps Geospatial APIs
+
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
+
+    The version of the OpenAPI document: 7.0.0
+    Contact: support@stadiamaps.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from stadiamaps.models.osrm_route import OsrmRoute
+from stadiamaps.models.osrm_waypoint import OsrmWaypoint
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmRouteResponse(BaseModel):
+    """
+    OsrmRouteResponse
+    """ # noqa: E501
+    code: StrictStr
+    message: Optional[StrictStr] = None
+    data_version: Optional[StrictStr] = None
+    waypoints: Optional[List[OsrmWaypoint]] = None
+    routes: Optional[List[OsrmRoute]] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["code", "message", "data_version", "waypoints", "routes"]
+
+    @field_validator('code')
+    def code_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['Ok', 'InvalidUrl', 'InvalidService', 'InvalidVersion', 'InvalidOptions', 'InvalidQuery', 'InvalidValue', 'NoSegment', 'TooBig', 'NoRoute', 'NoTable', 'NotImplemented', 'NoTrips']):
+            raise ValueError("must be one of enum values ('Ok', 'InvalidUrl', 'InvalidService', 'InvalidVersion', 'InvalidOptions', 'InvalidQuery', 'InvalidValue', 'NoSegment', 'TooBig', 'NoRoute', 'NoTable', 'NotImplemented', 'NoTrips')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OsrmRouteResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in waypoints (list)
+        _items = []
+        if self.waypoints:
+            for _item_waypoints in self.waypoints:
+                if _item_waypoints:
+                    _items.append(_item_waypoints.to_dict())
+            _dict['waypoints'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in routes (list)
+        _items = []
+        if self.routes:
+            for _item_routes in self.routes:
+                if _item_routes:
+                    _items.append(_item_routes.to_dict())
+            _dict['routes'] = _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: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OsrmRouteResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "code": obj.get("code"),
+            "message": obj.get("message"),
+            "data_version": obj.get("data_version"),
+            "waypoints": [OsrmWaypoint.from_dict(_item) for _item in obj["waypoints"]] if obj.get("waypoints") is not None else None,
+            "routes": [OsrmRoute.from_dict(_item) for _item in obj["routes"]] if obj.get("routes") 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/osrm_route_step.py

@@ -0,0 +1,185 @@
+# coding: utf-8
+
+"""
+    Stadia Maps Geospatial APIs
+
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
+
+    The version of the OpenAPI document: 7.0.0
+    Contact: support@stadiamaps.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from stadiamaps.models.osrm_banner_instruction import OsrmBannerInstruction
+from stadiamaps.models.osrm_intersection import OsrmIntersection
+from stadiamaps.models.osrm_step_maneuver import OsrmStepManeuver
+from stadiamaps.models.osrm_voice_instruction import OsrmVoiceInstruction
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OsrmRouteStep(BaseModel):
+    """
+    A maneuver such as a turn or merge, followed by travel along a single road or path.
+    """ # noqa: E501
+    distance: Union[StrictFloat, StrictInt] = Field(description="The distance traveled by the route, in meters.")
+    duration: Union[StrictFloat, StrictInt] = Field(description="The estimated travel time, in number of seconds.")
+    geometry: StrictStr = Field(description="An encoded polyline (https://developers.google.com/maps/documentation/utilities/polylinealgorithm) with 6 digits of decimal precision.")
+    weight: Optional[Union[StrictFloat, StrictInt]] = None
+    name: Optional[StrictStr] = Field(default=None, description="The name of the segment (ex: road) being traversed")
+    ref: Optional[StrictStr] = Field(default=None, description="A reference number of code for the segment being traversed.")
+    pronunciation: Optional[StrictStr] = Field(default=None, description="Pronunciation of the name (if available). The format of this varies by implementation/vendor.")
+    destinations: Optional[StrictStr] = None
+    exits: Optional[StrictStr] = None
+    mode: StrictStr = Field(description="The mode of travel.")
+    maneuver: OsrmStepManeuver
+    intersections: Optional[List[OsrmIntersection]] = None
+    rotary_name: Optional[StrictStr] = Field(default=None, description="The name of the traffic circle.")
+    rotary_pronunciation: Optional[StrictStr] = Field(default=None, description="Pronunciation of the rotary name (if available). The format of this varies by implementation/vendor.")
+    driving_side: Optional[StrictStr] = Field(default=None, description="The side of the road on which driving is legal for this step.")
+    voice_instructions: Optional[List[OsrmVoiceInstruction]] = Field(default=None, description="A list of announcements which should be spoken at various points along the maneuver.", alias="voiceInstructions")
+    banner_instructions: Optional[List[OsrmBannerInstruction]] = Field(default=None, description="A list of announcements which should be displayed prominently on screen at various points along the maneuver.", alias="bannerInstructions")
+    speed_limit_sign: Optional[StrictStr] = Field(default=None, description="The style of speed limit signs used along the step.", alias="speedLimitSign")
+    speed_limit_unit: Optional[StrictStr] = Field(default=None, description="The unit of measure that is used locally along the step. This may be different from the unit used in maxspeed annotations, and is provided so that apps can localize their display.", alias="speedLimitUnit")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["distance", "duration", "geometry", "weight", "name", "ref", "pronunciation", "destinations", "exits", "mode", "maneuver", "intersections", "rotary_name", "rotary_pronunciation", "driving_side", "voiceInstructions", "bannerInstructions", "speedLimitSign", "speedLimitUnit"]
+
+    @field_validator('driving_side')
+    def driving_side_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['left', 'right']):
+            raise ValueError("must be one of enum values ('left', 'right')")
+        return value
+
+    @field_validator('speed_limit_sign')
+    def speed_limit_sign_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['mutcd', 'vienna']):
+            raise ValueError("must be one of enum values ('mutcd', 'vienna')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of OsrmRouteStep from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of maneuver
+        if self.maneuver:
+            _dict['maneuver'] = self.maneuver.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in intersections (list)
+        _items = []
+        if self.intersections:
+            for _item_intersections in self.intersections:
+                if _item_intersections:
+                    _items.append(_item_intersections.to_dict())
+            _dict['intersections'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in voice_instructions (list)
+        _items = []
+        if self.voice_instructions:
+            for _item_voice_instructions in self.voice_instructions:
+                if _item_voice_instructions:
+                    _items.append(_item_voice_instructions.to_dict())
+            _dict['voiceInstructions'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in banner_instructions (list)
+        _items = []
+        if self.banner_instructions:
+            for _item_banner_instructions in self.banner_instructions:
+                if _item_banner_instructions:
+                    _items.append(_item_banner_instructions.to_dict())
+            _dict['bannerInstructions'] = _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: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of OsrmRouteStep from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "distance": obj.get("distance"),
+            "duration": obj.get("duration"),
+            "geometry": obj.get("geometry"),
+            "weight": obj.get("weight"),
+            "name": obj.get("name"),
+            "ref": obj.get("ref"),
+            "pronunciation": obj.get("pronunciation"),
+            "destinations": obj.get("destinations"),
+            "exits": obj.get("exits"),
+            "mode": obj.get("mode"),
+            "maneuver": OsrmStepManeuver.from_dict(obj["maneuver"]) if obj.get("maneuver") is not None else None,
+            "intersections": [OsrmIntersection.from_dict(_item) for _item in obj["intersections"]] if obj.get("intersections") is not None else None,
+            "rotary_name": obj.get("rotary_name"),
+            "rotary_pronunciation": obj.get("rotary_pronunciation"),
+            "driving_side": obj.get("driving_side"),
+            "voiceInstructions": [OsrmVoiceInstruction.from_dict(_item) for _item in obj["voiceInstructions"]] if obj.get("voiceInstructions") is not None else None,
+            "bannerInstructions": [OsrmBannerInstruction.from_dict(_item) for _item in obj["bannerInstructions"]] if obj.get("bannerInstructions") is not None else None,
+            "speedLimitSign": obj.get("speedLimitSign"),
+            "speedLimitUnit": obj.get("speedLimitUnit")
+        })
+        # 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
+
+