diff --git a/arpav_ppcv/exceptions.py b/arpav_ppcv/exceptions.py new file mode 100644 index 00000000..c5b768f6 --- /dev/null +++ b/arpav_ppcv/exceptions.py @@ -0,0 +1,10 @@ +class ArpavError(Exception): + ... + + +class InvalidCoverageIdentifierException(ArpavError): + ... + + +class CoverageDataRetrievalError(ArpavError): + ... diff --git a/arpav_ppcv/migrations/versions/e8bc68ec327b_add_uncertainty_cov_conf_relationships.py b/arpav_ppcv/migrations/versions/e8bc68ec327b_add_uncertainty_cov_conf_relationships.py new file mode 100644 index 00000000..aa67fb18 --- /dev/null +++ b/arpav_ppcv/migrations/versions/e8bc68ec327b_add_uncertainty_cov_conf_relationships.py @@ -0,0 +1,37 @@ +"""add-uncertainty-cov-conf-relationships + +Revision ID: e8bc68ec327b +Revises: 9f2dedc5396e +Create Date: 2024-05-17 15:47:58.878242 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +import sqlmodel + + +# revision identifiers, used by Alembic. +revision: str = 'e8bc68ec327b' +down_revision: Union[str, None] = '9f2dedc5396e' +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.add_column('coverageconfiguration', sa.Column('uncertainty_lower_bounds_coverage_configuration_id', sqlmodel.sql.sqltypes.GUID(), nullable=True)) + op.add_column('coverageconfiguration', sa.Column('uncertainty_upper_bounds_coverage_configuration_id', sqlmodel.sql.sqltypes.GUID(), nullable=True)) + op.create_foreign_key(None, 'coverageconfiguration', 'coverageconfiguration', ['uncertainty_lower_bounds_coverage_configuration_id'], ['id']) + op.create_foreign_key(None, 'coverageconfiguration', 'coverageconfiguration', ['uncertainty_upper_bounds_coverage_configuration_id'], ['id']) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_constraint(None, 'coverageconfiguration', type_='foreignkey') + op.drop_constraint(None, 'coverageconfiguration', type_='foreignkey') + op.drop_column('coverageconfiguration', 'uncertainty_upper_bounds_coverage_configuration_id') + op.drop_column('coverageconfiguration', 'uncertainty_lower_bounds_coverage_configuration_id') + # ### end Alembic commands ### diff --git a/arpav_ppcv/operations.py b/arpav_ppcv/operations.py index 50eb65e5..ee8f0a47 100644 --- a/arpav_ppcv/operations.py +++ b/arpav_ppcv/operations.py @@ -32,75 +32,85 @@ def get_coverage_time_series( settings: ArpavPpcvSettings, session: sqlmodel.Session, http_client: httpx.Client, - coverage_configuration: coverages.CoverageConfiguration, - coverage_identifier: str, + coverage: coverages.CoverageInternal, point_geom: shapely.Point, temporal_range: str, - coverage_data_smoothing: list[base.CoverageDataSmoothingStrategy], - observation_data_smoothing: list[base.ObservationDataSmoothingStrategy], + coverage_smoothing_strategies: list[base.CoverageDataSmoothingStrategy], + observation_smoothing_strategies: list[base.ObservationDataSmoothingStrategy], include_coverage_data: bool = True, include_observation_data: bool = False, include_coverage_uncertainty: bool = False, include_coverage_related_data: bool = False, ) -> dict[str, pd.DataFrame]: + """Retrieve time series for a coverage.""" start, end = _parse_temporal_range(temporal_range) coverage_data_ncss_url = "/".join(( settings.thredds_server.base_url, settings.thredds_server.netcdf_subset_service_url_fragment, - coverage_configuration.get_thredds_url_fragment(coverage_identifier) + coverage.configuration.get_thredds_url_fragment(coverage.identifier) )) raw_coverage_data = ncss.query_dataset( http_client, thredds_ncss_url=coverage_data_ncss_url, - variable_name=coverage_configuration.netcdf_main_dataset_name, + variable_name=coverage.configuration.netcdf_main_dataset_name, longitude=point_geom.x, latitude=point_geom.y, time_start=start, time_end=end, ) measurements = {} - if raw_coverage_data is not None: - if include_coverage_data: - coverage_data = _process_coverage_data( - raw_coverage_data, - coverage_configuration, - coverage_identifier, - coverage_data_smoothing, - start, - end - ) - measurements[coverage_identifier] = coverage_data - if include_observation_data: + if include_coverage_data: + coverage_data = _process_coverage_data( + raw_coverage_data, + coverage.configuration.netcdf_main_dataset_name, + coverage_smoothing_strategies, + start, + end, + base_column_name=coverage.identifier + ) + measurements[coverage.identifier] = coverage_data + if include_coverage_uncertainty: + has_uncertainty_cov_confs = any(( + coverage.configuration.uncertainty_lower_bounds_coverage_configuration, + coverage.configuration.uncertainty_upper_bounds_coverage_configuration, + )) + if has_uncertainty_cov_confs: + uncertainty_data = _get_coverage_uncertainty_time_series( + settings, http_client, coverage, + point_geom, start, end, coverage_smoothing_strategies, + ) + measurements.update(**uncertainty_data) + if include_coverage_related_data: + # TODO: how to map to related data? + ... + if include_observation_data: + if coverage.configuration.related_observation_variable is not None: station_data = _get_station_data( session, settings, point_geom, - coverage_configuration, - coverage_identifier, + coverage.configuration, + coverage.identifier, ) if station_data is not None: raw_station_data, station = station_data data_ = _process_seasonal_station_data( - coverage_configuration.related_observation_variable, - raw_station_data, - data_smoothing=observation_data_smoothing, - time_start=start, - time_end=end + raw_station_data, observation_smoothing_strategies, start, end, + base_name=coverage.configuration.related_observation_variable.name ) station_data_series_key = "_".join(( "station", str(station.id), - coverage_configuration.related_observation_variable.name, + coverage.configuration.related_observation_variable.name, )) measurements[station_data_series_key] = data_ - if include_coverage_uncertainty: - # TODO: how to map to uncertainty related data? - ... - if include_coverage_related_data: - # TODO: how to map to related data? - ... - else: - raise RuntimeError("Could not retrieve coverage data") + else: + logger.info("No station data found, skipping...") + else: + logger.info( + "Cannot include observation data - no observation variable is related " + "to this coverage configuration" + ) return measurements @@ -173,17 +183,17 @@ def _get_station_data( def _process_seasonal_station_data( - variable: observations.Variable, raw_data: list[observations.SeasonalMeasurement], - data_smoothing: list[base.ObservationDataSmoothingStrategy], + smoothing_strategies: list[base.ObservationDataSmoothingStrategy], time_start: Optional[dt.datetime], time_end: Optional[dt.datetime], + base_name: str, ) -> pd.DataFrame: df = pd.DataFrame( [i.model_dump() for i in raw_data] ) df = df[["value", "season", "year"]] - df = df.rename(columns={"value": variable.name}) + df = df.rename(columns={"value": base_name}) df["season_month"] = df["season"].astype("string").replace({ "Season.WINTER": "01", @@ -195,35 +205,35 @@ def _process_seasonal_station_data( df["year"].astype("string") + "-" + df["season_month"] + "-01", utc=True ) - df = df[[variable.name, "time"]] + df = df[[base_name, "time"]] df.set_index("time", inplace=True) if time_start is not None: df = df[time_start:] if time_end is not None: df = df[:time_end] - for strategy in data_smoothing: - column_name = "__".join((variable.name, strategy.value)) + for strategy in smoothing_strategies: + column_name = "__".join((base_name, strategy.value)) if strategy == base.ObservationDataSmoothingStrategy.NO_SMOOTHING: - df[column_name] = df[variable.name] + df[column_name] = df[base_name] elif strategy == base.ObservationDataSmoothingStrategy.MOVING_AVERAGE_5_YEARS: - df[column_name] = df[variable.name].rolling(window=5, center=True).mean() - df = df.drop(columns=[variable.name]) + df[column_name] = df[base_name].rolling(window=5, center=True).mean() + df = df.drop(columns=[base_name]) df = df.dropna() return df def _process_coverage_data( raw_data: str, - coverage_configuration: coverages.CoverageConfiguration, - coverage_identifier: str, - data_smoothing: list[base.CoverageDataSmoothingStrategy], + netcdf_main_dataset_name: str, + smoothing_strategies: list[base.CoverageDataSmoothingStrategy], time_start: Optional[dt.datetime], time_end: Optional[dt.datetime], + base_column_name: str ) -> pd.DataFrame: df = pd.read_csv(io.StringIO(raw_data), parse_dates=["time"]) # get name of the colum that holds the main variable - variable_name = coverage_configuration.netcdf_main_dataset_name + variable_name = netcdf_main_dataset_name try: col_name = [c for c in df.columns if c.startswith(f"{variable_name}[")][0] except IndexError: @@ -234,7 +244,7 @@ def _process_coverage_data( else: # keep only time and main variable - we don't care about other stuff df = df[["time", col_name]] - df = df.rename(columns={col_name: coverage_identifier}) + df = df.rename(columns={col_name: base_column_name}) # - filter out values outside the temporal range df.set_index("time", inplace=True) @@ -242,24 +252,93 @@ def _process_coverage_data( df = df[time_start:] if time_end is not None: df = df[:time_end] - for strategy in data_smoothing: - column_name = "__".join((coverage_identifier, strategy.value)) + for strategy in smoothing_strategies: + column_name = "__".join((base_column_name, strategy.value)) if strategy == base.CoverageDataSmoothingStrategy.NO_SMOOTHING: - df[column_name] = df[coverage_identifier] + df[column_name] = df[base_column_name] elif strategy == base.CoverageDataSmoothingStrategy.MOVING_AVERAGE_11_YEARS: - df[column_name] = df[coverage_identifier].rolling( + df[column_name] = df[base_column_name].rolling( center=True, window=11).mean() elif strategy == base.CoverageDataSmoothingStrategy.LOESS_SMOOTHING: _, loess_smoothed, _ = loess_1d( df.index.astype("int64"), - df[coverage_identifier], + df[base_column_name], ) df[column_name] = loess_smoothed - df = df.drop(columns=[coverage_identifier]) + df = df.drop(columns=[base_column_name]) df = df.dropna() return df +def _get_individual_uncertainty_time_series( + settings: ArpavPpcvSettings, + http_client: httpx.Client, + used_values: list[coverages.ConfigurationParameterValue], + uncert_coverage_configuration: coverages.CoverageConfiguration, + point_geom: shapely.Point, + time_start: Optional[dt.datetime], + time_end: Optional[dt.datetime], + smoothing_strategies: list[base.CoverageDataSmoothingStrategy], + base_column_name: str +) -> pd.DataFrame: + cov_identifier = ( + uncert_coverage_configuration.build_coverage_identifier(used_values) + ) + ncss_url = "/".join(( + settings.thredds_server.base_url, + settings.thredds_server.netcdf_subset_service_url_fragment, + uncert_coverage_configuration.get_thredds_url_fragment(cov_identifier) + )) + raw_coverage_data = ncss.query_dataset( + http_client, + thredds_ncss_url=ncss_url, + variable_name=uncert_coverage_configuration.netcdf_main_dataset_name, + longitude=point_geom.x, + latitude=point_geom.y, + time_start=time_start, + time_end=time_end, + ) + return _process_coverage_data( + raw_coverage_data, + uncert_coverage_configuration.netcdf_main_dataset_name, + smoothing_strategies, + time_start, + time_end, + base_column_name=base_column_name + ) + + +def _get_coverage_uncertainty_time_series( + settings: ArpavPpcvSettings, + http_client: httpx.Client, + coverage: coverages.CoverageInternal, + point_geom: shapely.Point, + time_start: Optional[dt.datetime], + time_end: Optional[dt.datetime], + smoothing_strategies: list[base.CoverageDataSmoothingStrategy], +) -> dict[str, pd.DataFrame]: + used_possible_values = coverage.configuration.retrieve_used_values( + coverage.identifier) + result = {} + used_values = [ + pv.configuration_parameter_value for pv in used_possible_values] + if lower_conf := coverage.configuration.uncertainty_lower_bounds_coverage_configuration: + lower_df = _get_individual_uncertainty_time_series( + settings, http_client, used_values, lower_conf, + point_geom, time_start, time_end, smoothing_strategies, + base_column_name="__".join((coverage.identifier, "UNCERTAINTY_LOWER_BOUND")) + ) + result[f"{base.UNCERTAINTY_TIME_SERIES_PATTERN}_LOWER_BOUND"] = lower_df + if upper_conf := coverage.configuration.uncertainty_upper_bounds_coverage_configuration: + upper_df = _get_individual_uncertainty_time_series( + settings, http_client, used_values, upper_conf, + point_geom, time_start, time_end, smoothing_strategies, + base_column_name="__".join((coverage.identifier, "UNCERTAINTY_UPPER_BOUND")) + ) + result[f"{base.UNCERTAINTY_TIME_SERIES_PATTERN}_UPPER_BOUND"] = upper_df + return result + + def _parse_temporal_range( raw_temporal_range: str) -> tuple[dt.datetime | None, dt.datetime | None]: """Parse a temporal range string, converting time to UTC. diff --git a/arpav_ppcv/schemas/base.py b/arpav_ppcv/schemas/base.py index 23bdb60c..db14806b 100644 --- a/arpav_ppcv/schemas/base.py +++ b/arpav_ppcv/schemas/base.py @@ -15,6 +15,9 @@ class ObservationDataSmoothingStrategy(enum.Enum): MOVING_AVERAGE_5_YEARS = "MOVING_AVERAGE_5_YEARS" +UNCERTAINTY_TIME_SERIES_PATTERN = "**UNCERTAINTY**" + + class ObservationAggregationType(enum.Enum): MONTHLY = "MONTHLY" SEASONAL = "SEASONAL" diff --git a/arpav_ppcv/schemas/coverages.py b/arpav_ppcv/schemas/coverages.py index c949212b..e1867f79 100644 --- a/arpav_ppcv/schemas/coverages.py +++ b/arpav_ppcv/schemas/coverages.py @@ -1,3 +1,4 @@ +import dataclasses import logging import re import uuid @@ -12,6 +13,7 @@ import sqlalchemy import sqlmodel +from .. import exceptions from . import base if TYPE_CHECKING: @@ -135,6 +137,14 @@ class CoverageConfiguration(sqlmodel.SQLModel, table=True): foreign_key="variable.id" ) observation_variable_aggregation_type: Optional[base.ObservationAggregationType] = None + uncertainty_lower_bounds_coverage_configuration_id: Optional[uuid.UUID] = sqlmodel.Field( + default=None, + foreign_key="coverageconfiguration.id" + ) + uncertainty_upper_bounds_coverage_configuration_id: Optional[uuid.UUID] = sqlmodel.Field( + default=None, + foreign_key="coverageconfiguration.id" + ) possible_values: list["ConfigurationParameterPossibleValue"] = sqlmodel.Relationship( back_populates="coverage_configuration", @@ -147,6 +157,34 @@ class CoverageConfiguration(sqlmodel.SQLModel, table=True): back_populates="related_coverage_configurations" ) + uncertainty_lower_bounds_coverage_configuration: Optional["CoverageConfiguration"] = sqlmodel.Relationship( + back_populates="is_lower_bounds_coverage_configuration_to", + sa_relationship_kwargs={ + "foreign_keys": "CoverageConfiguration.uncertainty_lower_bounds_coverage_configuration_id", + "remote_side": "CoverageConfiguration.id", + } + ) + is_lower_bounds_coverage_configuration_to: Optional["CoverageConfiguration"] = sqlmodel.Relationship( + back_populates="uncertainty_lower_bounds_coverage_configuration", + sa_relationship_kwargs={ + "foreign_keys": "CoverageConfiguration.uncertainty_lower_bounds_coverage_configuration_id", + } + ) + + uncertainty_upper_bounds_coverage_configuration: Optional["CoverageConfiguration"] = sqlmodel.Relationship( + back_populates="is_upper_bounds_coverage_configuration_to", + sa_relationship_kwargs={ + "foreign_keys": "CoverageConfiguration.uncertainty_upper_bounds_coverage_configuration_id", + "remote_side": "CoverageConfiguration.id", + } + ) + is_upper_bounds_coverage_configuration_to: Optional["CoverageConfiguration"] = sqlmodel.Relationship( + back_populates="uncertainty_upper_bounds_coverage_configuration", + sa_relationship_kwargs={ + "foreign_keys": "CoverageConfiguration.uncertainty_upper_bounds_coverage_configuration_id", + } + ) + @pydantic.computed_field() @property def coverage_id_pattern(self) -> str: @@ -156,7 +194,11 @@ def coverage_id_pattern(self) -> str: return "-".join(id_parts) def get_thredds_url_fragment(self, coverage_identifier: str) -> str: - used_values = self.retrieve_used_values(coverage_identifier) + try: + used_values = self.retrieve_used_values(coverage_identifier) + except IndexError as err: + logger.exception("Could not retrieve used values") + raise exceptions.InvalidCoverageIdentifierException() from err rendered = self.thredds_url_pattern for used_value in used_values: param_name = used_value.configuration_parameter_value.configuration_parameter.name @@ -165,17 +207,20 @@ def get_thredds_url_fragment(self, coverage_identifier: str) -> str: return rendered def build_coverage_identifier( - self, parameters: list["ConfigurationParameterPossibleValue"]) -> str: - id_parts = ["{name}"] + self, parameters: list[ConfigurationParameterValue]) -> str: + id_parts = [self.name] for match_obj in re.finditer(r"(\{\w+\})", self.coverage_id_pattern): param_name = match_obj.group(1)[1:-1] - for possible_param in parameters: - conf_param = possible_param.configuration_parameter_value.configuration_parameter - if conf_param.name == param_name: - id_parts.append(possible_param.configuration_parameter_value.name) - break + if param_name != "name": + for conf_param_value in parameters: + conf_param = conf_param_value.configuration_parameter + if conf_param.name == param_name: + id_parts.append(conf_param_value.name) + break + else: + raise ValueError(f"Invalid param_name {param_name!r}") else: - raise ValueError(f"Invalid param_name {param_name!r}") + continue return "-".join(id_parts) def retrieve_used_values( @@ -258,6 +303,8 @@ class CoverageConfigurationCreate(sqlmodel.SQLModel): possible_values: list["ConfigurationParameterPossibleValueCreate"] observation_variable_id: Optional[uuid.UUID] = None observation_variable_aggregation_type: Optional[base.ObservationAggregationType] = None + uncertainty_lower_bounds_coverage_configuration_id: Optional[uuid.UUID] = None + uncertainty_upper_bounds_coverage_configuration_id: Optional[uuid.UUID] = None @pydantic.field_validator("thredds_url_pattern") @classmethod @@ -266,7 +313,7 @@ def validate_thredds_url_pattern(cls, v: str) -> str: logger.debug(f"{match_obj.group(1)[1:-1]=}") if re.match(_NAME_PATTERN, match_obj.group(1)[1:-1]) is None: raise ValueError(f"configuration parameter {v!r} has invalid name") - return v + return v.strip() class CoverageConfigurationUpdate(sqlmodel.SQLModel): @@ -285,6 +332,8 @@ class CoverageConfigurationUpdate(sqlmodel.SQLModel): observation_variable_id: Optional[uuid.UUID] = None observation_variable_aggregation_type: Optional[base.ObservationAggregationType] = None possible_values: list["ConfigurationParameterPossibleValueUpdate"] + uncertainty_lower_bounds_coverage_configuration_id: Optional[uuid.UUID] = None + uncertainty_upper_bounds_coverage_configuration_id: Optional[uuid.UUID] = None @pydantic.field_validator("thredds_url_pattern") @classmethod @@ -293,7 +342,7 @@ def validate_thredds_url_pattern(cls, v: str) -> str: logger.debug(f"{match_obj.group(1)[1:-1]=}") if re.match(_NAME_PATTERN, match_obj.group(1)[1:-1]) is None: raise ValueError(f"configuration parameter {v!r} has invalid name") - return v + return v.strip() class ConfigurationParameterPossibleValue(sqlmodel.SQLModel, table=True): @@ -342,13 +391,8 @@ class ConfigurationParameterPossibleValueCreate(sqlmodel.SQLModel): class ConfigurationParameterPossibleValueUpdate(sqlmodel.SQLModel): configuration_parameter_value_id: uuid.UUID -# def _get_subclasses(cls): -# for subclass in cls.__subclasses__(): -# yield from _get_subclasses(subclass) -# yield subclass -# -# -# _models_dict = {cls.__name__: cls for cls in _get_subclasses(sqlmodel.SQLModel)} -# -# for cls in _models_dict.values(): -# cls.model_rebuild(_types_namespace=_models_dict) + +@dataclasses.dataclass +class CoverageInternal: + configuration: CoverageConfiguration + identifier: str diff --git a/arpav_ppcv/thredds/ncss.py b/arpav_ppcv/thredds/ncss.py index cd84e32a..abdc576d 100644 --- a/arpav_ppcv/thredds/ncss.py +++ b/arpav_ppcv/thredds/ncss.py @@ -8,11 +8,11 @@ import datetime as dt import logging import xml.etree.ElementTree as etree -from typing import Optional import httpx import shapely +from ..exceptions import CoverageDataRetrievalError from . import models logger = logging.getLogger(__name__) @@ -61,7 +61,7 @@ def query_dataset( latitude: float, time_start: dt.datetime | None = None, time_end: dt.datetime | None = None, -) -> Optional[str]: +) -> str: """Query THREDDS for the specified variable.""" if time_start is None or time_end is None: temporal_parameters = { @@ -84,9 +84,10 @@ def query_dataset( ) try: response.raise_for_status() - except httpx.HTTPError: + except httpx.HTTPError as err: logger.exception(msg="Could not retrieve data") - result = None + logger.debug(f"upstream NCSS error: {response.content}") + raise CoverageDataRetrievalError() from err else: result = response.text return result diff --git a/arpav_ppcv/webapp/admin/fields.py b/arpav_ppcv/webapp/admin/fields.py new file mode 100644 index 00000000..6a7ea141 --- /dev/null +++ b/arpav_ppcv/webapp/admin/fields.py @@ -0,0 +1,85 @@ +from typing import Any + +import starlette_admin +from starlette.requests import Request + +from ... import database +from . import schemas as read_schemas + + +class UuidField(starlette_admin.StringField): + """Custom field for handling item identifiers. + + This field, in conjunction with the custom collection template, ensures + that we can have related fields be edited inline, by sending the item's `id` + as a form hidden field. + """ + + def __init__(self, *args, **kwargs) -> None: + super().__init__(*args, **kwargs) + self.input_type = "hidden" + + async def serialize_value( + self, request: Request, value: Any, action: starlette_admin.RequestAction + ) -> Any: + return str(value) + + +class PossibleConfigurationParameterValuesField(starlette_admin.EnumField): + + def _get_label( + self, + value: read_schemas.ConfigurationParameterPossibleValueRead, + request: Request + ) -> Any: + conf_parameter_value = database.get_configuration_parameter_value( + request.state.session, value.configuration_parameter_value_id) + result = " - ".join(( + conf_parameter_value.configuration_parameter.name, + conf_parameter_value.name + )) + return result + + async def serialize_value( + self, + request: Request, + value: read_schemas.ConfigurationParameterPossibleValueRead, + action: starlette_admin.RequestAction + ) -> Any: + return self._get_label(value, request) + + +class RelatedObservationsVariableField(starlette_admin.EnumField): + + def _get_label( + self, + value: read_schemas.ObservationVariableRead, + request: Request + ) -> Any: + return value.name + + async def serialize_value( + self, + request: Request, + value: read_schemas.ObservationVariableRead, + action: starlette_admin.RequestAction + ) -> Any: + return self._get_label(value, request) + + +class RelatedCoverageconfigurationsField(starlette_admin.EnumField): + + def _get_label( + self, + value: read_schemas.CoverageConfigurationReadListItem, + request: Request + ) -> Any: + return value.name + + async def serialize_value( + self, + request: Request, + value: read_schemas.CoverageConfigurationReadListItem, + action: starlette_admin.RequestAction + ) -> Any: + return self._get_label(value, request) diff --git a/arpav_ppcv/webapp/admin/schemas.py b/arpav_ppcv/webapp/admin/schemas.py index 62d2d50d..0c84d40b 100644 --- a/arpav_ppcv/webapp/admin/schemas.py +++ b/arpav_ppcv/webapp/admin/schemas.py @@ -37,8 +37,15 @@ class CoverageConfigurationRead(sqlmodel.SQLModel): possible_values: list[ConfigurationParameterPossibleValueRead] observation_variable_aggregation_type: ObservationAggregationType observation_variable: Optional["ObservationVariableRead"] + uncertainty_lower_bounds_coverage_configuration: Optional["CoverageConfigurationReadListItem"] + uncertainty_upper_bounds_coverage_configuration: Optional["CoverageConfigurationReadListItem"] class ObservationVariableRead(sqlmodel.SQLModel): id: uuid.UUID name: str + + +class CoverageConfigurationReadListItem(sqlmodel.SQLModel): + id: uuid.UUID + name: str diff --git a/arpav_ppcv/webapp/admin/views.py b/arpav_ppcv/webapp/admin/views.py index 52090a6b..46e3da46 100644 --- a/arpav_ppcv/webapp/admin/views.py +++ b/arpav_ppcv/webapp/admin/views.py @@ -20,7 +20,6 @@ import anyio.to_thread import starlette_admin from starlette.requests import Request -from starlette_admin import RequestAction from starlette_admin.contrib.sqlmodel import ModelView from ... import database @@ -28,70 +27,40 @@ coverages, base, ) -from . import schemas as read_schemas +from . import ( + fields, + schemas as read_schemas, +) logger = logging.getLogger(__name__) -class UuidField(starlette_admin.StringField): - """Custom field for handling item identifiers. - - This field, in conjuction with the custom collection template, ensures - that we can have related fields be edited inline, by sending the item's `id` - as a form hidden field. - """ - - def __init__(self, *args, **kwargs) -> None: - super().__init__(*args, **kwargs) - self.input_type = "hidden" - - async def serialize_value( - self, request: Request, value: Any, action: RequestAction - ) -> Any: - return str(value) - - -class PossibleConfigurationParameterValuesField(starlette_admin.EnumField): - - def _get_label( - self, - value: read_schemas.ConfigurationParameterPossibleValueRead, - request: Request - ) -> Any: - conf_parameter_value = database.get_configuration_parameter_value( - request.state.session, value.configuration_parameter_value_id) - result = " - ".join(( - conf_parameter_value.configuration_parameter.name, - conf_parameter_value.name - )) - return result - - async def serialize_value( - self, - request: Request, - value: read_schemas.ConfigurationParameterPossibleValueRead, - action: RequestAction - ) -> Any: - return self._get_label(value, request) +def possible_values_choices_loader(request: Request) -> Sequence[tuple[str, str]]: + all_conf_parameter_values = database.collect_all_configuration_parameter_values( + request.state.session + ) + result = [] + for conf_param_value in all_conf_parameter_values: + repr_value = " - ".join(( + conf_param_value.configuration_parameter.name, conf_param_value.name)) + result.append((repr_value, repr_value)) + return result -class RelatedObservationsVariableField(starlette_admin.EnumField): +def related_observation_variable_choices_loader( + request: Request) -> Sequence[tuple[str, str]]: + all_obs_variables = database.collect_all_variables(request.state.session) + return [(v.name, v.name) for v in all_obs_variables] - def _get_label( - self, - value: read_schemas.ObservationVariableRead, - request: Request - ) -> Any: - return value.name - async def serialize_value( - self, - request: Request, - value: read_schemas.ObservationVariableRead, - action: RequestAction - ) -> Any: - return self._get_label(value, request) +def coverage_configurations_choices_loader( + request: Request) -> Sequence[tuple[str, str]]: + all_cov_confs = database.collect_all_coverage_configurations(request.state.session) + result = [] + for cov_conf in all_cov_confs: + result.append((cov_conf.name, cov_conf.name)) + return result class ConfigurationParameterView(ModelView): @@ -109,7 +78,7 @@ class ConfigurationParameterView(ModelView): ) fields = ( - UuidField("id"), + fields.UuidField("id"), starlette_admin.StringField( "name", help_text=( @@ -124,7 +93,7 @@ class ConfigurationParameterView(ModelView): field=starlette_admin.CollectionField( "allowed_values", fields=( - UuidField( + fields.UuidField( "id", read_only=True, # disabled=True, @@ -271,24 +240,6 @@ async def find_all( return result -def possible_values_choices_loader(request: Request) -> Sequence[tuple[str, str]]: - all_conf_parameter_values = database.collect_all_configuration_parameter_values( - request.state.session - ) - result = [] - for conf_param_value in all_conf_parameter_values: - repr_value = " - ".join(( - conf_param_value.configuration_parameter.name, conf_param_value.name)) - result.append((repr_value, repr_value)) - return result - - -def related_observation_variable_choices_loader( - request: Request) -> Sequence[tuple[str, str]]: - all_obs_variables = database.collect_all_variables(request.state.session) - return [(v.name, v.name) for v in all_obs_variables] - - class CoverageConfigurationView(ModelView): identity = "coverage_configurations" name = "Coverage Configuration" @@ -296,7 +247,7 @@ class CoverageConfigurationView(ModelView): icon = "fa fa-blog" pk_attr = "id" fields = ( - UuidField("id"), + fields.UuidField("id"), starlette_admin.StringField("name"), starlette_admin.StringField("netcdf_main_dataset_name"), starlette_admin.StringField("thredds_url_pattern"), @@ -305,7 +256,7 @@ class CoverageConfigurationView(ModelView): starlette_admin.StringField("palette"), starlette_admin.FloatField("color_scale_min"), starlette_admin.FloatField("color_scale_max"), - RelatedObservationsVariableField( + fields.RelatedObservationsVariableField( "observation_variable", help_text="Related observation variable", choices_loader=related_observation_variable_choices_loader, @@ -315,9 +266,25 @@ class CoverageConfigurationView(ModelView): enum=base.ObservationAggregationType ), starlette_admin.ListField( - field=PossibleConfigurationParameterValuesField( + field=fields.PossibleConfigurationParameterValuesField( "possible_values", choices_loader=possible_values_choices_loader) ), + fields.RelatedCoverageconfigurationsField( + "uncertainty_lower_bounds_coverage_configuration", + choices_loader=coverage_configurations_choices_loader, + help_text=( + "Coverage configuration to be used when looking for coverages " + "which have the lower uncertainty bounds values" + ) + ), + fields.RelatedCoverageconfigurationsField( + "uncertainty_upper_bounds_coverage_configuration", + choices_loader=coverage_configurations_choices_loader, + help_text=( + "Coverage configuration to be used when looking for coverages " + "which have the upper uncertainty bounds values" + ) + ), ) exclude_fields_from_list = ( @@ -331,6 +298,8 @@ class CoverageConfigurationView(ModelView): "color_scale_max", "observation_variable", "observation_variable_aggregation_type", + "uncertainty_lower_bounds_coverage_configuration", + "uncertainty_upper_bounds_coverage_configuration", ) exclude_fields_from_edit = ( "coverage_id_pattern", @@ -351,6 +320,24 @@ def _serialize_instance(self, instance: coverages.CoverageConfiguration): **obs_variable.model_dump()) else: observation_variable = None + uncertainty_lower_cov_conf = instance.uncertainty_lower_bounds_coverage_configuration + if uncertainty_lower_cov_conf is not None: + uncertainty_lower_bounds_coverage_configuration = ( + read_schemas.CoverageConfigurationReadListItem( + id=uncertainty_lower_cov_conf.id, + name=uncertainty_lower_cov_conf.name) + ) + else: + uncertainty_lower_bounds_coverage_configuration = None + uncertainty_upper_cov_conf = instance.uncertainty_upper_bounds_coverage_configuration + if uncertainty_upper_cov_conf is not None: + uncertainty_upper_bounds_coverage_configuration = ( + read_schemas.CoverageConfigurationReadListItem( + id=uncertainty_upper_cov_conf.id, + name=uncertainty_upper_cov_conf.name) + ) + else: + uncertainty_upper_bounds_coverage_configuration = None return read_schemas.CoverageConfigurationRead( **instance.model_dump( exclude={"observation_variable_aggregation_type"} @@ -365,7 +352,9 @@ def _serialize_instance(self, instance: coverages.CoverageConfiguration): configuration_parameter_value_id=pv.configuration_parameter_value_id, configuration_parameter_value_name=pv.configuration_parameter_value.name) for pv in instance.possible_values - ] + ], + uncertainty_lower_bounds_coverage_configuration=uncertainty_lower_bounds_coverage_configuration, + uncertainty_upper_bounds_coverage_configuration=uncertainty_upper_bounds_coverage_configuration, ) @@ -403,7 +392,6 @@ async def find_all( return result async def create(self, request: Request, data: Dict[str, Any]) -> Any: - logger.debug(f"inside create: {locals()=}") session = request.state.session try: data = await self._arrange_data(request, data) @@ -422,6 +410,24 @@ async def create(self, request: Request, data: Dict[str, Any]) -> Any: ) related_obs_variable = database.get_variable_by_name( session, data["observation_variable"]) + if ( + uncertainty_lower_name := data.get( + "uncertainty_lower_bounds_coverage_configuration") + ) is not None: + db_uncertainty_lower = database.get_coverage_configuration_by_name( + session, uncertainty_lower_name) + uncertainty_lower_id = db_uncertainty_lower.id + else: + uncertainty_lower_id = None + if ( + uncertainty_upper_name := data.get( + "uncertainty_upper_bounds_coverage_configuration") + ) is not None: + db_uncertainty_upper = database.get_coverage_configuration_by_name( + session, uncertainty_upper_name) + uncertainty_upper_id = db_uncertainty_upper.id + else: + uncertainty_upper_id = None cov_conf_create = coverages.CoverageConfigurationCreate( name=data["name"], netcdf_main_dataset_name=data["netcdf_main_dataset_name"], @@ -435,9 +441,14 @@ async def create(self, request: Request, data: Dict[str, Any]) -> Any: related_obs_variable.id if related_obs_variable else None), observation_variable_aggregation_type=data.get( "observation_variable_aggregation_type"), + uncertainty_lower_bounds_coverage_configuration_id=uncertainty_lower_id, + uncertainty_upper_bounds_coverage_configuration_id=uncertainty_upper_id, + ) + db_cov_conf = await anyio.to_thread.run_sync( + database.create_coverage_configuration, + session, + cov_conf_create ) - db_cov_conf = database.create_coverage_configuration( - session, cov_conf_create) return self._serialize_instance(db_cov_conf) except Exception as e: return self.handle_exception(e) @@ -459,6 +470,24 @@ async def edit(self, request: Request, pk: Any, data: Dict[str, Any]) -> Any: ) related_obs_variable = database.get_variable_by_name( session, data["observation_variable"]) + if ( + uncertainty_lower_name := data.get( + "uncertainty_lower_bounds_coverage_configuration") + ) is not None: + db_uncertainty_lower = database.get_coverage_configuration_by_name( + session, uncertainty_lower_name) + uncertainty_lower_id = db_uncertainty_lower.id + else: + uncertainty_lower_id = None + if ( + uncertainty_upper_name := data.get( + "uncertainty_upper_bounds_coverage_configuration") + ) is not None: + db_uncertainty_upper = database.get_coverage_configuration_by_name( + session, uncertainty_upper_name) + uncertainty_upper_id = db_uncertainty_upper.id + else: + uncertainty_upper_id = None cov_conv_update = coverages.CoverageConfigurationUpdate( name=data.get("name"), netcdf_main_dataset_name=data.get("netcdf_main_dataset_name"), @@ -472,6 +501,8 @@ async def edit(self, request: Request, pk: Any, data: Dict[str, Any]) -> Any: related_obs_variable.id if related_obs_variable else None), observation_variable_aggregation_type=data.get( "observation_variable_aggregation_type"), + uncertainty_lower_bounds_coverage_configuration_id=uncertainty_lower_id, + uncertainty_upper_bounds_coverage_configuration_id=uncertainty_upper_id, ) db_coverage_configuration = await anyio.to_thread.run_sync( database.get_coverage_configuration, diff --git a/arpav_ppcv/webapp/api_v2/routers/coverages.py b/arpav_ppcv/webapp/api_v2/routers/coverages.py index 72fdfc70..0000d361 100644 --- a/arpav_ppcv/webapp/api_v2/routers/coverages.py +++ b/arpav_ppcv/webapp/api_v2/routers/coverages.py @@ -4,9 +4,11 @@ from typing import ( Annotated, Optional, + Type, ) import httpx +import pandas as pd import pydantic import shapely.io from fastapi import ( @@ -22,6 +24,7 @@ from .... import ( database as db, + exceptions, operations, ) from ....config import ArpavPpcvSettings @@ -29,7 +32,9 @@ from ....schemas.base import ( CoverageDataSmoothingStrategy, ObservationDataSmoothingStrategy, + UNCERTAINTY_TIME_SERIES_PATTERN, ) +from ....schemas.coverages import CoverageInternal from ... import dependencies from ..schemas import coverages as coverage_schemas @@ -37,6 +42,34 @@ logger = logging.getLogger(__name__) router = APIRouter() +@router.get( + "/configuration-parameters", + response_model=coverage_schemas.ConfigurationParameterList +) +async def list_configuration_parameters( + request: Request, + db_session: Annotated[Session, Depends(dependencies.get_db_session)], + list_params: Annotated[dependencies.CommonListFilterParameters, Depends()], +): + """List configuration parameters.""" + config_params, filtered_total = db.list_configuration_parameters( + db_session, + limit=list_params.limit, + offset=list_params.offset, + include_total=True + ) + _, unfiltered_total = db.list_configuration_parameters( + db_session, limit=1, offset=0, include_total=True + ) + return coverage_schemas.ConfigurationParameterList.from_items( + config_params, + request, + limit=list_params.limit, + offset=list_params.offset, + filtered_total=filtered_total, + unfiltered_total=unfiltered_total + ) + @router.get( "/coverage-configurations", @@ -210,7 +243,15 @@ def get_time_series( coords: str, datetime: Optional[str] = "../..", include_coverage_data: bool = True, - include_observation_data: bool = False, + include_observation_data: Annotated[ + bool, + Query( + description=( + "Whether data from the nearest observation station (if any) " + "should be included in the response." + ) + ) + ] = False, coverage_data_smoothing: Annotated[ list[CoverageDataSmoothingStrategy], Query() @@ -222,107 +263,132 @@ def get_time_series( include_coverage_uncertainty: bool = False, include_coverage_related_data: bool = False, ): - db_coverage_configuration = db.get_coverage_configuration_by_coverage_identifier( - db_session, coverage_identifier) - if db_coverage_configuration is not None: - geom = shapely.io.from_wkt(coords) - if geom.geom_type == "MultiPoint": - logger.warning( - f"Expected coords parameter to be a WKT Point but " - f"got {geom.geom_type!r} instead - Using the first point" - ) - point_geom = geom.geoms[0] - elif geom.geom_type == "Point": - point_geom = geom - else: - logger.warning( - f"Expected coords parameter to be a WKT Point but " - f"got {geom.geom_type!r} instead - Using the centroid instead" - ) - point_geom = geom.centroid - time_series = operations.get_coverage_time_series( - settings, - db_session, - http_client, - coverage_configuration=db_coverage_configuration, - coverage_identifier=coverage_identifier, - point_geom=point_geom, - temporal_range=datetime, - include_coverage_data=include_coverage_data, - include_observation_data=include_observation_data, - coverage_data_smoothing=coverage_data_smoothing, - observation_data_smoothing=observation_data_smoothing, - include_coverage_uncertainty=include_coverage_uncertainty, - include_coverage_related_data=include_coverage_related_data, - ) - coverage_df = time_series[coverage_identifier] - series = [] - if include_coverage_data: - for series_name, series_measurements in coverage_df.to_dict().items(): - name_prefix, smoothing_strategy = series_name.rpartition("__")[::2] - smoothed_with = CoverageDataSmoothingStrategy(smoothing_strategy) - if ( - smoothed_with == CoverageDataSmoothingStrategy.NO_SMOOTHING and - CoverageDataSmoothingStrategy.NO_SMOOTHING not in coverage_data_smoothing - ): - continue # client did not ask for the NO_SMOOTHING strategy - else: - measurements = [] - for timestamp, value in series_measurements.items(): - measurements.append( - coverage_schemas.TimeSeriesItem( - value=value, datetime=timestamp) - ) - series.append( - coverage_schemas.TimeSeries( - name=series_name, - values=measurements, - info={ - "coverage_identifier": coverage_identifier, - "smoothing": smoothing_strategy.lower() - } + """### Get forecast-related time series for a geographic location. + + Given that a `coverage_identifier` represents a dataset generated by running a + forecast model, this endpoint will return a representation of the various temporal + series of data related to this forecast. + """ + if ( + db_cov_conf := db.get_coverage_configuration_by_coverage_identifier( + db_session, coverage_identifier) + ) is not None: + allowed_cov_ids = db.list_allowed_coverage_identifiers( + db_session, coverage_configuration_id=db_cov_conf.id) + if coverage_identifier in allowed_cov_ids: + coverage = CoverageInternal( + configuration=db_cov_conf, identifier=coverage_identifier) + # TODO: catch errors with invalid geom + geom = shapely.io.from_wkt(coords) + if geom.geom_type == "MultiPoint": + logger.warning( + f"Expected coords parameter to be a WKT Point but " + f"got {geom.geom_type!r} instead - Using the first point" + ) + point_geom = geom.geoms[0] + elif geom.geom_type == "Point": + point_geom = geom + else: + logger.warning( + f"Expected coords parameter to be a WKT Point but " + f"got {geom.geom_type!r} instead - Using the centroid instead" + ) + point_geom = geom.centroid + try: + time_series = operations.get_coverage_time_series( + settings, db_session, http_client, coverage, point_geom, + datetime, coverage_data_smoothing, observation_data_smoothing, + include_coverage_data, include_observation_data, + include_coverage_uncertainty, include_coverage_related_data, + ) + except exceptions.CoverageDataRetrievalError as err: + raise HTTPException( + status_code=status.HTTP_502_BAD_GATEWAY, + detail="Could not retrieve data" + ) from err + else: + series = [] + if include_coverage_data: + series.extend( + _serialize_dataframe( + time_series[coverage.identifier], + CoverageDataSmoothingStrategy.NO_SMOOTHING in coverage_data_smoothing, + available_smoothing_strategies=CoverageDataSmoothingStrategy, + extra_info={"coverage_identifier": coverage.identifier} ) ) - - if include_observation_data: - variable = db_coverage_configuration.related_observation_variable - for df_name, df in time_series.items(): - if df_name.startswith("station_"): - station_id = uuid.UUID(df_name.split("_")[1]) - db_station = db.get_station(db_session, station_id) - for series_name, series_measurements in df.to_dict().items(): - name_prefix, smoothing_strategy = series_name.rpartition("__")[::2] - smoothed_with = ObservationDataSmoothingStrategy(smoothing_strategy) - if ( - smoothed_with == ObservationDataSmoothingStrategy.NO_SMOOTHING and - ObservationDataSmoothingStrategy.NO_SMOOTHING not in observation_data_smoothing - ): - continue # client did not ask for the NO_SMOOTHING strategy - else: - measurements = [] - for timestamp, value in series_measurements.items(): - measurements.append( - coverage_schemas.TimeSeriesItem( - value=value, datetime=timestamp) + if include_coverage_uncertainty: + uncertainty_time_series = { + k: v for k, v in time_series.items() + if UNCERTAINTY_TIME_SERIES_PATTERN in k + } + for uncert_name, uncert_df in uncertainty_time_series.items(): + series.extend( + _serialize_dataframe( + uncert_df, + CoverageDataSmoothingStrategy.NO_SMOOTHING in coverage_data_smoothing, + available_smoothing_strategies=CoverageDataSmoothingStrategy, + extra_info={"related": uncert_name}, ) - series.append( - coverage_schemas.TimeSeries( - name=series_name, - values=measurements, - info={ - "station_id": str(db_station.id), - "station_name": db_station.name, - "variable_name": variable.name, - "variable_description": variable.description, - "smoothing": smoothing_strategy.lower() - } - ), ) - if include_coverage_uncertainty: - ... - if include_coverage_related_data: - ... - return coverage_schemas.TimeSeriesList(series=series) + if include_coverage_related_data: + series.extend([]) + if include_observation_data: + variable = coverage.configuration.related_observation_variable + for df_name, df in time_series.items(): + if df_name.startswith("station_"): + station_id = uuid.UUID(df_name.split("_")[1]) + db_station = db.get_station(db_session, station_id) + station_series = _serialize_dataframe( + df, + ObservationDataSmoothingStrategy.NO_SMOOTHING in observation_data_smoothing, + available_smoothing_strategies=ObservationDataSmoothingStrategy, + extra_info={ + "station_id": str(db_station.id), + "station_name": db_station.name, + "variable_name": variable.name, + "variable_description": variable.description, + } + ) + series.extend(station_series) + return coverage_schemas.TimeSeriesList(series=series) + else: + raise HTTPException(status_code=400, detail="Invalid coverage_identifier") else: raise HTTPException(status_code=400, detail="Invalid coverage_identifier") + +def _serialize_dataframe( + data_: pd.DataFrame, + include_unsmoothed: bool, + available_smoothing_strategies: Type[ + ObservationDataSmoothingStrategy | CoverageDataSmoothingStrategy], + extra_info +) -> list[coverage_schemas.TimeSeries]: + series = [] + for series_name, series_measurements in data_.to_dict().items(): + name_prefix, smoothing_strategy = series_name.rpartition("__")[::2] + smoothed_with = available_smoothing_strategies(smoothing_strategy) + if ( + smoothed_with == available_smoothing_strategies.NO_SMOOTHING and + not include_unsmoothed + ): + continue # client did not ask for the NO_SMOOTHING strategy + else: + measurements = [] + for timestamp, value in series_measurements.items(): + measurements.append( + coverage_schemas.TimeSeriesItem( + value=value, datetime=timestamp) + ) + series.append( + coverage_schemas.TimeSeries( + name=series_name, + values=measurements, + info={ + "smoothing": smoothing_strategy.lower(), + **extra_info + } + ) + ) + return series diff --git a/arpav_ppcv/webapp/api_v2/schemas/coverages.py b/arpav_ppcv/webapp/api_v2/schemas/coverages.py index 9b6fb3e5..f7594f9a 100644 --- a/arpav_ppcv/webapp/api_v2/schemas/coverages.py +++ b/arpav_ppcv/webapp/api_v2/schemas/coverages.py @@ -9,9 +9,30 @@ from ....schemas import coverages as app_models -class ForecastModelScenario(pydantic.BaseModel): +class ConfigurationParameterValueEmbeddedInConfigurationParameter(pydantic.BaseModel): name: str - code: str + description: str + + +class ConfigurationParameterReadListItem(pydantic.BaseModel): + name: str + description: str + allowed_values: list[ConfigurationParameterValueEmbeddedInConfigurationParameter] + + @classmethod + def from_db_instance( + cls, + instance: app_models.ConfigurationParameter, + request: Request, + ): + return cls( + **instance.model_dump(), + allowed_values=[ + ConfigurationParameterValueEmbeddedInConfigurationParameter( + **pv.model_dump() + ) for pv in instance.allowed_values + ] + ) class ConfigurationParameterPossibleValueRead(pydantic.BaseModel): @@ -92,8 +113,10 @@ class CoverageIdentifierList(WebResourceList): path_operation_name = "list_coverage_identifiers" -class ForecastModelScenarioList(WebResourceList): - items: list[ForecastModelScenario] +class ConfigurationParameterList(WebResourceList): + items: list[ConfigurationParameterReadListItem] + list_item_type = ConfigurationParameterReadListItem + path_operation_name = "list_configuration_parameters" class TimeSeriesItem(pydantic.BaseModel): diff --git a/tests/notebooks/generic.ipynb b/tests/notebooks/generic.ipynb new file mode 100644 index 00000000..b7647567 --- /dev/null +++ b/tests/notebooks/generic.ipynb @@ -0,0 +1,88 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "dbcc00b1-2fc1-43ff-9549-ebca8cf03262", + "metadata": {}, + "source": [ + "%matplotlib widget\n", + "\n", + "import logging\n", + "\n", + "import httpx\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import shapely.io\n", + "import sqlmodel\n", + "from loess.loess_1d import loess_1d\n", + "\n", + "from arpav_ppcv import (\n", + " database as db,\n", + " operations,\n", + ")\n", + "from arpav_ppcv.config import get_settings\n", + "from arpav_ppcv.schemas.base import (\n", + " CoverageDataSmoothingStrategy,\n", + " ObservationDataSmoothingStrategy,\n", + " Season,\n", + ")\n", + "\n", + "logging.basicConfig(level=logging.DEBUG)\n", + "logging.getLogger(\"httpx\").setLevel(logging.WARNING)\n", + "logging.getLogger(\"httpcore\").setLevel(logging.WARNING)\n", + "logging.getLogger(\"matplotlib\").setLevel(logging.WARNING)\n", + "\n", + "settings = get_settings()\n", + "session = sqlmodel.Session(db.get_engine(settings))\n", + "http_client = httpx.Client()\n", + "\n", + "coverage_identifier = \"uncertainty_bounds_test\"\n", + "coverage_configuration = db.get_coverage_configuration_by_coverage_identifier(\n", + " session, coverage_identifier)\n" + ], + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f564bc8c-cf2a-410d-ba89-d3686c9aadb7", + "metadata": {}, + "source": [ + "coverage_configuration.uncertainty_lower_bounds_coverage_configuration" + ], + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5ffd5df7-48b6-4822-99f5-dd60e1328d31", + "metadata": {}, + "source": [ + "coverage_configuration.uncertainty_upper_bounds_coverage_configuration" + ], + "outputs": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/notebooks/timeseries_via_api.ipynb b/tests/notebooks/timeseries_via_api.ipynb index de8d3e18..50916581 100644 --- a/tests/notebooks/timeseries_via_api.ipynb +++ b/tests/notebooks/timeseries_via_api.ipynb @@ -12,8 +12,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "id": "ff511e0b-ab32-49a6-add1-28f5423929c9", + "execution_count": 1, + "id": "79050d6c-1899-47b9-8d8e-d6f28bdcdb58", "metadata": {}, "outputs": [], "source": [ @@ -23,16 +23,24 @@ "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "\n", - "coverage_identifier = \"tas_absolute-rcp26-DJF\"\n", + "# coverage_identifier = \"tas_absolute-rcp26-DJF\"\n", + "coverage_identifier = \"uncertainty_bounds_test-rcp26-DJF\"\n", "point_coords = \"POINT(11.5469 44.9524)\"\n", "date_range = \"../..\"\n", - "api_url = f\"http://webapp:5001/api/v2/coverages/time-series/{coverage_identifier}\"" + "api_url = f\"http://webapp:5001/api/v2/coverages/time-series/{coverage_identifier}\"\n", + "\n", + "\n", + "def _parse_to_dataframe(time_series: dict):\n", + " df = pd.DataFrame.from_records(time_series[\"values\"])\n", + " df[\"datetime\"] = pd.to_datetime(df[\"datetime\"])\n", + " df.set_index(\"datetime\", inplace=True)\n", + " return df " ] }, { "cell_type": "code", - "execution_count": 8, - "id": "d983c33d-f903-45e4-a5f2-930bcbe8b246", + "execution_count": 39, + "id": "b296c605-af4f-4212-819c-454cc7cd01bb", "metadata": {}, "outputs": [], "source": [ @@ -52,7 +60,7 @@ " \"NO_SMOOTHING\",\n", " \"MOVING_AVERAGE_5_YEARS\",\n", " ],\n", - " \"include_coverage_uncertainty\": False,\n", + " \"include_coverage_uncertainty\": True,\n", " \"include_coverage_related_data\": False,\n", " }\n", ")\n", @@ -60,27 +68,30 @@ "\n", "raw_series = raw_response.json()[\"series\"]\n", "\n", - "series = {s[\"name\"]: s for s in raw_series}\n", - "\n", - "raw_coverage_df = pd.DataFrame.from_records(series[f\"{coverage_identifier}__NO_SMOOTHING\"][\"values\"])\n", - "raw_coverage_df[\"datetime\"] = pd.to_datetime(raw_coverage_df[\"datetime\"])\n", - "raw_coverage_df.set_index(\"datetime\", inplace=True)\n", - "\n", - "smoothed_ma11_coverage_df = pd.DataFrame.from_records(series[f\"{coverage_identifier}__MOVING_AVERAGE_11_YEARS\"][\"values\"])\n", - "smoothed_ma11_coverage_df[\"datetime\"] = pd.to_datetime(smoothed_ma11_coverage_df[\"datetime\"])\n", - "smoothed_ma11_coverage_df.set_index(\"datetime\", inplace=True)\n", + "series = {s[\"name\"]: s for s in raw_series}" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "5d266d88-4a0e-4bad-a36c-d3532f7d6f84", + "metadata": {}, + "outputs": [], + "source": [ + "raw_coverage_df = _parse_to_dataframe(series[f\"{coverage_identifier}__NO_SMOOTHING\"])\n", + "smoothed_ma11_coverage_df = _parse_to_dataframe(series[f\"{coverage_identifier}__MOVING_AVERAGE_11_YEARS\"])\n", + "smoothed_loess_coverage_df = _parse_to_dataframe(series[f\"{coverage_identifier}__LOESS_SMOOTHING\"])\n", "\n", - "smoothed_loess_coverage_df = pd.DataFrame.from_records(series[f\"{coverage_identifier}__LOESS_SMOOTHING\"][\"values\"])\n", - "smoothed_loess_coverage_df[\"datetime\"] = pd.to_datetime(smoothed_loess_coverage_df[\"datetime\"])\n", - "smoothed_loess_coverage_df.set_index(\"datetime\", inplace=True)\n", + "raw_uncertainty_lower_coverage_df = _parse_to_dataframe(series[f\"{coverage_identifier}__UNCERTAINTY_LOWER_BOUND__NO_SMOOTHING\"])\n", + "smoothed_ma11_uncertainty_lower_coverage_df = _parse_to_dataframe(series[f\"{coverage_identifier}__UNCERTAINTY_LOWER_BOUND__MOVING_AVERAGE_11_YEARS\"])\n", + "smoothed_loess_uncertainty_lower_coverage_df = _parse_to_dataframe(series[f\"{coverage_identifier}__UNCERTAINTY_LOWER_BOUND__LOESS_SMOOTHING\"])\n", "\n", - "raw_station_df = pd.DataFrame.from_records(series[\"TDd__NO_SMOOTHING\"][\"values\"])\n", - "raw_station_df[\"datetime\"] = pd.to_datetime(raw_station_df[\"datetime\"])\n", - "raw_station_df.set_index(\"datetime\", inplace=True)\n", + "raw_uncertainty_upper_coverage_df = _parse_to_dataframe(series[f\"{coverage_identifier}__UNCERTAINTY_UPPER_BOUND__NO_SMOOTHING\"])\n", + "smoothed_ma11_uncertainty_upper_coverage_df = _parse_to_dataframe(series[f\"{coverage_identifier}__UNCERTAINTY_UPPER_BOUND__MOVING_AVERAGE_11_YEARS\"])\n", + "smoothed_loess_uncertainty_upper_coverage_df = _parse_to_dataframe(series[f\"{coverage_identifier}__UNCERTAINTY_UPPER_BOUND__LOESS_SMOOTHING\"])\n", "\n", - "smoothed_ma5_station_df = pd.DataFrame.from_records(series[\"TDd__MOVING_AVERAGE_5_YEARS\"][\"values\"])\n", - "smoothed_ma5_station_df[\"datetime\"] = pd.to_datetime(smoothed_ma5_station_df[\"datetime\"])\n", - "smoothed_ma5_station_df.set_index(\"datetime\", inplace=True)\n" + "raw_station_df = _parse_to_dataframe(series[f\"TDd__NO_SMOOTHING\"])\n", + "smoothed_ma5_station_df = _parse_to_dataframe(series[f\"TDd__MOVING_AVERAGE_5_YEARS\"])" ] }, { @@ -93,35 +104,35 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 43, "id": "9b1ddd10-6e0e-478f-babe-464e16dc07d3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 10, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8c9e53dd71264883b97771e771c792b4", + "model_id": "2bf33555acbd47809852a505be8a0408", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -135,36 +146,50 @@ ], "source": [ "fig, ax = plt.subplots()\n", - "raw_tas_line, = ax.plot(raw_coverage_df, label=f\"raw_{coverage_identifier}\")\n", - "raw_station_line, = ax.plot(raw_station_df, label=\"raw_TDd\")\n", - "raw_tas_line.set_linestyle(\":\")\n", - "raw_tas_line.set_marker(\".\")\n", - "raw_station_line.set_linestyle(\":\")\n", - "raw_station_line.set_marker(\".\")\n", - "\n", - "smoothed_ma11_tas_line, = ax.plot(smoothed_ma11_coverage_df, label=f\"smoothed_{coverage_identifier}_ma11\")\n", - "smoothed_loess_tas_line, = ax.plot(smoothed_loess_coverage_df, label=f\"smoothed_{coverage_identifier}_loess\")\n", - "smoothed_ma5_station_line, = ax.plot(smoothed_ma5_station_df, label=\"smoothed_TDd_ma5\")\n", + "\n", + "# raw_tas_line, = ax.plot(raw_coverage_df, label=series[f\"{coverage_identifier}__NO_SMOOTHING\"][\"name\"])\n", + "# raw_tas_line.set_linestyle(\":\")\n", + "# raw_tas_line.set_marker(\".\")\n", + "\n", + "smoothed_ma11_tas_line, = ax.plot(smoothed_ma11_coverage_df, label=series[f\"{coverage_identifier}__MOVING_AVERAGE_11_YEARS\"][\"name\"])\n", + "# smoothed_loess_tas_line, = ax.plot(smoothed_loess_coverage_df, label=series[f\"{coverage_identifier}__LOESS_SMOOTHING\"][\"name\"])\n", + "\n", + "# raw_lower_uncert_line, = ax.plot(raw_uncertainty_lower_coverage_df, label=series[f\"{coverage_identifier}__UNCERTAINTY_LOWER_BOUND__NO_SMOOTHING\"][\"name\"])\n", + "# smoothed_ma11_lower_uncert_line, = ax.plot(smoothed_ma11_uncertainty_lower_coverage_df, label=series[f\"{coverage_identifier}__UNCERTAINTY_LOWER_BOUND__MOVING_AVERAGE_11_YEARS\"][\"name\"])\n", + "# smoothed_loess_lower_uncert_line, = ax.plot(smoothed_loess_uncertainty_lower_coverage_df, label=series[f\"{coverage_identifier}__UNCERTAINTY_LOWER_BOUND__LOESS_SMOOTHING\"][\"name\"])\n", + "\n", + "# raw_upper_uncert_line, = ax.plot(raw_uncertainty_upper_coverage_df, label=series[f\"{coverage_identifier}__UNCERTAINTY_UPPER_BOUND__NO_SMOOTHING\"][\"name\"])\n", + "# smoothed_ma11_upper_uncert_line, = ax.plot(smoothed_ma11_uncertainty_upper_coverage_df, label=series[f\"{coverage_identifier}__UNCERTAINTY_UPPER_BOUND__MOVING_AVERAGE_11_YEARS\"][\"name\"])\n", + "# smoothed_loess_upper_uncert_line, = ax.plot(smoothed_loess_uncertainty_upper_coverage_df, label=series[f\"{coverage_identifier}__UNCERTAINTY_UPPER_BOUND__LOESS_SMOOTHING\"][\"name\"])\n", + "\n", + "ax.fill_between(\n", + " smoothed_ma11_uncertainty_lower_coverage_df.index, \n", + " smoothed_ma11_uncertainty_lower_coverage_df.value, \n", + " smoothed_ma11_uncertainty_upper_coverage_df.value,\n", + " alpha=0.5,\n", + " linewidth=0\n", + ")\n", + "\n", + "\n", + "# raw_station_line, = ax.plot(raw_station_df, label=series[\"TDd__NO_SMOOTHING\"][\"name\"])\n", + "# raw_station_line.set_linestyle(\":\")\n", + "# raw_station_line.set_marker(\".\")\n", + "\n", + "smoothed_ma5_station_line, = ax.plot(smoothed_ma5_station_df, label=series[\"TDd__MOVING_AVERAGE_5_YEARS\"][\"name\"])\n", + "\n", + "\n", "ax.legend()" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 42, "id": "ad36d2cb-c748-4076-944c-fffecf3c5818", "metadata": {}, "outputs": [], "source": [ "ax.clear()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2a6b9b95-aacb-4f4d-af08-50c60751675e", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": {