stadiamaps 1.0.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

stadiamaps/models/base_trace_request.py

@@ -3,14 +3,14 @@
 """
     Stadia Maps Geospatial APIs
 
-    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.  # noqa: E501
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
 
-    The version of the OpenAPI document: 5.0.5
+    The version of the OpenAPI document: 6.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
@@ -18,63 +18,93 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import List, Optional
-from pydantic import BaseModel, Field, StrictStr, conlist, validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
 from stadiamaps.models.costing_options import CostingOptions
-from stadiamaps.models.directions_options import DirectionsOptions
+from stadiamaps.models.distance_unit import DistanceUnit
 from stadiamaps.models.map_match_costing_model import MapMatchCostingModel
 from stadiamaps.models.map_match_waypoint import MapMatchWaypoint
+from stadiamaps.models.valhalla_languages import ValhallaLanguages
+from typing import Optional, Set
+from typing_extensions import Self
 
 class BaseTraceRequest(BaseModel):
     """
     BaseTraceRequest
-    """
-    id: Optional[StrictStr] = Field(None, description="An identifier to disambiguate requests (echoed by the server).")
-    shape: Optional[conlist(MapMatchWaypoint)] = Field(None, description="REQUIRED if `encoded_polyline` is not present. Note that `break` type locations are only supported when `shape_match` is set to `map_match`.")
-    encoded_polyline: Optional[StrictStr] = Field(None, description="REQUIRED if `shape` is not present. An encoded polyline (https://developers.google.com/maps/documentation/utilities/polylinealgorithm). Note that the polyline must be encoded with 6 digits of precision rather than the usual 5.")
-    costing: MapMatchCostingModel = Field(...)
+    """ # noqa: E501
+    units: Optional[DistanceUnit] = None
+    language: Optional[ValhallaLanguages] = None
+    directions_type: Optional[StrictStr] = Field(default='instructions', description="The level of directional narrative to include. Locations and times will always be returned, but narrative generation verbosity can be controlled with this parameter.")
+    id: Optional[StrictStr] = Field(default=None, description="An identifier to disambiguate requests (echoed by the server).")
+    shape: Optional[List[MapMatchWaypoint]] = Field(default=None, description="REQUIRED if `encoded_polyline` is not present. Note that `break` type locations are only supported when `shape_match` is set to `map_match`.")
+    encoded_polyline: Optional[StrictStr] = Field(default=None, description="REQUIRED if `shape` is not present. An encoded polyline (https://developers.google.com/maps/documentation/utilities/polylinealgorithm). Note that the polyline must be encoded with 6 digits of precision rather than the usual 5.")
+    costing: MapMatchCostingModel
     costing_options: Optional[CostingOptions] = None
-    shape_match: Optional[StrictStr] = Field(None, description="Three snapping modes provide some control over how the map matching occurs. `edge_walk` is fast, but requires extremely precise data that matches the route graph almost perfectly. `map_snap` can handle significantly noisier data, but is very expensive. `walk_or_snap`, the default, tries to use edge walking first and falls back to map matching if edge walking fails. In general, you should not need to change this parameter unless you want to trace a multi-leg route with multiple `break` locations in the `shape`.")
-    directions_options: Optional[DirectionsOptions] = None
+    shape_match: Optional[StrictStr] = Field(default=None, description="Three snapping modes provide some control over how the map matching occurs. `edge_walk` is fast, but requires extremely precise data that matches the route graph almost perfectly. `map_snap` can handle significantly noisier data, but is very expensive. `walk_or_snap`, the default, tries to use edge walking first and falls back to map matching if edge walking fails. In general, you should not need to change this parameter unless you want to trace a multi-leg route with multiple `break` locations in the `shape`.")
     additional_properties: Dict[str, Any] = {}
-    __properties = ["id", "shape", "encoded_polyline", "costing", "costing_options", "shape_match", "directions_options"]
+    __properties: ClassVar[List[str]] = ["units", "language", "directions_type", "id", "shape", "encoded_polyline", "costing", "costing_options", "shape_match"]
 
-    @validator('shape_match')
+    @field_validator('directions_type')
+    def directions_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['none', 'maneuvers', 'instructions']):
+            raise ValueError("must be one of enum values ('none', 'maneuvers', 'instructions')")
+        return value
+
+    @field_validator('shape_match')
     def shape_match_validate_enum(cls, value):
         """Validates the enum"""
         if value is None:
             return value
 
