overturetoosm.segments

Pydantic models needed for transportation segments.

Partly autogenerated by datamodel-codegen.

  1"""Pydantic models needed for transportation segments.
  2
  3Partly autogenerated by datamodel-codegen.
  4"""
  5
  6from enum import Enum
  7from typing import Any, List, Optional, Union
  8
  9try:
 10    from typing import Annotated
 11except ImportError:
 12    from typing_extensions import Annotated
 13
 14from pydantic import BaseModel, ConfigDict, Field, RootModel
 15
 16from .objects import Names, Sources, Wikidata
 17
 18
 19class Subtype(str, Enum):
 20    """Model for transportation segment subtype."""
 21
 22    road = "road"
 23    rail = "rail"
 24    water = "water"
 25
 26
 27class AccessType(str, Enum):
 28    """Model for transportation segment access type."""
 29
 30    allowed = "allowed"
 31    denied = "denied"
 32    designated = "designated"
 33
 34
 35class Id(RootModel):
 36    """Model for transportation segment id.
 37
 38    A feature ID. This may be an ID associated with the Global Entity Reference System
 39    (GERS) if—and-only-if the feature represents an entity that is part of GERS.
 40    """
 41
 42    root: str
 43
 44
 45class Level(RootModel):
 46    """Model for transportation segment level."""
 47
 48    root: int = Field(default=0)
 49
 50
 51class LinearlyReferencedPosition(RootModel):
 52    """Model for transportation segment linearly referenced position."""
 53
 54    root: Annotated[float, Field(strict=True, ge=0.0, le=1.0)]
 55
 56
 57class LinearlyReferencedRange(RootModel):
 58    """Model for transportation segment linearly referenced range."""
 59
 60    root: Annotated[list, Field(float, min_length=2, max_length=2)]
 61
 62
 63class RoadClass(str, Enum):
 64    """Model for transportation segment road class."""
 65
 66    motorway = "motorway"
 67    primary = "primary"
 68    secondary = "secondary"
 69    tertiary = "tertiary"
 70    residential = "residential"
 71    living_street = "living_street"
 72    trunk = "trunk"
 73    unclassified = "unclassified"
 74    service = "service"
 75    pedestrian = "pedestrian"
 76    footway = "footway"
 77    steps = "steps"
 78    path = "path"
 79    track = "track"
 80    cycleway = "cycleway"
 81    bridleway = "bridleway"
 82    sidewalk = "sidewalk"
 83    crosswalk = "crosswalk"
 84    parking_aisle = "parking_aisle"
 85    driveway = "driveway"
 86    alley = "alley"
 87    cycle_crossing = "cycle_crossing"
 88    unknown = "unknown"
 89
 90
 91class Subclass(str, Enum):
 92    """Model for transportation segment subclass."""
 93
 94    link = "link"
 95    sidewalk = "sidewalk"
 96    crosswalk = "crosswalk"
 97    parking_aisle = "parking_aisle"
 98    driveway = "driveway"
 99    alley = "alley"
