Timeseries plot style

modelskill/comparison/_comparer_plotter.py

@@ -31,6 +31,17 @@
 from ..settings import options
 
 
+def _check_arg_length_match_nmodels(arg, n_mod):
+    if isinstance(arg, str):
+        # If arg is str, convert to list (for looping)
+        arg = [arg]
+    if arg is not None and len(arg) < n_mod:
+        raise ValueError(
+            f"Number of elements in {arg} does not match the number of models in the comparer."
+        )
+    return arg
+
+
 class ComparerPlotter:
     """Plotter class for Comparer
 
@@ -62,6 +73,8 @@ def timeseries(
         ax=None,
         figsize: Tuple[float, float] | None = None,
         backend: str = "matplotlib",
+        style: list[str] | str | None = None,
+        color: list[str] | tuple | str | None = None,
         **kwargs,
     ):
         """Timeseries plot showing compared data: observation vs modelled
@@ -79,32 +92,62 @@ def timeseries(
         backend : str, optional
             use "plotly" (interactive) or "matplotlib" backend,
             by default "matplotlib"
+        style: list of str, optional
+            Only for matplotlib backend. Containing line styles of the model results. Cannot be passed together with color input.
+            by default None
+        color: list of str, optional
+            Only for matplotlib backend. containing colors of the model results.
+            If len(colors) == num_models + 1, the first color will be used for the observations.
+            Cannot be passed together with style input.
+            by default None
         **kwargs
             other keyword arguments to fig.update_layout (plotly backend)
 
         Returns
         -------
         matplotlib.axes.Axes or plotly.graph_objects.Figure
         """
+
         from ._comparison import MOD_COLORS
 
         cmp = self.comparer
 
         if title is None:
             title = cmp.name
 
+        if color is not None and style is not None:
+            raise ValueError(
+                "It is not possible to pass both the color argument and the style argument. Choose one."
+            )
+
+        # Color for observations:
+        obs_color = cmp.data[cmp._obs_name].attrs["color"]
+
+        color = _check_arg_length_match_nmodels(color, cmp.n_models)
+        style = _check_arg_length_match_nmodels(style, cmp.n_models)
+
+        if color is not None and len(color) > cmp.n_models:
+            # If more than n_models colors is given, the first color is used for the observations
+            obs_color = color[0]
+            color = color[1:]
+
         if backend == "matplotlib":
             fig, ax = _get_fig_ax(ax, figsize)
             for j in range(cmp.n_models):
                 key = cmp.mod_names[j]
                 mod = cmp.raw_mod_data[key]._values_as_series
-                mod.plot(ax=ax, color=MOD_COLORS[j])
+                if style is not None:
+                    mod.plot(ax=ax, style=style[j])
+                else:
+                    if color is None:
+                        color = MOD_COLORS
+                    mod.plot(ax=ax, color=color[j])
 
             ax.scatter(
                 cmp.time,
                 cmp.data[cmp._obs_name].values,
                 marker=".",
-                color=cmp.data[cmp._obs_name].attrs["color"],
+                color=obs_color,
             )
             ax.set_ylabel(cmp._unit_text)
             ax.legend([*cmp.mod_names, cmp._obs_name])
@@ -117,6 +160,15 @@ def timeseries(
         elif backend == "plotly":  # pragma: no cover
             import plotly.graph_objects as go  # type: ignore
 
+            if style is not None:
+                raise NotImplementedError(
+                    "style argument is not supported for plotly backend"
+                )
+            if color is not None:
+                raise NotImplementedError(
+                    "color argument not supported for plotly backend"
+                )
+
             mod_scatter_list = []
             for j in range(cmp.n_models):
                 key = cmp.mod_names[j]

pyproject.toml

@@ -55,18 +55,18 @@ docs = [
     "dask",
 ]
 
-dev = ["pytest", "plotly >= 4.5", "ruff==0.6.2"]
-
-test = [
-    "pytest",
-    "pytest-cov",
-    "openpyxl",
-    "dask",
-    "mypy",
-    "types-PyYAML",
-    "geopandas",
+test =  [
+        "pytest",
+        "pytest-cov", 
+        "netCDF4",
+        "openpyxl",
+        "dask",
+        "mypy",
+        "geopandas",
+        "plotly",
 ]
 
+
 notebooks = ["nbformat", "nbconvert", "jupyter", "plotly", "shapely", "seaborn"]
 
 [project.urls]

tests/test_comparer.py

@@ -1,11 +1,12 @@
+import matplotlib.pyplot as plt
 import numpy as np
-import pytest
 import pandas as pd
+import pytest
 import xarray as xr
-import matplotlib.pyplot as plt
-from modelskill.comparison import Comparer
-from modelskill import __version__
+
 import modelskill as ms
+from modelskill import __version__
+from modelskill.comparison import Comparer
 
 
 @pytest.fixture
@@ -889,6 +890,34 @@ def test_from_matched_dfs0():
     ) == pytest.approx(0.0476569069177831)
 
 
+def test_timeseriesplot_accepts_style_color_input(pc):
+    # Check that it can take the inputs
+    ax = pc.plot.timeseries(color=["red", "blue"])
+    ax = pc.plot.timeseries(style=["b-", "g--"])
+    assert ax.lines[1].get_color() == "g"
+
+    # Check that errors are raised
+    with pytest.raises(ValueError, match="Choose one"):
+        ax = pc.plot.timeseries(color=["red", "blue"], style="b-")
+    with pytest.raises(ValueError, match="number of models"):
+        ax = pc.plot.timeseries(color=["red"])
+    with pytest.raises(ValueError, match="number of models"):
+        ax = pc.plot.timeseries(style=["b-"])
+
+    ax = pc.plot.timeseries(color=["red", "blue", "black"])
+    # first line is blue (red is for observations).
+    assert ax.lines[0].get_color() == "blue"
+    plt.show()
+
+
+def test_timeseriesplot_plotly_does_not_accept_style_color_input(pc):
+    with pytest.raises(NotImplementedError):
+        pc.plot.timeseries(backend="plotly", style=["b-", "g--"])
+
+    with pytest.raises(NotImplementedError):
+        pc.plot.timeseries(backend="plotly", color=["red", "blue"])
+
+
 def test_from_matched_x_or_x_item_not_both():
     with pytest.raises(ValueError, match="x and x_item cannot both be specified"):
         ms.from_matched(