floodmodeller-api 0.4.4.post1__py3-none-any.whl → 0.5.0__py3-none-any.whl

floodmodeller_api/test/test_data/network_ied_expected.json

@@ -1,16 +1,16 @@
 {
   "API Class": "floodmodeller_api.ied.IED",
-  "API Version": "0.4.2.post1",
+  "API Version": "0.4.4.post1",
   "Object Attributes": {
-    "_filepath": "C:\\Users\\PIERCEJA\\OneDrive - Jacobs\\Documents\\Projects\\Flood Modeller API\\development\\floodmodeller-api\\floodmodeller_api\\test\\test_data\\network.ied",
+    "_filepath": "c:\\Users\\PIERCEJA\\OneDrive - Jacobs\\Documents\\Projects\\Flood Modeller API\\development\\floodmodeller-api\\floodmodeller_api\\test\\test_data\\network.ied",
     "file": {
       "API Class": "floodmodeller_api.backup.File",
       "Object Attributes": {
-        "path": "C:\\Users\\PIERCEJA\\OneDrive - Jacobs\\Documents\\Projects\\Flood Modeller API\\development\\floodmodeller-api\\floodmodeller_api\\test\\test_data\\network.ied",
+        "path": "c:\\Users\\PIERCEJA\\OneDrive - Jacobs\\Documents\\Projects\\Flood Modeller API\\development\\floodmodeller-api\\floodmodeller_api\\test\\test_data\\network.ied",
         "ext": ".ied",
-        "dttm_str": "2024-04-17-14-09-24",
-        "file_id": "88256e1c368ee0953d6b32dba41eeafa01bcb245",
-        "backup_filename": "88256e1c368ee0953d6b32dba41eeafa01bcb245_2024-04-17-14-09-24.ied",
+        "dttm_str": "2024-09-10-16-49-49",
+        "file_id": "b54eee4697704dd5fd29f9faa79728e67f517e26",
+        "backup_filename": "b54eee4697704dd5fd29f9faa79728e67f517e26_2024-09-10-16-49-49.ied",
         "temp_dir": "C:\\Users\\PIERCEJA\\AppData\\Local\\Temp",
         "backup_dirname": "floodmodeller_api_backup",
         "backup_dir": "C:\\Users\\PIERCEJA\\AppData\\Local\\Temp\\floodmodeller_api_backup",

floodmodeller_api/test/test_data/network_with_comments.ied

@@ -0,0 +1,55 @@
+COMMENT
+         5
+Comment with 
+five
+lines
+at the 
+very start
+FSSR16BDY
+resin
+    66.000                    
+       0.0     1.000          SCALEFACT      1.000HYDROGRAPH      1.00      FULL
+ENGLAND
+    99.000     6.500    11.300     0.400     0.050
+     0.000    13.000    30.900     0.000
+   761.000    55.000     0.370   167.400
+FSRER
+   100.000     0.000     0.960
+FSRCW
+     0.000
+F16PR     FIXED
+    30.000
+OBSTP
+     1.000     4.500
+F16BF
+     0.000
+OBSUH
+7         mmarea
+     0.000
+     0.100
+     0.300
+     0.500
+     0.300
+     0.100
+     0.000
+WINRP              0
+         0
+COMMENT
+         1
+Adding a comment part way through to test
+QTBDY 
+CS26
+         4     0.000     0.000   seconds  NOEXTEND    LINEAR     0.000     0.000  OVERRIDE
+     1.000     0.000
+     1.000 46800.000
+     0.000 47160.000
+     0.000 1.000e+09
+QHBDY 
+DS4
+         6     0.000    LINEAR
+     0.000    67.030
+     1.751    67.750
+     5.303    68.220
+    10.351    68.560
+    33.975    69.059
+    65.165    69.487

floodmodeller_api/test/test_flowtimeprofile.py

@@ -0,0 +1,133 @@
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from floodmodeller_api.ief import FlowTimeProfile
+
+
+@pytest.fixture
+def valid_raw_strings():
+    return [
+        ',,4,"fmfile.csv",fm1,T=100,"SingleEvent,AllNodes"',
+        'label1,5,4,"fmfile.csv",fm1,T=100,"SingleEvent,SingleNode"',
+        'label1 label2,5 6,4,"fmfile.csv",fm2,T=100,MultiEvent&Nodes',
+        'label1,9,2,"ReFH2.csv",refh2,T=100',
+        'label1,5,4,"fsu.csv",fsu,T=100,"Total flow m3/s (1 year)- urbanised model"',
+        r'Welches_Dam,12,23,"C:\Users\ka007155\Downloads\Baseline unchecked.csv",hplus,1 - 11 - 2020 Upper',
+    ]
+
+
+@pytest.mark.parametrize(
+    "raw_string, expected",
+    [
+        (
+            ',,4,"fmfile.csv",fm1,T=100,"SingleEvent,AllNodes"',
+            {
+                "labels": [],
+                "columns": [],
+                "start_row": 4,
+                "csv_filepath": "fmfile.csv",
+                "file_type": "fm1",
+                "profile": "T=100",
+                "comment": '"SingleEvent,AllNodes"',
+            },
+        ),
+        (
+            'label1,5,4,fmfile.csv,fm1,T=100,"SingleEvent,SingleNode"',
+            {
+                "labels": ["label1"],
+                "columns": [5],
+                "start_row": 4,
+                "csv_filepath": "fmfile.csv",
+                "file_type": "fm1",
+                "profile": "T=100",
+                "comment": '"SingleEvent,SingleNode"',
+            },
+        ),
+    ],
+)
+def test_parse_raw_string(raw_string, expected):
+    flow_profile = FlowTimeProfile(raw_string=raw_string)
+
+    assert flow_profile.labels == expected["labels"]
+    assert flow_profile.columns == expected["columns"]
+    assert flow_profile.start_row == expected["start_row"]
+    assert flow_profile.csv_filepath == expected["csv_filepath"]
+    assert flow_profile.file_type == expected["file_type"]
+    assert flow_profile.profile == expected["profile"]
+    assert flow_profile.comment == expected["comment"]
+
+
+def test_init_with_kwargs():
+    kwargs = {
+        "labels": ["label1", "label2"],
+        "columns": [5, 6],
+        "start_row": 4,
+        "csv_filepath": '"fmfile.csv"',
+        "file_type": "fm2",
+        "profile": "T=100",
+        "comment": "MultiEvent&Nodes",
+        "ief_filepath": "../projects",
+    }
+    flow_profile = FlowTimeProfile(**kwargs)
+
+    assert flow_profile.labels == ["label1", "label2"]
+    assert flow_profile.columns == [5, 6]
+    assert flow_profile.start_row == 4
+    assert flow_profile.csv_filepath == '"fmfile.csv"'
+    assert flow_profile.file_type == "fm2"
+    assert flow_profile.profile == "T=100"
+    assert flow_profile.comment == "MultiEvent&Nodes"
+    assert flow_profile._csvfile == Path("../projects/fmfile.csv").resolve()
+
+
+@pytest.mark.parametrize(
+    "raw_string",
+    [
+        "label1 label2,5 6,4,fmfile.csv,fm2,T=100,MultiEvent&Nodes",
+        ',,4,fmfile.csv,fm1,T=100,"SingleEvent,AllNodes"',
+    ],
+)
+def test_str_representation(raw_string):
+    flow_profile = FlowTimeProfile(raw_string=raw_string)
+
+    assert str(flow_profile) == raw_string
+
+
+def test_count_series_with_fm1(mocker):
+    mocker.patch("pandas.read_csv", return_value=pd.DataFrame(columns=["A", "B", "C"]))
+
+    kwargs = {
+        "labels": ["label1"],
+        "columns": [5],
+        "start_row": 4,
+        "csv_filepath": '"fmfile.csv"',
+        "file_type": "fm1",
+        "profile": "T=100",
+        "comment": "SingleEvent,AllNodes",
+        "ief_filepath": "../projects",
+    }
+
+    flow_profile = FlowTimeProfile(**kwargs)
+
+    series_count = flow_profile.count_series()
+    assert series_count == 3  # Since the mock CSV has 3 columns
+
+
+def test_count_series_without_fm1():
+    kwargs = {
+        "labels": ["label1"],
+        "columns": [5, 6],
+        "start_row": 4,
+        "csv_filepath": '"fmfile.csv"',
+        "file_type": "fm2",
+        "profile": "T=100",
+        "comment": "MultiEvent&Nodes",
+        "ief_filepath": "../projects",
+    }
+
+    flow_profile = FlowTimeProfile(**kwargs)
+
+    series_count = flow_profile.count_series()
+    assert series_count == 2  # Number of columns passed

floodmodeller_api/test/test_hydrology_plus_export.py

@@ -0,0 +1,210 @@
+"""Tests to check the class HydrographPlus"""
+
+import pandas as pd
+import pytest
+
+from floodmodeller_api.hydrology_plus.hydrology_plus_export import HydrologyPlusExport
+from floodmodeller_api.ief import IEF, FlowTimeProfile
+from floodmodeller_api.units import QTBDY
+from floodmodeller_api.util import FloodModellerAPIError
+
+
+@pytest.fixture()
+def expected_metadata():
+    """Extracts the metadata from the csv to be compared with the class"""
+
+    return {
+        "Hydrograph Name": "Baseline unchecked",
+        "Hydrograph Description": "",
+        "Calculation Point": "CP_003",
+        "ReFH2 Name": "CP_003_ReFH2_1",
+        "Winfap Name": "CP_003_WINFAP_1",
+        "Urban/Rural": "Urban",
+        "Urban/Rural Comment": "",
+        "ReFH2 Comment": "",
+        "Winfap Comment": "",
+        "Winfap Distribution": "GEV",
+        "Winfap Distribution Comment": "",
+        "Use Climate Change Allowances": "True",
+        "Use Custom Scale Factors": "False",
+        "Created By": "KA007155",
+        "Created Date": "30/04/2024 09:42:23",
+        "Checksum": "ef77d9bd-2eb3-4689-a1e3-665d293db810",
+    }
+
+
+@pytest.fixture()
+def expected_dataframe(test_workspace):
+    """Extracts the df with all the flows to be compared with the df of the class"""
+
+    return pd.read_csv(test_workspace / "df_flows_hplus.csv", index_col=0)
+
+
+@pytest.fixture()
+def expected_event(test_workspace):
+    """Extracts the event from the original csv to be compared with the output of the class"""
+    event_file = pd.read_csv(test_workspace / "event_hplus.csv", index_col=0)
+
+    return event_file.squeeze()
+
+
+@pytest.fixture()
+def hydrology_plus_export_object(test_workspace):
+    """Creates the object to make the comparison with the csv data"""
+
+    return HydrologyPlusExport(test_workspace / "Baseline_unchecked.csv")
+
+
+def test_data_metadata(
+    expected_metadata: dict[str, str],
+    hydrology_plus_export_object: HydrologyPlusExport,
+):
+    """Compares the metadata between the csv and the class"""
+    assert expected_metadata == hydrology_plus_export_object.metadata
+
+
+def test_data_flows_df(
+    expected_dataframe: pd.DataFrame,
+    hydrology_plus_export_object: HydrologyPlusExport,
+):
+    """Compares the df with all the flows between the csv and the class"""
+    pd.testing.assert_frame_equal(expected_dataframe, hydrology_plus_export_object.data)
+
+
+def test_data_event(expected_event: pd.Series, hydrology_plus_export_object: HydrologyPlusExport):
+    """Compares the event between the csv and the class"""
+    pd.testing.assert_series_equal(
+        expected_event,
+        hydrology_plus_export_object.get_event_flow("2020 Upper - 11 - 1"),
+    )
+
+
+def test_data_event_from_params(
+    expected_event: pd.Series,
+    hydrology_plus_export_object: HydrologyPlusExport,
+):
+    """Compares the event between the csv and the class"""
+    pd.testing.assert_series_equal(
+        expected_event,
+        hydrology_plus_export_object.get_event_flow(
+            scenario="2020 Upper",
+            storm_duration=11.0,
+            return_period=1.0,
+        ),
+    )
+
+
+def test_get_unique_event_components(hydrology_plus_export_object: HydrologyPlusExport):
+    """Test that unique event components are correctly extracted."""
+    # Expected unique components
+    expected_return_periods = sorted({1, 2, 5, 10, 30, 50, 75, 100, 200, 1000})
+    expected_storm_durations = sorted({11})
+    expected_scenarios = sorted({"2020 Upper", "Reconciled Baseline"})
+
+    # Trigger the _get_unique_event_components method
+    hydrology_plus_export_object._get_unique_event_components()
+
+    # Assertions
+    assert hydrology_plus_export_object.return_periods == expected_return_periods
+    assert hydrology_plus_export_object.storm_durations == expected_storm_durations
+    assert hydrology_plus_export_object.scenarios == expected_scenarios
+
+
+def test_invalid_header_in_file(tmp_path):
+    """Test that _read raises a ValueError if the file header is invalid."""
+    # Create a temporary file with an invalid header
+    invalid_header_file = tmp_path / "invalid_header.csv"
+    invalid_header_content = "Invalid Header\nSome other content\n"
+    invalid_header_file.write_text(invalid_header_content)
+
+    with pytest.raises(FloodModellerAPIError):
+        HydrologyPlusExport(invalid_header_file)
+
+
+def test_gereate_ief_files(test_workspace, hydrology_plus_export_object: HydrologyPlusExport):
+    iefs = hydrology_plus_export_object.generate_iefs(node_label="pytest")
+    assert len(iefs) == len(hydrology_plus_export_object.data.columns)
+    generated_files = list(test_workspace.glob("*_generated.ief"))
+    assert len(generated_files) == len(hydrology_plus_export_object.data.columns)
+    for file in generated_files:
+        file.unlink()
+
+
+def test_generate_ief(
+    test_workspace,
+    hydrology_plus_export_object: HydrologyPlusExport,
+):
+    """Test generating a single IEF file."""
+    node_label = "test_node"
+    event = "2020 Upper - 11 - 1"
+
+    # Generate a single IEF file
+    generated_ief = hydrology_plus_export_object.generate_ief(
+        node_label=node_label,
+        event=event,
+    )
+
+    # Assert the IEF file was created and matches expectations
+    assert isinstance(generated_ief, IEF)
+    assert len(generated_ief.flowtimeprofiles) == 1
+    output_file = test_workspace / "2020Upper-11-1_generated.ief"
+    assert output_file.exists()
+    assert generated_ief._filepath == output_file
+
+    # Cleanup
+    output_file.unlink()
+
+
+def test_get_qtbdy(hydrology_plus_export_object: HydrologyPlusExport, expected_event: pd.Series):
+    """Test generating a QTBDY object."""
+    qtbdy_name = "test_qtbdy"
+    event = "2020 Upper - 11 - 1"
+
+    # Generate a QTBDY object
+    qtbdy = hydrology_plus_export_object.get_qtbdy(
+        qtbdy_name=qtbdy_name,
+        event=event,
+    )
+
+    # Assert the QTBDY object is created and contains expected data
+    assert isinstance(qtbdy, QTBDY)
+    pd.testing.assert_series_equal(qtbdy.data, expected_event)
+    assert qtbdy.name == qtbdy_name
+
+    # assert QTBDY is valid
+    qtbdy._write()
+
+
+def test_get_flowtimeprofile(hydrology_plus_export_object: HydrologyPlusExport):
+    """Test generating a FlowTimeProfile object."""
+    node_label = "test_node"
+    event = "2020 Upper - 11 - 1"
+
+    # Generate a FlowTimeProfile object
+    ftp = hydrology_plus_export_object.get_flowtimeprofile(node_label=node_label, event=event)
+
+    # Assert the FlowTimeProfile object is created and contains expected attributes
+    assert isinstance(ftp, FlowTimeProfile)
+    assert ftp.labels == [node_label]
+    assert ftp.csv_filepath == hydrology_plus_export_object._filepath.name
+    assert ftp.profile == f"{event} - Flow (m3/s)"
+
+
+@pytest.mark.parametrize(
+    "export_csv",
+    [
+        "hplus_export_example_1.csv",
+        "hplus_export_example_2.csv",
+        "hplus_export_example_3.csv",
+        "hplus_export_example_4.csv",
+        "hplus_export_example_5.csv",
+        "hplus_export_example_6.csv",
+        "hplus_export_example_7.csv",
+        "hplus_export_example_8.csv",
+        "hplus_export_example_9.csv",
+        "hplus_export_example_10.csv",
+    ],
+)
+def test_load_hydrology_plus_export_doesnt_fail(test_workspace, export_csv):
+    """Ensure loading a hydrology+ export file succeeds without error"""
+    HydrologyPlusExport(test_workspace / export_csv)

floodmodeller_api/test/test_ied.py

@@ -10,6 +10,11 @@ def ied_fp(test_workspace):
     return Path(test_workspace, "network.ied")
 
 
+@pytest.fixture
+def ied_fp_comments(test_workspace):
+    return Path(test_workspace, "network_with_comments.ied")
+
+
 def test_open_ied_does_not_change_file(ied_fp):
     """IED: Test str representation equal to ied file with no changes"""
     with open(ied_fp) as ied_file:
@@ -27,3 +32,10 @@ def test_open_ied_does_not_change_file(ied_fp):
         "     0.000 1.000e+09",
     ]
     assert ied.boundaries["CS26"]._write() == cs26_expected
+
+
+def test_ied_with_comments(ied_fp_comments):
+    with open(ied_fp_comments) as ied_file:
+        data_before = ied_file.read()
+    ied = IED(ied_fp_comments)
+    assert ied._write() == data_before

floodmodeller_api/test/test_ief.py

@@ -4,6 +4,7 @@ from unittest.mock import call, patch
 import pytest
 
 from floodmodeller_api import IEF
+from floodmodeller_api.ief import FlowTimeProfile
 from floodmodeller_api.util import FloodModellerAPIError
 
 
@@ -17,12 +18,6 @@ def ief(ief_fp: Path) -> IEF:
     return IEF(ief_fp)
 
 
-@pytest.fixture()
-def data_before(ief_fp: Path) -> str:
-    with open(ief_fp) as ief_file:
-        return ief_file.read()
-
-
 @pytest.fixture()
 def exe_bin(tmpdir) -> Path:
     for exe in ["ISISf32.exe", "ISISf32_DoubleP.exe"]:
@@ -43,9 +38,54 @@ def sleep():
         yield sleep
 
 
-def test_ief_open_does_not_change_data(ief: IEF, data_before: str):
-    """IEF: Test str representation equal to ief file with no changes"""
-    assert ief._write() == data_before
+def test_ief_read_doesnt_change_data(test_workspace, tmpdir):
+    """IEF: Check all '.ief' files in folder by reading the _write() output into a new IEF instance and checking it stays the same."""
+    for ief_file in Path(test_workspace).glob("*.ief"):
+        ief = IEF(ief_file)
+        first_output = ief._write()
+        new_path = Path(tmpdir) / "tmp.ief"
+        ief.save(new_path)
+        second_ief = IEF(new_path)
+        assert ief == second_ief  # Checks equivalence on the class itself
+        second_output = second_ief._write()
+        assert first_output == second_output
+
+
+def test_update_property(ief):
+    """Check if updating a property is correctly reflected in _write"""
+    ief.title = "updated_property"
+    assert "Title=updated_property" in ief._write()
+
+
+def test_delete_property(ief):
+    del ief.slot
+    assert "Slot=1" not in ief._write()
+
+
+def test_add_new_group_property(ief):
+    ief.FlowScaling1 = "test"
+    assert "FlowScaling1=test" in ief._write()
+    assert "[Boundary Adjustments]" in ief._write()
+
+
+def test_add_flowtimeprofile(ief):
+    prev_output = ief._write()
+    ief.flowtimeprofiles = [FlowTimeProfile("lbl,2,4,../../path.csv,hplus,scoobydoo,where-are-you")]
+    output = ief._write()
+    assert prev_output in output
+    assert ief.noofflowtimeprofiles == 1
+    assert ief.noofflowtimeseries == 1
+    assert "[Flow Time Profiles]" in output
+    assert "FlowTimeProfile0=lbl,2,4,../../path.csv,hplus,scoobydoo,where-are-you" in output
+
+
+def test_delete_all_flowtimeprofiles(test_workspace):
+    ief = IEF(test_workspace / "7082.ief")
+    ief.flowtimeprofiles = []
+    output = ief._write()
+    assert "[Flow Time Profiles]" not in output
+    assert not hasattr(ief, "noofflowtimeprofiles")
+    assert not hasattr(ief, "noofflowtimeseries")
 
 
 @pytest.mark.usefixtures("log_timeout")

floodmodeller_api/test/test_json.py

@@ -71,7 +71,8 @@ def test_to_json_matches_expected(parameterised_objs_and_expected):
         json_dict_from_obj = json.loads(obj.to_json())["Object Attributes"]
 
         # Second, to handle the json file ..._expected.json which must be the same as the object created above.
-        json_dict_from_file = json.load(open(json_expected))["Object Attributes"]  # noqa: SIM115
+        with open(json_expected) as file:
+            json_dict_from_file = json.load(file)["Object Attributes"]
 
         # keys to ignore when testing for equivalence
         keys_to_remove = ["_filepath", "file", "_log_path"]
@@ -112,3 +113,7 @@ def test_is_jsonable_with_non_jsonable_object():
             pass
 
     assert not is_jsonable(NonJsonable())
+
+
+if __name__ == "__main__":
+    create_expected_json_files()

floodmodeller_api/test/test_read_file.py

@@ -0,0 +1,27 @@
+import pytest
+
+from floodmodeller_api import read_file
+from floodmodeller_api.util import FloodModellerAPIError
+
+
+def test_read_file(test_workspace):
+    for file in test_workspace.glob("*"):
+        if (
+            file.suffix.lower()
+            in [
+                ".ief",
+                ".dat",
+                ".ied",
+                ".xml",
+                ".zzn",
+                ".inp",
+                ".lf1",
+                ".lf2",
+            ]
+            or file.name in ["example_h+_export.csv", "Baseline_unchecked.csv"]
+            or file.name.startswith("hplus_export_example")
+        ):
+            read_file(file)
+        else:
+            with pytest.raises((ValueError, FloodModellerAPIError)):
+                read_file(file)