100    cycle_crossing = "cycle_crossing"
101
102
103class TemporalScopeContainer(BaseModel):
104    """Model for transportation segment temporal scope container."""
105
106    during: Optional[Any] = None
107
108
109class Heading(str, Enum):
110    """Model for transportation segment heading."""
111
112    forward = "forward"
113    backward = "backward"
114
115
116class PurposeOfUse(str, Enum):
117    """Model for transportation segment purpose of use."""
118
119    as_customer = "as_customer"
120    at_destination = "at_destination"
121    to_deliver = "to_deliver"
122    to_farm = "to_farm"
123    for_forestry = "for_forestry"
124
125
126class RecognizedStatus(str, Enum):
127    """Model for transportation segment recognized status."""
128
129    as_permitted = "as_permitted"
130    as_private = "as_private"
131    as_disabled = "as_disabled"
132    as_employee = "as_employee"
133    as_student = "as_student"
134
135
136class TravelMode(str, Enum):
137    """Model for transportation segment travel mode."""
138
139    vehicle = "vehicle"
140    motor_vehicle = "motor_vehicle"
141    car = "car"
142    truck = "truck"
143    motorcycle = "motorcycle"
144    foot = "foot"
145    bicycle = "bicycle"
146    bus = "bus"
147    hgv = "hgv"
148    hov = "hov"
149    emergency = "emergency"
150
151
152class VehicleScopeComparison(str, Enum):
153    """Model for transportation segment vehicle scope comparison."""
154
155    greater_than = "greater_than"
156    greater_than_equal = "greater_than_equal"
157    equal = "equal"
158    less_than = "less_than"
159    less_than_equal = "less_than_equal"
160
161
162class VehicleScopeDimension(str, Enum):
163    """Model for transportation segment vehicle scope dimension."""
164
165    axle_count = "axle_count"
166    height = "height"
167    length = "length"
168    weight = "weight"
169    width = "width"
170
171
172class LengthUnit(str, Enum):
173    """Model for transportation segment length unit."""
174
175    in_ = "in"
176    ft = "ft"
177    yd = "yd"
178    mi = "mi"
179    cm = "cm"
180    m = "m"
181    km = "km"
182
183
184class WeightUnit(str, Enum):
185    """Model for transportation segment weight unit."""
186
187    oz = "oz"
188    lb = "lb"
189    st = "st"
190    lt = "lt"
191    g = "g"
192    kg = "kg"
193    t = "t"
194
195
196class Connector(BaseModel):
197    """Model for transportation segment connector."""
198
199    connector_id: Id
200    at: LinearlyReferencedPosition
201
202
203class LevelRules(BaseModel):
204    """Model for transportation segment level rules container item."""
205
206    value: Level
207    between: Optional[LinearlyReferencedRange] = None
208
209
210class Route(BaseModel):
211    """Model for transportation segment route."""
212
213    name: Optional[str] = Field(description="Full name of the route")
214    network: Optional[str] = Field(
215        description="Name of the highway system this route belongs to"
216    )
217    ref: Optional[str] = Field(description="Code or number used to reference the route")
218    symbol: Optional[str] = Field(description="URL or description of route signage")
219    wikidata: Optional[Wikidata] = None
220
221
222class Routes(RootModel):
223    """Model for transportation segment routes."""
224
225    root: List[Route] = Field(description="Routes this segment belongs to.")
226
227
228class HeadingScopeContainer(BaseModel):
229    """Model for transportation segment heading scope container."""
230
231    heading: Optional[Heading] = None
232
233
234class PurposeOfUseScopeContainer(BaseModel):
235    """Model for transportation segment purpose of use scope container."""
236
237    using: Optional[List[PurposeOfUse]] = Field(None, min_length=1)
238
239
240class RecognizedStatusScopeContainer(BaseModel):
241    """Model for transportation segment recognized status scope container."""
242
243    recognized: Optional[List[RecognizedStatus]] = Field(None, min_length=1)
244
245
246class TravelModeScopeContainer(BaseModel):
247    """Model for transportation segment travel mode scope container."""
248
249    mode: Optional[List[TravelMode]] = Field(
250        None, min_length=1, description="Travel mode(s) to which the rule applies"
251    )
252
253
254class VehicleScopeUnit(RootModel):
255    """Model for transportation segment vehicle scope unit."""
256
257    root: Union[LengthUnit, WeightUnit] = Field(
258        description="Parent enum of both length and width for use in vehicle scoping"
259    )
260
261
262class VehicleItem(BaseModel):
263    """Model for transportation segment vehicle item."""
264
265    dimension: VehicleScopeDimension
266    comparison: VehicleScopeComparison
267    value: Annotated[float, Field(strict=True, ge=0.0)]
268    unit: Optional[VehicleScopeUnit] = None
269
270
271class VehicleScopeContainer(BaseModel):
272    """Model for transportation segment vehicle scope container."""
273
274    vehicle: Optional[List[VehicleItem]] = Field(
275        None, min_length=1, description="Vehicle attributes for which the rule applies"
276    )
277
278
279class When(
280    TemporalScopeContainer,
281    HeadingScopeContainer,
282    PurposeOfUseScopeContainer,
283    RecognizedStatusScopeContainer,
284    TravelModeScopeContainer,
285    VehicleScopeContainer,
286):
287    """Model for transportation segment when."""
288
289
290class AccessContainer(BaseModel):
291    """Model for transportation segment access container item."""
292
293    access_type: AccessType
294    when: Optional[When] = None
295
296
297class RoadFlagEnum(str, Enum):
298    """Overture road flag options."""
299
300    is_bridge = "is_bridge"
301    is_link = "is_link"
302    is_tunnel = "is_tunnel"
303    is_under_construction = "is_under_construction"
304    is_abandoned = "is_abandoned"
305    is_covered = "is_covered"
306
307
308class RoadFlag(BaseModel):
309    """Overture road flag."""
310
311    values: List[RoadFlagEnum]
312    between: Optional[LinearlyReferencedRange] = None
313
314
315class RoadSurfaceEnum(str, Enum):
316    """Overture road surface options."""
317
318    unknown = "unknown"
319    paved = "paved"
320    unpaved = "unpaved"
321    gravel = "gravel"
322    dirt = "dirt"
323    paving_stones = "paving_stones"
324    metal = "metal"
325
326
327class RoadSurface(BaseModel):
328    """Overture road surface."""
329
330    value: RoadSurfaceEnum
331    between: Optional[LinearlyReferencedRange] = None
332
333
334class SpeedUnit(str, Enum):
335    """Overture speed unit options."""
336
337    kmh = "km/h"
338    mph = "mph"
339
340
341class Speed(BaseModel):
342    """Overture speed."""
343
344    value: Annotated[int, Field(ge=1, le=350)]
345    unit: Optional[SpeedUnit] = None
346
347
348class SpeedLimit(BaseModel):
349    """Overture speed limit."""
350
351    min_speed: Optional[Speed] = None
352    max_speed: Speed
353
354
355class Sequence(BaseModel):
356    """Overture sequence."""
357
358    connector_id: Id
359    segment_id: Id
360
361
362class ProhibitedTransition(BaseModel):
363    """Overture prohibited transition."""
364
365    sequence: List[Sequence]
366    final_heading: Heading
367    when: When
368    between: Optional[LinearlyReferencedRange] = None
369
370
371class SegmentProperties(BaseModel):
372    """Model for transportation segment properties."""
373
374    model_config = ConfigDict(extra="forbid")
375
376    version: int = Field(
377        ge=0,
378        description="""Version number of the feature, incremented in each Overture
379        release where the geometry or attributes of this feature changed.""",
380    )
381    id: Id
382    subtype: Subtype = Field(description="Broad category of transportation segment.")
383    sources: Optional[List[Sources]] = None
384    class_: Optional[RoadClass] = Field(None, alias="class")
385    access_restrictions: Optional[List[AccessContainer]] = Field(
386        None, description="Rules governing access to this road segment or lane"
387    )
388    level: Optional[Level] = Field(
389        0, description="Z-order of the feature where 0 is visual level"
390    )
391    level_rules: Optional[List[LevelRules]] = None
392    connector_ids: Optional[List[Id]] = Field(
393        None, min_length=2, description="** DEPRECATED **"
394    )
395    connectors: Optional[Annotated[List[Connector], Field(min_length=2)]] = Field([])
396    """
397    List of connectors which this segment is physically connected to and their relative
398    location. Each connector is a possible routing decision point, meaning it defines a
399    place along the segment in which there is possibility to transition to other
400    segments which share the same connector.
401    """
402    road_surface: Optional[List[RoadSurface]] = None
403    road_flags: Optional[List[RoadFlag]] = None
404    speed_limits: Optional[List[SpeedLimit]] = None
405    prohibited_transitions: Optional[List[ProhibitedTransition]] = None
406    routes: Optional[Routes] = None
407    names: Optional[Names] = None
class Subtype(builtins.str, enum.Enum):
20class Subtype(str, Enum):
21    """Model for transportation segment subtype."""
22
23    road = "road"
24    rail = "rail"
25    water = "water"