-        if value not in ('edge_walk', 'map_snap', 'walk_or_snap'):
+        if value not in set(['edge_walk', 'map_snap', 'walk_or_snap']):
             raise ValueError("must be one of enum values ('edge_walk', 'map_snap', 'walk_or_snap')")
         return value
 
-    class Config:
-        """Pydantic configuration"""
-        allow_population_by_field_name = True
-        validate_assignment = True
+    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.dict(by_alias=True))
+        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) -> BaseTraceRequest:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of BaseTraceRequest 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)
+    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 shape (list)
         _items = []
         if self.shape:
@@ -85,9 +115,6 @@ class BaseTraceRequest(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of costing_options
         if self.costing_options:
             _dict['costing_options'] = self.costing_options.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of directions_options
-        if self.directions_options:
-            _dict['directions_options'] = self.directions_options.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():
@@ -96,22 +123,24 @@ class BaseTraceRequest(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> BaseTraceRequest:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of BaseTraceRequest from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return BaseTraceRequest.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = BaseTraceRequest.parse_obj({
+        _obj = cls.model_validate({
+            "units": obj.get("units"),
+            "language": obj.get("language"),
+            "directions_type": obj.get("directions_type") if obj.get("directions_type") is not None else 'instructions',
             "id": obj.get("id"),
-            "shape": [MapMatchWaypoint.from_dict(_item) for _item in obj.get("shape")] if obj.get("shape") is not None else None,
+            "shape": [MapMatchWaypoint.from_dict(_item) for _item in obj["shape"]] if obj.get("shape") is not None else None,
             "encoded_polyline": obj.get("encoded_polyline"),
             "costing": obj.get("costing"),
-            "costing_options": CostingOptions.from_dict(obj.get("costing_options")) if obj.get("costing_options") is not None else None,
-            "shape_match": obj.get("shape_match"),
-            "directions_options": DirectionsOptions.from_dict(obj.get("directions_options")) if obj.get("directions_options") is not None else None
+            "costing_options": CostingOptions.from_dict(obj["costing_options"]) if obj.get("costing_options") is not None else None,
+            "shape_match": obj.get("shape_match")
         })
         # store additional fields in additional_properties
         for _key in obj.keys():
@@ -120,3 +149,4 @@ class BaseTraceRequest(BaseModel):
 
         return _obj
 
+

stadiamaps/models/bicycle_costing_options.py

@@ -3,14 +3,14 @@
 """
     Stadia Maps Geospatial APIs
 
-    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.  # noqa: E501
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
 
-    The version of the OpenAPI document: 5.0.5
+    The version of the OpenAPI document: 6.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
@@ -18,68 +18,86 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Optional, Union
-from pydantic import BaseModel, Field, StrictFloat, StrictInt, StrictStr, confloat, conint, validator
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
 
 class BicycleCostingOptions(BaseModel):
     """
     BicycleCostingOptions
-    """
-    maneuver_penalty: Optional[StrictInt] = Field(5, description="A penalty (in seconds) applied when transitioning between roads (determined by name).")
-    gate_cost: Optional[StrictInt] = Field(15, description="The estimated cost (in seconds) when a gate is encountered.")
-    gate_penalty: Optional[StrictInt] = Field(300, description="A penalty (in seconds) applied to the route cost when a gate is encountered. This penalty can be used to reduce the likelihood of suggesting a route with gates unless absolutely necessary.")
-    country_crossing_cost: Optional[StrictInt] = Field(600, description="The estimated cost (in seconds) when encountering an international border.")
-    country_crossing_penalty: Optional[StrictInt] = Field(0, description="A penalty applied to transitions to international border crossings. This penalty can be used to reduce the likelihood of suggesting a route with border crossings unless absolutely necessary.")
-    service_penalty: Optional[StrictInt] = Field(None, description="A penalty applied to transitions to service roads. This penalty can be used to reduce the likelihood of suggesting a route with service roads unless absolutely necessary. The default penalty is 15 for cars, busses, motor scooters, and motorcycles; and zero for others.")
-    service_factor: Optional[Union[StrictFloat, StrictInt]] = Field(1, description="A factor that multiplies the cost when service roads are encountered. The default is 1.2 for cars and busses, and 1 for trucks, motor scooters, and motorcycles.")
-    use_living_streets: Optional[Union[confloat(le=1, ge=0, strict=True), conint(le=1, ge=0, strict=True)]] = Field(None, description="A measure of willingness to take living streets. Values near 0 attempt to avoid them, and values near 1 will favour them. Note that as some routes may be impossible without living streets, 0 does not guarantee avoidance of them. The default value is 0 for trucks; 0.1 for other motor vehicles; 0.5 for bicycles; and 0.6 for pedestrians.")
-    use_ferry: Optional[Union[confloat(le=1, ge=0, strict=True), conint(le=1, ge=0, strict=True)]] = Field(0.5, description="A measure of willingness to take ferries. Values near 0 attempt to avoid ferries, and values near 1 will favour them. Note that as some routes may be impossible without ferries, 0 does not guarantee avoidance of them.")
-    bicycle_type: Optional[StrictStr] = 'Hybrid'
-    cycling_speed: Optional[StrictInt] = Field(None, description="The average comfortable travel speed (in kph) along smooth, flat roads. The costing will vary the speed based on the surface, bicycle type, elevation change, etc. This value should be the average sustainable cruising speed the cyclist can maintain over the entire route. The default speeds are as follows based on bicycle type:   * Road - 25kph   * Cross - 20kph   * Hybrid - 18kph   * Mountain - 16kph")
-    use_roads: Optional[Union[confloat(le=1, ge=0, strict=True), conint(le=1, ge=0, strict=True)]] = Field(0.5, description="A measure of willingness to use roads alongside other vehicles. Values near 0 attempt to avoid roads and stay on cycleways, and values near 1 indicate the cyclist is more comfortable on roads.")
-    use_hills: Optional[Union[confloat(le=1, ge=0, strict=True), conint(le=1, ge=0, strict=True)]] = Field(0.5, description="A measure of willingness to take tackle hills. Values near 0 attempt to avoid hills and steeper grades even if it means a longer route, and values near 1 indicates that the user does not fear them. Note that as some routes may be impossible without hills, 0 does not guarantee avoidance of them.")
-    avoid_bad_surfaces: Optional[Union[confloat(le=1, ge=0, strict=True), conint(le=1, ge=0, strict=True)]] = Field(0.25, description="A measure of how much the cyclist wants to avoid roads with poor surfaces relative to the type of bicycle being ridden. When 0, there is no penalization of roads with poorer surfaces, and only bicycle speed is taken into account. As the value approaches 1, roads with poor surfaces relative to the bicycle type receive a heaver penalty, so they will only be taken if they significantly reduce travel time. When the value is 1, all bad surfaces are completely avoided from the route, including the start and end points.")
-    bss_return_cost: Optional[StrictInt] = Field(120, description="The estimated cost (in seconds) to return a bicycle in `bikeshare` mode.")
-    bss_return_penalty: Optional[StrictInt] = Field(0, description="A penalty (in seconds) to return a bicycle in `bikeshare` mode.")
+    """ # noqa: E501
+    maneuver_penalty: Optional[StrictInt] = Field(default=5, description="A penalty (in seconds) applied when transitioning between roads (determined by name).")
+    gate_cost: Optional[StrictInt] = Field(default=15, description="The estimated cost (in seconds) when a gate is encountered.")
+    gate_penalty: Optional[StrictInt] = Field(default=300, description="A penalty (in seconds) applied to the route cost when a gate is encountered. This penalty can be used to reduce the likelihood of suggesting a route with gates unless absolutely necessary.")
+    country_crossing_cost: Optional[StrictInt] = Field(default=600, description="The estimated cost (in seconds) when encountering an international border.")
+    country_crossing_penalty: Optional[StrictInt] = Field(default=0, description="A penalty applied to transitions to international border crossings. This penalty can be used to reduce the likelihood of suggesting a route with border crossings unless absolutely necessary.")
+    service_penalty: Optional[StrictInt] = Field(default=None, description="A penalty applied to transitions to service roads. This penalty can be used to reduce the likelihood of suggesting a route with service roads unless absolutely necessary. The default penalty is 15 for cars, busses, motor scooters, and motorcycles; and zero for others.")
+    service_factor: Optional[Union[StrictFloat, StrictInt]] = Field(default=1, description="A factor that multiplies the cost when service roads are encountered. The default is 1.2 for cars and busses, and 1 for trucks, motor scooters, and motorcycles.")
+    use_living_streets: Optional[Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = Field(default=None, description="A measure of willingness to take living streets. Values near 0 attempt to avoid them, and values near 1 will favour them. Note that as some routes may be impossible without living streets, 0 does not guarantee avoidance of them. The default value is 0 for trucks; 0.1 for other motor vehicles; 0.5 for bicycles; and 0.6 for pedestrians.")
+    use_ferry: Optional[Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = Field(default=0.5, description="A measure of willingness to take ferries. Values near 0 attempt to avoid ferries, and values near 1 will favour them. Note that as some routes may be impossible without ferries, 0 does not guarantee avoidance of them.")
+    bicycle_type: Optional[StrictStr] = Field(default='Hybrid', description="The type of bicycle: * Road: has narrow tires and is generally lightweight and designed for speed on paved surfaces * Hybrid or City: designed for city riding or casual riding on roads and paths with good surfaces * Cross: similar to a road bike, but has wider tires so it can handle rougher surfaces * Mountain: able to handle most surfaces, but generally heavier and slower on paved surfaces")
+    cycling_speed: Optional[StrictInt] = Field(default=None, description="The average comfortable travel speed (in kph) along smooth, flat roads. The costing will vary the speed based on the surface, bicycle type, elevation change, etc. This value should be the average sustainable cruising speed the cyclist can maintain over the entire route. The default speeds are as follows based on bicycle type:   * Road - 25kph   * Cross - 20kph   * Hybrid - 18kph   * Mountain - 16kph")
+    use_roads: Optional[Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = Field(default=0.5, description="A measure of willingness to use roads alongside other vehicles. Values near 0 attempt to avoid roads and stay on cycleways, and values near 1 indicate the cyclist is more comfortable on roads.")
+    use_hills: Optional[Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = Field(default=0.5, description="A measure of willingness to take tackle hills. Values near 0 attempt to avoid hills and steeper grades even if it means a longer route, and values near 1 indicates that the user does not fear them. Note that as some routes may be impossible without hills, 0 does not guarantee avoidance of them.")
+    avoid_bad_surfaces: Optional[Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = Field(default=0.25, description="A measure of how much the cyclist wants to avoid roads with poor surfaces relative to the type of bicycle being ridden. When 0, there is no penalization of roads with poorer surfaces, and only bicycle speed is taken into account. As the value approaches 1, roads with poor surfaces relative to the bicycle type receive a heaver penalty, so they will only be taken if they significantly reduce travel time. When the value is 1, all bad surfaces are completely avoided from the route, including the start and end points.")
+    bss_return_cost: Optional[StrictInt] = Field(default=120, description="The estimated cost (in seconds) to return a bicycle in `bikeshare` mode.")
+    bss_return_penalty: Optional[StrictInt] = Field(default=0, description="A penalty (in seconds) to return a bicycle in `bikeshare` mode.")
     additional_properties: Dict[str, Any] = {}
-    __properties = ["maneuver_penalty", "gate_cost", "gate_penalty", "country_crossing_cost", "country_crossing_penalty", "service_penalty", "service_factor", "use_living_streets", "use_ferry", "bicycle_type", "cycling_speed", "use_roads", "use_hills", "avoid_bad_surfaces", "bss_return_cost", "bss_return_penalty"]
+    __properties: ClassVar[List[str]] = ["maneuver_penalty", "gate_cost", "gate_penalty", "country_crossing_cost", "country_crossing_penalty", "service_penalty", "service_factor", "use_living_streets", "use_ferry", "bicycle_type", "cycling_speed", "use_roads", "use_hills", "avoid_bad_surfaces", "bss_return_cost", "bss_return_penalty"]
 
-    @validator('bicycle_type')
+    @field_validator('bicycle_type')
     def bicycle_type_validate_enum(cls, value):
         """Validates the enum"""
         if value is None:
             return value
 
-        if value not in ('Road', 'Hybrid', 'Cross', 'Mountain'):
+        if value not in set(['Road', 'Hybrid', 'Cross', 'Mountain']):
             raise ValueError("must be one of enum values ('Road', 'Hybrid', 'Cross', 'Mountain')")
         return value
 
-    class Config:
-        """Pydantic configuration"""
-        allow_population_by_field_name = True
-        validate_assignment = True
+    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.dict(by_alias=True))
+        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) -> BicycleCostingOptions:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of BicycleCostingOptions 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)
+    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,
+        )
         # 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():
@@ -88,15 +106,15 @@ class BicycleCostingOptions(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> BicycleCostingOptions:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of BicycleCostingOptions from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return BicycleCostingOptions.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = BicycleCostingOptions.parse_obj({
+        _obj = cls.model_validate({
             "maneuver_penalty": obj.get("maneuver_penalty") if obj.get("maneuver_penalty") is not None else 5,
             "gate_cost": obj.get("gate_cost") if obj.get("gate_cost") is not None else 15,
             "gate_penalty": obj.get("gate_penalty") if obj.get("gate_penalty") is not None else 300,
@@ -121,3 +139,4 @@ class BicycleCostingOptions(BaseModel):
 
         return _obj
 
+

stadiamaps/models/bicycle_costing_options_all_of.py

@@ -5,7 +5,7 @@
 
     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.5
+    The version of the OpenAPI document: 5.0.6
     Contact: support@stadiamaps.com
     Generated by OpenAPI Generator (https://openapi-generator.tech)
 

stadiamaps/models/bike_network.py

@@ -3,14 +3,14 @@
 """
     Stadia Maps Geospatial APIs
 
-    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.  # noqa: E501
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
 
-    The version of the OpenAPI document: 5.0.5
+    The version of the OpenAPI document: 6.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
@@ -18,46 +18,63 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Optional
-from pydantic import BaseModel, StrictBool
+from pydantic import BaseModel, ConfigDict, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
 
 class BikeNetwork(BaseModel):
     """
     BikeNetwork
-    """
+    """ # noqa: E501
     mountain: Optional[StrictBool] = None
     local: Optional[StrictBool] = None
     regional: Optional[StrictBool] = None
     national: Optional[StrictBool] = None
     additional_properties: Dict[str, Any] = {}
-    __properties = ["mountain", "local", "regional", "national"]
+    __properties: ClassVar[List[str]] = ["mountain", "local", "regional", "national"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
 
-    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))
+        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) -> BikeNetwork:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of BikeNetwork 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)
+    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,
+        )
         # 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():
@@ -66,15 +83,15 @@ class BikeNetwork(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> BikeNetwork:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of BikeNetwork from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return BikeNetwork.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = BikeNetwork.parse_obj({
+        _obj = cls.model_validate({
             "mountain": obj.get("mountain"),
             "local": obj.get("local"),
             "regional": obj.get("regional"),
@@ -87,3 +104,4 @@ class BikeNetwork(BaseModel):
 
         return _obj
 
+

stadiamaps/models/contour.py

@@ -3,14 +3,14 @@
 """
     Stadia Maps Geospatial APIs
 
-    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.  # noqa: E501
+    The Stadia Maps Geospatial APIs provide you with the data you need to build awesome applications.
 
-    The version of the OpenAPI document: 5.0.5
+    The version of the OpenAPI document: 6.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
@@ -18,45 +18,62 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Optional, Union
-from pydantic import BaseModel, Field, StrictFloat, StrictInt, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
 
 class Contour(BaseModel):
     """
     Contour
-    """
-    time: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="The time in minutes for the contour. Mutually exclusive of distance.")
-    distance: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="The distance in km for the contour. Mutually exclusive of time.")
-    color: Optional[StrictStr] = Field(None, description="The color for the output contour, specified as a hex value (without a leading `#`). If no color is specified, one will be assigned automatically.")
+    """ # noqa: E501
+    time: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The time in minutes for the contour. Mutually exclusive of distance.")
+    distance: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The distance in km for the contour. Mutually exclusive of time.")
+    color: Optional[StrictStr] = Field(default=None, description="The color for the output contour, specified as a hex value (without a leading `#`). If no color is specified, one will be assigned automatically.")
     additional_properties: Dict[str, Any] = {}
-    __properties = ["time", "distance", "color"]
+    __properties: ClassVar[List[str]] = ["time", "distance", "color"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
 
-    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))
+        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) -> Contour:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of Contour 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)
+    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,
+        )
         # 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():
@@ -65,15 +82,15 @@ class Contour(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> Contour:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of Contour from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return Contour.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = Contour.parse_obj({
+        _obj = cls.model_validate({
             "time": obj.get("time"),
             "distance": obj.get("distance"),
             "color": obj.get("color")
@@ -85,3 +102,4 @@ class Contour(BaseModel):
 
         return _obj
 
+