60 observed flow and stage data

.devcontainer/Dockerfile

@@ -0,0 +1 @@
+FROM mcr.microsoft.com/devcontainers/base:jammy

.devcontainer/devcontainer.json

@@ -0,0 +1,28 @@
+{
+	"name": "rashdf-devcontainer",
+	"build": {
+		"dockerfile": "Dockerfile",
+		"context": ".."
+	},
+	"features": {
+		"ghcr.io/devcontainers/features/git:1": {},
+		"ghcr.io/devcontainers/features/python:1":{"version":"3.12"}
+	},
+  "mounts": [],
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"ms-python.python",
+				"ms-python.pylint",
+				"GitHub.copilot",
+				"ms-python.black-formatter"
+			],
+			"settings": {
+				"python.defaultInterpreterPath": "/opt/conda/envs/rashdf/bin/python"
+			}
+		}
+	},
+	// avoid dubious ownership of the workspace folder https://www.kenmuse.com/blog/avoiding-dubious-ownership-in-dev-containers/
+	"postStartCommand": "git config --global --add safe.directory ${containerWorkspaceFolder}",
+	"postCreateCommand": "sudo chown -R vscode:vscode ${containerWorkspaceFolder}"
+}

README.md

@@ -110,8 +110,14 @@ $ python -m venv venv-rashdf
 
 Activate the virtual environment:
 ```
+# For macOS/Linux
 $ source ./venv/bin/activate
-(venv-rashdf) $
+(venv-rashdf)
+Or
+$ source venv-rashdf/bin/activate
+
+# For Windows
+$ source venv-rashdf/Scripts/activate
 ```
 
 Install dev dependencies:

pyproject.toml

@@ -13,10 +13,10 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
 ]
 version = "0.6.0"
-dependencies = ["h5py", "geopandas>=1.0,<2.0", "pyarrow", "xarray"]
+dependencies = ["h5py", "geopandas>=1.0,<2.0", "pyarrow", "xarray", "fiona==1.9.6"]
 
 [project.optional-dependencies]
-dev = ["pre-commit", "ruff", "pytest", "pytest-cov", "fiona", "kerchunk", "zarr", "dask", "fsspec", "s3fs"]
+dev = ["pre-commit", "ruff", "pytest", "pytest-cov", "kerchunk", "zarr", "dask", "fsspec", "s3fs"]
 docs = ["sphinx", "numpydoc", "sphinx_rtd_theme"]
 
 [project.urls]

src/rashdf/plan.py

@@ -4,6 +4,7 @@
 from .utils import (
     df_datetimes_to_str,
     ras_timesteps_to_datetimes,
+    parse_ras_datetime,
     parse_ras_datetime_ms,
     deprecated,
 )
@@ -156,6 +157,7 @@
     PLAN_INFO_PATH = "Plan Data/Plan Information"
     PLAN_PARAMS_PATH = "Plan Data/Plan Parameters"
     PRECIP_PATH = "Event Conditions/Meteorology/Precipitation"
+    OBS_DATA_PATH = "Event Conditions/Observed Data"
     RESULTS_UNSTEADY_PATH = "Results/Unsteady"
     RESULTS_UNSTEADY_SUMMARY_PATH = f"{RESULTS_UNSTEADY_PATH}/Summary"
     VOLUME_ACCOUNTING_PATH = f"{RESULTS_UNSTEADY_PATH}/Volume Accounting"
@@ -166,6 +168,8 @@
     UNSTEADY_TIME_SERIES_PATH = f"{BASE_OUTPUT_PATH}/Unsteady Time Series"
     REFERENCE_LINES_OUTPUT_PATH = f"{UNSTEADY_TIME_SERIES_PATH}/Reference Lines"
     REFERENCE_POINTS_OUTPUT_PATH = f"{UNSTEADY_TIME_SERIES_PATH}/Reference Points"
+    OBS_FLOW_OUTPUT_PATH = f"{OBS_DATA_PATH}/Flow"
+    OBS_STAGE_OUTPUT_PATH = f"{OBS_DATA_PATH}/Stage"
 
     RESULTS_STEADY_PATH = "Results/Steady"
     BASE_STEADY_PATH = f"{RESULTS_STEADY_PATH}/Output/Output Blocks/Base Output"