Model for transportation segment subtype.

road = <Subtype.road: 'road'>
rail = <Subtype.rail: 'rail'>
water = <Subtype.water: 'water'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class AccessType(builtins.str, enum.Enum):
28class AccessType(str, Enum):
29    """Model for transportation segment access type."""
30
31    allowed = "allowed"
32    denied = "denied"
33    designated = "designated"

Model for transportation segment access type.

allowed = <AccessType.allowed: 'allowed'>
denied = <AccessType.denied: 'denied'>
designated = <AccessType.designated: 'designated'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class Id(pydantic.main.BaseModel, typing.Generic[~RootModelRootType]):
36class Id(RootModel):
37    """Model for transportation segment id.
38
39    A feature ID. This may be an ID associated with the Global Entity Reference System
40    (GERS) if—and-only-if the feature represents an entity that is part of GERS.
41    """
42
43    root: str

Model for transportation segment id.

A feature ID. This may be an ID associated with the Global Entity Reference System (GERS) if—and-only-if the feature represents an entity that is part of GERS.

root: str
Inherited Members
pydantic.main.BaseModel
BaseModel
model_config
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
model_fields
model_computed_fields
class Level(pydantic.main.BaseModel, typing.Generic[~RootModelRootType]):
46class Level(RootModel):
47    """Model for transportation segment level."""
48
49    root: int = Field(default=0)

Model for transportation segment level.

root: int
Inherited Members
pydantic.main.BaseModel
BaseModel
model_config
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
model_fields
model_computed_fields
class LinearlyReferencedPosition(pydantic.main.BaseModel, typing.Generic[~RootModelRootType]):
52class LinearlyReferencedPosition(RootModel):
53    """Model for transportation segment linearly referenced position."""
54
55    root: Annotated[float, Field(strict=True, ge=0.0, le=1.0)]

Model for transportation segment linearly referenced position.

root: Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=0.0), Le(le=1.0)])]
Inherited Members
pydantic.main.BaseModel
BaseModel
model_config
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
model_fields
model_computed_fields
class LinearlyReferencedRange(pydantic.main.BaseModel, typing.Generic[~RootModelRootType]):
58class LinearlyReferencedRange(RootModel):
59    """Model for transportation segment linearly referenced range."""
60
61    root: Annotated[list, Field(float, min_length=2, max_length=2)]

Model for transportation segment linearly referenced range.

root: Annotated[list, FieldInfo(annotation=NoneType, required=False, default=<class 'float'>, metadata=[MinLen(min_length=2), MaxLen(max_length=2)])]
Inherited Members
pydantic.main.BaseModel
BaseModel
model_config
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
model_fields
model_computed_fields
class RoadClass(builtins.str, enum.Enum):
64class RoadClass(str, Enum):
65    """Model for transportation segment road class."""
66
67    motorway = "motorway"
68    primary = "primary"
69    secondary = "secondary"
70    tertiary = "tertiary"
71    residential = "residential"
72    living_street = "living_street"
73    trunk = "trunk"
74    unclassified = "unclassified"
75    service = "service"
76    pedestrian = "pedestrian"
77    footway = "footway"
78    steps = "steps"
79    path = "path"
80    track = "track"
81    cycleway = "cycleway"
82    bridleway = "bridleway"
83    sidewalk = "sidewalk"
84    crosswalk = "crosswalk"
85    parking_aisle = "parking_aisle"
86    driveway = "driveway"
87    alley = "alley"
88    cycle_crossing = "cycle_crossing"
89    unknown = "unknown"

Model for transportation segment road class.

