obsplus.events.schema module

Pydantic schema for ObsPlus event model.

ObsPlus Event Model is a superset of, and compatible with, ObsPy’s Event model.

class obsplus.events.schema.Amplitude(**data)

Bases: _ModelWithResourceID

category: Optional[Literal['point', 'mean', 'duration', 'period', 'integral', 'other']]

comments: List[Comment]

creation_info: Optional[CreationInfo]

evaluation_mode: Optional[Literal['manual', 'automatic']]

evaluation_status: Optional[Literal['preliminary', 'confirmed', 'reviewed', 'final', 'rejected']]

filter_id: Optional[ResourceIdentifier]

generic_amplitude: Optional[float]

generic_amplitude_errors: Optional[QuantityError]

magnitude_hint: Optional[str]

method_id: Optional[ResourceIdentifier]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'category': FieldInfo(annotation=Union[Literal['point', 'mean', 'duration', 'period', 'integral', 'other'], NoneType], required=False), 'comments': FieldInfo(annotation=List[Comment], required=False, default=[]), 'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'evaluation_mode': FieldInfo(annotation=Union[Literal['manual', 'automatic'], NoneType], required=False), 'evaluation_status': FieldInfo(annotation=Union[Literal['preliminary', 'confirmed', 'reviewed', 'final', 'rejected'], NoneType], required=False), 'filter_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'generic_amplitude': FieldInfo(annotation=Union[float, NoneType], required=False), 'generic_amplitude_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'magnitude_hint': FieldInfo(annotation=Union[str, NoneType], required=False), 'method_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'period': FieldInfo(annotation=Union[float, NoneType], required=False), 'period_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'pick_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>), 'scaling_time': FieldInfo(annotation=Union[Annotated[UTCDateTime, PlainValidator], NoneType], required=False), 'scaling_time_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'snr': FieldInfo(annotation=Union[float, NoneType], required=False), 'time_window': FieldInfo(annotation=Union[TimeWindow, NoneType], required=False), 'type': FieldInfo(annotation=Union[str, NoneType], required=False), 'unit': FieldInfo(annotation=Union[Literal['m', 's', 'm/s', 'm/(s*s)', 'm*s', 'dimensionless', 'other'], NoneType], required=False), 'waveform_id': FieldInfo(annotation=Union[WaveformStreamID, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

period: Optional[float]

period_errors: Optional[QuantityError]

pick_id: Optional[ResourceIdentifier]

scaling_time: Optional[Annotated[UTCDateTime]]

scaling_time_errors: Optional[QuantityError]

snr: Optional[float]

time_window: Optional[TimeWindow]

type: Optional[str]

unit: Optional[Literal['m', 's', 'm/s', 'm/(s*s)', 'm*s', 'dimensionless', 'other']]

waveform_id: Optional[WaveformStreamID]

class obsplus.events.schema.Arrival(**data)

Bases: _ModelWithResourceID

azimuth: Optional[float]

backazimuth_residual: Optional[float]

backazimuth_weight: Optional[float]

comments: List[Comment]

creation_info: Optional[CreationInfo]

distance: Optional[float]

earth_model_id: Optional[ResourceIdentifier]

horizontal_slowness_residual: Optional[float]

