diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile deleted file mode 100644 index 9b87b6a..0000000 --- a/.devcontainer/Dockerfile +++ /dev/null @@ -1,4 +0,0 @@ -FROM mambaorg/micromamba:1.4.2 -COPY --chown=$MAMBA_USER:$MAMBA_USER env.yaml /tmp/env.yaml -RUN micromamba install -y -n base -f /tmp/env.yaml && \ - micromamba clean --all --yes \ No newline at end of file diff --git a/.devcontainer/README.md b/.devcontainer/README.md deleted file mode 100644 index 59d21b5..0000000 --- a/.devcontainer/README.md +++ /dev/null @@ -1,10 +0,0 @@ -# FFRD Devcontainer Template -Devcontainers enable interactive development within a Docker container using VSCode. - -This devcontainer sets up a reproducible environment for Python projects using micromamba environments (a faster and more robust version of Conda). - -When you open this repository in VSCode, you might receive a prompt to re-open the project in a devcontainer. Alternatively, you can access this option through the View menu by selecting Command Palette and then choosing DevContainers: Reopen in Container. - -Additional requirements: -1. An environment file (env.yaml) is required in the .devcontainer folder. -2. Make sure you have a Docker engine installed locally (such as Docker Desktop). diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json deleted file mode 100644 index 15e8d4a..0000000 --- a/.devcontainer/devcontainer.json +++ /dev/null @@ -1,47 +0,0 @@ -{ - "name": "Ubuntu", - // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile - "build": { - "dockerfile": "Dockerfile" - }, - "features": { - "ghcr.io/devcontainers/features/git:1": {}, - "ghcr.io/devcontainers/features/aws-cli:1": {} - }, - // mount aws credentials folder to dev container - "mounts": [ - "source=${localEnv:HOME}${localEnv:USERPROFILE}/.aws,target=/home/mambauser/.aws,type=bind,consistency=cached" - ], - // uncomment to enable gpu in the container - // "runArgs": [ - // "--gpus=all" - // ], - // Configure tool-specific properties. - "customizations": { - "settings": { - "python.defaultInterpreterPath": "/opt/conda/bin/python", - "python.linting.enabled": true, - "python.linting.pylintEnabled": true, - "editor.defaultFormatter": "ms-python.python", - "python.formatting.provider": "black", - "python.formatting.blackPath": "/opt/conda/bin/black", - "python.linting.pylintPath": "/opt/conda/bin/pylint", - "python.editor.defaultFormatter": "ms-python.black-formatter", - "editor.formatOnSave": true, - "python.languageServer": "Pylance", - "python.linting.lintOnSave": true, - "python.analysis.extraPaths": [ - "${workspaceFolder}/src" - ] - }, - "vscode": { - "extensions": [ - "ms-python.python", - "njpwerner.autodocstring", - "ms-python.pylint", - "github.copilot", - "ms-python.python" - ] - } - } -} \ No newline at end of file diff --git a/.devcontainer/env.yaml b/.devcontainer/env.yaml deleted file mode 100644 index 205d218..0000000 --- a/.devcontainer/env.yaml +++ /dev/null @@ -1,11 +0,0 @@ -# base packages that can be added to. Updated by micromamba env export --from-history > env.yaml -name: base -channels: -- conda-forge -dependencies: - - black - - click - - pip - - pylint - - pytest - - python \ No newline at end of file diff --git a/.github/workflows/continuous-integration.yml b/.github/workflows/continuous-integration.yml index a93f864..a56e6a5 100644 --- a/.github/workflows/continuous-integration.yml +++ b/.github/workflows/continuous-integration.yml @@ -40,6 +40,11 @@ jobs: python -m pip install --upgrade pip pip install ".[dev]" + - name: Lint (ruff) + run: | + ruff check + ruff format --check + - name: Test with pytest run: | pytest diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..dad7062 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,9 @@ +repos: +- repo: https://github.com/astral-sh/ruff-pre-commit + # Ruff version. + rev: v0.4.2 + hooks: + # Run the linter. + - id: ruff + # Run the formatter. + - id: ruff-format \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json index 8108b2b..b1828e7 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -2,16 +2,10 @@ "python.testing.pytestArgs": [ "." ], - "python.testing.unittestEnabled": false, "python.testing.pytestEnabled": true, - "python.formatting.provider": "none", - "editor.formatOnSave": true, - "python.formatting.blackArgs": [ - "--line-length=120" - ], - "python.languageServer": "Pylance", - "python.linting.lintOnSave": true, + "python.testing.unittestEnabled": false, "[python]": { - "editor.defaultFormatter": "ms-python.black-formatter" + "editor.defaultFormatter": "charliermarsh.ruff", + "editor.formatOnSave": true } } \ No newline at end of file diff --git a/README.md b/README.md index 7e7bd49..ab02cf7 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,19 @@ # rashdf -Read data from HEC-RAS HDF files. +[![CI](https://github.com/fema-ffrd/rashdf/actions/workflows/continuous-integration.yml/badge.svg?branch=main)](https://github.com/fema-ffrd/rashdf/actions/workflows/continuous-integration.yml) +[![Release](https://github.com/fema-ffrd/rashdf/actions/workflows/release.yml/badge.svg)](https://github.com/fema-ffrd/rashdf/actions/workflows/release.yml) +[![PyPI version](https://badge.fury.io/py/rashdf.svg)](https://badge.fury.io/py/rashdf) -## Setup +Read data from [HEC-RAS](https://www.hec.usace.army.mil/software/hec-ras/) [HDF](https://github.com/HDFGroup/hdf5) files. + +*Pronunciation: `raz·aitch·dee·eff`* + +## Install +A prerelease version of `rashdf` is available from PyPI: +```bash +$ pip install rashdf=0.1.0b1 +``` + +## Developer Setup Create a virtual environment in the project directory: ``` $ python -m venv venv-rashdf @@ -13,6 +25,16 @@ $ source ./venv/bin/activate (venv-rashdf) $ ``` +Install dev dependencies: +``` +(venv-rashdf) $ pip install ".[dev]" +``` + +Install git hook scripts (used for automatic liniting/formatting) +``` +(venv-rashdf) $ pre-commit install +``` + With the virtual environment activated, run the tests: ``` (venv-rashdf) $ pytest diff --git a/pyproject.toml b/pyproject.toml index 053bf48..bd64e0d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -16,7 +16,7 @@ version = "0.1.0-beta.1" dependencies = ["h5py", "geopandas"] [project.optional-dependencies] -dev = ["pytest"] +dev = ["pre-commit", "ruff", "pytest"] [project.urls] repository = "https://github.com/fema-ffrd/rashdf" diff --git a/src/rashdf/__init__.py b/src/rashdf/__init__.py index 8f03a64..21b0045 100644 --- a/src/rashdf/__init__.py +++ b/src/rashdf/__init__.py @@ -1,3 +1,5 @@ from .base import RasHdf from .geom import RasGeomHdf from .plan import RasPlanHdf + +__all__ = ["RasHdf", "RasGeomHdf", "RasPlanHdf"] diff --git a/src/rashdf/base.py b/src/rashdf/base.py index 4b1aaab..c13b9cc 100644 --- a/src/rashdf/base.py +++ b/src/rashdf/base.py @@ -6,7 +6,7 @@ class RasHdf(h5py.File): def __init__(self, name: str, **kwargs): """Open a HEC-RAS HDF file. - + Parameters ---------- name : str @@ -17,7 +17,9 @@ def __init__(self, name: str, **kwargs): super().__init__(name, mode="r", **kwargs) @classmethod - def open_uri(cls, uri: str, fsspec_kwargs: dict = {}, h5py_kwargs: dict = {}) -> 'RasHdf': + def open_uri( + cls, uri: str, fsspec_kwargs: dict = {}, h5py_kwargs: dict = {} + ) -> "RasHdf": """Open a HEC-RAS HDF file from a URI. Parameters @@ -40,6 +42,7 @@ def open_uri(cls, uri: str, fsspec_kwargs: dict = {}, h5py_kwargs: dict = {}) -> -------- >>> results_hdf = RasHdf.open_uri("s3://my-bucket/results.hdf") """ - import fsspec + import fsspec # type: ignore + remote_file = fsspec.open(uri, mode="rb", **fsspec_kwargs) - return cls(remote_file.open(), **h5py_kwargs) \ No newline at end of file + return cls(remote_file.open(), **h5py_kwargs) diff --git a/src/rashdf/geom.py b/src/rashdf/geom.py index 725b6cd..8447342 100644 --- a/src/rashdf/geom.py +++ b/src/rashdf/geom.py @@ -2,20 +2,25 @@ from .utils import convert_ras_hdf_string import numpy as np -import pandas as pd from geopandas import GeoDataFrame from pyproj import CRS -from shapely import Polygon, Point, LineString, MultiLineString, MultiPolygon, polygonize +from shapely import ( + Polygon, + Point, + LineString, + MultiLineString, + MultiPolygon, + polygonize, +) -from typing import Optional +from typing import List, Optional class RasGeomHdf(RasHdf): - def projection(self) -> Optional[CRS]: """Return the projection of the RAS geometry as a pyproj.CRS object. - + Returns ------- CRS @@ -24,14 +29,14 @@ def projection(self) -> Optional[CRS]: proj_wkt = self.attrs.get("Projection") if proj_wkt is None: return None - if type(proj_wkt) == bytes or type(proj_wkt) == np.bytes_: + if isinstance(proj_wkt, bytes) or isinstance(proj_wkt, np.bytes_): proj_wkt = proj_wkt.decode("utf-8") return CRS.from_wkt(proj_wkt) - - def mesh_area_names(self) -> list: - """Return a list of the 2D mesh area names of + + def mesh_area_names(self) -> List[str]: + """Return a list of the 2D mesh area names of the RAS geometry. - + Returns ------- list @@ -39,11 +44,16 @@ def mesh_area_names(self) -> list: """ if "/Geometry/2D Flow Areas" not in self: return list() - return list([convert_ras_hdf_string(n) for n in self["/Geometry/2D Flow Areas/Attributes"][()]["Name"]]) + return list( + [ + convert_ras_hdf_string(n) + for n in self["/Geometry/2D Flow Areas/Attributes"][()]["Name"] + ] + ) def mesh_areas(self) -> GeoDataFrame: """Return 2D flow area perimeter polygons. - + Returns ------- GeoDataFrame @@ -52,12 +62,19 @@ def mesh_areas(self) -> GeoDataFrame: mesh_area_names = self.mesh_area_names() if not mesh_area_names: return GeoDataFrame() - mesh_area_polygons = [Polygon(self[f"/Geometry/2D Flow Areas/{n}/Perimeter"][()]) for n in mesh_area_names] - return GeoDataFrame({"mesh_name" : mesh_area_names, "geometry" : mesh_area_polygons}, geometry="geometry", crs=self.projection()) + mesh_area_polygons = [ + Polygon(self[f"/Geometry/2D Flow Areas/{n}/Perimeter"][()]) + for n in mesh_area_names + ] + return GeoDataFrame( + {"mesh_name": mesh_area_names, "geometry": mesh_area_polygons}, + geometry="geometry", + crs=self.projection(), + ) def mesh_cell_polygons(self) -> GeoDataFrame: """Return the 2D flow mesh cell polygons. - + Returns ------- GeoDataFrame @@ -69,30 +86,49 @@ def mesh_cell_polygons(self) -> GeoDataFrame: face_gdf = self.mesh_cell_faces() - cell_dict = {"mesh_name":[], "cell_id":[], "geometry":[]} + cell_dict = {"mesh_name": [], "cell_id": [], "geometry": []} for i, mesh_name in enumerate(mesh_area_names): cell_cnt = self["/Geometry/2D Flow Areas/Cell Info"][()][i][1] cell_ids = list(range(cell_cnt)) - cell_face_info = self[f"/Geometry/2D Flow Areas/{mesh_name}/Cells Face and Orientation Info"][()] - cell_face_values = self[f"/Geometry/2D Flow Areas/{mesh_name}/Cells Face and Orientation Values"][()][:,0] + cell_face_info = self[ + f"/Geometry/2D Flow Areas/{mesh_name}/Cells Face and Orientation Info" + ][()] + cell_face_values = self[ + f"/Geometry/2D Flow Areas/{mesh_name}/Cells Face and Orientation Values" + ][()][:, 0] face_id_lists = list( np.vectorize( - lambda cell_id: str(cell_face_values[cell_face_info[cell_id][0]:cell_face_info[cell_id][0]+cell_face_info[cell_id][1]]) + lambda cell_id: str( + cell_face_values[ + cell_face_info[cell_id][0] : cell_face_info[cell_id][0] + + cell_face_info[cell_id][1] + ] + ) )(cell_ids) ) - mesh_faces = face_gdf[face_gdf.mesh_name == mesh_name][["face_id", "geometry"]].set_index("face_id").to_numpy() - cell_dict["mesh_name"] += [mesh_name]*cell_cnt + mesh_faces = ( + face_gdf[face_gdf.mesh_name == mesh_name][["face_id", "geometry"]] + .set_index("face_id") + .to_numpy() + ) + cell_dict["mesh_name"] += [mesh_name] * cell_cnt cell_dict["cell_id"] += cell_ids cell_dict["geometry"] += list( np.vectorize( - lambda face_id_list: polygonize(np.ravel(mesh_faces[np.array(face_id_list.strip("[]").split()).astype(int)])).geoms[0] + lambda face_id_list: polygonize( + np.ravel( + mesh_faces[ + np.array(face_id_list.strip("[]").split()).astype(int) + ] + ) + ).geoms[0] )(face_id_lists) ) return GeoDataFrame(cell_dict, geometry="geometry", crs=self.projection()) def mesh_cell_points(self) -> GeoDataFrame: """Return the 2D flow mesh cell points. - + Returns ------- GeoDataFrame @@ -101,18 +137,24 @@ def mesh_cell_points(self) -> GeoDataFrame: mesh_area_names = self.mesh_area_names() if not mesh_area_names: return GeoDataFrame() - pnt_dict = {"mesh_name":[], "cell_id":[], "geometry":[]} + pnt_dict = {"mesh_name": [], "cell_id": [], "geometry": []} for i, mesh_name in enumerate(mesh_area_names): starting_row, count = self["/Geometry/2D Flow Areas/Cell Info"][()][i] - cell_pnt_coords = self["/Geometry/2D Flow Areas/Cell Points"][()][starting_row:starting_row+count] - pnt_dict["mesh_name"] += [mesh_name]*cell_pnt_coords.shape[0] + cell_pnt_coords = self["/Geometry/2D Flow Areas/Cell Points"][()][ + starting_row : starting_row + count + ] + pnt_dict["mesh_name"] += [mesh_name] * cell_pnt_coords.shape[0] pnt_dict["cell_id"] += range(count) - pnt_dict["geometry"] += list(np.vectorize(lambda coords: Point(coords), signature="(n)->()")(cell_pnt_coords)) + pnt_dict["geometry"] += list( + np.vectorize(lambda coords: Point(coords), signature="(n)->()")( + cell_pnt_coords + ) + ) return GeoDataFrame(pnt_dict, geometry="geometry", crs=self.projection()) def mesh_cell_faces(self) -> GeoDataFrame: """Return the 2D flow mesh cell faces. - + Returns ------- GeoDataFrame @@ -121,29 +163,39 @@ def mesh_cell_faces(self) -> GeoDataFrame: mesh_area_names = self.mesh_area_names() if not mesh_area_names: return GeoDataFrame() - face_dict = {"mesh_name":[], "face_id":[], "geometry":[]} + face_dict = {"mesh_name": [], "face_id": [], "geometry": []} for mesh_name in mesh_area_names: - facepoints_index = self[f"/Geometry/2D Flow Areas/{mesh_name}/Faces FacePoint Indexes"][()] - facepoints_coordinates = self[f"/Geometry/2D Flow Areas/{mesh_name}/FacePoints Coordinate"][()] - faces_perimeter_info = self[f"/Geometry/2D Flow Areas/{mesh_name}/Faces Perimeter Info"][()] - faces_perimeter_values = self[f"/Geometry/2D Flow Areas/{mesh_name}/Faces Perimeter Values"][()] + facepoints_index = self[ + f"/Geometry/2D Flow Areas/{mesh_name}/Faces FacePoint Indexes" + ][()] + facepoints_coordinates = self[ + f"/Geometry/2D Flow Areas/{mesh_name}/FacePoints Coordinate" + ][()] + faces_perimeter_info = self[ + f"/Geometry/2D Flow Areas/{mesh_name}/Faces Perimeter Info" + ][()] + faces_perimeter_values = self[ + f"/Geometry/2D Flow Areas/{mesh_name}/Faces Perimeter Values" + ][()] face_id = -1 for pnt_a_index, pnt_b_index in facepoints_index: - face_id+=1 + face_id += 1 face_dict["mesh_name"].append(mesh_name) face_dict["face_id"].append(face_id) coordinates = list() coordinates.append(facepoints_coordinates[pnt_a_index]) starting_row, count = faces_perimeter_info[face_id] if count > 0: - coordinates += list(faces_perimeter_values[starting_row:starting_row+count]) + coordinates += list( + faces_perimeter_values[starting_row : starting_row + count] + ) coordinates.append(facepoints_coordinates[pnt_b_index]) face_dict["geometry"].append(LineString(coordinates)) return GeoDataFrame(face_dict, geometry="geometry", crs=self.projection()) def bc_lines(self) -> GeoDataFrame: """Return the 2D mesh area boundary condition lines. - + Returns ------- GeoDataFrame @@ -158,32 +210,41 @@ def bc_lines(self) -> GeoDataFrame: mesh_names = v_conv_str(bc_line_data["Attributes"][()]["SA-2D"]) types = v_conv_str(bc_line_data["Attributes"][()]["Type"]) geoms = list() - for pnt_start, pnt_cnt, part_start, part_cnt in bc_line_data["Polyline Info"][()]: - points = bc_line_data["Polyline Points"][()][pnt_start:pnt_start+pnt_cnt] + for pnt_start, pnt_cnt, part_start, part_cnt in bc_line_data["Polyline Info"][ + () + ]: + points = bc_line_data["Polyline Points"][()][ + pnt_start : pnt_start + pnt_cnt + ] if part_cnt == 1: geoms.append(LineString(points)) else: - parts = bc_line_data["Polyline Parts"][()][part_start:part_start+part_cnt] + parts = bc_line_data["Polyline Parts"][()][ + part_start : part_start + part_cnt + ] geoms.append( MultiLineString( - list(points[part_pnt_start:part_pnt_start+part_pnt_cnt] for part_pnt_start, part_pnt_cnt in parts) + list( + points[part_pnt_start : part_pnt_start + part_pnt_cnt] + for part_pnt_start, part_pnt_cnt in parts + ) ) ) return GeoDataFrame( { - "bc_line_id":bc_line_ids, - "name":names, - "mesh_name":mesh_names, - "type":types, - "geometry":geoms + "bc_line_id": bc_line_ids, + "name": names, + "mesh_name": mesh_names, + "type": types, + "geometry": geoms, }, geometry="geometry", - crs=self.projection() + crs=self.projection(), ) def breaklines(self) -> GeoDataFrame: """Return the 2D mesh area breaklines. - + Returns ------- GeoDataFrame @@ -193,32 +254,39 @@ def breaklines(self) -> GeoDataFrame: return GeoDataFrame() bl_line_data = self["/Geometry/2D Flow Area Break Lines"] bl_line_ids = range(bl_line_data["Attributes"][()].shape[0]) - names = np.vectorize(convert_ras_hdf_string)(bl_line_data["Attributes"][()]["Name"]) + names = np.vectorize(convert_ras_hdf_string)( + bl_line_data["Attributes"][()]["Name"] + ) geoms = list() - for pnt_start, pnt_cnt, part_start, part_cnt in bl_line_data["Polyline Info"][()]: - points = bl_line_data["Polyline Points"][()][pnt_start:pnt_start+pnt_cnt] + for pnt_start, pnt_cnt, part_start, part_cnt in bl_line_data["Polyline Info"][ + () + ]: + points = bl_line_data["Polyline Points"][()][ + pnt_start : pnt_start + pnt_cnt + ] if part_cnt == 1: geoms.append(LineString(points)) else: - parts = bl_line_data["Polyline Parts"][()][part_start:part_start+part_cnt] + parts = bl_line_data["Polyline Parts"][()][ + part_start : part_start + part_cnt + ] geoms.append( MultiLineString( - list(points[part_pnt_start:part_pnt_start+part_pnt_cnt] for part_pnt_start, part_pnt_cnt in parts) + list( + points[part_pnt_start : part_pnt_start + part_pnt_cnt] + for part_pnt_start, part_pnt_cnt in parts + ) ) ) return GeoDataFrame( - { - "bl_id":bl_line_ids, - "name":names, - "geometry":geoms - }, + {"bl_id": bl_line_ids, "name": names, "geometry": geoms}, geometry="geometry", - crs=self.projection() + crs=self.projection(), ) def refinement_regions(self) -> GeoDataFrame: """Return the 2D mesh area refinement regions. - + Returns ------- GeoDataFrame @@ -231,24 +299,23 @@ def refinement_regions(self) -> GeoDataFrame: names = np.vectorize(convert_ras_hdf_string)(rr_data["Attributes"][()]["Name"]) geoms = list() for pnt_start, pnt_cnt, part_start, part_cnt in rr_data["Polygon Info"][()]: - points = rr_data["Polygon Points"][()][pnt_start:pnt_start+pnt_cnt] + points = rr_data["Polygon Points"][()][pnt_start : pnt_start + pnt_cnt] if part_cnt == 1: geoms.append(Polygon(points)) else: - parts = rr_data["Polygon Parts"][()][part_start:part_start+part_cnt] + parts = rr_data["Polygon Parts"][()][part_start : part_start + part_cnt] geoms.append( MultiPolygon( - list(points[part_pnt_start:part_pnt_start+part_pnt_cnt] for part_pnt_start, part_pnt_cnt in parts) + list( + points[part_pnt_start : part_pnt_start + part_pnt_cnt] + for part_pnt_start, part_pnt_cnt in parts + ) ) ) return GeoDataFrame( - { - "rr_id":rr_ids, - "name":names, - "geometry":geoms - }, + {"rr_id": rr_ids, "name": names, "geometry": geoms}, geometry="geometry", - crs=self.projection() + crs=self.projection(), ) def connections(self) -> GeoDataFrame: @@ -289,7 +356,7 @@ def flowpaths(self) -> GeoDataFrame: def bank_points(self) -> GeoDataFrame: raise NotImplementedError - + def bank_lines(self) -> GeoDataFrame: raise NotImplementedError diff --git a/src/rashdf/plan.py b/src/rashdf/plan.py index 3e007ed..a64ec57 100644 --- a/src/rashdf/plan.py +++ b/src/rashdf/plan.py @@ -4,6 +4,5 @@ class RasPlanHdf(RasGeomHdf): - def enroachment_points(self) -> GeoDataFrame: raise NotImplementedError diff --git a/src/rashdf/utils.py b/src/rashdf/utils.py index 218ed28..0d6dc81 100644 --- a/src/rashdf/utils.py +++ b/src/rashdf/utils.py @@ -40,7 +40,7 @@ def parse_ras_simulation_window_datetime(datetime_str) -> datetime: def parse_run_time_window(window: str) -> Tuple[datetime, datetime]: """ Parse a run time window string into a tuple of datetime objects. - + Parameters ---------- window (str): The run time window string to be parsed. @@ -167,4 +167,4 @@ def convert_ras_hdf_value( # Convert all other types to string else: - return str(value) \ No newline at end of file + return str(value) diff --git a/tests/test_geom.py b/tests/test_geom.py index 964095e..8673727 100644 --- a/tests/test_geom.py +++ b/tests/test_geom.py @@ -1,10 +1,14 @@ from src.rashdf import RasGeomHdf import h5py +from geopandas import GeoDataFrame from pyproj import CRS from pathlib import Path TEST_DATA = Path("./tests/data") +MUNCIE_G05 = TEST_DATA / "ras/Muncie.g05.hdf" +TEST_JSON = TEST_DATA / "json" + def test_projection(tmp_path): wkt = 'PROJCS["Albers_Conic_Equal_Area",GEOGCS["GCS_North_American_1983",DATUM["D_North_American_1983",SPHEROID["GRS_1980",6378137.0,298.257222101]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],PROJECTION["Albers"],PARAMETER["false_easting",0.0],PARAMETER["false_northing",0.0],PARAMETER["central_meridian",-96.0],PARAMETER["standard_parallel_1",29.5],PARAMETER["standard_parallel_2",45.5],PARAMETER["latitude_of_origin",37.5],UNIT["Foot_US",0.3048006096012192]]' @@ -16,49 +20,54 @@ def test_projection(tmp_path): # Test the projection assert ras_hdf.projection() == CRS.from_wkt(wkt) + +def _gdf_matches_json(gdf: GeoDataFrame, json_file: Path) -> bool: + with open(json_file) as j: + return gdf.to_json() == j.read() + + def test_mesh_area_names(): - geom = TEST_DATA / "ras/Muncie.g05.hdf" - with RasGeomHdf(geom) as ghdf: + with RasGeomHdf(MUNCIE_G05) as ghdf: assert ghdf.mesh_area_names() == ["2D Interior Area", "Perimeter_NW"] + def test_mesh_areas(): - geom = TEST_DATA / "ras/Muncie.g05.hdf" - with RasGeomHdf(geom) as ghdf: - with open(TEST_DATA / "json/mesh_areas.json") as json: - assert ghdf.mesh_areas().to_json() == json.read() + mesh_areas_json = TEST_JSON / "mesh_areas.json" + with RasGeomHdf(MUNCIE_G05) as ghdf: + assert _gdf_matches_json(ghdf.mesh_areas(), mesh_areas_json) + def test_mesh_cell_faces(): - geom = TEST_DATA / "ras/Muncie.g05.hdf" - with RasGeomHdf(geom) as ghdf: - with open(TEST_DATA / "json/mesh_cell_faces.json") as json: - assert ghdf.mesh_cell_faces().to_json() == json.read() + mesh_cell_faces_json = TEST_JSON / "mesh_cell_faces.json" + with RasGeomHdf(MUNCIE_G05) as ghdf: + assert _gdf_matches_json(ghdf.mesh_cell_faces(), mesh_cell_faces_json) + def test_mesh_cell_points(): - geom = TEST_DATA / "ras/Muncie.g05.hdf" - with RasGeomHdf(geom) as ghdf: - with open(TEST_DATA / "json/mesh_cell_points.json") as json: - assert ghdf.mesh_cell_points().to_json() == json.read() + mesh_cell_points_json = TEST_JSON / "mesh_cell_points.json" + with RasGeomHdf(MUNCIE_G05) as ghdf: + assert _gdf_matches_json(ghdf.mesh_cell_points(), mesh_cell_points_json) + def test_mesh_cell_polygons(): - geom = TEST_DATA / "ras/Muncie.g05.hdf" - with RasGeomHdf(geom) as ghdf: - with open(TEST_DATA / "json/mesh_cell_polygons.json") as json: - assert ghdf.mesh_cell_polygons().to_json() == json.read() + mesh_cell_polygons_json = TEST_JSON / "mesh_cell_polygons.json" + with RasGeomHdf(MUNCIE_G05) as ghdf: + assert _gdf_matches_json(ghdf.mesh_cell_polygons(), mesh_cell_polygons_json) + def test_bc_lines(): - geom = TEST_DATA / "ras/Muncie.g05.hdf" - with RasGeomHdf(geom) as ghdf: - with open(TEST_DATA / "json/bc_lines.json") as json: - assert ghdf.bc_lines().to_json() == json.read() + bc_lines_json = TEST_JSON / "bc_lines.json" + with RasGeomHdf(MUNCIE_G05) as ghdf: + assert _gdf_matches_json(ghdf.bc_lines(), bc_lines_json) + def test_breaklines(): - geom = TEST_DATA / "ras/Muncie.g05.hdf" - with RasGeomHdf(geom) as ghdf: - with open(TEST_DATA / "json/breaklines.json") as json: - assert ghdf.breaklines().to_json() == json.read() + breaklines_json = TEST_JSON / "breaklines.json" + with RasGeomHdf(MUNCIE_G05) as ghdf: + assert _gdf_matches_json(ghdf.breaklines(), breaklines_json) + def test_refinement_regions(): - geom = TEST_DATA / "ras/Muncie.g05.hdf" - with RasGeomHdf(geom) as ghdf: - with open(TEST_DATA / "json/refinement_regions.json") as json: - assert ghdf.refinement_regions().to_json() == json.read() \ No newline at end of file + rr_json = TEST_JSON / "refinement_regions.json" + with RasGeomHdf(MUNCIE_G05) as ghdf: + assert _gdf_matches_json(ghdf.refinement_regions(), rr_json) diff --git a/tests/test_utils.py b/tests/test_utils.py index 3dee3d0..14f820b 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -7,11 +7,13 @@ def test_convert_ras_hdf_value(): - assert utils.convert_ras_hdf_value(b"True") == True - assert utils.convert_ras_hdf_value(b"False") == False + assert utils.convert_ras_hdf_value(b"True") is True + assert utils.convert_ras_hdf_value(b"False") is False assert utils.convert_ras_hdf_value(np.float32(1.23)) == pytest.approx(1.23) assert utils.convert_ras_hdf_value(np.int32(123)) == 123 - assert utils.convert_ras_hdf_value(b"15Mar2024 16:39:01") == datetime(2024, 3, 15, 16, 39, 1) + assert utils.convert_ras_hdf_value(b"15Mar2024 16:39:01") == datetime( + 2024, 3, 15, 16, 39, 1 + ) assert utils.convert_ras_hdf_value(b"15Mar2024 16:39:01 to 16Mar2024 16:39:01") == [ datetime(2024, 3, 15, 16, 39, 1), datetime(2024, 3, 16, 16, 39, 1),