motorway = <RoadClass.motorway: 'motorway'>
primary = <RoadClass.primary: 'primary'>
secondary = <RoadClass.secondary: 'secondary'>
tertiary = <RoadClass.tertiary: 'tertiary'>
residential = <RoadClass.residential: 'residential'>
living_street = <RoadClass.living_street: 'living_street'>
trunk = <RoadClass.trunk: 'trunk'>
unclassified = <RoadClass.unclassified: 'unclassified'>
service = <RoadClass.service: 'service'>
pedestrian = <RoadClass.pedestrian: 'pedestrian'>
footway = <RoadClass.footway: 'footway'>
steps = <RoadClass.steps: 'steps'>
path = <RoadClass.path: 'path'>
track = <RoadClass.track: 'track'>
cycleway = <RoadClass.cycleway: 'cycleway'>
bridleway = <RoadClass.bridleway: 'bridleway'>
sidewalk = <RoadClass.sidewalk: 'sidewalk'>
crosswalk = <RoadClass.crosswalk: 'crosswalk'>
parking_aisle = <RoadClass.parking_aisle: 'parking_aisle'>
driveway = <RoadClass.driveway: 'driveway'>
alley = <RoadClass.alley: 'alley'>
cycle_crossing = <RoadClass.cycle_crossing: 'cycle_crossing'>
unknown = <RoadClass.unknown: 'unknown'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class Subclass(builtins.str, enum.Enum):
 92class Subclass(str, Enum):
 93    """Model for transportation segment subclass."""
 94
 95    link = "link"
 96    sidewalk = "sidewalk"
 97    crosswalk = "crosswalk"
 98    parking_aisle = "parking_aisle"
 99    driveway = "driveway"
100    alley = "alley"
101    cycle_crossing = "cycle_crossing"

Model for transportation segment subclass.

sidewalk = <Subclass.sidewalk: 'sidewalk'>
crosswalk = <Subclass.crosswalk: 'crosswalk'>
parking_aisle = <Subclass.parking_aisle: 'parking_aisle'>
driveway = <Subclass.driveway: 'driveway'>
alley = <Subclass.alley: 'alley'>
cycle_crossing = <Subclass.cycle_crossing: 'cycle_crossing'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class TemporalScopeContainer(pydantic.main.BaseModel):
104class TemporalScopeContainer(BaseModel):
105    """Model for transportation segment temporal scope container."""
106
107    during: Optional[Any] = None

Model for transportation segment temporal scope container.