horizontal_slowness_weight: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'azimuth': FieldInfo(annotation=Union[float, NoneType], required=False), 'backazimuth_residual': FieldInfo(annotation=Union[float, NoneType], required=False), 'backazimuth_weight': FieldInfo(annotation=Union[float, NoneType], required=False), 'comments': FieldInfo(annotation=List[Comment], required=False, default=[]), 'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'distance': FieldInfo(annotation=Union[float, NoneType], required=False), 'earth_model_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'horizontal_slowness_residual': FieldInfo(annotation=Union[float, NoneType], required=False), 'horizontal_slowness_weight': FieldInfo(annotation=Union[float, NoneType], required=False), 'phase': FieldInfo(annotation=Union[str, NoneType], required=False), 'pick_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>), 'takeoff_angle': FieldInfo(annotation=Union[float, NoneType], required=False), 'takeoff_angle_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'time_correction': FieldInfo(annotation=Union[float, NoneType], required=False), 'time_residual': FieldInfo(annotation=Union[float, NoneType], required=False), 'time_weight': FieldInfo(annotation=Union[float, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

phase: Optional[str]

pick_id: Optional[ResourceIdentifier]

takeoff_angle: Optional[float]

takeoff_angle_errors: Optional[QuantityError]

time_correction: Optional[float]

time_residual: Optional[float]

time_weight: Optional[float]

class obsplus.events.schema.Axis(**data)

Bases: _ObsPyModel

azimuth: Optional[float]

length: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'azimuth': FieldInfo(annotation=Union[float, NoneType], required=False), 'length': FieldInfo(annotation=Union[float, NoneType], required=False), 'plunge': FieldInfo(annotation=Union[float, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

plunge: Optional[float]

class obsplus.events.schema.Catalog(**data)

Bases: _ModelWithResourceID

A collection of events.

comments: Optional[List[Comment]]

creation_info: Optional[CreationInfo]

description: Optional[str]

events: List[Event]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'comments': FieldInfo(annotation=Union[List[Comment], NoneType], required=False), 'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'description': FieldInfo(annotation=Union[str, NoneType], required=False), 'events': FieldInfo(annotation=List[Event], required=False, default=[]), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class obsplus.events.schema.Comment(**data)

Bases: _ModelWithResourceID

creation_info: Optional[CreationInfo]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>), 'text': FieldInfo(annotation=Union[str, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

text: Optional[str]

class obsplus.events.schema.CompositeTime(**data)

Bases: _ObsPyModel

Composite Time

day: Optional[int]

day_errors: Optional[QuantityError]

hour: Optional[int]

hour_errors: Optional[QuantityError]

minute: Optional[int]

minute_errors: Optional[QuantityError]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'day': FieldInfo(annotation=Union[int, NoneType], required=False), 'day_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'hour': FieldInfo(annotation=Union[int, NoneType], required=False), 'hour_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'minute': FieldInfo(annotation=Union[int, NoneType], required=False), 'minute_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'month': FieldInfo(annotation=Union[int, NoneType], required=False), 'month_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'second': FieldInfo(annotation=Union[float, NoneType], required=False), 'second_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'year': FieldInfo(annotation=Union[int, NoneType], required=False), 'year_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

month: Optional[int]

month_errors: Optional[QuantityError]

second: Optional[float]

second_errors: Optional[QuantityError]

year: Optional[int]

year_errors: Optional[QuantityError]

class obsplus.events.schema.ConfidenceEllipsoid(**data)

Bases: _ObsPyModel

Confidence Ellipsoid

major_axis_azimuth: Optional[float]

major_axis_plunge: Optional[float]

major_axis_rotation: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'major_axis_azimuth': FieldInfo(annotation=Union[float, NoneType], required=False), 'major_axis_plunge': FieldInfo(annotation=Union[float, NoneType], required=False), 'major_axis_rotation': FieldInfo(annotation=Union[float, NoneType], required=False), 'semi_intermediate_axis_length': FieldInfo(annotation=Union[float, NoneType], required=False), 'semi_major_axis_length': FieldInfo(annotation=Union[float, NoneType], required=False), 'semi_minor_axis_length': FieldInfo(annotation=Union[float, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

semi_intermediate_axis_length: Optional[float]

semi_major_axis_length: Optional[float]

semi_minor_axis_length: Optional[float]

class obsplus.events.schema.CreationInfo(**data)

Bases: _ObsPyModel

Creation info

agency_id: Optional[str]

agency_uri: Optional[ResourceIdentifier]

author: Optional[str]

author_uri: Optional[ResourceIdentifier]

creation_time: Optional[Annotated[UTCDateTime]]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'agency_id': FieldInfo(annotation=Union[str, NoneType], required=False), 'agency_uri': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'author': FieldInfo(annotation=Union[str, NoneType], required=False), 'author_uri': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'creation_time': FieldInfo(annotation=Union[Annotated[UTCDateTime, PlainValidator], NoneType], required=False), 'version': FieldInfo(annotation=Union[str, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

version: Optional[str]

class obsplus.events.schema.DataUsed(**data)

Bases: _ObsPyModel

Data Used

component_count: Optional[int]

longest_period: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'component_count': FieldInfo(annotation=Union[int, NoneType], required=False), 'longest_period': FieldInfo(annotation=Union[float, NoneType], required=False), 'shortest_period': FieldInfo(annotation=Union[float, NoneType], required=False), 'station_count': FieldInfo(annotation=Union[int, NoneType], required=False), 'wave_type': FieldInfo(annotation=Union[Literal['P waves', 'body waves', 'surface waves', 'mantle waves', 'combined', 'unknown'], NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

shortest_period: Optional[float]

station_count: Optional[int]

wave_type: Optional[Literal['P waves', 'body waves', 'surface waves', 'mantle waves', 'combined', 'unknown']]

class obsplus.events.schema.Event(**data)

Bases: _ModelWithResourceID

amplitudes: List[Amplitude]

comments: List[Comment]

creation_info: Optional[CreationInfo]

event_descriptions: List[EventDescription]

event_type: Optional[Literal['not existing', 'not reported', 'earthquake', 'anthropogenic event', 'collapse', 'cavity collapse', 'mine collapse', 'building collapse', 'explosion', 'accidental explosion', 'chemical explosion', 'controlled explosion', 'experimental explosion', 'industrial explosion', 'mining explosion', 'quarry blast', 'road cut', 'blasting levee', 'nuclear explosion', 'induced or triggered event', 'rock burst', 'reservoir loading', 'fluid injection', 'fluid extraction', 'crash', 'plane crash', 'train crash', 'boat crash', 'other event', 'atmospheric event', 'sonic boom', 'sonic blast', 'acoustic noise', 'thunder', 'avalanche', 'snow avalanche', 'debris avalanche', 'hydroacoustic event', 'ice quake', 'slide', 'landslide', 'rockslide', 'meteorite', 'volcanic eruption']]

event_type_certainty: Optional[Literal['known', 'suspected']]

focal_mechanisms: List[FocalMechanism]

magnitudes: List[Magnitude]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'amplitudes': FieldInfo(annotation=List[Amplitude], required=False, default=[]), 'comments': FieldInfo(annotation=List[Comment], required=False, default=[]), 'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'event_descriptions': FieldInfo(annotation=List[EventDescription], required=False, default=[]), 'event_type': FieldInfo(annotation=Union[Literal['not existing', 'not reported', 'earthquake', 'anthropogenic event', 'collapse', 'cavity collapse', 'mine collapse', 'building collapse', 'explosion', 'accidental explosion', 'chemical explosion', 'controlled explosion', 'experimental explosion', 'industrial explosion', 'mining explosion', 'quarry blast', 'road cut', 'blasting levee', 'nuclear explosion', 'induced or triggered event', 'rock burst', 'reservoir loading', 'fluid injection', 'fluid extraction', 'crash', 'plane crash', 'train crash', 'boat crash', 'other event', 'atmospheric event', 'sonic boom', 'sonic blast', 'acoustic noise', 'thunder', 'avalanche', 'snow avalanche', 'debris avalanche', 'hydroacoustic event', 'ice quake', 'slide', 'landslide', 'rockslide', 'meteorite', 'volcanic eruption'], NoneType], required=False), 'event_type_certainty': FieldInfo(annotation=Union[Literal['known', 'suspected'], NoneType], required=False), 'focal_mechanisms': FieldInfo(annotation=List[FocalMechanism], required=False, default=[]), 'magnitudes': FieldInfo(annotation=List[Magnitude], required=False, default=[]), 'origins': FieldInfo(annotation=List[Origin], required=False, default=[]), 'picks': FieldInfo(annotation=List[Pick], required=False, default=[]), 'preferred_focal_mechanism_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'preferred_magnitude_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'preferred_origin_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>), 'station_magnitudes': FieldInfo(annotation=List[StationMagnitude], required=False, default=[])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

origins: List[Origin]

picks: List[Pick]

preferred_focal_mechanism_id: Optional[ResourceIdentifier]

preferred_magnitude_id: Optional[ResourceIdentifier]

preferred_origin_id: Optional[ResourceIdentifier]

station_magnitudes: List[StationMagnitude]

to_obspy()

convert the catalog to obspy form

class obsplus.events.schema.EventDescription(**data)

Bases: _ObsPyModel

Event Description

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'text': FieldInfo(annotation=Union[str, NoneType], required=False), 'type': FieldInfo(annotation=Union[Literal['felt report', 'Flinn-Engdahl region', 'local time', 'tectonic summary', 'nearest cities', 'earthquake name', 'region name'], NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

text: Optional[str]

type: Optional[Literal['felt report', 'Flinn-Engdahl region', 'local time', 'tectonic summary', 'nearest cities', 'earthquake name', 'region name']]

class obsplus.events.schema.FocalMechanism(**data)

Bases: _ModelWithResourceID

Focal Mechanism

azimuthal_gap: Optional[float]

comments: List[Comment]

creation_info: Optional[CreationInfo]

evaluation_mode: Optional[Literal['manual', 'automatic']]

evaluation_status: Optional[Literal['preliminary', 'confirmed', 'reviewed', 'final', 'rejected']]

method_id: Optional[ResourceIdentifier]

misfit: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'azimuthal_gap': FieldInfo(annotation=Union[float, NoneType], required=False), 'comments': FieldInfo(annotation=List[Comment], required=False, default=[]), 'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'evaluation_mode': FieldInfo(annotation=Union[Literal['manual', 'automatic'], NoneType], required=False), 'evaluation_status': FieldInfo(annotation=Union[Literal['preliminary', 'confirmed', 'reviewed', 'final', 'rejected'], NoneType], required=False), 'method_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'misfit': FieldInfo(annotation=Union[float, NoneType], required=False), 'moment_tensor': FieldInfo(annotation=Union[MomentTensor, NoneType], required=False), 'nodal_planes': FieldInfo(annotation=Union[NodalPlanes, NoneType], required=False), 'principal_axes': FieldInfo(annotation=Union[PrincipalAxes, NoneType], required=False), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>), 'station_distribution_ratio': FieldInfo(annotation=Union[float, NoneType], required=False), 'station_polarity_count': FieldInfo(annotation=Union[int, NoneType], required=False), 'triggering_origin_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'waveform_id': FieldInfo(annotation=List[WaveformStreamID], required=False, default=[])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

moment_tensor: Optional[MomentTensor]

nodal_planes: Optional[NodalPlanes]

principal_axes: Optional[PrincipalAxes]

station_distribution_ratio: Optional[float]

station_polarity_count: Optional[int]

triggering_origin_id: Optional[ResourceIdentifier]

waveform_id: List[WaveformStreamID]

class obsplus.events.schema.Magnitude(**data)

Bases: _ModelWithResourceID

azimuthal_gap: Optional[float]

comments: List[Comment]

creation_info: Optional[CreationInfo]

evaluation_mode: Optional[Literal['manual', 'automatic']]

evaluation_status: Optional[Literal['preliminary', 'confirmed', 'reviewed', 'final', 'rejected']]

mag: Optional[float]

mag_errors: Optional[QuantityError]

magnitude_type: Optional[str]

method_id: Optional[ResourceIdentifier]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'azimuthal_gap': FieldInfo(annotation=Union[float, NoneType], required=False), 'comments': FieldInfo(annotation=List[Comment], required=False, default=[]), 'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'evaluation_mode': FieldInfo(annotation=Union[Literal['manual', 'automatic'], NoneType], required=False), 'evaluation_status': FieldInfo(annotation=Union[Literal['preliminary', 'confirmed', 'reviewed', 'final', 'rejected'], NoneType], required=False), 'mag': FieldInfo(annotation=Union[float, NoneType], required=False), 'mag_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'magnitude_type': FieldInfo(annotation=Union[str, NoneType], required=False), 'method_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'origin_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>), 'station_count': FieldInfo(annotation=Union[int, NoneType], required=False), 'station_magnitude_contributions': FieldInfo(annotation=List[StationMagnitudeContribution], required=False, default=[])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

origin_id: Optional[ResourceIdentifier]

station_count: Optional[int]

station_magnitude_contributions: List[StationMagnitudeContribution]

class obsplus.events.schema.MomentTensor(**data)

Bases: _ModelWithResourceID

Moment Tensor

category: Optional[Literal['teleseismic', 'regional']]

clvd: Optional[float]

creation_info: Optional[CreationInfo]

data_used: Optional[List[DataUsed]]

derived_origin_id: Optional[ResourceIdentifier]

double_couple: Optional[float]

filter_id: Optional[ResourceIdentifier]

greens_function_id: Optional[float]

inversion_type: Optional[Literal['general', 'zero trace', 'double couple']]

iso: Optional[float]

method_id: Optional[ResourceIdentifier]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'category': FieldInfo(annotation=Union[Literal['teleseismic', 'regional'], NoneType], required=False), 'clvd': FieldInfo(annotation=Union[float, NoneType], required=False), 'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'data_used': FieldInfo(annotation=Union[List[DataUsed], NoneType], required=False), 'derived_origin_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'double_couple': FieldInfo(annotation=Union[float, NoneType], required=False), 'filter_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'greens_function_id': FieldInfo(annotation=Union[float, NoneType], required=False), 'inversion_type': FieldInfo(annotation=Union[Literal['general', 'zero trace', 'double couple'], NoneType], required=False), 'iso': FieldInfo(annotation=Union[float, NoneType], required=False), 'method_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'moment_magnitude_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>), 'scalar_moment': FieldInfo(annotation=Union[float, NoneType], required=False), 'scalar_moment_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'source_time_function': FieldInfo(annotation=Union[SourceTimeFunction, NoneType], required=False), 'tensor': FieldInfo(annotation=Union[Tensor, NoneType], required=False), 'variance': FieldInfo(annotation=Union[float, NoneType], required=False), 'variance_reduction': FieldInfo(annotation=Union[float, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

moment_magnitude_id: Optional[ResourceIdentifier]

scalar_moment: Optional[float]

scalar_moment_errors: Optional[QuantityError]

source_time_function: Optional[SourceTimeFunction]

tensor: Optional[Tensor]

variance: Optional[float]

variance_reduction: Optional[float]

class obsplus.events.schema.NodalPlane(**data)

Bases: _ObsPyModel

Nodal Plane

dip: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'dip': FieldInfo(annotation=Union[float, NoneType], required=False), 'rake': FieldInfo(annotation=Union[float, NoneType], required=False), 'strike': FieldInfo(annotation=Union[float, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

rake: Optional[float]

strike: Optional[float]

class obsplus.events.schema.NodalPlanes(**data)

Bases: _ObsPyModel

Nodal Planes

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'nodal_plane_1': FieldInfo(annotation=Union[NodalPlane, NoneType], required=False), 'nodal_plane_2': FieldInfo(annotation=Union[NodalPlane, NoneType], required=False), 'preferred_plane': FieldInfo(annotation=Union[int, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

nodal_plane_1: Optional[NodalPlane]

nodal_plane_2: Optional[NodalPlane]

preferred_plane: Optional[int]

class obsplus.events.schema.Origin(**data)

Bases: _ModelWithResourceID

arrivals: List[Arrival]

comments: List[Comment]

composite_times: List[CompositeTime]

creation_info: Optional[CreationInfo]

depth: Optional[float]

depth_errors: Optional[QuantityError]

depth_type: Optional[Literal['from location', 'from moment tensor inversion', 'from modeling of broad-band P waveforms', 'constrained by depth phases', 'constrained by direct phases', 'constrained by depth and direct phases', 'operator assigned', 'other']]

earth_model_id: Optional[ResourceIdentifier]

epicenter_fixed: Optional[bool]

evaluation_mode: Optional[Literal['manual', 'automatic']]

evaluation_status: Optional[Literal['preliminary', 'confirmed', 'reviewed', 'final', 'rejected']]

latitude: Optional[float]

latitude_errors: Optional[QuantityError]

longitude: Optional[float]

longitude_errors: Optional[QuantityError]

method_id: Optional[ResourceIdentifier]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'arrivals': FieldInfo(annotation=List[Arrival], required=False, default=[]), 'comments': FieldInfo(annotation=List[Comment], required=False, default=[]), 'composite_times': FieldInfo(annotation=List[CompositeTime], required=False, default=[]), 'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'depth': FieldInfo(annotation=Union[float, NoneType], required=False), 'depth_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'depth_type': FieldInfo(annotation=Union[Literal['from location', 'from moment tensor inversion', 'from modeling of broad-band P waveforms', 'constrained by depth phases', 'constrained by direct phases', 'constrained by depth and direct phases', 'operator assigned', 'other'], NoneType], required=False), 'earth_model_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'epicenter_fixed': FieldInfo(annotation=Union[bool, NoneType], required=False), 'evaluation_mode': FieldInfo(annotation=Union[Literal['manual', 'automatic'], NoneType], required=False), 'evaluation_status': FieldInfo(annotation=Union[Literal['preliminary', 'confirmed', 'reviewed', 'final', 'rejected'], NoneType], required=False), 'latitude': FieldInfo(annotation=Union[float, NoneType], required=False), 'latitude_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'longitude': FieldInfo(annotation=Union[float, NoneType], required=False), 'longitude_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'method_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'origin_type': FieldInfo(annotation=Union[Literal['hypocenter', 'centroid', 'amplitude', 'macroseismic', 'rupture start', 'rupture end'], NoneType], required=False), 'origin_uncertainty': FieldInfo(annotation=Union[OriginUncertainty, NoneType], required=False), 'quality': FieldInfo(annotation=Union[OriginQuality, NoneType], required=False), 'reference_system_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'region': FieldInfo(annotation=Union[str, NoneType], required=False), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>), 'time': FieldInfo(annotation=UTCDateTime, required=True, metadata=[PlainValidator(func=<function _to_datetime>)]), 'time_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'time_fixed': FieldInfo(annotation=Union[bool, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

origin_type: Optional[Literal['hypocenter', 'centroid', 'amplitude', 'macroseismic', 'rupture start', 'rupture end']]

origin_uncertainty: Optional[OriginUncertainty]

quality: Optional[OriginQuality]

reference_system_id: Optional[ResourceIdentifier]

region: Optional[str]

time: Annotated[UTCDateTime]

time_errors: Optional[QuantityError]

time_fixed: Optional[bool]

class obsplus.events.schema.OriginQuality(**data)

Bases: _ObsPyModel

Origin Quality

associated_phase_count: Optional[int]

associated_station_count: Optional[int]

azimuthal_gap: Optional[float]

depth_phase_count: Optional[int]

ground_truth_level: Optional[str]

maximum_distance: Optional[float]

median_distance: Optional[float]

minimum_distance: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'associated_phase_count': FieldInfo(annotation=Union[int, NoneType], required=False), 'associated_station_count': FieldInfo(annotation=Union[int, NoneType], required=False), 'azimuthal_gap': FieldInfo(annotation=Union[float, NoneType], required=False), 'depth_phase_count': FieldInfo(annotation=Union[int, NoneType], required=False), 'ground_truth_level': FieldInfo(annotation=Union[str, NoneType], required=False), 'maximum_distance': FieldInfo(annotation=Union[float, NoneType], required=False), 'median_distance': FieldInfo(annotation=Union[float, NoneType], required=False), 'minimum_distance': FieldInfo(annotation=Union[float, NoneType], required=False), 'secondary_azimuthal_gap': FieldInfo(annotation=Union[float, NoneType], required=False), 'standard_error': FieldInfo(annotation=Union[float, NoneType], required=False), 'used_phase_count': FieldInfo(annotation=Union[int, NoneType], required=False), 'used_station_count': FieldInfo(annotation=Union[int, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

secondary_azimuthal_gap: Optional[float]

standard_error: Optional[float]

used_phase_count: Optional[int]

used_station_count: Optional[int]

class obsplus.events.schema.OriginUncertainty(**data)

Bases: _ObsPyModel

Origin Uncertainty

azimuth_max_horizontal_uncertainty: Optional[float]

confidence_ellipsoid: Optional[ConfidenceEllipsoid]

confidence_level: Optional[float]

horizontal_uncertainty: Optional[float]

max_horizontal_uncertainty: Optional[float]

min_horizontal_uncertainty: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'azimuth_max_horizontal_uncertainty': FieldInfo(annotation=Union[float, NoneType], required=False), 'confidence_ellipsoid': FieldInfo(annotation=Union[ConfidenceEllipsoid, NoneType], required=False), 'confidence_level': FieldInfo(annotation=Union[float, NoneType], required=False), 'horizontal_uncertainty': FieldInfo(annotation=Union[float, NoneType], required=False), 'max_horizontal_uncertainty': FieldInfo(annotation=Union[float, NoneType], required=False), 'min_horizontal_uncertainty': FieldInfo(annotation=Union[float, NoneType], required=False), 'preferred_description': FieldInfo(annotation=Union[Literal['horizontal uncertainty', 'uncertainty ellipse', 'confidence ellipsoid'], NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

preferred_description: Optional[Literal['horizontal uncertainty', 'uncertainty ellipse', 'confidence ellipsoid']]

class obsplus.events.schema.Pick(**data)

Bases: _ModelWithResourceID

backazimuth: Optional[float]

backazimuth_errors: Optional[QuantityError]

comments: List[Comment]

creation_info: Optional[CreationInfo]

evaluation_mode: Optional[Literal['manual', 'automatic']]

evaluation_status: Optional[Literal['preliminary', 'confirmed', 'reviewed', 'final', 'rejected']]

filter_id: Optional[ResourceIdentifier]

horizontal_slowness: Optional[float]

horizontal_slowness_errors: Optional[QuantityError]

method_id: Optional[ResourceIdentifier]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'backazimuth': FieldInfo(annotation=Union[float, NoneType], required=False), 'backazimuth_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'comments': FieldInfo(annotation=List[Comment], required=False, default=[]), 'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'evaluation_mode': FieldInfo(annotation=Union[Literal['manual', 'automatic'], NoneType], required=False), 'evaluation_status': FieldInfo(annotation=Union[Literal['preliminary', 'confirmed', 'reviewed', 'final', 'rejected'], NoneType], required=False), 'filter_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'horizontal_slowness': FieldInfo(annotation=Union[float, NoneType], required=False), 'horizontal_slowness_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'method_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'onset': FieldInfo(annotation=Union[Literal['emergent', 'impulsive', 'questionable'], NoneType], required=False), 'phase_hint': FieldInfo(annotation=Union[str, NoneType], required=False), 'polarity': FieldInfo(annotation=Union[Literal['positive', 'negative', 'undecidable'], NoneType], required=False), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>), 'slowness_method_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'time': FieldInfo(annotation=Union[Annotated[UTCDateTime, PlainValidator], NoneType], required=False), 'time_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'waveform_id': FieldInfo(annotation=Union[WaveformStreamID, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

onset: Optional[Literal['emergent', 'impulsive', 'questionable']]

phase_hint: Optional[str]

polarity: Optional[Literal['positive', 'negative', 'undecidable']]

slowness_method_id: Optional[ResourceIdentifier]

time: Optional[Annotated[UTCDateTime]]

time_errors: Optional[QuantityError]

waveform_id: Optional[WaveformStreamID]

class obsplus.events.schema.PrincipalAxes(**data)

Bases: _ObsPyModel

Principal Axes

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'n_axis': FieldInfo(annotation=Union[Axis, NoneType], required=False), 'p_axis': FieldInfo(annotation=Union[Axis, NoneType], required=False), 't_axis': FieldInfo(annotation=Union[Axis, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

n_axis: Optional[Axis]

p_axis: Optional[Axis]

t_axis: Optional[Axis]

class obsplus.events.schema.QuantityError(**data)

Bases: _ObsPyModel

Quantity Error

confidence_level: Optional[float]

lower_uncertainty: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'confidence_level': FieldInfo(annotation=Union[float, NoneType], required=False), 'lower_uncertainty': FieldInfo(annotation=Union[float, NoneType], required=False), 'uncertainty': FieldInfo(annotation=Union[float, NoneType], required=False), 'upper_uncertainty': FieldInfo(annotation=Union[float, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

uncertainty: Optional[float]

upper_uncertainty: Optional[float]

class obsplus.events.schema.ResourceIdentifier(**data)

Bases: _ObsPyModel

Resource ID

id: str

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'id': FieldInfo(annotation=str, required=False, default_factory=<lambda>)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class obsplus.events.schema.SourceTimeFunction(**data)

Bases: _ObsPyModel

Source Time Function

decay_time: Optional[float]

duration: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'decay_time': FieldInfo(annotation=Union[float, NoneType], required=False), 'duration': FieldInfo(annotation=Union[float, NoneType], required=False), 'rise_time': FieldInfo(annotation=Union[float, NoneType], required=False), 'type': FieldInfo(annotation=Union[Literal['box car', 'triangle', 'trapezoid', 'unknown'], NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

rise_time: Optional[float]

type: Optional[Literal['box car', 'triangle', 'trapezoid', 'unknown']]

class obsplus.events.schema.StationMagnitude(**data)

Bases: _ModelWithResourceID

Station Magnitude.

amplitude_id: Optional[ResourceIdentifier]

comments: List[Comment]

creation_info: Optional[CreationInfo]

mag: Optional[float]

mag_errors: Optional[QuantityError]

method_id: Optional[ResourceIdentifier]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'amplitude_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'comments': FieldInfo(annotation=List[Comment], required=False, default=[]), 'creation_info': FieldInfo(annotation=Union[CreationInfo, NoneType], required=False), 'mag': FieldInfo(annotation=Union[float, NoneType], required=False), 'mag_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'method_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'origin_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'resource_id': FieldInfo(annotation=ResourceIdentifier, required=False, default_factory=<lambda>), 'station_magnitude_type': FieldInfo(annotation=Union[str, NoneType], required=False), 'waveform_id': FieldInfo(annotation=Union[WaveformStreamID, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

origin_id: Optional[ResourceIdentifier]

station_magnitude_type: Optional[str]

waveform_id: Optional[WaveformStreamID]

class obsplus.events.schema.StationMagnitudeContribution(**data)

Bases: _ObsPyModel

Station Magnitude Contribution

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'residual': FieldInfo(annotation=Union[float, NoneType], required=False), 'station_magnitude_id': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'weight': FieldInfo(annotation=Union[float, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

residual: Optional[float]

station_magnitude_id: Optional[ResourceIdentifier]

weight: Optional[float]

class obsplus.events.schema.Tensor(**data)

Bases: _ObsPyModel

m_pp: Optional[float]

m_pp_errors: Optional[QuantityError]

m_rp: Optional[float]

m_rp_errors: Optional[QuantityError]

m_rr: Optional[float]

m_rr_errors: Optional[QuantityError]

m_rt: Optional[float]

m_rt_errors: Optional[QuantityError]

m_tp: Optional[float]

m_tp_errors: Optional[QuantityError]

m_tt: Optional[float]

m_tt_errors: Optional[QuantityError]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'m_pp': FieldInfo(annotation=Union[float, NoneType], required=False), 'm_pp_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'm_rp': FieldInfo(annotation=Union[float, NoneType], required=False), 'm_rp_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'm_rr': FieldInfo(annotation=Union[float, NoneType], required=False), 'm_rr_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'm_rt': FieldInfo(annotation=Union[float, NoneType], required=False), 'm_rt_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'm_tp': FieldInfo(annotation=Union[float, NoneType], required=False), 'm_tp_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False), 'm_tt': FieldInfo(annotation=Union[float, NoneType], required=False), 'm_tt_errors': FieldInfo(annotation=Union[QuantityError, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class obsplus.events.schema.TimeWindow(**data)

Bases: _ObsPyModel

Time Window

begin: Optional[float]

end: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'begin': FieldInfo(annotation=Union[float, NoneType], required=False), 'end': FieldInfo(annotation=Union[float, NoneType], required=False), 'reference': FieldInfo(annotation=Union[Annotated[UTCDateTime, PlainValidator], NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

reference: Optional[Annotated[UTCDateTime]]

class obsplus.events.schema.WaveformStreamID(**data)

Bases: _ObsPyModel

Waveform stream ID

channel_code: Optional[str]

location_code: Optional[str]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'extra': 'ignore', 'from_attributes': True, 'validate_assignment': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'channel_code': FieldInfo(annotation=Union[str, NoneType], required=False), 'location_code': FieldInfo(annotation=Union[str, NoneType], required=False), 'network_code': FieldInfo(annotation=Union[str, NoneType], required=False), 'resource_uri': FieldInfo(annotation=Union[ResourceIdentifier, NoneType], required=False), 'seed_string': FieldInfo(annotation=Union[str, NoneType], required=False), 'station_code': FieldInfo(annotation=Union[str, NoneType], required=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

network_code: Optional[str]

classmethod parse_seed_id(values)

Parse seed IDs if needed.

resource_uri: Optional[ResourceIdentifier]

seed_string: Optional[str]

station_code: Optional[str]