stadiamaps 1.0.7__py3-none-any.whl → 2.1.0__py3-none-any.whl

stadiamaps/models/routing_waypoint.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.6
+    The version of the OpenAPI document: 6.1.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,76 +18,94 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Optional, Union
-from pydantic import BaseModel, Field, StrictBool, StrictFloat, StrictInt, StrictStr, conint, validator
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
 from stadiamaps.models.routing_waypoint_all_of_search_filter import RoutingWaypointAllOfSearchFilter
+from typing import Optional, Set
+from typing_extensions import Self
 
 class RoutingWaypoint(BaseModel):
     """
     RoutingWaypoint
-    """
-    lat: Union[StrictFloat, StrictInt] = Field(..., description="The latitude of a point in the shape.")
-    lon: Union[StrictFloat, StrictInt] = Field(..., description="The longitude of a point in the shape.")
-    type: Optional[StrictStr] = Field('break', description="A `break` represents the start or end of a leg, and allows reversals. A `through` location is an intermediate waypoint that must be visited between `break`s, but at which reversals are not allowed. A `via` is similar to a `through` except that reversals are allowed. A `break_through` is similar to a `break` in that it can be the start/end of a leg, but does not allow reversals.")
-    heading: Optional[conint(strict=True, le=360, ge=0)] = Field(None, description="The preferred direction of travel when starting the route, in integer clockwise degrees from north. North is 0, south is 180, east is 90, and west is 270.")
-    heading_tolerance: Optional[conint(strict=True, le=360, ge=0)] = Field(60, description="The tolerance (in degrees) determining whether a street is considered the same direction.")
-    minimum_reachability: Optional[conint(strict=True, ge=0)] = Field(50, description="The minimum number of nodes that must be reachable for a given edge to consider that edge as belonging to a connected region. If a candidate edge has fewer connections, it will be considered a disconnected island.")
-    radius: Optional[conint(strict=True, ge=0)] = Field(0, description="The distance (in meters) to look for candidate edges around the location for purposes of snapping locations to the route graph. If there are no candidates within this distance, the closest candidate within a reasonable search distance will be used. This is subject to clamping by internal limits.")
-    rank_candidates: Optional[StrictBool] = Field(True, description="If true, candidates will be ranked according to their distance from the target location as well as other factors. If false, candidates will only be ranked using their distance from the target.")
-    preferred_side: Optional[StrictStr] = Field(None, description="If the location is not offset from the road centerline or is closest to an intersection, this option has no effect. Otherwise, the preferred side of street is used to determine whether or not the location should be visited from the same, opposite or either side of the road with respect to the side of the road the given locale drives on.")
-    node_snap_tolerance: Optional[conint(strict=True, ge=0)] = Field(5, description="During edge correlation this is the tolerance (in meters) used to determine whether or not to snap to the intersection rather than along the street, if the snap location is within this distance from the intersection, the intersection is used instead.")
-    street_side_tolerance: Optional[conint(strict=True, ge=0)] = Field(5, description="A tolerance in meters from the edge centerline used for determining the side of the street that the location is on. If the distance to the centerline is less than this tolerance, no side will be inferred. Otherwise, the left or right side will be selected depending on the direction of travel.")
-    street_side_max_distance: Optional[conint(strict=True, ge=0)] = Field(1000, description="A tolerance in meters from the edge centerline used for determining the side of the street that the location is on. If the distance to the centerline is greater than this tolerance, no side will be inferred. Otherwise, the left or right side will be selected depending on the direction of travel.")
+    """ # noqa: E501
+    lat: Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]] = Field(description="The latitude of a point in the shape.")
+    lon: Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]] = Field(description="The longitude of a point in the shape.")
+    type: Optional[StrictStr] = Field(default='break', description="A `break` represents the start or end of a leg, and allows reversals. A `through` location is an intermediate waypoint that must be visited between `break`s, but at which reversals are not allowed. A `via` is similar to a `through` except that reversals are allowed. A `break_through` is similar to a `break` in that it can be the start/end of a leg, but does not allow reversals.")
+    heading: Optional[Annotated[int, Field(le=360, strict=True, ge=0)]] = Field(default=None, description="The preferred direction of travel when starting the route, in integer clockwise degrees from north. North is 0, south is 180, east is 90, and west is 270.")
+    heading_tolerance: Optional[Annotated[int, Field(le=360, strict=True, ge=0)]] = Field(default=60, description="The tolerance (in degrees) determining whether a street is considered the same direction.")
+    minimum_reachability: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=50, description="The minimum number of nodes that must be reachable for a given edge to consider that edge as belonging to a connected region. If a candidate edge has fewer connections, it will be considered a disconnected island.")
+    radius: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=0, description="The distance (in meters) to look for candidate edges around the location for purposes of snapping locations to the route graph. If there are no candidates within this distance, the closest candidate within a reasonable search distance will be used. This is subject to clamping by internal limits.")
+    rank_candidates: Optional[StrictBool] = Field(default=True, description="If true, candidates will be ranked according to their distance from the target location as well as other factors. If false, candidates will only be ranked using their distance from the target.")
+    preferred_side: Optional[StrictStr] = Field(default=None, description="If the location is not offset from the road centerline or is closest to an intersection, this option has no effect. Otherwise, the preferred side of street is used to determine whether or not the location should be visited from the same, opposite or either side of the road with respect to the side of the road the given locale drives on.")
+    node_snap_tolerance: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=5, description="During edge correlation this is the tolerance (in meters) used to determine whether or not to snap to the intersection rather than along the street, if the snap location is within this distance from the intersection, the intersection is used instead.")
+    street_side_tolerance: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=5, description="A tolerance in meters from the edge centerline used for determining the side of the street that the location is on. If the distance to the centerline is less than this tolerance, no side will be inferred. Otherwise, the left or right side will be selected depending on the direction of travel.")
+    street_side_max_distance: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=1000, description="A tolerance in meters from the edge centerline used for determining the side of the street that the location is on. If the distance to the centerline is greater than this tolerance, no side will be inferred. Otherwise, the left or right side will be selected depending on the direction of travel.")
     search_filter: Optional[RoutingWaypointAllOfSearchFilter] = None
     additional_properties: Dict[str, Any] = {}
-    __properties = ["lat", "lon", "type", "heading", "heading_tolerance", "minimum_reachability", "radius", "rank_candidates", "preferred_side", "node_snap_tolerance", "street_side_tolerance", "street_side_max_distance", "search_filter"]
+    __properties: ClassVar[List[str]] = ["lat", "lon", "type", "heading", "heading_tolerance", "minimum_reachability", "radius", "rank_candidates", "preferred_side", "node_snap_tolerance", "street_side_tolerance", "street_side_max_distance", "search_filter"]
 
-    @validator('type')
+    @field_validator('type')
     def type_validate_enum(cls, value):
         """Validates the enum"""
         if value is None:
             return value
 
-        if value not in ('break', 'through', 'via', 'break_through'):
+        if value not in set(['break', 'through', 'via', 'break_through']):
             raise ValueError("must be one of enum values ('break', 'through', 'via', 'break_through')")
         return value
 
-    @validator('preferred_side')
+    @field_validator('preferred_side')
     def preferred_side_validate_enum(cls, value):
         """Validates the enum"""
         if value is None:
             return value
 
-        if value not in ('same', 'opposite', 'either'):
+        if value not in set(['same', 'opposite', 'either']):
             raise ValueError("must be one of enum values ('same', 'opposite', 'either')")
         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) -> RoutingWaypoint:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of RoutingWaypoint 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 search_filter
         if self.search_filter:
             _dict['search_filter'] = self.search_filter.to_dict()
@@ -99,15 +117,15 @@ class RoutingWaypoint(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> RoutingWaypoint:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of RoutingWaypoint from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return RoutingWaypoint.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = RoutingWaypoint.parse_obj({
+        _obj = cls.model_validate({
             "lat": obj.get("lat"),
             "lon": obj.get("lon"),
             "type": obj.get("type") if obj.get("type") is not None else 'break',
@@ -120,7 +138,7 @@ class RoutingWaypoint(BaseModel):
             "node_snap_tolerance": obj.get("node_snap_tolerance") if obj.get("node_snap_tolerance") is not None else 5,
             "street_side_tolerance": obj.get("street_side_tolerance") if obj.get("street_side_tolerance") is not None else 5,
             "street_side_max_distance": obj.get("street_side_max_distance") if obj.get("street_side_max_distance") is not None else 1000,
-            "search_filter": RoutingWaypointAllOfSearchFilter.from_dict(obj.get("search_filter")) if obj.get("search_filter") is not None else None
+            "search_filter": RoutingWaypointAllOfSearchFilter.from_dict(obj["search_filter"]) if obj.get("search_filter") is not None else None
         })
         # store additional fields in additional_properties
         for _key in obj.keys():
@@ -129,3 +147,4 @@ class RoutingWaypoint(BaseModel):
 
         return _obj
 
+

stadiamaps/models/routing_waypoint_all_of_search_filter.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.6
+    The version of the OpenAPI document: 6.1.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,49 +18,66 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Optional
-from pydantic import BaseModel, Field, StrictBool
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
 from stadiamaps.models.road_class import RoadClass
+from typing import Optional, Set
+from typing_extensions import Self
 
 class RoutingWaypointAllOfSearchFilter(BaseModel):
     """
     RoutingWaypointAllOfSearchFilter
