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

stadiamaps/models/pedestrian_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.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,58 +18,76 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Optional, Union
-from pydantic import BaseModel, Field, StrictFloat, StrictInt, confloat, conint
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt
+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 PedestrianCostingOptions(BaseModel):
     """
     PedestrianCostingOptions
-    """
-    walking_speed: Optional[conint(strict=True, le=25, ge=0)] = Field(None, description="Walking speed in kph.")
-    walkway_factor: Optional[Union[StrictFloat, StrictInt]] = Field(1, description="A factor that multiplies the cost when walkways are encountered.")
-    sidewalk_factor: Optional[Union[StrictFloat, StrictInt]] = Field(1, description="A factor that multiplies the cost when sidewalks are encountered.")
-    alley_factor: Optional[Union[StrictFloat, StrictInt]] = Field(2, description="A factor that multiplies the cost when alleys are encountered.")
-    driveway_factor: Optional[Union[StrictFloat, StrictInt]] = Field(5, description="A factor that multiplies the cost when driveways are encountered.")
-    step_penalty: Optional[StrictInt] = Field(30, description="A penalty (in seconds) added to each transition onto a path with steps or stairs.")
-    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.")
-    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_tracks: 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 track roads. Values near 0 attempt to avoid them, and values near 1 will favour them. Note that as some routes may be impossible without track roads, 0 does not guarantee avoidance of them. The default value is 0 for automobiles, busses, and trucks; and 0.5 for all other costing modes.")
-    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.")
-    use_lit: Optional[Union[confloat(le=1, ge=0, strict=True), conint(le=1, ge=0, strict=True)]] = Field(0, description="A measure of preference for streets that are lit. 0 indicates indifference toward lit streets, and 1 indicates that unlit streets should be avoided. Note that even with values near 1, there is no guarantee that the returned route will include lit segments.")
-    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.")
-    max_hiking_difficulty: Optional[conint(strict=True, le=6, ge=1)] = Field(1, description="The maximum difficulty of hiking trails allowed. This corresponds to the OSM `sac_scale`.")
-    bss_rent_cost: Optional[StrictInt] = Field(120, description="The estimated cost (in seconds) to rent a bicycle from a sharing station in `bikeshare` mode.")
-    bss_rent_penalty: Optional[StrictInt] = Field(0, description="A penalty (in seconds) to rent a bicycle in `bikeshare` mode.")
+    """ # noqa: E501
+    walking_speed: Optional[Annotated[int, Field(le=25, strict=True, ge=0)]] = Field(default=None, description="Walking speed in kph.")
+    walkway_factor: Optional[Union[StrictFloat, StrictInt]] = Field(default=1, description="A factor that multiplies the cost when walkways are encountered.")
+    sidewalk_factor: Optional[Union[StrictFloat, StrictInt]] = Field(default=1, description="A factor that multiplies the cost when sidewalks are encountered.")
+    alley_factor: Optional[Union[StrictFloat, StrictInt]] = Field(default=2, description="A factor that multiplies the cost when alleys are encountered.")
+    driveway_factor: Optional[Union[StrictFloat, StrictInt]] = Field(default=5, description="A factor that multiplies the cost when driveways are encountered.")
+    step_penalty: Optional[StrictInt] = Field(default=30, description="A penalty (in seconds) added to each transition onto a path with steps or stairs.")
+    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.")
+    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_tracks: 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 track roads. Values near 0 attempt to avoid them, and values near 1 will favour them. Note that as some routes may be impossible without track roads, 0 does not guarantee avoidance of them. The default value is 0 for automobiles, busses, and trucks; and 0.5 for all other costing modes.")
+    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.")
+    use_lit: Optional[Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = Field(default=0, description="A measure of preference for streets that are lit. 0 indicates indifference toward lit streets, and 1 indicates that unlit streets should be avoided. Note that even with values near 1, there is no guarantee that the returned route will include lit segments.")
+    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.")
+    max_hiking_difficulty: Optional[Annotated[int, Field(le=6, strict=True, ge=1)]] = Field(default=1, description="The maximum difficulty of hiking trails allowed. This corresponds to the OSM `sac_scale`.")
+    bss_rent_cost: Optional[StrictInt] = Field(default=120, description="The estimated cost (in seconds) to rent a bicycle from a sharing station in `bikeshare` mode.")
+    bss_rent_penalty: Optional[StrictInt] = Field(default=0, description="A penalty (in seconds) to rent a bicycle in `bikeshare` mode.")
     additional_properties: Dict[str, Any] = {}
-    __properties = ["walking_speed", "walkway_factor", "sidewalk_factor", "alley_factor", "driveway_factor", "step_penalty", "use_ferry", "use_living_streets", "use_tracks", "use_hills", "use_lit", "service_penalty", "service_factor", "max_hiking_difficulty", "bss_rent_cost", "bss_rent_penalty"]
+    __properties: ClassVar[List[str]] = ["walking_speed", "walkway_factor", "sidewalk_factor", "alley_factor", "driveway_factor", "step_penalty", "use_ferry", "use_living_streets", "use_tracks", "use_hills", "use_lit", "service_penalty", "service_factor", "max_hiking_difficulty", "bss_rent_cost", "bss_rent_penalty"]
+
+    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) -> PedestrianCostingOptions:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of PedestrianCostingOptions 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():
@@ -78,15 +96,15 @@ class PedestrianCostingOptions(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> PedestrianCostingOptions:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of PedestrianCostingOptions from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return PedestrianCostingOptions.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = PedestrianCostingOptions.parse_obj({
+        _obj = cls.model_validate({
             "walking_speed": obj.get("walking_speed"),
             "walkway_factor": obj.get("walkway_factor") if obj.get("walkway_factor") is not None else 1,
             "sidewalk_factor": obj.get("sidewalk_factor") if obj.get("sidewalk_factor") is not None else 1,
@@ -111,3 +129,4 @@ class PedestrianCostingOptions(BaseModel):
 
         return _obj
 
+

stadiamaps/models/pelias_geo_json_feature.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,56 +18,74 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import List, Optional, Union
-from pydantic import BaseModel, Field, StrictFloat, StrictInt, StrictStr, conlist, 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 stadiamaps.models.geo_json_point import GeoJSONPoint
 from stadiamaps.models.pelias_geo_json_properties import PeliasGeoJSONProperties
+from typing import Optional, Set
+from typing_extensions import Self
 
 class PeliasGeoJSONFeature(BaseModel):
     """
     PeliasGeoJSONFeature
