more tests, rounding bug fix

Author: jeremiah-kang

src/hecdss/dss_csv.py

@@ -184,8 +184,8 @@ def paired_data_to_csv(paired_data: PairedData, path: str, with_metadata: bool)
         x: float  # x is the same as "ordinate"
         y_row: list[float]  # Each y_row is one row of y_values, as paired_data.values is Row-Major
         for x, y_row in zip(paired_data.ordinates, paired_data.values):
-            full_row: list[float] = [round(x, ROUND_PRECISION)] + \
-                [round(y, ROUND_PRECISION) for y in y_row]
+            full_row: list[float] = [_round_or_none(x)] + \
+                [_round_or_none(y) for y in y_row]
             writer.writerow([counter] + full_row)
             counter += 1
     return
@@ -277,6 +277,19 @@ def paired_data_read_csv(cls: type[PairedData], path: str) -> PairedData:
     )
 
 
+def _round_or_none(value: float | None) -> float | None:
+    """
+    Rounds a numeric value to ROUND_PRECISION, passing None through unchanged.
+
+    Parameters:
+        value (float | None): the value to round, or None if missing
+
+    Returns:
+        float | None: the rounded value, or None if value was None
+    """
+    return round(value, ROUND_PRECISION) if value is not None else None
+
+
 def _empty_path_parts() -> dict[str, str]:
     """
     Returns a fresh dict of empty A-F DSS path components.

tests/test_pd_csv.py

@@ -640,6 +640,28 @@ def test_curve_count_on_dataless_read_should_be_zero(self):
         pd = self.read_pd_from_string(content)
         self.assertEqual(pd.curve_count(), 0)
 
+    def test_to_csv_missing_value_does_not_crash(self):
+        """A blank/malformed numeric cell is read back as DEFAULT_MISSING_VALUE
+        (None), producing an object-dtype array. The writer must tolerate a None
+        ordinate/value (write an empty cell) rather than crash trying to round it."""
+        pd = self.read_pd_from_string(
+            "Type,TIME,POINTS\n"
+            "1,,10\n"       # blank ordinate -> None
+            "2,2,20\n"
+        )
+        written = self.write_pd_to_string(pd, with_metadata=True)
+        self.assertIn("1,,10.0", written)
+        self.assertIn("2,2.0,20.0", written)
+
+    def test_round_trip_nan_value_survives(self):
+        """A NaN dependent value is written as 'nan' and read back as a real NaN
+        (it is NOT collapsed into the missing-value default)."""
+        path = self.test_files.create_test_file(".csv")
+        pd = self.make_pd(x_values=[1.0], y_values=[[float("nan")]], labels=["a"])
+        pd.to_csv(path, with_metadata=True)
+        result = PairedData.read_csv(path)
+        self.assertTrue(math.isnan(result.values.tolist()[0][0]))
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_ts_csv.py

@@ -2,6 +2,8 @@
 from datetime import datetime
 from unittest.mock import mock_open, patch
 
+import numpy as np
+
 from file_manager import FileManager
 
 from hecdss import HecDss
@@ -565,6 +567,101 @@ def test_read_write_with_missing(self):
         self.assertIn("Type,Date/Time,INST-VAL", written_data)
         self.assertIn("2,01Sep2021 1200,\r\n", written_data)
 
+    def test_to_csv_writes_empty_cell_for_missing_value(self):
+        """A missing (None) value is written as an empty cell, never the literal
+        text 'None'. (Isolates the write path with an injected None, independent
+        of what the reader produces.)"""
+        rts = RegularTimeSeries.create(
+            values=[1.0, 2.0],
+            times=[datetime(2021, 9, 1, 6, 0), datetime(2021, 9, 1, 12, 0)],
+            units="CFS",
+            data_type="INST-VAL",
+            path="/A/B/C//6Hour/F/",
+        )
+        rts.values = np.array([1.0, None], dtype=object)  # simulate a missing value
+        mock_file = mock_open()
+        with patch("builtins.open", mock_file):
+            rts.to_csv("fake.csv", with_metadata=False)
+        handle = mock_file()
+        written = "".join(call.args[0] for call in handle.write.call_args_list)
+        self.assertIn("2,01Sep2021 1200,\r\n", written)
+        self.assertNotIn("None", written)
+
+    def test_to_csv_quality_shorter_than_values_truncates(self):
+        """FOOTGUN: to_csv takes the with-quality branch whenever quality is
+        non-empty, then zips (times, values, quality). A quality list shorter than
+        values makes zip stop at the shortest input, so trailing data points are
+        silently dropped from the CSV."""
+        rts = RegularTimeSeries.create(
+            values=[1.0, 2.0, 3.0],
+            times=[
+                datetime(2021, 9, 1, 6, 0),
+                datetime(2021, 9, 1, 12, 0),
+                datetime(2021, 9, 1, 18, 0),
+            ],
+            quality=[0],  # only one flag for three values
+            units="CFS",
+            data_type="INST-VAL",
+            path="/A/B/C//6Hour/F/",
+        )
+        mock_file = mock_open()
+        with patch("builtins.open", mock_file):
+            rts.to_csv("fake.csv", with_metadata=False)
+        handle = mock_file()
+        written = "".join(call.args[0] for call in handle.write.call_args_list)
+        self.assertIn("1,01Sep2021 0600,1.0,0", written)
+        self.assertNotIn("2,01Sep2021 1200", written)  # silently dropped
+        self.assertNotIn("3,01Sep2021 1800", written)  # silently dropped
+
+    def test_read_csv_skips_short_data_row(self):
+        """A data row with fewer than 3 columns is malformed and skipped without
+        raising (parity with the paired-data reader's short-row handling)."""
+        content = (
+            "Type,Date/Time,INST-VAL\n"
+            "1,01Sep2021 0600\n"        # only 2 columns -> skipped
+            "2,01Sep2021 1200,20.0\n"
+        )
+        rts = self.read_rts_from_string(content)
+        self.assertEqual(rts.values.tolist(), [20.0])
+        self.assertEqual(rts.times, [datetime(2021, 9, 1, 12, 0)])
+
+    def test_read_csv_metadata_only_no_data_rows(self):
+        """Metadata rows with zero data rows yield an empty series (no crash);
+        units and the E interval are still captured."""
+        content = (
+            "A,,,A\n"
+            "E,,,6Hour\n"
+            "Units,,,CFS\n"
+            "Type,Date/Time,INST-VAL\n"
+        )
+        rts = self.read_rts_from_string(content)
+        self.assertEqual(rts.values.tolist(), [])
+        self.assertEqual(rts.times, [])
+        self.assertEqual(rts.units, "CFS")
+        self.assertEqual(rts.interval, 21600)
+
+    def test_round_trip_irregular(self):
+        """Full write->read round trip for IrregularTimeSeries on a real temp file:
+        irregular gaps, units, data_type and id all survive."""
+        path = self.test_files.create_test_file(".csv")
+        its = IrregularTimeSeries.create(
+            values=[10.5, 20.0, 42.0],
+            times=[datetime(2021, 9, 1), datetime(2021, 9, 5), datetime(2021, 9, 20)],
+            units="CFS",
+            data_type="INST-VAL",
+            path="/A/B/C//IR-Year/F/",
+        )
+        its.to_csv(path, with_metadata=True)
+        result = IrregularTimeSeries.read_csv(path)
+        self.assertEqual(result.values.tolist(), [10.5, 20.0, 42.0])
+        self.assertEqual(
+            result.times,
+            [datetime(2021, 9, 1), datetime(2021, 9, 5), datetime(2021, 9, 20)],
+        )
+        self.assertEqual(result.units, "CFS")
+        self.assertEqual(result.data_type, "INST-VAL")
+        self.assertEqual(result.id, "/A/B/C//IR-Year/F/")
+
 
 if __name__ == "__main__":
     unittest.main()