Only call extract on model result types where it makes sense

modelskill/comparison/_comparison.py

@@ -25,8 +25,8 @@
 from .. import Quantity
 from ..types import GeometryType
 from ..obs import PointObservation, TrackObservation
-from ..model import PointModelResult
-from ..timeseries._timeseries import _validate_data_var_name, TimeSeries
+from ..model import PointModelResult, TrackModelResult
+from ..timeseries._timeseries import _validate_data_var_name
 from ._comparer_plotter import ComparerPlotter
 from ..metrics import _parse_metric
 
@@ -456,14 +456,13 @@ class Comparer(Scoreable):
     """
 
     data: xr.Dataset
-    raw_mod_data: Dict[str, PointModelResult]
     _obs_str = "Observation"
     plotter = ComparerPlotter
 
     def __init__(
         self,
         matched_data: xr.Dataset,
-        raw_mod_data: Optional[Dict[str, PointModelResult]] = None,
+        raw_mod_data: dict[str, PointModelResult | TrackModelResult] | None = None,
     ) -> None:
         self.data = _parse_dataset(matched_data)
         self.raw_mod_data = (
@@ -476,29 +475,14 @@ def __init__(
                 if value.attrs["kind"] == "model"
             }
         )
-        # TODO: validate that the names in raw_mod_data are the same as in matched_data
-        assert isinstance(self.raw_mod_data, dict)
-        for k in self.raw_mod_data.keys():
-            v = self.raw_mod_data[k]
-            if not isinstance(v, TimeSeries):
-                try:
-                    self.raw_mod_data[k] = TimeSeries(v)
-                except Exception:
-                    raise ValueError(
-                        f"raw_mod_data[{k}] could not be converted to a TimeSeries object"
-                    )
-            else:
-                assert isinstance(
-                    v, TimeSeries
-                ), f"raw_mod_data[{k}] must be a TimeSeries object"
 
         self.plot = Comparer.plotter(self)
         """Plot using the [](`~modelskill.comparison.ComparerPlotter`)"""
 
     @staticmethod
     def from_matched_data(
         data: xr.Dataset | pd.DataFrame,
-        raw_mod_data: Optional[Dict[str, PointModelResult]] = None,
+        raw_mod_data: Optional[Dict[str, PointModelResult | TrackModelResult]] = None,
         obs_item: str | int | None = None,
         mod_items: Optional[Iterable[str | int]] = None,
         aux_items: Optional[Iterable[str | int]] = None,
@@ -770,7 +754,7 @@ def _to_observation(self) -> PointObservation | TrackObservation:
         else:
             raise NotImplementedError(f"Unknown gtype: {self.gtype}")
 
-    def _to_model(self) -> list[PointModelResult]:
+    def _to_model(self) -> list[PointModelResult | TrackModelResult]:
         mods = list(self.raw_mod_data.values())
         return mods
 
@@ -1291,7 +1275,7 @@ def load(filename: Union[str, Path]) -> "Comparer":
             return Comparer(matched_data=data)
 
         if data.gtype == "point":
-            raw_mod_data: Dict[str, PointModelResult] = {}
+            raw_mod_data: Dict[str, PointModelResult | TrackModelResult] = {}
 
             for var in data.data_vars:
                 var_name = str(var)

modelskill/matching.py

@@ -3,10 +3,8 @@
 from datetime import timedelta
 from pathlib import Path
 from typing import (
-    Any,
     Collection,
     Iterable,
-    List,
     Literal,
     Mapping,
     Optional,
@@ -22,14 +20,16 @@
 import pandas as pd
 import xarray as xr
 
+from modelskill.model.point import PointModelResult
+
 from . import Quantity, __version__, model_result
 from .comparison import Comparer, ComparerCollection
 from .model._base import Alignable
 from .model.dfsu import DfsuModelResult
 from .model.dummy import DummyModelResult
 from .model.grid import GridModelResult
 from .model.track import TrackModelResult
-from .obs import Observation, observation
+from .obs import Observation, PointObservation, TrackObservation, observation
 from .timeseries import TimeSeries
 from .types import Period
 
@@ -301,15 +301,22 @@ def _single_obs_compare(
     spatial_method: Optional[str] = None,
 ) -> Comparer:
     """Compare a single observation with multiple models"""
-    obs = _parse_single_obs(obs, obs_item, gtype=gtype)
+    observation = _parse_single_obs(obs, obs_item, gtype=gtype)
 
     mods = _parse_models(mod, mod_item, gtype=gtype)
 
-    raw_mod_data = {m.name: m.extract(obs, spatial_method) for m in mods}
+    raw_mod_data: dict[str, PointModelResult | TrackModelResult] = {}
+    for m in mods:
+        if isinstance(m, (DfsuModelResult, GridModelResult, DummyModelResult)):
+            raw_mod_data[m.name] = m.extract(observation, spatial_method=spatial_method)
+        elif isinstance(m, (PointModelResult, TrackModelResult)):
+            raw_mod_data[m.name] = m
+        else:
+            pass
     matched_data = match_space_time(
-        observation=obs, raw_mod_data=raw_mod_data, max_model_gap=max_model_gap
+        observation=observation, raw_mod_data=raw_mod_data, max_model_gap=max_model_gap
     )
-    matched_data.attrs["weight"] = obs.weight
+    matched_data.attrs["weight"] = observation.weight
 
     # TODO where does this line belong?
     matched_data.attrs["modelskill_version"] = __version__
@@ -393,8 +400,8 @@ def _parse_single_obs(
     obs: ObsInputType,
     obs_item: Optional[int | str],
     gtype: Optional[GeometryTypes],
-) -> Observation:
-    if isinstance(obs, Observation):
+) -> PointObservation | TrackObservation:
+    if isinstance(obs, (PointObservation, TrackObservation)):
         if obs_item is not None:
             raise ValueError(
                 "obs_item argument not allowed if obs is an modelskill.Observation type"
@@ -406,10 +413,16 @@ def _parse_single_obs(
 
 
 def _parse_models(
-    mod: Any,  # TODO
+    mod: MRInputType | Sequence[MRInputType],
     item: Optional[IdxOrNameTypes] = None,
     gtype: Optional[GeometryTypes] = None,
-) -> List[Any]:  # TODO
+) -> list[
+    PointModelResult
+    | TrackModelResult
+    | GridModelResult
+    | DfsuModelResult
+    | DummyModelResult
+]:
     """Return a list of ModelResult objects"""
     if isinstance(mod, get_args(MRInputType)):
         return [_parse_single_model(mod, item=item, gtype=gtype)]
@@ -420,10 +433,16 @@ def _parse_models(
 
 
 def _parse_single_model(
-    mod: Any,  # TODO
+    mod: MRInputType,
     item: Optional[IdxOrNameTypes] = None,
     gtype: Optional[GeometryTypes] = None,
-) -> Any:  # TODO
+) -> (
+    PointModelResult
+    | TrackModelResult
+    | GridModelResult
+    | DfsuModelResult
+    | DummyModelResult
+):
     if isinstance(
         mod,
         (
@@ -447,5 +466,14 @@ def _parse_single_model(
     else:
         if item is not None:
             raise ValueError("item argument not allowed if mod is a ModelResult type")
-        # assume it is already a model result
+        assert isinstance(
+            mod,
+            (
+                PointModelResult,
+                TrackModelResult,
+                GridModelResult,
+                DfsuModelResult,
+                DummyModelResult,
+            ),
+        )
         return mod

modelskill/model/point.py

@@ -5,7 +5,7 @@
 import xarray as xr
 import pandas as pd
 
-from ..obs import Observation, PointObservation
+from ..obs import Observation
 from ..types import PointType
 from ..quantity import Quantity
 from ..timeseries import TimeSeries, _parse_point_input
@@ -71,17 +71,6 @@ def __init__(
         data[data_var].attrs["kind"] = "model"
         super().__init__(data=data)
 
-    def extract(
-        self, obs: PointObservation, spatial_method: Optional[str] = None
-    ) -> PointModelResult:
-        if not isinstance(obs, PointObservation):
-            raise ValueError(f"obs must be a PointObservation not {type(obs)}")
-        if spatial_method is not None:
-            raise NotImplementedError(
-                "spatial interpolation not possible when matching point model results with point observations"
-            )
-        return self
-
     def interp_time(self, observation: Observation, **kwargs: Any) -> PointModelResult:
         """
         Interpolate model result to the time of the observation

