Merge pull request #791 from DHI/improve_test_coverage

Improve test coverage

Author: ecomodeller

mikeio/__init__.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
-from platform import architecture
 from collections.abc import Sequence
 from typing import Any
 
@@ -15,9 +14,6 @@
 __dfs_version__: int = 220
 
 
-if "64" not in architecture()[0]:
-    raise Exception("This library has not been tested for a 32 bit system.")
-
 from .dataset import DataArray, Dataset, from_pandas, from_polars
 from .dfs import Dfs0, Dfs1, Dfs2, Dfs3
 from .dfsu import Dfsu, Mesh, Dfsu2DH, Dfsu2DV, Dfsu3D, DfsuSpectral
@@ -121,7 +117,9 @@ def read(
     ext = Path(filename).suffix.lower()
 
     if "dfs" not in ext:
-        raise ValueError("mikeio.read() is only supported for dfs files")
+        raise ValueError(
+            "mikeio.read() is only supported for dfs files. Use mikeio.open for mesh files."
+        )
 
     dfs = open(filename)
     if isinstance(dfs, Mesh):

mikeio/_track.py

@@ -19,7 +19,7 @@ def _extract_track(
     end_time: pd.Timestamp,
     timestep: float,
     geometry: GeometryFM2D,
-    track: str | Dataset | pd.DataFrame,
+    track: str | Path | Dataset | pd.DataFrame,
     items: Sequence[ItemInfo],
     item_numbers: Sequence[int],
     time_steps: Sequence[int],
@@ -36,6 +36,8 @@ def _extract_track(
     match track:
         case str():
             times, coords = _get_track_data_from_file(track)
+        case Path():
+            times, coords = _get_track_data_from_file(str(track))
         case Dataset():
             times, coords = _get_track_data_from_dataset(track)
         case pd.DataFrame():
@@ -193,20 +195,3 @@ def _get_track_data_from_file(track: str) -> tuple[pd.DatetimeIndex, np.ndarray]
     coords = df.iloc[:, 0:2].to_numpy(copy=True)
 
     return times, coords
-
-
-def _find_end_index(t_rel: pd.Index, end_time: pd.Timestamp) -> int:
-    # largest idx for which (times - self.end_time)<=0
-    tmp = np.where(t_rel <= 0)[0]
-    if len(tmp) == 0:
-        raise ValueError("No time overlap!")
-    i_end = tmp[-1]
-    return i_end
-
-
-def _find_start_index(t_rel: pd.Index, start_time: pd.Timestamp) -> int:
-    tmp = np.where(t_rel >= 0)[0]
-    if len(tmp) == 0:
-        raise ValueError("No time overlap!")
-    i_start = tmp[0]  # smallest idx for which t_rel>=0
-    return i_start

mikeio/dataset/_dataarray.py

@@ -98,12 +98,9 @@ def __call__(self, tail: bool = True) -> "DataArray":
         dims = tuple([d for d in self.da.dims if d not in ("frequency", "direction")])
         item = ItemInfo(EUMType.Significant_wave_height)
         g = self.da.geometry
-        if isinstance(g, GeometryFMPointSpectrum):
-            if g.x is not None and g.y is not None:
-                geometry: Any = GeometryPoint2D(x=g.x, y=g.y)
-            else:
-                geometry = GeometryUndefined()
-        elif isinstance(g, GeometryFMLineSpectrum):
+        geometry: Any = GeometryUndefined()
+
+        if isinstance(g, GeometryFMLineSpectrum):
             geometry = Grid1D(
                 nx=g.n_nodes,
                 dx=1.0,
@@ -119,8 +116,6 @@ def __call__(self, tail: bool = True) -> "DataArray":
                 element_table=g.element_table,
                 element_ids=g.element_ids,
             )
-        else:
-            geometry = GeometryUndefined()
 
         return DataArray(
             data=Hm0,

mikeio/dataset/_dataset.py

@@ -162,8 +162,6 @@ def _init_from_DataArrays(
             for da in data_vars.values():
                 first._is_compatible(da, raise_error=True)
 
-        self._check_all_different_ids(list(data_vars.values()))
-
         # TODO is it necessary to keep track of item names?
         self.__itemattr: set[str] = set()
         for key, value in data_vars.items():
@@ -266,32 +264,6 @@ def _unique_item_names(das: Sequence[DataArray]) -> list[str]:
             )
         return item_names
 
-    @staticmethod
-    def _check_all_different_ids(das: Sequence[DataArray]) -> None:
-        """Are all the DataArrays different objects or are some referring to the same."""
-        ids = np.zeros(len(das), dtype=np.int64)
-        ids_val = np.zeros(len(das), dtype=np.int64)
-        for j, da in enumerate(das):
-            ids[j] = id(da)
-            ids_val[j] = id(da.values)
-
-        if len(ids) != len(np.unique(ids)):
-            # DataArrays not unique! - find first duplicate and report error
-            das = list(das)
-            u, c = np.unique(ids, return_counts=True)
-            dups = u[c > 1]
-            for dup in dups:
-                jj = np.where(ids == dup)[0]
-                Dataset._id_of_DataArrays_equal(das[jj[0]], das[jj[1]])
-        if len(ids_val) != len(np.unique(ids_val)):
-            # DataArray *values* not unique! - find first duplicate and report error
-            das = list(das)
-            u, c = np.unique(ids_val, return_counts=True)
-            dups = u[c > 1]
-            for dup in dups:
-                jj = np.where(ids_val == dup)[0]
-                Dataset._id_of_DataArrays_equal(das[jj[0]], das[jj[1]])
-
     @staticmethod
     def _id_of_DataArrays_equal(da1: DataArray, da2: DataArray) -> None:
         """Check if two DataArrays are actually the same object."""
@@ -529,10 +501,12 @@ def __len__(self) -> int:
     def __iter__(self) -> Iterator[DataArray]:
         yield from self._data_vars.values()
 
-    def __setitem__(self, key, value) -> None:  # type: ignore
+    def __setitem__(self, key: int | str, value: DataArray) -> None:  # type: ignore
         self.__set_or_insert_item(key, value, insert=False)
 
-    def __set_or_insert_item(self, key, value: DataArray, insert=False) -> None:  # type: ignore
+    def __set_or_insert_item(
+        self, key: int | str, value: DataArray, insert: bool = False
+    ) -> None:  # type: ignore
         if len(self) > 0:
             self[0]._is_compatible(value)
 
@@ -1008,19 +982,17 @@ def __dataset_read_item_time_func(
 
     def extract_track(
         self,
-        track: pd.DataFrame,
+        track: str | Path | Dataset | pd.DataFrame,
         method: Literal["nearest", "inverse_distance"] = "nearest",
         dtype: Any = np.float32,
     ) -> "Dataset":
         """Extract data along a moving track.
 
         Parameters
         ---------
-        track: pandas.DataFrame
+        track: pandas.DataFrame, str or Dataset
             with DatetimeIndex and (x, y) of track points as first two columns
-            x,y coordinates must be in same coordinate system as dfsu
-        track: str
-            filename of csv or dfs0 file containing t,x,y
+            x,y coordinates must be in same coordinate system as dataset
         method: str, optional
             Spatial interpolation method ('nearest' or 'inverse_distance')
             default='nearest'

mikeio/dfs/_dfs.py

@@ -7,7 +7,6 @@
 from typing import Any, Sequence
 import numpy as np
 import pandas as pd
-from tqdm import tqdm
 
 from mikecore.DfsFile import (
     DfsDynamicItemInfo,
@@ -349,99 +348,6 @@ def __repr__(self) -> str:
 
         return str.join("\n", out)
 
-    def read(
-        self,
-        *,
-        items: str | int | Sequence[str | int] | None = None,
-        time: int | str | slice | None = None,
-        keepdims: bool = False,
-        dtype: Any = np.float32,
-    ) -> Dataset:
-        """Read data from a dfs file.
-
-        Parameters
-        ---------
-        items: list[int] or list[str], optional
-            Read only selected items, by number (0-based), or by name
-        time: int, str, datetime, pd.TimeStamp, sequence, slice or pd.DatetimeIndex, optional
-            Read only selected time steps, by default None (=all)
-        keepdims: bool, optional
-            When reading a single time step only, should the time-dimension be kept
-            in the returned Dataset? by default: False
-        dtype: data-type, optional
-            Define the dtype of the returned dataset (default = np.float32)
-
-        Returns
-        -------
-        Dataset
-
-        """
-        self._open()
-
-        item_numbers = _valid_item_numbers(self._dfs.ItemInfo, items)
-        n_items = len(item_numbers)
-
-        single_time_selected, time_steps = _valid_timesteps(self._dfs.FileInfo, time)
-        nt = len(time_steps) if not single_time_selected else 1
-
-        shape: tuple[int, ...]
-
-        if self._ndim == 1:
-            shape = (nt, self.nx)  # type: ignore
-        elif self._ndim == 2:
-            shape = (nt, self.ny, self.nx)  # type: ignore
-        else:
-            # TODO this is not used, since Dfs3 has a separate .read method
-            shape = (nt, self.nz, self.ny, self.nx)  # type: ignore
-
-        dims = self.geometry.default_dims
-
-        if single_time_selected and not keepdims:
-            shape = shape[1:]
-        else:
-            dims = ["time"] + list(dims)
-
-        data_list: list[np.ndarray] = [
-            np.ndarray(shape=shape, dtype=dtype) for _ in range(n_items)
-        ]
-
-        t_seconds = np.zeros(len(time_steps))
-
-        for i, it in enumerate(tqdm(time_steps, disable=not self.show_progress)):
-            for item in range(n_items):
-                itemdata = self._dfs.ReadItemTimeStep(item_numbers[item] + 1, int(it))
-
-                d = itemdata.Data
-                assert d.ndim == 1
-
-                d[d == self.deletevalue] = np.nan
-
-                if self._ndim == 2:
-                    d = d.reshape(self.ny, self.nx)  # type: ignore
-
-                if single_time_selected:
-                    data_list[item] = np.atleast_2d(d) if keepdims else d
-                else:
-                    data_list[item][i] = d
-
-            t_seconds[i] = itemdata.Time
-
-        time = pd.to_datetime(t_seconds, unit="s", origin=self.start_time)
-
-        items = _get_item_info(self._dfs.ItemInfo, item_numbers)
-
-        self._dfs.Close()
-
-        return Dataset(
-            data=data_list,
-            time=time,
-            items=items,
-            dims=tuple(dims),
-            geometry=self.geometry,
-            validate=False,
-            dt=self._timestep,
-        )
-
     def _open(self) -> None:
         raise NotImplementedError("Should be implemented by subclass")
 
@@ -494,7 +400,7 @@ def start_time(self) -> pd.Timestamp:
     def end_time(self) -> pd.Timestamp:
         """File end time."""
         if self._end_time is None:
-            self._end_time = self.read(items=[0]).time[-1].to_pydatetime()
+            self._end_time = self.read(items=[0]).time[-1].to_pydatetime()  # type: ignore
 
         return self._end_time
 

mikeio/dfs/_dfs1.py

@@ -1,15 +1,22 @@
 from __future__ import annotations
 from pathlib import Path
+from typing import Any, Sequence
 
 from mikecore.DfsFactory import DfsBuilder, DfsFactory
 from mikecore.DfsFile import DfsFile, DfsSimpleType
 from mikecore.DfsFileFactory import DfsFileFactory
 from mikecore.eum import eumQuantity, eumUnit
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
 
 from .. import __dfs_version__
 from ..dataset import Dataset
 from ._dfs import (
     _Dfs123,
+    _get_item_info,
+    _valid_item_numbers,
+    _valid_timesteps,
     write_dfs_data,
 )
 from ..eum import TimeStepUnit
@@ -91,6 +98,86 @@ def __init__(self, filename: str | Path) -> None:
     def _open(self) -> None:
         self._dfs = DfsFileFactory.Dfs1FileOpen(self._filename)
 
+    def read(
+        self,
+        *,
+        items: str | int | Sequence[str | int] | None = None,
+        time: int | str | slice | None = None,
+        keepdims: bool = False,
+        dtype: Any = np.float32,
+    ) -> Dataset:
+        """Read data from a dfs1 file.
+
+        Parameters
+        ---------
+        items: list[int] or list[str], optional
+            Read only selected items, by number (0-based), or by name
+        time: int, str, datetime, pd.TimeStamp, sequence, slice or pd.DatetimeIndex, optional
+            Read only selected time steps, by default None (=all)
+        keepdims: bool, optional
+            When reading a single time step only, should the time-dimension be kept
+            in the returned Dataset? by default: False
+        dtype: data-type, optional
+            Define the dtype of the returned dataset (default = np.float32)
+
+        Returns
+        -------
+        Dataset
+
+        """
+        self._open()
+
+        item_numbers = _valid_item_numbers(self._dfs.ItemInfo, items)
+        n_items = len(item_numbers)
+
+        single_time_selected, time_steps = _valid_timesteps(self._dfs.FileInfo, time)
+        nt = len(time_steps) if not single_time_selected else 1
+        shape: tuple[int, ...] = (nt, self.nx)
+        dims = self.geometry.default_dims
+
+        if single_time_selected and not keepdims:
+            shape = shape[1:]
+        else:
+            dims = ("time", *dims)
+
+        data_list: list[np.ndarray] = [
+            np.ndarray(shape=shape, dtype=dtype) for _ in range(n_items)
+        ]
+
+        t_seconds = np.zeros(len(time_steps))
+
+        for i, it in enumerate(tqdm(time_steps, disable=not self.show_progress)):
+            for item in range(n_items):
+                itemdata = self._dfs.ReadItemTimeStep(item_numbers[item] + 1, int(it))
+
+                d = itemdata.Data
+                assert d.ndim == 1
+
+                d[d == self.deletevalue] = np.nan
+
+                if single_time_selected:
+                    data_list[item] = np.atleast_2d(d) if keepdims else d
+                else:
+                    data_list[item][i] = d
+
+            t_seconds[i] = itemdata.Time
+
+        time = pd.to_datetime(t_seconds, unit="s", origin=self.start_time)
+
+        items = _get_item_info(self._dfs.ItemInfo, item_numbers)
+
+        self._dfs.Close()
+
+        return Dataset(
+            data=data_list,
+            time=time,
+            items=items,
+            dims=tuple(dims),
+            geometry=self.geometry,
+            validate=False,
+            dt=self._timestep,
+        )
+
     @property
     def geometry(self) -> Grid1D:
         assert isinstance(self._geometry, Grid1D)