@@ -1117,6 +1121,106 @@
         """
         return self.reference_timeseries_output(reftype="lines")
 
+    def observed_timeseries_input(self, vartype: str = "Flow") -> xr.Dataset:
+        """Return observed timeseries input data for reference lines and points from a HEC-RAS HDF plan file.
+
+        Parameters
+        ----------
+        vartype : str, optional
+            The type of observed data to retrieve. Must be either "Flow" or "Stage".
+            (default: "Flow")
+
+        Returns
+        -------
+        Dict[Site: str, xr.DataArray]
+            An xarray Dataset with observed timeseries data for both reference lines and reference points.
+
+            Coordinates:
+            - 'time': datetime64[ns]
+
+            Data variables:
+            - 'Flow' or 'Stage': float64
+        """
+
+        # Decode the contents of the DataFrame from utf-8
+        def decode_bytes(val):
+            if isinstance(val, bytes):
+                return val.decode("utf-8")
+            return val
+
+        if vartype == "Flow":
+            output_path = self.OBS_FLOW_OUTPUT_PATH
+        elif vartype == "Stage":
+            output_path = self.OBS_STAGE_OUTPUT_PATH
+        else:
+            raise ValueError('vartype must be either "Flow" or "Stage".')
+
+        observed_group = self.get(output_path)
+        if observed_group is None:
+            raise RasPlanHdfError(
+                f"Could not find HDF group at path '{output_path}'."
+                f" Does the Plan HDF file contain reference {vartype[:-1]} output data?"
+            )
+        print(f"observed_group: {observed_group}")
+        if "Attributes" in observed_group.keys():
+            attr_path = observed_group["Attributes"]
+            print(f"attr_path: {attr_path}")
+            attrs_df = pd.DataFrame(attr_path[:])
+            # Apply the decoding function to each element in the DataFrame
+            attrs_df = attrs_df.map(decode_bytes)
+            if vartype == "Flow":
+                attrs_df["Units"] = "cfs"
+            elif vartype == "Stage":
+                attrs_df["Units"] = "ft"
+            else:
+                attrs_df["Units"] = "Unknown"
+        das = {}
+        for site in observed_group.keys():
+            if site != "Attributes":
+                # Site Ex: 'Ref Point: Grapevine_Lake_RP'
+                site_path = observed_group[site]
+                prefix = site.split(":")[0]
+                suffix = site.split(":")[1][1:]
+                data_df = pd.DataFrame(site_path[:])
+                # Apply the decoding function to each element in the DataFrame
+                data_df = data_df.map(decode_bytes)
+                # Assign data types to the columns
+                data_df["Date"] = data_df["Date"].apply(parse_ras_datetime)
+                data_df["Date"] = pd.to_datetime(
+                    data_df["Date"], format="%d%b%Y %H:%M:%S"
+                )
+                data_df["Value"] = data_df["Value"].astype(float)
+                # Determine the site type
+                site_type = (
+                    "reference_line" if "Ref Line" in site else "reference_point"
+                )
+                # Package into an xarray DataArray
+                da = xr.DataArray(
+                    data_df["Value"].values,
+                    name=vartype,
+                    dims=["time"],
+                    coords={
+                        "time": data_df["Date"].values,
+                    },
+                    attrs={
+                        "units": attrs_df["Units"][0],
+                        "hdf_path": f"{output_path}/{site}",
+                    },
+                )
+                das[suffix] = da
+
+        return das
+
+    def observed_data_timeseries_input(self) -> xr.Dataset:
+        """Return observed data timeseries input data for reference lines or points from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        xr.Dataset
+            An xarray Dataset with observed timeseries input data for reference lines or points.
+        """
+        return self.observed_timeseries_input(vartype="Flow")
+
     def reference_points_timeseries_output(self) -> xr.Dataset:
         """Return timeseries output data for reference points from a HEC-RAS HDF plan file.
 
@@ -1279,6 +1383,16 @@
         """
         return self.get_attrs(self.PRECIP_PATH)
 
+    def get_obs_data_attrs(self) -> Dict:
+        """Return observed data attributes from a HEC-RAS HDF plan file.
+
+        Returns
+        -------
+        dict
+            Dictionary of observed data attributes.
+        """
+        return self.get_attrs(self.OBS_DATA_PATH)
+
     def get_results_unsteady_attrs(self) -> Dict:
         """Return unsteady attributes from a HEC-RAS HDF plan file.