modelskill/model/track.py

@@ -5,7 +5,7 @@
 import numpy as np
 import xarray as xr
 
-from ..obs import Observation, TrackObservation
+from ..obs import Observation
 from ..types import TrackType
 from ..quantity import Quantity
 from ..timeseries import TimeSeries, _parse_track_input
@@ -72,17 +72,6 @@ def __init__(
         data[data_var].attrs["kind"] = "model"
         super().__init__(data=data)
 
-    def extract(
-        self, obs: TrackObservation, spatial_method: Optional[str] = None
-    ) -> TrackModelResult:
-        if not isinstance(obs, TrackObservation):
-            raise ValueError(f"obs must be a TrackObservation not {type(obs)}")
-        if spatial_method is not None:
-            raise NotImplementedError(
-                "spatial interpolation not possible when matching track model results with track observations"
-            )
-        return self
-
     def align(self, observation: Observation, **kwargs: Any) -> xr.Dataset:
         spatial_tolerance = 1e-3
 

modelskill/obs.py

@@ -33,7 +33,7 @@ def observation(
     *,
     gtype: Optional[Literal["point", "track"]] = None,
     **kwargs,
-):
+) -> PointObservation | TrackObservation:
     """Create an appropriate observation object.
 
     A factory function for creating an appropriate observation object

modelskill/timeseries/_point.py

@@ -80,12 +80,12 @@ def _parse_point_input(
 
     # parse items
     if isinstance(data, (mikeio.DataArray, pd.Series, xr.DataArray)):
-        item_name = data.name if hasattr(data, "name") else "PointModelResult"
+        item_name = data.name if data.name is not None else "PointModelResult"
         if item is not None:
             raise ValueError(f"item must be None when data is a {type(data)}")
         if aux_items is not None:
             raise ValueError(f"aux_items must be None when data is a {type(data)}")
-        sel_items = PointItem(values=item_name, aux=[])
+        sel_items = PointItem(values=str(item_name), aux=[])
 
         if isinstance(data, mikeio.DataArray):
             data = mikeio.Dataset([data])
@@ -135,8 +135,9 @@ def _parse_point_input(
 
     assert isinstance(ds, xr.Dataset)
 
-    name = name or item_name
-    name = _validate_data_var_name(name)
+    varname = name or item_name
+    assert isinstance(varname, str)
+    name = _validate_data_var_name(varname)
 
     n_unique_times = len(ds.time.to_index().unique())
     if n_unique_times < len(ds.time):

tests/test_comparer.py

@@ -6,6 +6,8 @@
 from modelskill.comparison import Comparer
 from modelskill import __version__
 import modelskill as ms
+from modelskill.model.point import PointModelResult
+from modelskill.model.track import TrackModelResult
 
 
 @pytest.fixture
@@ -60,7 +62,10 @@ def pc() -> Comparer:
     data.coords["z"] = np.nan
     data = _set_attrs(data)
 
-    raw_data = {"m1": data[["m1"]], "m2": data[["m2"]]}
+    raw_data = {
+        "m1": PointModelResult(data[["m1"]]),
+        "m2": PointModelResult(data[["m2"]]),
+    }
 
     data = data.dropna(dim="time")
 
@@ -78,7 +83,10 @@ def tc() -> Comparer:
     data.attrs["name"] = "fake track obs"
     data = _set_attrs(data)
 
-    raw_data = {"m1": data[["m1"]], "m2": data[["m2"]]}
+    raw_data = {
+        "m1": TrackModelResult(data[["m1"]]),
+        "m2": TrackModelResult(data[["m2"]]),
+    }
 
     data = data.dropna(dim="time")
     return Comparer(matched_data=data, raw_mod_data=raw_data)

tests/test_comparercollection.py

@@ -58,7 +58,10 @@ def pc() -> modelskill.comparison.Comparer:
     data.coords["z"] = np.nan
     data = _set_attrs(data)
 
-    raw_data = {"m1": data[["m1"]].copy(), "m2": data[["m2"]].copy()}
+    raw_data = {
+        "m1": PointModelResult(data[["m1"]].copy()),
+        "m2": PointModelResult(data[["m2"]].copy()),
+    }
 
     data = data.dropna(dim="time")
     return modelskill.comparison.Comparer(matched_data=data, raw_mod_data=raw_data)
@@ -86,14 +89,8 @@ def tc() -> modelskill.comparison.Comparer:
     data["m3"].attrs["kind"] = "model"
     data = _set_attrs(data)
 
-    raw_data = {
-        "m1": data[["m1"]].copy(),
-        "m2": data[["m2"]].copy(),
-        "m3": data[["m3"]].copy(),
-    }
-
     data = data.dropna(dim="time")
-    return modelskill.comparison.Comparer(matched_data=data, raw_mod_data=raw_data)
+    return modelskill.comparison.Comparer(matched_data=data)
 
 
 @pytest.fixture