Merge pull request #33 from CentralValleyModeling/main

Release `0.8.3`

Author: dwr-zroy

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pandss"
-version = "0.8.2"
+version = "0.8.3"
 dependencies = [
     "pyhecdss==1.3",
     "pandas==2",

src/pandss/dss.py

@@ -10,6 +10,7 @@
 from .paths import DatasetPath, DatasetPathCollection
 from .quiet import silent, suppress_stdout_stderr
 from .timeseries import RegularTimeseries
+from .timeseries.interval import Interval
 
 module_engine = ModuleEngine()
 
@@ -349,6 +350,73 @@ def write_rts(self, path: DatasetPath | str, rts: RegularTimeseries):
         with suppress_stdout_stderr():
             return self.engine.write_rts(path, rts)
 
+    def write_dataframe(
+        self,
+        paths: list[DatasetPath],
+        df: pd.DataFrame,
+        units: str | list[str],
+        period_types: str | list[str],
+        intervals: str | Interval | list[str | Interval],
+    ):
+        """Write DSS data from a DataFrame, where each column is a RegularTimeseries
+
+        Parameters
+        ----------
+        paths : list[DatasetPath]
+            The paths to write to in the DSS file.
+        df : pd.DataFrame
+            The data to convert into a DSS file.
+        units : str | list[str]
+            The units to use for the data in the DSS file.
+        period_types : str | list[str]
+            The DSS period types to use for the data in the DSS file.
+        intervals : str | Interval | list[str  |  Interval]
+            The DSS intervals to use for the data in the DSS file.
+
+        Raises
+        ------
+        ValueError
+            Raised when the data given cannot be assigned uniquely to the columns of the
+            DataFrame, or when a RegularTimeseries object cannot be created.
+
+        """
+        if isinstance(units, str):
+            units = [units for _ in paths]
+        if isinstance(period_types, str):
+            period_types = [period_types for _ in paths]
+        if isinstance(intervals, (str, Interval)):
+            intervals = [intervals for _ in paths]
+
+        try:
+            data = zip(
+                paths,
+                df.columns,
+                units,
+                period_types,
+                intervals,
+            )
+        except Exception as e:
+            raise ValueError(
+                "The lengths of the data given do not match,"
+                + " could not determine a 1-to-1 retionship between inputs"
+                + " and dataframe columns"
+            ) from e
+        for p, col, unit, pt, inter in data:
+            series = df[col]
+            try:
+                rts = RegularTimeseries.from_series(
+                    s=series,
+                    path=p,
+                    units=unit,
+                    period_type=pt,
+                    interval=inter,
+                )
+            except Exception as e:
+                raise ValueError(
+                    "Could not create a RegularTimeseries object from the data given."
+                ) from e
+            self.write_rts(path=p, rts=rts)
+
     def resolve_wildcard(
         self,
         path: DatasetPath | str,

src/pandss/paths/dataset_path.py

@@ -158,10 +158,16 @@ def __eq__(self, __other: Any):
                     for f in fields(self)
                 )
             except AttributeError:
+                # If the attributes don't match, return False
                 return False
         elif isinstance(__other, str):
             # First clean up, then do str comparison
-            return str(self) == str(self.__class__.from_str(__other))
+            try:
+                __other = self.__class__.from_str(__other)
+                return str(self) == str(__other)
+            except DatasetPathParseError:
+                # If you can't parse the second string, return False
+                return False
         else:
             # Resort to regular string comparison
             return str(self) == str(__other)

src/pandss/timeseries/regular_timeseries.py

@@ -4,7 +4,7 @@
 
 from numpy import array, datetime64, datetime_as_string, intersect1d, ndarray
 from numpy.typing import NDArray
-from pandas import DataFrame, Index, MultiIndex
+from pandas import DataFrame, Index, MultiIndex, Series
 
 from ..paths import DatasetPath
 from .interval import Interval
@@ -278,6 +278,28 @@ def to_frame(
 
         return df
 
+    @classmethod
+    def from_series(
+        cls,
+        s: Series,
+        path: DatasetPath | str,
+        period_type: str,
+        units: str,
+        interval: Interval | str,
+    ) -> "RegularTimeseries":
+        if isinstance(interval, str):
+            interval = Interval(interval)
+        if isinstance(path, str):
+            path = DatasetPath.from_str(path)
+        return cls(
+            path=path,
+            values=s.values,  # type: ignore
+            dates=s.index,  # type: ignore
+            period_type=period_type,
+            units=units,
+            interval=interval,
+        )
+
     def to_json(self) -> dict:
         """Create a JSON-compliant dictionary with the RegularTimeseries data
 

tests/test_dss.py

@@ -91,3 +91,23 @@ def test_to_plaintext(dss, created_dir, random_name, request: FixtureRequest):
             rts_new = new_dss.read_rts(p)
             assert len(rts_old.values) == len(rts_new.values)
             assert (sum(rts_old.values) - sum(rts_new.values)) < 0.000_000_000_1
+
+
+@pytest.mark.parametrize("dss", ("dss_6", "dss_7", "dss_large"))
+def test_write_from_dataframe(dss, request: FixtureRequest):
+    dss: Path = request.getfixturevalue(dss)
+    p = "/CALSIM/MONTH_DAYS/DAY//1MON/L2020A/"
+    p_new = "/CALSIM/TEST_WRITE_FROM_DF/DAY//1MON/L2020A/"
+    with pdss.DSS(dss) as DSS:
+        rts = DSS.read_rts(p)
+        df = rts.to_frame()
+        DSS.write_dataframe(
+            paths=[pdss.DatasetPath.from_str(p_new)],
+            df=df,
+            units=[rts.units],
+            period_types=[rts.period_type],
+            intervals=[rts.interval],
+        )
+    with pdss.DSS(dss) as DSS:
+        rts_new = DSS.read_rts(p_new)
+        assert rts_new.interval == rts.interval

tests/test_paths.py

@@ -250,3 +250,27 @@ def test_to_catalog():
     assert tuple(df.columns) == ("A", "B", "C", "D", "E", "F")
     assert tuple(df["B"]) == ("1", "2")
     assert tuple(df["C"]) == (".*", ".*")
+
+
+def test_pattern_matching_as_str():
+    dsp = pdss.DatasetPath(b="FOO")
+    match dsp:
+        case "/OTHER/FOO/.*/.*/.*/.*/":
+            assert False, "pattern matching succeeded too early"
+        case "FOO":
+            assert False, "pattern matching succeeded too early"
+        case "/.*/FOO/.*/.*/.*/.*/":
+            pass
+        case _:
+            assert False, "pattern matching failed"
+
+
+def test_pattern_matching():
+    dsp = pdss.DatasetPath(b="FOO")
+    match dsp:
+        case pdss.DatasetPath(b="FOO", c="BAR"):
+            assert False, "pattern matching succeeded too early"
+        case pdss.DatasetPath(b="FOO"):
+            pass
+        case _:
+            assert False, "pattern matching failed"

tests/test_rts.py

@@ -207,6 +207,24 @@ def test_accept_path_as_str():
     assert rts.path.b == "MONTH_DAYS"
 
 
+def test_rts_from_series():
+    series = pd.Series(
+        data=[1, 2, 3, 4, 5],
+        index=pd.DatetimeIndex(
+            data=["2000-01-01", "2000-02-01", "2000-03-01", "2000-04-01", "2000-05-01"]
+        ),
+    )
+    path = pdss.DatasetPath(b="TEST")
+    rts = pdss.RegularTimeseries.from_series(
+        series,
+        path,
+        period_type="PER-AVG",
+        units="NONE",
+        interval="1MON",
+    )
+    assert isinstance(rts, pdss.RegularTimeseries)
+
+
 @pytest.mark.parametrize("dss", ("dss_6", "dss_7"))
 def test_write_rts(dss, temporary_dss, request: FixtureRequest):
     dss = request.getfixturevalue(dss)
@@ -306,17 +324,4 @@ def test_read_write_daily_inst(dss, temporary_dss, request: FixtureRequest):
         assert L == R
 
 
-@pytest.mark.parametrize("dss", ("dss_6", "dss_7"))
-def test_to_frame_small_header(dss, request: FixtureRequest):
-    dss = request.getfixturevalue(dss)
-    p1 = pdss.DatasetPath(b="MONTH_DAYS")
-    rts = pdss.read_rts(dss, p1)
-    df_1 = rts.to_frame(include_in_header="B")
-    assert isinstance(df_1.columns, pd.Index)
-    assert len(df_1.columns) == 1
-    df_2 = rts.to_frame(include_in_header=("B", "C"))
-    assert isinstance(df_2.columns, pd.MultiIndex)
-    assert len(df_2.columns) == 1
-
-
 # TODO: add tests for daily data