-    """
-    type: StrictStr = Field(...)
-    geometry: GeoJSONPoint = Field(...)
+    """ # noqa: E501
+    type: StrictStr
+    geometry: GeoJSONPoint
     properties: Optional[PeliasGeoJSONProperties] = None
-    bbox: Optional[conlist(Union[StrictFloat, StrictInt], max_items=4, min_items=4)] = Field(None, description="An array of 4 floating point numbers representing the (W, S, E, N) extremes of the features found.")
+    bbox: Optional[Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=4, max_length=4)]] = Field(default=None, description="An array of 4 floating point numbers representing the (W, S, E, N) extremes of the features found.")
     id: Optional[StrictStr] = None
     additional_properties: Dict[str, Any] = {}
-    __properties = ["type", "geometry", "properties", "bbox", "id"]
+    __properties: ClassVar[List[str]] = ["type", "geometry", "properties", "bbox", "id"]
 
-    @validator('type')
+    @field_validator('type')
     def type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('Feature'):
+        if value not in set(['Feature']):
             raise ValueError("must be one of enum values ('Feature')")
         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) -> PeliasGeoJSONFeature:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of PeliasGeoJSONFeature 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 geometry
         if self.geometry:
             _dict['geometry'] = self.geometry.to_dict()
@@ -82,18 +100,18 @@ class PeliasGeoJSONFeature(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> PeliasGeoJSONFeature:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of PeliasGeoJSONFeature from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return PeliasGeoJSONFeature.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = PeliasGeoJSONFeature.parse_obj({
+        _obj = cls.model_validate({
             "type": obj.get("type"),
-            "geometry": GeoJSONPoint.from_dict(obj.get("geometry")) if obj.get("geometry") is not None else None,
-            "properties": PeliasGeoJSONProperties.from_dict(obj.get("properties")) if obj.get("properties") is not None else None,
+            "geometry": GeoJSONPoint.from_dict(obj["geometry"]) if obj.get("geometry") is not None else None,
+            "properties": PeliasGeoJSONProperties.from_dict(obj["properties"]) if obj.get("properties") is not None else None,
             "bbox": obj.get("bbox"),
             "id": obj.get("id")
         })
@@ -104,3 +122,4 @@ class PeliasGeoJSONFeature(BaseModel):
 
         return _obj
 
+

stadiamaps/models/pelias_geo_json_properties.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,22 +18,23 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Optional
-from pydantic import BaseModel, Field, StrictStr, validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
 from stadiamaps.models.pelias_geo_json_properties_addendum import PeliasGeoJSONPropertiesAddendum
 from stadiamaps.models.pelias_layer import PeliasLayer
+from typing import Optional, Set
+from typing_extensions import Self
 
 class PeliasGeoJSONProperties(BaseModel):
     """
     PeliasGeoJSONProperties
-    """
-    gid: Optional[StrictStr] = Field(None, description="A scoped GID for this result. This can be passed to the place endpoint. Note that these are not always stable. For OSM, Geonames, and Who's on First, these are usually stable, but for other sources like OSM, no stability is guaranteed.")
-    source_id: Optional[StrictStr] = Field(None, description="An ID referencing the original data source (specified via source) for the result. These IDs are specific to the source that they originated from. For example, in the case of OSM, these typically look like way/123 or point/123.")
-    label: Optional[StrictStr] = Field(None, description="A full, human-readable label. However, you may not necessarily want to use this; be sure to read the docs for name, locality, and region before making a decision. This field is mostly localized. The order of components is generally locally correct (ex: for an address in South Korea, the house number appears after the street name). However, components will use a request language equivalent if one exists (ex: Seoul instead of 서울 if lang=en).")
+    """ # noqa: E501
+    gid: Optional[StrictStr] = Field(default=None, description="A scoped GID for this result. This can be passed to the place endpoint. Note that these are not always stable. For OSM, Geonames, and Who's on First, these are usually stable, but for other sources like OSM, no stability is guaranteed.")
+    source_id: Optional[StrictStr] = Field(default=None, description="An ID referencing the original data source (specified via source) for the result. These IDs are specific to the source that they originated from. For example, in the case of OSM, these typically look like way/123 or point/123.")
+    label: Optional[StrictStr] = Field(default=None, description="A full, human-readable label. However, you may not necessarily want to use this; be sure to read the docs for name, locality, and region before making a decision. This field is mostly localized. The order of components is generally locally correct (ex: for an address in South Korea, the house number appears after the street name). However, components will use a request language equivalent if one exists (ex: Seoul instead of 서울 if lang=en).")
     layer: Optional[PeliasLayer] = None
-    name: Optional[StrictStr] = Field(None, description="The name of the place, the street address including house number, or label of similar relevance. If your app is localized to a specific region, you may get better display results by combining name, locality OR region (or neither?), and postal code together in the local format. Experiment with what works best for your use case.")
-    accuracy: Optional[StrictStr] = Field(None, description="The accuracy of the geographic coordinates in the result. This value is a property of the result itself and won't change based on the query. A point result means that the record can reasonably be represented by a single geographic point. Addresses, venues, or interpolated addresses usually have point accuracy. Larger areas, such as a city or country, cannot be represented by a single point, so a centroid is given instead.")
+    name: Optional[StrictStr] = Field(default=None, description="The name of the place, the street address including house number, or label of similar relevance. If your app is localized to a specific region, you may get better display results by combining name, locality OR region (or neither?), and postal code together in the local format. Experiment with what works best for your use case.")
+    accuracy: Optional[StrictStr] = Field(default=None, description="The accuracy of the geographic coordinates in the result. This value is a property of the result itself and won't change based on the query. A point result means that the record can reasonably be represented by a single geographic point. Addresses, venues, or interpolated addresses usually have point accuracy. Larger areas, such as a city or country, cannot be represented by a single point, so a centroid is given instead.")
     addendum: Optional[PeliasGeoJSONPropertiesAddendum] = None
     continent: Optional[StrictStr] = None
     continent_gid: Optional[StrictStr] = None
@@ -46,49 +47,65 @@ class PeliasGeoJSONProperties(BaseModel):
     postalcode: Optional[StrictStr] = None
     street: Optional[StrictStr] = None
     housenumber: Optional[StrictStr] = None
-    locality: Optional[StrictStr] = Field(None, description="The city, village, town, etc. that the place / address is part of. Note that values may not always match postal or local conventions perfectly.")
+    locality: Optional[StrictStr] = Field(default=None, description="The city, village, town, etc. that the place / address is part of. Note that values may not always match postal or local conventions perfectly.")
     locality_gid: Optional[StrictStr] = None
-    county: Optional[StrictStr] = Field(None, description="Administrative divisions between localities and regions. Useful for disambiguating nearby results with similar names.")
-    region: Optional[StrictStr] = Field(None, description="Typically the first administrative division within a country. For example, a US state or a Canadian province.")
-    region_a: Optional[StrictStr] = Field(None, description="The abbreviation for the region.")
+    county: Optional[StrictStr] = Field(default=None, description="Administrative divisions between localities and regions. Useful for disambiguating nearby results with similar names.")
+    region: Optional[StrictStr] = Field(default=None, description="Typically the first administrative division within a country. For example, a US state or a Canadian province.")
+    region_a: Optional[StrictStr] = Field(default=None, description="The abbreviation for the region.")
     additional_properties: Dict[str, Any] = {}
-    __properties = ["gid", "source_id", "label", "layer", "name", "accuracy", "addendum", "continent", "continent_gid", "country", "country_gid", "neighbourhood", "neighbourhood_gid", "borough", "borough_gid", "postalcode", "street", "housenumber", "locality", "locality_gid", "county", "region", "region_a"]
+    __properties: ClassVar[List[str]] = ["gid", "source_id", "label", "layer", "name", "accuracy", "addendum", "continent", "continent_gid", "country", "country_gid", "neighbourhood", "neighbourhood_gid", "borough", "borough_gid", "postalcode", "street", "housenumber", "locality", "locality_gid", "county", "region", "region_a"]
 
-    @validator('accuracy')
+    @field_validator('accuracy')
     def accuracy_validate_enum(cls, value):
         """Validates the enum"""
         if value is None:
             return value
 
-        if value not in ('point', 'centroid'):
+        if value not in set(['point', 'centroid']):
             raise ValueError("must be one of enum values ('point', 'centroid')")
         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) -> PeliasGeoJSONProperties:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of PeliasGeoJSONProperties 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 addendum
         if self.addendum:
             _dict['addendum'] = self.addendum.to_dict()
@@ -100,22 +117,22 @@ class PeliasGeoJSONProperties(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> PeliasGeoJSONProperties:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of PeliasGeoJSONProperties from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return PeliasGeoJSONProperties.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = PeliasGeoJSONProperties.parse_obj({
+        _obj = cls.model_validate({
             "gid": obj.get("gid"),
             "source_id": obj.get("source_id"),
             "label": obj.get("label"),
             "layer": obj.get("layer"),
             "name": obj.get("name"),
             "accuracy": obj.get("accuracy"),
-            "addendum": PeliasGeoJSONPropertiesAddendum.from_dict(obj.get("addendum")) if obj.get("addendum") is not None else None,
+            "addendum": PeliasGeoJSONPropertiesAddendum.from_dict(obj["addendum"]) if obj.get("addendum") is not None else None,
             "continent": obj.get("continent"),
             "continent_gid": obj.get("continent_gid"),
             "country": obj.get("country"),
@@ -140,3 +157,4 @@ class PeliasGeoJSONProperties(BaseModel):
 
         return _obj
 
+

stadiamaps/models/pelias_geo_json_properties_addendum.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,44 +18,61 @@ import pprint
 import re  # noqa: F401
 import json
 
-
-from typing import Optional
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
 from stadiamaps.models.pelias_geo_json_properties_addendum_osm import PeliasGeoJSONPropertiesAddendumOsm
+from typing import Optional, Set
+from typing_extensions import Self
 
 class PeliasGeoJSONPropertiesAddendum(BaseModel):
     """
     Optional additional information from the underlying data source (ex: OSM). This includes select fields. The most useful fields are mapped in the definition here, but others may be available.
-    """
+    """ # noqa: E501
     osm: Optional[PeliasGeoJSONPropertiesAddendumOsm] = None
     additional_properties: Dict[str, Any] = {}
-    __properties = ["osm"]
+    __properties: ClassVar[List[str]] = ["osm"]
+
+    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) -> PeliasGeoJSONPropertiesAddendum:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of PeliasGeoJSONPropertiesAddendum 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 osm
         if self.osm:
             _dict['osm'] = self.osm.to_dict()
@@ -67,16 +84,16 @@ class PeliasGeoJSONPropertiesAddendum(BaseModel):
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> PeliasGeoJSONPropertiesAddendum:
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
         """Create an instance of PeliasGeoJSONPropertiesAddendum from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return PeliasGeoJSONPropertiesAddendum.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = PeliasGeoJSONPropertiesAddendum.parse_obj({
-            "osm": PeliasGeoJSONPropertiesAddendumOsm.from_dict(obj.get("osm")) if obj.get("osm") is not None else None
+        _obj = cls.model_validate({
+            "osm": PeliasGeoJSONPropertiesAddendumOsm.from_dict(obj["osm"]) if obj.get("osm") is not None else None
         })
         # store additional fields in additional_properties
         for _key in obj.keys():
@@ -85,3 +102,4 @@ class PeliasGeoJSONPropertiesAddendum(BaseModel):
 
         return _obj
 
+