-    """
-    exclude_tunnel: Optional[StrictBool] = Field(False, description="Excludes roads marked as tunnels")
-    exclude_bridge: Optional[StrictBool] = Field(False, description="Excludes roads marked as bridges")
-    exclude_ramp: Optional[StrictBool] = Field(False, description="Excludes roads marked as ramps")
-    exclude_closures: Optional[StrictBool] = Field(True, description="Excludes roads marked as closed")
-    min_road_class: Optional[RoadClass] = None
-    max_road_class: Optional[RoadClass] = None
+    """ # noqa: E501
+    exclude_tunnel: Optional[StrictBool] = Field(default=False, description="Excludes roads marked as tunnels")
+    exclude_bridge: Optional[StrictBool] = Field(default=False, description="Excludes roads marked as bridges")
+    exclude_ramp: Optional[StrictBool] = Field(default=False, description="Excludes roads marked as ramps")
+    exclude_closures: Optional[StrictBool] = Field(default=True, description="Excludes roads marked as closed")
+    min_road_class: Optional[RoadClass] = Field(default=None, description="The lowest road class allowed")
+    max_road_class: Optional[RoadClass] = Field(default=None, description="The highest road class allowed")
     additional_properties: Dict[str, Any] = {}
-    __properties = ["exclude_tunnel", "exclude_bridge", "exclude_ramp", "exclude_closures", "min_road_class", "max_road_class"]
+    __properties: ClassVar[List[str]] = ["exclude_tunnel", "exclude_bridge", "exclude_ramp", "exclude_closures", "min_road_class", "max_road_class"]
+
+    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) -> RoutingWaypointAllOfSearchFilter:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of RoutingWaypointAllOfSearchFilter 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():
@@ -69,15 +86,15 @@ class RoutingWaypointAllOfSearchFilter(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> RoutingWaypointAllOfSearchFilter:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of RoutingWaypointAllOfSearchFilter from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return RoutingWaypointAllOfSearchFilter.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = RoutingWaypointAllOfSearchFilter.parse_obj({
+        _obj = cls.model_validate({
             "exclude_tunnel": obj.get("exclude_tunnel") if obj.get("exclude_tunnel") is not None else False,
             "exclude_bridge": obj.get("exclude_bridge") if obj.get("exclude_bridge") is not None else False,
             "exclude_ramp": obj.get("exclude_ramp") if obj.get("exclude_ramp") is not None else False,
@@ -92,3 +109,4 @@ class RoutingWaypointAllOfSearchFilter(BaseModel):
 
         return _obj
 
+

stadiamaps/models/simple_routing_waypoint.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.6
+    The version of the OpenAPI document: 6.1.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,55 +18,73 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Optional, Union
-from pydantic import BaseModel, Field, StrictFloat, StrictInt, StrictStr, validator
+from pydantic import BaseModel, ConfigDict, Field, 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 SimpleRoutingWaypoint(BaseModel):
     """
     SimpleRoutingWaypoint
-    """
-    lat: Union[StrictFloat, StrictInt] = Field(..., description="The latitude of a point in the shape.")
-    lon: Union[StrictFloat, StrictInt] = Field(..., description="The longitude of a point in the shape.")
-    type: Optional[StrictStr] = Field('break', description="A `break` represents the start or end of a leg, and allows reversals. A `through` location is an intermediate waypoint that must be visited between `break`s, but at which reversals are not allowed. A `via` is similar to a `through` except that reversals are allowed. A `break_through` is similar to a `break` in that it can be the start/end of a leg, but does not allow reversals.")
+    """ # noqa: E501
+    lat: Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]] = Field(description="The latitude of a point in the shape.")
+    lon: Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]] = Field(description="The longitude of a point in the shape.")
+    type: Optional[StrictStr] = Field(default='break', description="A `break` represents the start or end of a leg, and allows reversals. A `through` location is an intermediate waypoint that must be visited between `break`s, but at which reversals are not allowed. A `via` is similar to a `through` except that reversals are allowed. A `break_through` is similar to a `break` in that it can be the start/end of a leg, but does not allow reversals.")
     additional_properties: Dict[str, Any] = {}
-    __properties = ["lat", "lon", "type"]
+    __properties: ClassVar[List[str]] = ["lat", "lon", "type"]
 
-    @validator('type')
+    @field_validator('type')
     def type_validate_enum(cls, value):
         """Validates the enum"""
         if value is None:
             return value
 
-        if value not in ('break', 'through', 'via', 'break_through'):
+        if value not in set(['break', 'through', 'via', 'break_through']):
             raise ValueError("must be one of enum values ('break', 'through', 'via', 'break_through')")
         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) -> SimpleRoutingWaypoint:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of SimpleRoutingWaypoint 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():
@@ -75,15 +93,15 @@ class SimpleRoutingWaypoint(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> SimpleRoutingWaypoint:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of SimpleRoutingWaypoint from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return SimpleRoutingWaypoint.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = SimpleRoutingWaypoint.parse_obj({
+        _obj = cls.model_validate({
             "lat": obj.get("lat"),
             "lon": obj.get("lon"),
             "type": obj.get("type") if obj.get("type") is not None else 'break'
@@ -95,3 +113,4 @@ class SimpleRoutingWaypoint(BaseModel):
 
         return _obj
 
+

stadiamaps/models/speeds.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.6
+    The version of the OpenAPI document: 6.1.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,57 +18,74 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Optional
-from pydantic import BaseModel, Field, StrictBool, StrictInt, StrictStr, validator
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
 
 class Speeds(BaseModel):
     """
     Speeds
-    """
-    predicted: Optional[StrictBool] = Field(None, description="Does this edge have predicted (historical) speed records?")
-    constrained_flow: Optional[StrictInt] = Field(None, description="Speed when there is no traffic, in kph.")
-    free_flow: Optional[StrictInt] = Field(None, description="Speed when there is heavy traffic, in kph.")
-    type: Optional[StrictStr] = Field(None, description="The type of speed which is used when setting default speeds. When `tagged`, the explicit `max_speed` tags from OpenStreetMap are being used. When `classified`, the values are being inferred from the highway classification.")
-    default: Optional[StrictInt] = Field(None, description="The default speed used for calculations. NOTE: Values greater than 250 are used for special cases and should not be treated as literal.")
+    """ # noqa: E501
+    predicted: Optional[StrictBool] = Field(default=None, description="Does this edge have predicted (historical) speed records?")
+    constrained_flow: Optional[StrictInt] = Field(default=None, description="Speed when there is no traffic, in kph.")
+    free_flow: Optional[StrictInt] = Field(default=None, description="Speed when there is heavy traffic, in kph.")
+    type: Optional[StrictStr] = Field(default=None, description="The type of speed which is used when setting default speeds. When `tagged`, the explicit `max_speed` tags from OpenStreetMap are being used. When `classified`, the values are being inferred from the highway classification.")
+    default: Optional[StrictInt] = Field(default=None, description="The default speed used for calculations. NOTE: Values greater than 250 are used for special cases and should not be treated as literal.")
     additional_properties: Dict[str, Any] = {}
-    __properties = ["predicted", "constrained_flow", "free_flow", "type", "default"]
+    __properties: ClassVar[List[str]] = ["predicted", "constrained_flow", "free_flow", "type", "default"]
 
-    @validator('type')
+    @field_validator('type')
     def type_validate_enum(cls, value):
         """Validates the enum"""
         if value is None:
             return value
 
-        if value not in ('classified', 'tagged'):
+        if value not in set(['classified', 'tagged']):
             raise ValueError("must be one of enum values ('classified', 'tagged')")
         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) -> Speeds:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of Speeds 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():
@@ -77,15 +94,15 @@ class Speeds(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> Speeds:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of Speeds from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return Speeds.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = Speeds.parse_obj({
+        _obj = cls.model_validate({
             "predicted": obj.get("predicted"),
             "constrained_flow": obj.get("constrained_flow"),
             "free_flow": obj.get("free_flow"),
@@ -99,3 +116,4 @@ class Speeds(BaseModel):
 
         return _obj
 
+