during: Optional[Any]
model_config = {}
model_fields = {'during': FieldInfo(annotation=Union[Any, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class Heading(builtins.str, enum.Enum):
110class Heading(str, Enum):
111    """Model for transportation segment heading."""
112
113    forward = "forward"
114    backward = "backward"

Model for transportation segment heading.

forward = <Heading.forward: 'forward'>
backward = <Heading.backward: 'backward'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class PurposeOfUse(builtins.str, enum.Enum):
117class PurposeOfUse(str, Enum):
118    """Model for transportation segment purpose of use."""
119
120    as_customer = "as_customer"
121    at_destination = "at_destination"
122    to_deliver = "to_deliver"
123    to_farm = "to_farm"
124    for_forestry = "for_forestry"

Model for transportation segment purpose of use.

as_customer = <PurposeOfUse.as_customer: 'as_customer'>
at_destination = <PurposeOfUse.at_destination: 'at_destination'>
to_deliver = <PurposeOfUse.to_deliver: 'to_deliver'>
to_farm = <PurposeOfUse.to_farm: 'to_farm'>
for_forestry = <PurposeOfUse.for_forestry: 'for_forestry'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class RecognizedStatus(builtins.str, enum.Enum):
127class RecognizedStatus(str, Enum):
128    """Model for transportation segment recognized status."""
129
130    as_permitted = "as_permitted"
131    as_private = "as_private"
132    as_disabled = "as_disabled"
133    as_employee = "as_employee"
134    as_student = "as_student"

Model for transportation segment recognized status.

as_permitted = <RecognizedStatus.as_permitted: 'as_permitted'>
as_private = <RecognizedStatus.as_private: 'as_private'>
as_disabled = <RecognizedStatus.as_disabled: 'as_disabled'>
as_employee = <RecognizedStatus.as_employee: 'as_employee'>
as_student = <RecognizedStatus.as_student: 'as_student'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class TravelMode(builtins.str, enum.Enum):
137class TravelMode(str, Enum):
138    """Model for transportation segment travel mode."""
139
140    vehicle = "vehicle"
141    motor_vehicle = "motor_vehicle"
142    car = "car"
143    truck = "truck"
144    motorcycle = "motorcycle"
145    foot = "foot"
146    bicycle = "bicycle"
147    bus = "bus"
148    hgv = "hgv"
149    hov = "hov"
150    emergency = "emergency"

Model for transportation segment travel mode.

vehicle = <TravelMode.vehicle: 'vehicle'>
motor_vehicle = <TravelMode.motor_vehicle: 'motor_vehicle'>
car = <TravelMode.car: 'car'>
truck = <TravelMode.truck: 'truck'>
motorcycle = <TravelMode.motorcycle: 'motorcycle'>
foot = <TravelMode.foot: 'foot'>
bicycle = <TravelMode.bicycle: 'bicycle'>
bus = <TravelMode.bus: 'bus'>
hgv = <TravelMode.hgv: 'hgv'>
hov = <TravelMode.hov: 'hov'>
emergency = <TravelMode.emergency: 'emergency'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class VehicleScopeComparison(builtins.str, enum.Enum):
153class VehicleScopeComparison(str, Enum):
154    """Model for transportation segment vehicle scope comparison."""
155
156    greater_than = "greater_than"
157    greater_than_equal = "greater_than_equal"
158    equal = "equal"
159    less_than = "less_than"
160    less_than_equal = "less_than_equal"

Model for transportation segment vehicle scope comparison.

greater_than = <VehicleScopeComparison.greater_than: 'greater_than'>
greater_than_equal = <VehicleScopeComparison.greater_than_equal: 'greater_than_equal'>
equal = <VehicleScopeComparison.equal: 'equal'>
less_than = <VehicleScopeComparison.less_than: 'less_than'>
less_than_equal = <VehicleScopeComparison.less_than_equal: 'less_than_equal'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class VehicleScopeDimension(builtins.str, enum.Enum):
163class VehicleScopeDimension(str, Enum):
164    """Model for transportation segment vehicle scope dimension."""
165
166    axle_count = "axle_count"
167    height = "height"
168    length = "length"
169    weight = "weight"
170    width = "width"

Model for transportation segment vehicle scope dimension.

axle_count = <VehicleScopeDimension.axle_count: 'axle_count'>
height = <VehicleScopeDimension.height: 'height'>
length = <VehicleScopeDimension.length: 'length'>
weight = <VehicleScopeDimension.weight: 'weight'>
width = <VehicleScopeDimension.width: 'width'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class LengthUnit(builtins.str, enum.Enum):
173class LengthUnit(str, Enum):
174    """Model for transportation segment length unit."""
175
176    in_ = "in"
177    ft = "ft"
178    yd = "yd"
179    mi = "mi"
180    cm = "cm"
181    m = "m"
182    km = "km"

Model for transportation segment length unit.

in_ = <LengthUnit.in_: 'in'>
ft = <LengthUnit.ft: 'ft'>
yd = <LengthUnit.yd: 'yd'>
mi = <LengthUnit.mi: 'mi'>
cm = <LengthUnit.cm: 'cm'>
m = <LengthUnit.m: 'm'>
km = <LengthUnit.km: 'km'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class WeightUnit(builtins.str, enum.Enum):
185class WeightUnit(str, Enum):
186    """Model for transportation segment weight unit."""
187
188    oz = "oz"
189    lb = "lb"
190    st = "st"
191    lt = "lt"
192    g = "g"
193    kg = "kg"
194    t = "t"

Model for transportation segment weight unit.

oz = <WeightUnit.oz: 'oz'>
lb = <WeightUnit.lb: 'lb'>
st = <WeightUnit.st: 'st'>
lt = <WeightUnit.lt: 'lt'>
g = <WeightUnit.g: 'g'>
kg = <WeightUnit.kg: 'kg'>
t = <WeightUnit.t: 't'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class Connector(pydantic.main.BaseModel):
197class Connector(BaseModel):
198    """Model for transportation segment connector."""
199
200    connector_id: Id
201    at: LinearlyReferencedPosition

Model for transportation segment connector.

connector_id: Id
model_config = {}
model_fields = {'connector_id': FieldInfo(annotation=Id, required=True), 'at': FieldInfo(annotation=LinearlyReferencedPosition, required=True)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class LevelRules(pydantic.main.BaseModel):
204class LevelRules(BaseModel):
205    """Model for transportation segment level rules container item."""
206
207    value: Level
208    between: Optional[LinearlyReferencedRange] = None

Model for transportation segment level rules container item.

value: Level
between: Optional[LinearlyReferencedRange]
model_config = {}
model_fields = {'value': FieldInfo(annotation=Level, required=True), 'between': FieldInfo(annotation=Union[LinearlyReferencedRange, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class Route(pydantic.main.BaseModel):
211class Route(BaseModel):
212    """Model for transportation segment route."""
213
214    name: Optional[str] = Field(description="Full name of the route")
215    network: Optional[str] = Field(
216        description="Name of the highway system this route belongs to"
217    )
218    ref: Optional[str] = Field(description="Code or number used to reference the route")
219    symbol: Optional[str] = Field(description="URL or description of route signage")
220    wikidata: Optional[Wikidata] = None

Model for transportation segment route.

name: Optional[str]
network: Optional[str]
ref: Optional[str]
symbol: Optional[str]
wikidata: Optional[overturetoosm.objects.Wikidata]
model_config = {}
model_fields = {'name': FieldInfo(annotation=Union[str, NoneType], required=True, description='Full name of the route'), 'network': FieldInfo(annotation=Union[str, NoneType], required=True, description='Name of the highway system this route belongs to'), 'ref': FieldInfo(annotation=Union[str, NoneType], required=True, description='Code or number used to reference the route'), 'symbol': FieldInfo(annotation=Union[str, NoneType], required=True, description='URL or description of route signage'), 'wikidata': FieldInfo(annotation=Union[Wikidata, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class Routes(pydantic.main.BaseModel, typing.Generic[~RootModelRootType]):
223class Routes(RootModel):
224    """Model for transportation segment routes."""
225
226    root: List[Route] = Field(description="Routes this segment belongs to.")

Model for transportation segment routes.

root: List[Route]
Inherited Members
pydantic.main.BaseModel
BaseModel
model_config
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
model_fields
model_computed_fields
class HeadingScopeContainer(pydantic.main.BaseModel):
229class HeadingScopeContainer(BaseModel):
230    """Model for transportation segment heading scope container."""
231
232    heading: Optional[Heading] = None

Model for transportation segment heading scope container.

heading: Optional[Heading]
model_config = {}
model_fields = {'heading': FieldInfo(annotation=Union[Heading, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class PurposeOfUseScopeContainer(pydantic.main.BaseModel):
235class PurposeOfUseScopeContainer(BaseModel):
236    """Model for transportation segment purpose of use scope container."""
237
238    using: Optional[List[PurposeOfUse]] = Field(None, min_length=1)

Model for transportation segment purpose of use scope container.

using: Optional[List[PurposeOfUse]]
model_config = {}
model_fields = {'using': FieldInfo(annotation=Union[List[PurposeOfUse], NoneType], required=False, default=None, metadata=[MinLen(min_length=1)])}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class RecognizedStatusScopeContainer(pydantic.main.BaseModel):
241class RecognizedStatusScopeContainer(BaseModel):
242    """Model for transportation segment recognized status scope container."""
243
244    recognized: Optional[List[RecognizedStatus]] = Field(None, min_length=1)

Model for transportation segment recognized status scope container.

recognized: Optional[List[RecognizedStatus]]
model_config = {}
model_fields = {'recognized': FieldInfo(annotation=Union[List[RecognizedStatus], NoneType], required=False, default=None, metadata=[MinLen(min_length=1)])}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class TravelModeScopeContainer(pydantic.main.BaseModel):
247class TravelModeScopeContainer(BaseModel):
248    """Model for transportation segment travel mode scope container."""
249
250    mode: Optional[List[TravelMode]] = Field(
251        None, min_length=1, description="Travel mode(s) to which the rule applies"
252    )

Model for transportation segment travel mode scope container.

mode: Optional[List[TravelMode]]
model_config = {}
model_fields = {'mode': FieldInfo(annotation=Union[List[TravelMode], NoneType], required=False, default=None, description='Travel mode(s) to which the rule applies', metadata=[MinLen(min_length=1)])}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class VehicleScopeUnit(pydantic.main.BaseModel, typing.Generic[~RootModelRootType]):
255class VehicleScopeUnit(RootModel):
256    """Model for transportation segment vehicle scope unit."""
257
258    root: Union[LengthUnit, WeightUnit] = Field(
259        description="Parent enum of both length and width for use in vehicle scoping"
260    )

Model for transportation segment vehicle scope unit.

root: Union[LengthUnit, WeightUnit]
Inherited Members
pydantic.main.BaseModel
BaseModel
model_config
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
model_fields
model_computed_fields
class VehicleItem(pydantic.main.BaseModel):
263class VehicleItem(BaseModel):
264    """Model for transportation segment vehicle item."""
265
266    dimension: VehicleScopeDimension
267    comparison: VehicleScopeComparison
268    value: Annotated[float, Field(strict=True, ge=0.0)]
269    unit: Optional[VehicleScopeUnit] = None

Model for transportation segment vehicle item.

value: Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=0.0)])]
unit: Optional[VehicleScopeUnit]
model_config = {}
model_fields = {'dimension': FieldInfo(annotation=VehicleScopeDimension, required=True), 'comparison': FieldInfo(annotation=VehicleScopeComparison, required=True), 'value': FieldInfo(annotation=float, required=True, metadata=[Strict(strict=True), Ge(ge=0.0)]), 'unit': FieldInfo(annotation=Union[VehicleScopeUnit, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class VehicleScopeContainer(pydantic.main.BaseModel):
272class VehicleScopeContainer(BaseModel):
273    """Model for transportation segment vehicle scope container."""
274
275    vehicle: Optional[List[VehicleItem]] = Field(
276        None, min_length=1, description="Vehicle attributes for which the rule applies"
277    )

Model for transportation segment vehicle scope container.

vehicle: Optional[List[VehicleItem]]
model_config = {}
model_fields = {'vehicle': FieldInfo(annotation=Union[List[VehicleItem], NoneType], required=False, default=None, description='Vehicle attributes for which the rule applies', metadata=[MinLen(min_length=1)])}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
280class When(
281    TemporalScopeContainer,
282    HeadingScopeContainer,
283    PurposeOfUseScopeContainer,
284    RecognizedStatusScopeContainer,
285    TravelModeScopeContainer,
286    VehicleScopeContainer,
287):
288    """Model for transportation segment when."""

Model for transportation segment when.

model_config = {}
model_fields = {'vehicle': FieldInfo(annotation=Union[List[VehicleItem], NoneType], required=False, default=None, description='Vehicle attributes for which the rule applies', metadata=[MinLen(min_length=1)]), 'mode': FieldInfo(annotation=Union[List[TravelMode], NoneType], required=False, default=None, description='Travel mode(s) to which the rule applies', metadata=[MinLen(min_length=1)]), 'recognized': FieldInfo(annotation=Union[List[RecognizedStatus], NoneType], required=False, default=None, metadata=[MinLen(min_length=1)]), 'using': FieldInfo(annotation=Union[List[PurposeOfUse], NoneType], required=False, default=None, metadata=[MinLen(min_length=1)]), 'heading': FieldInfo(annotation=Union[Heading, NoneType], required=False, default=None), 'during': FieldInfo(annotation=Union[Any, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
TemporalScopeContainer
during
HeadingScopeContainer
heading
PurposeOfUseScopeContainer
using
RecognizedStatusScopeContainer
recognized
TravelModeScopeContainer
mode
VehicleScopeContainer
vehicle
class AccessContainer(pydantic.main.BaseModel):
291class AccessContainer(BaseModel):
292    """Model for transportation segment access container item."""
293
294    access_type: AccessType
295    when: Optional[When] = None

Model for transportation segment access container item.

access_type: AccessType
when: Optional[When]
model_config = {}
model_fields = {'access_type': FieldInfo(annotation=AccessType, required=True), 'when': FieldInfo(annotation=Union[When, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class RoadFlagEnum(builtins.str, enum.Enum):
298class RoadFlagEnum(str, Enum):
299    """Overture road flag options."""
300
301    is_bridge = "is_bridge"
302    is_link = "is_link"
303    is_tunnel = "is_tunnel"
304    is_under_construction = "is_under_construction"
305    is_abandoned = "is_abandoned"
306    is_covered = "is_covered"

Overture road flag options.

is_bridge = <RoadFlagEnum.is_bridge: 'is_bridge'>
is_tunnel = <RoadFlagEnum.is_tunnel: 'is_tunnel'>
is_under_construction = <RoadFlagEnum.is_under_construction: 'is_under_construction'>
is_abandoned = <RoadFlagEnum.is_abandoned: 'is_abandoned'>
is_covered = <RoadFlagEnum.is_covered: 'is_covered'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class RoadFlag(pydantic.main.BaseModel):
309class RoadFlag(BaseModel):
310    """Overture road flag."""
311
312    values: List[RoadFlagEnum]
313    between: Optional[LinearlyReferencedRange] = None

Overture road flag.

values: List[RoadFlagEnum]
between: Optional[LinearlyReferencedRange]
model_config = {}
model_fields = {'values': FieldInfo(annotation=List[RoadFlagEnum], required=True), 'between': FieldInfo(annotation=Union[LinearlyReferencedRange, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class RoadSurfaceEnum(builtins.str, enum.Enum):
316class RoadSurfaceEnum(str, Enum):
317    """Overture road surface options."""
318
319    unknown = "unknown"
320    paved = "paved"
321    unpaved = "unpaved"
322    gravel = "gravel"
323    dirt = "dirt"
324    paving_stones = "paving_stones"
325    metal = "metal"

Overture road surface options.

unknown = <RoadSurfaceEnum.unknown: 'unknown'>
paved = <RoadSurfaceEnum.paved: 'paved'>
unpaved = <RoadSurfaceEnum.unpaved: 'unpaved'>
gravel = <RoadSurfaceEnum.gravel: 'gravel'>
dirt = <RoadSurfaceEnum.dirt: 'dirt'>
paving_stones = <RoadSurfaceEnum.paving_stones: 'paving_stones'>
metal = <RoadSurfaceEnum.metal: 'metal'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class RoadSurface(pydantic.main.BaseModel):
328class RoadSurface(BaseModel):
329    """Overture road surface."""
330
331    value: RoadSurfaceEnum
332    between: Optional[LinearlyReferencedRange] = None

Overture road surface.

between: Optional[LinearlyReferencedRange]
model_config = {}
model_fields = {'value': FieldInfo(annotation=RoadSurfaceEnum, required=True), 'between': FieldInfo(annotation=Union[LinearlyReferencedRange, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class SpeedUnit(builtins.str, enum.Enum):
335class SpeedUnit(str, Enum):
336    """Overture speed unit options."""
337
338    kmh = "km/h"
339    mph = "mph"

Overture speed unit options.

kmh = <SpeedUnit.kmh: 'km/h'>
mph = <SpeedUnit.mph: 'mph'>
Inherited Members
enum.Enum
name
value
builtins.str
encode
replace
split
rsplit
join
capitalize
casefold
title
center
count
expandtabs
find
partition
index
ljust
lower
lstrip
rfind
rindex
rjust
rstrip
rpartition
splitlines
strip
swapcase
translate
upper
startswith
endswith
removeprefix
removesuffix
isascii
islower
isupper
istitle
isspace
isdecimal
isdigit
isnumeric
isalpha
isalnum
isidentifier
isprintable
zfill
format
format_map
maketrans
class Speed(pydantic.main.BaseModel):
342class Speed(BaseModel):
343    """Overture speed."""
344
345    value: Annotated[int, Field(ge=1, le=350)]
346    unit: Optional[SpeedUnit] = None

Overture speed.

value: Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=1), Le(le=350)])]
unit: Optional[SpeedUnit]
model_config = {}
model_fields = {'value': FieldInfo(annotation=int, required=True, metadata=[Ge(ge=1), Le(le=350)]), 'unit': FieldInfo(annotation=Union[SpeedUnit, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class SpeedLimit(pydantic.main.BaseModel):
349class SpeedLimit(BaseModel):
350    """Overture speed limit."""
351
352    min_speed: Optional[Speed] = None
353    max_speed: Speed

Overture speed limit.

min_speed: Optional[Speed]
max_speed: Speed
model_config = {}
model_fields = {'min_speed': FieldInfo(annotation=Union[Speed, NoneType], required=False, default=None), 'max_speed': FieldInfo(annotation=Speed, required=True)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class Sequence(pydantic.main.BaseModel):
356class Sequence(BaseModel):
357    """Overture sequence."""
358
359    connector_id: Id
360    segment_id: Id

Overture sequence.

connector_id: Id
segment_id: Id
model_config = {}
model_fields = {'connector_id': FieldInfo(annotation=Id, required=True), 'segment_id': FieldInfo(annotation=Id, required=True)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class ProhibitedTransition(pydantic.main.BaseModel):
363class ProhibitedTransition(BaseModel):
364    """Overture prohibited transition."""
365
366    sequence: List[Sequence]
367    final_heading: Heading
368    when: When
369    between: Optional[LinearlyReferencedRange] = None

Overture prohibited transition.

sequence: List[Sequence]
final_heading: Heading
when: When
between: Optional[LinearlyReferencedRange]
model_config = {}
model_fields = {'sequence': FieldInfo(annotation=List[Sequence], required=True), 'final_heading': FieldInfo(annotation=Heading, required=True), 'when': FieldInfo(annotation=When, required=True), 'between': FieldInfo(annotation=Union[LinearlyReferencedRange, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs
class SegmentProperties(pydantic.main.BaseModel):
372class SegmentProperties(BaseModel):
373    """Model for transportation segment properties."""
374
375    model_config = ConfigDict(extra="forbid")
376
377    version: int = Field(
378        ge=0,
379        description="""Version number of the feature, incremented in each Overture
380        release where the geometry or attributes of this feature changed.""",
381    )
382    id: Id
383    subtype: Subtype = Field(description="Broad category of transportation segment.")
384    sources: Optional[List[Sources]] = None
385    class_: Optional[RoadClass] = Field(None, alias="class")
386    access_restrictions: Optional[List[AccessContainer]] = Field(
387        None, description="Rules governing access to this road segment or lane"
388    )
389    level: Optional[Level] = Field(
390        0, description="Z-order of the feature where 0 is visual level"
391    )
392    level_rules: Optional[List[LevelRules]] = None
393    connector_ids: Optional[List[Id]] = Field(
394        None, min_length=2, description="** DEPRECATED **"
395    )
396    connectors: Optional[Annotated[List[Connector], Field(min_length=2)]] = Field([])
397    """
398    List of connectors which this segment is physically connected to and their relative
399    location. Each connector is a possible routing decision point, meaning it defines a
400    place along the segment in which there is possibility to transition to other
401    segments which share the same connector.
402    """
403    road_surface: Optional[List[RoadSurface]] = None
404    road_flags: Optional[List[RoadFlag]] = None
405    speed_limits: Optional[List[SpeedLimit]] = None
406    prohibited_transitions: Optional[List[ProhibitedTransition]] = None
407    routes: Optional[Routes] = None
408    names: Optional[Names] = None

Model for transportation segment properties.

model_config = {'extra': 'forbid'}
version: int
id: Id
subtype: Subtype
sources: Optional[List[overturetoosm.objects.Sources]]
class_: Optional[RoadClass]
access_restrictions: Optional[List[AccessContainer]]
level: Optional[Level]
level_rules: Optional[List[LevelRules]]
connector_ids: Optional[List[Id]]
connectors: Optional[Annotated[List[Connector], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=2)])]]

List of connectors which this segment is physically connected to and their relative location. Each connector is a possible routing decision point, meaning it defines a place along the segment in which there is possibility to transition to other segments which share the same connector.

road_surface: Optional[List[RoadSurface]]
road_flags: Optional[List[RoadFlag]]
speed_limits: Optional[List[SpeedLimit]]
prohibited_transitions: Optional[List[ProhibitedTransition]]
routes: Optional[Routes]
names: Optional[overturetoosm.objects.Names]
model_fields = {'version': FieldInfo(annotation=int, required=True, description='Version number of the feature, incremented in each Overture\n release where the geometry or attributes of this feature changed.', metadata=[Ge(ge=0)]), 'id': FieldInfo(annotation=Id, required=True), 'subtype': FieldInfo(annotation=Subtype, required=True, description='Broad category of transportation segment.'), 'sources': FieldInfo(annotation=Union[List[Sources], NoneType], required=False, default=None), 'class_': FieldInfo(annotation=Union[RoadClass, NoneType], required=False, default=None, alias='class', alias_priority=2), 'access_restrictions': FieldInfo(annotation=Union[List[AccessContainer], NoneType], required=False, default=None, description='Rules governing access to this road segment or lane'), 'level': FieldInfo(annotation=Union[Level, NoneType], required=False, default=0, description='Z-order of the feature where 0 is visual level'), 'level_rules': FieldInfo(annotation=Union[List[LevelRules], NoneType], required=False, default=None), 'connector_ids': FieldInfo(annotation=Union[List[Id], NoneType], required=False, default=None, description='** DEPRECATED **', metadata=[MinLen(min_length=2)]), 'connectors': FieldInfo(annotation=Union[Annotated[List[Connector], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=2)])], NoneType], required=False, default=[]), 'road_surface': FieldInfo(annotation=Union[List[RoadSurface], NoneType], required=False, default=None), 'road_flags': FieldInfo(annotation=Union[List[RoadFlag], NoneType], required=False, default=None), 'speed_limits': FieldInfo(annotation=Union[List[SpeedLimit], NoneType], required=False, default=None), 'prohibited_transitions': FieldInfo(annotation=Union[List[ProhibitedTransition], NoneType], required=False, default=None), 'routes': FieldInfo(annotation=Union[Routes, NoneType], required=False, default=None), 'names': FieldInfo(annotation=Union[Names, NoneType], required=False, default=None)}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs