floodmodeller-api 0.5.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

floodmodeller_api/test/test_toolbox_structure_log.py

@@ -1,22 +1,28 @@
 import copy
 import csv
+import json
+import subprocess
 from pathlib import Path
 
 import pandas as pd
 import pytest
 
 from floodmodeller_api import DAT
-from floodmodeller_api.toolbox.model_build.structure_log import StructureLogBuilder
+from floodmodeller_api.toolbox import StructureLog
+from floodmodeller_api.toolbox.model_build.structure_log.structure_log import (
+    StructureLogBuilder,
+    serialise_keys,
+)
 from floodmodeller_api.units.conduits import CONDUIT
 from floodmodeller_api.units.structures import ORIFICE
 
 
-@pytest.fixture
+@pytest.fixture()
 def slb():
     return StructureLogBuilder("", "")
 
 
-@pytest.fixture
+@pytest.fixture()
 def conduit_empty():
     c = CONDUIT()
     c.dist_to_next = 0
@@ -27,6 +33,7 @@ def conduit_empty():
     c.height = 0
     c.width = 0
     c.diameter = 0
+    c.elevation_invert = 0
     c.friction_on_invert = 0
     c.friction_on_soffit = 0
     c.friction_on_walls = 0
@@ -40,7 +47,7 @@ def conduit_empty():
     return c
 
 
-@pytest.fixture
+@pytest.fixture()
 def conduit_filled():
     c = CONDUIT()
     c.dist_to_next = 0
@@ -51,6 +58,7 @@ def conduit_filled():
     c.height = 25.45
     c.width = 3
     c.diameter = 6
+    c.elevation_invert = 3
     c.friction_on_invert = 1.876
     c.friction_on_soffit = 1.34
     c.friction_on_walls = 1.8
@@ -64,171 +72,154 @@ def conduit_filled():
     return c
 
 
-@pytest.fixture
+@pytest.fixture()
 def no_length():
     return 0
 
 
-@pytest.fixture
+@pytest.fixture()
 def with_length():
     return 4.973
 
 
-@pytest.fixture
+@pytest.fixture()
 def structure():
     return ORIFICE()
 
 
-def test_conduit_data(slb, conduit_empty):
-    slb._dat = DAT()
-    output = slb._conduit_data(conduit_empty)
-    assert output == [0.0, "", ""]
-
-
-def test_culvert_loss_data(slb):
-    output = slb._culvert_loss_data("", "")
-    assert output == ""
-    output = slb._culvert_loss_data("TEST1", "TEST2")
-    assert output == "Ki: TEST1, Ko: TEST2"
-
-
-def test_circular_data(slb, conduit_empty, conduit_filled, no_length, with_length):
-    slb._dat = DAT()
-    output = slb._circular_data(conduit_empty, no_length)
-    assert output == ["Mannings: 0", "dia: 0.00 x l: 0.00"]
-    output = slb._circular_data(conduit_filled, with_length)
-    assert output == [
-        "Mannings: [min: 1.453345, max: 3.435]",
-        "dia: 6.00 x l: 4.97",
-    ]
-
-
-def test_sprungarch_data(slb, conduit_empty, conduit_filled, no_length, with_length):
-    output = slb._sprungarch_data(conduit_empty, no_length)
-    assert output == [
-        "Mannings: 0",
-        "(Springing: 0.00, Crown: 0.00) x w: 0.00 x l: 0.00",
-    ]
-    output = slb._sprungarch_data(conduit_filled, with_length)
-    assert output == [
-        "Mannings: [min: 1.34, max: 1.876]",
-        "(Springing: 23.10, Crown: 5.40) x w: 3.00 x l: 4.97",
-    ]
-
-
-def test_rectangular_data(slb, conduit_empty, conduit_filled, no_length, with_length):
-    output = slb._rectangular_data(conduit_empty, no_length)
-    assert output == ["Mannings: 0", "h: 0.00 x w: 0.00 x l: 0.00"]
-    output = slb._rectangular_data(conduit_filled, with_length)
-    assert output == [
-        "Mannings: [min: 1.34, max: 1.876]",
-        "h: 25.45 x w: 3.00 x l: 4.97",
-    ]
-
-
-def test_section_data(slb, conduit_empty, conduit_filled, no_length, with_length):
-    output = slb._section_data(conduit_empty, no_length)
-    assert output == ["Colebrook-White: 0", "h: 0.00 x w: 0.00 x l: 0.00"]
-    output = slb._section_data(conduit_filled, with_length)
-    assert output == [
-        "Colebrook-White: [min: 0.0, max: 4.0]",
-        "h: 65.00 x w: 150.00 x l: 4.97",
-    ]
-
-
-def test_sprung_data(slb, conduit_empty, conduit_filled, no_length, with_length):
-    output = slb._sprung_data(conduit_empty, no_length)
-    assert output == [
-        "Mannings: 0",
-        "(Springing: 0.00, Crown: 0.00) x w: 0.00 x l: 0.00",
-    ]
-    output = slb._sprung_data(conduit_filled, with_length)
-    assert output == [
-        "Mannings: [min: 1.34, max: 1.876]",
-        "(Springing: 23.10, Crown: 5.40) x w: 3.00 x l: 4.97",
-    ]
-
-
-def test_orifice_dimensions(slb, structure):
-    structure.invert = 1
-    output = slb._orifice_dimensions(structure)
-    assert output == "h: -1.00 x w: -1.00"
-
-
-def test_spill_data(slb, structure):
-    structure.data = pd.DataFrame(data={"X": [0, 0], "Y": [0, 0]})
-    structure.weir_coefficient = 0
-    output = slb._spill_data(structure)
-    assert output == ["Elevation: 0.00 x w: 0.00", 0]
-
-
-def test_bridge_data(slb, structure):
-    structure.section_data = pd.DataFrame(data={"X": [0, 0], "Y": [0, 0], "Mannings n": [0, 0]})
-    structure.opening_data = pd.DataFrame(
-        data={"Start": 0, "Finish": 0, "Springing Level": 0, "Soffit Level": 0},
-        index=[0],
-    )
-    output = slb._bridge_data(structure)
-    assert output == ["Mannings: 0", "h: 0.00 x w: 0.00"]
-
-
-def test_add_conduits(slb, conduit_filled, tmpdir):
-    slb._dat = DAT()
-    prev_c = copy.deepcopy(conduit_filled)
-    prev_c.dist_to_next = 0
-    prev_c.name = "prev"
-    slb._dat.conduits["prev"] = prev_c
-    conduit_filled.dist_to_next = 5
-    slb._dat.conduits["test_conduit"] = conduit_filled
-    next_c = copy.deepcopy(conduit_filled)
-    next_c.dist_to_next = 0
-    slb._dat.conduits["next"] = next_c
-    slb._dat._all_units = [prev_c, conduit_filled, next_c]
-    conduit_non_subtype = copy.deepcopy(conduit_filled)
-    conduit_non_subtype._subtype = "NON_SUBTYPE"
-    slb._dat.conduits["test_conduit_NON_SUBTYPE"] = conduit_non_subtype
-
-    tmp_csv = Path(tmpdir) / "temp_structure_data.csv"
-    with tmp_csv.open("w") as file:
+@pytest.fixture()
+def conduit_chain_dat(conduit_filled):
+    dat = DAT()
+    names = ["first", "second", "third", "fourth"]
+    for name in names:
+        cond = copy.deepcopy(conduit_filled)
+        cond.dist_to_next = 10
+        cond.name = name
+        dat.conduits[name] = cond
+        dat._all_units.append(cond)
+
+    cond = copy.deepcopy(conduit_filled)
+    cond.dist_to_next = 0
+    cond.name = "fifth"
+    dat.conduits["fifth"] = cond
+    dat._all_units.append(cond)
+    return dat
+
+
+@pytest.fixture()
+def ex18_dat_path(test_workspace):
+    # TODO: Source a better test case that can be opened to public repo.
+    return Path(test_workspace, "EX18.DAT")
+
+
+@pytest.fixture()
+def ex18_dat_expected():
+    # This is about the limit of what can be pasted in code, if any larger test material is found then read from csv.
+    return """Unit Name,Unit Type,Unit Subtype,Comment,Friction,Dimensions (m),Weir Coefficient,Culvert Inlet/Outlet Loss
+C2,CONDUIT,CIRCULAR,,"Mannings: [min: 0.015, max: 0.020]",dia: 1.00 x l: 100.00 (Total conduit length: 500.00),,Ki: 0.6
+C2_R1,REPLICATE,,,,,,
+C2_R2,REPLICATE,,,,,,
+C2_R3,REPLICATE,,,,,,
+C2_R4,REPLICATE,,,,,,
+C2m,CONDUIT,CIRCULAR,,"Mannings: [min: 0.015, max: 0.020]",dia: 1.00 x l: 0.00,,
+C2md,CONDUIT,CIRCULAR,,"Mannings: [min: 0.015, max: 0.020]",dia: 1.00 x l: 100.00 (Total conduit length: 700.00),,
+C2_R5,REPLICATE,,,,,,
+C2_R6,REPLICATE,,,,,,
+C2_R7,REPLICATE,,,,,,
+C2_R8,REPLICATE,,,,,,
+C2_R9,REPLICATE,,,,,,
+C2_R10,REPLICATE,,,,,,
+C2d,CONDUIT,CIRCULAR,,"Mannings: [min: 0.015, max: 0.020]",dia: 1.00 x l: 0.00,,
+S0,WEIR,,,,Crest Elevation: 21.00 x w: 1.50,,
+C2d,WEIR,,,,Crest Elevation: 18.00 x w: 0.60,,
+S4,WEIR,,,,Crest Elevation: 17.90 x w: 2.00,,
+S8,WEIR,,,,Crest Elevation: 17.70 x w: 2.00,,
+S3LS,SPILL,,,,Elevation: 20.00 x w: 100.00,1.7,
+"""
+
+
+def test_empty_conduit(slb, conduit_empty):
+    slb.dat = DAT()
+    output, _ = slb._conduit_data(conduit_empty)
+    assert output == {
+        "length": 0.0,
+        "total_length": 0.0,
+    }
+
+
+def test_multi_conduits(slb, conduit_chain_dat, tmp_path):
+    expected = """Unit Name,Unit Type,Unit Subtype,Comment,Friction,Dimensions (m),Weir Coefficient,Culvert Inlet/Outlet Loss
+first,CONDUIT,SECTION,,"Colebrook-White: [min: 0.000, max: 4.000]",h: 65.00 x w: 156.00 x l: 10.00 (Total conduit length: 40.00),,
+second,CONDUIT,SECTION,,"Colebrook-White: [min: 0.000, max: 4.000]",h: 65.00 x w: 156.00 x l: 10.00,,
+third,CONDUIT,SECTION,,"Colebrook-White: [min: 0.000, max: 4.000]",h: 65.00 x w: 156.00 x l: 10.00,,
+fourth,CONDUIT,SECTION,,"Colebrook-White: [min: 0.000, max: 4.000]",h: 65.00 x w: 156.00 x l: 10.00,,
+fifth,CONDUIT,SECTION,,"Colebrook-White: [min: 0.000, max: 4.000]",h: 65.00 x w: 156.00 x l: 0.00,,
+"""
+
+    slb.dat = conduit_chain_dat
+    tmp_csv = tmp_path / "test_multi_conduits.csv"
+    with tmp_csv.open("w", newline="") as file:
         slb._writer = csv.writer(file)
-        slb._add_conduits()
-
-
-def test_add_structures(slb, structure, tmpdir):
-    slb._dat = DAT()
-    structure.soffit = 3
-    structure.weir_coefficient = 1
-    structure.data = pd.DataFrame(data={"X": [0, 0], "Y": [0, 0]})
-    structure.section_data = pd.DataFrame(data={"X": [0, 0], "Y": [0, 0], "Mannings n": [0, 0]})
-    structure.opening_data = pd.DataFrame(
-        data={"Start": 0, "Finish": 0, "Springing Level": 0, "Soffit Level": 0},
-        index=[0],
+        slb.add_conduits()
+        slb.write_csv_output(file)
+
+    with open(tmp_csv) as read_file:
+        text = read_file.read()
+
+    assert text == expected
+
+
+@pytest.mark.parametrize(
+    ("filename"),
+    [
+        ("EX18"),
+        ("EX6"),
+        ("EX17"),
+    ],
+)
+def test_multiple_dats(filename, test_workspace, tmp_path):
+    dat_path = Path(test_workspace, f"{filename}.DAT")
+    expected_csv_path = Path(test_workspace / "structure_logs", f"{filename}_expected.csv")
+    expected_json_path = Path(test_workspace / "structure_logs", f"{filename}_expected.json")
+    test_csv_path = tmp_path / f"test_multiple_dats_{filename}.csv"
+    slb = StructureLogBuilder(dat_path, test_csv_path)
+    slb.dat = DAT(slb.dat_file_path)
+    slb.add_conduits()
+    slb.add_structures()
+
+    with expected_json_path.open("r") as file:
+        expected_json_data = json.load(file)
+
+    assert serialise_keys(slb.unit_store) == expected_json_data
+
+    with open(slb.csv_output_path, "w", newline="") as file:
+        slb.write_csv_output(file)
+
+    with expected_csv_path.open("r") as file:
+        expected_csv_data = file.read()
+    with test_csv_path.open("r") as file:
+        test_csv_data = file.read()
+
+    assert test_csv_data == expected_csv_data
+
+
+def test_full_dat_from_python(slb, tmp_path, ex18_dat_path, ex18_dat_expected):
+    # these two tests should be as described in the toolbox documentation
+    tmp_csv = tmp_path / "test_full_dat_from_python.csv"
+    StructureLog.run(input_path=ex18_dat_path, output_path=tmp_csv)
+
+    with open(tmp_csv) as read_file:
+        text = read_file.read()
+    assert text == ex18_dat_expected
+
+
+def test_full_dat_from_commandline(slb, tmp_path, ex18_dat_path, ex18_dat_expected):
+    # these two tests should be as described in the toolbox documentation
+    tmp_csv = tmp_path / "test_full_dat_from_python.csv"
+    subprocess.call(
+        ["fmapi-structure_log", "--input_path", str(ex18_dat_path), "--output_path", str(tmp_csv)],
     )
-    structure.crest_elevation = 1
-    structure.weir_breadth = 1
-    structure.weir_length = 1
-    structure.weir_elevation = 1
-    slb._dat.structures["test_structure_orifice"] = structure
-    struc_spill = copy.deepcopy(structure)
-    struc_spill._unit = "SPILL"
-    slb._dat.structures["test_structure_spill"] = struc_spill
-    struc_sluice = copy.deepcopy(structure)
-    struc_sluice._unit = "SLUICE"
-    slb._dat.structures["test_structure_sluice"] = struc_sluice
-    struc_rnweir = copy.deepcopy(structure)
-    struc_rnweir._unit = "RNWEIR"
-    slb._dat.structures["test_structure_rnweir"] = struc_rnweir
-    struc_weir = copy.deepcopy(structure)
-    struc_weir._unit = "WEIR"
-    slb._dat.structures["test_structure_weir"] = struc_weir
-    struc_bridge = copy.deepcopy(structure)
-    struc_bridge._unit = "BRIDGE"
-    slb._dat.structures["test_structure_bridge"] = struc_bridge
-    struc_none = copy.deepcopy(structure)
-    struc_none._unit = "NONE"
-    slb._dat.structures["test_structure_none"] = struc_none
-
-    tmp_csv = Path(tmpdir) / "temp_structure_data.csv"
-    with tmp_csv.open("w") as file:
-        slb._writer = csv.writer(file)
-        slb._add_structures()
+
+    with open(tmp_csv) as read_file:
+        text = read_file.read()
+    assert text == ex18_dat_expected

floodmodeller_api/test/test_xml2d.py

@@ -5,12 +5,12 @@ import pytest
 from floodmodeller_api import XML2D
 
 
-@pytest.fixture
+@pytest.fixture()
 def xml_fp(test_workspace):
     return Path(test_workspace, "Domain1_Q.xml")
 
 
-@pytest.fixture
+@pytest.fixture()
 def data_before(xml_fp):
     return XML2D(xml_fp)._write()
 
@@ -25,7 +25,7 @@ def test_xml2d_link_dtm_changes(xml_fp, data_before):
     """XML2D: Test changing and reverting link1d file and dtm makes no changes"""
     x2d = XML2D(xml_fp)
     prev_link = x2d.link1d[0]["link"]
-    domain = list(x2d.domains)[0]
+    domain = next(iter(x2d.domains))
     prev_dtm = x2d.domains[domain]["topography"]
 
     x2d.link1d[0]["link"] = ["new_link"]
@@ -56,10 +56,8 @@ def test_xml2d_change_revert_elem_topography():
     """XML2D: Check that when we change an existing element
     that it is actually adding it and that it is being reverted."""
     x2d = XML2D()
-    domain = list(x2d.domains)[0]
-    orig_topography = []
-    for item in x2d.domains[domain]["topography"]:
-        orig_topography.append(str(item))
+    domain = next(iter(x2d.domains))
+    orig_topography = [str(item) for item in x2d.domains[domain]["topography"]]
     orig_xml = x2d._write()
     x2d.domains[domain]["topography"][0] = "my/new/topography"
 
@@ -74,7 +72,7 @@ def test_xml2d_add_remove_branch_roughness():
     """XML2D: Check that we can actually add a branch and that
     it is being added and passes validation (i.e write)"""
     x2d = XML2D()
-    domain = list(x2d.domains)[0]
+    domain = next(iter(x2d.domains))
     orig_xml = x2d._write()
     x2d.domains[domain]["roughness"] = []
     x2d.domains[domain]["roughness"].append(
@@ -91,7 +89,7 @@ def test_xml2d_append_remove_branch_roughness():
     """XML2D: Check that we can append an extra branch to preexisting branch
     so that it passes validation"""
     x2d = XML2D()
-    domain = list(x2d.domains)[0]
+    domain = next(iter(x2d.domains))
     x2d.domains[domain]["roughness"] = []
     x2d.domains[domain]["roughness"].append(
         {"type": "file", "law": "manning", "value": "my/roughness/file.shp"},
@@ -115,7 +113,7 @@ def test_xml2d_append_remove_branch_roughness():
 def test_xml2d_reorder_elem_computational_area_wrong_position():
     """XML2D: Check that if we add ??? in the wrong position does it reorder"""
     x2d = XML2D()
-    domain = list(x2d.domains)[0]
+    domain = next(iter(x2d.domains))
     x2d.domains[domain]["computational_area"] = {
         "yll": ...,
         "xll": ...,
@@ -145,7 +143,7 @@ def test_xml2d_reorder_elem_computational_area_wrong_position():
 def test_xml2d_update_value(xml_fp, data_before):
     """XML2D: Test changing and reverting link1d file and dtm makes no changes"""
     x2d = XML2D(xml_fp)
-    domain = list(x2d.domains)[0]
+    domain = next(iter(x2d.domains))
     x2d.domains[domain]["run_data"]["scheme"] = "TVD"
 
     assert x2d._write()

floodmodeller_api/test/test_zz.py

@@ -0,0 +1,143 @@
+# type: ignore
+# ignored because the output from _ZZ.to_dataframe() is only a series in special cases
+
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from floodmodeller_api import IEF, ZZN, ZZX
+
+
+@pytest.fixture()
+def zzn(test_workspace: Path) -> ZZN:
+    path = test_workspace / "network.zzn"
+    return ZZN(path)
+
+
+@pytest.fixture()
+def zzx(test_workspace: Path) -> ZZX:
+    path = test_workspace / "network.zzx"
+    return ZZX(path)
+
+
+@pytest.fixture()
+def ief(test_workspace: Path) -> IEF:
+    path = test_workspace / "network.ief"
+    return IEF(path)
+
+
+@pytest.fixture()
+def folder(test_workspace: Path) -> Path:
+    return test_workspace / "tabular_csv_outputs"
+
+
+@pytest.mark.parametrize(
+    ("csv", "file"),
+    [
+        ("network_zzn_max.csv", "zzn"),
+        ("network_zzx_max.csv", "zzx"),
+    ],
+)
+def test_max(zzn: ZZN, zzx: ZZX, folder: Path, csv: str, file: str):
+    file_obj = zzn if file == "zzn" else zzx
+    expected = pd.read_csv(folder / csv, index_col=0)
+
+    actual = file_obj.to_dataframe(result_type="max")
+    pd.testing.assert_frame_equal(actual, expected, atol=1e-3, check_dtype=False)
+
+
+@pytest.mark.parametrize(
+    ("variable", "csv", "file"),
+    [
+        # zzn
+        ("Flow", "network_zzn_flow.csv", "zzn"),
+        ("Stage", "network_zzn_stage.csv", "zzn"),
+        ("Froude", "network_zzn_fr.csv", "zzn"),
+        ("Velocity", "network_zzn_velocity.csv", "zzn"),
+        ("Mode", "network_zzn_mode.csv", "zzn"),
+        ("State", "network_zzn_state.csv", "zzn"),
+        # zzx
+        ("Left FP h", "network_zzx_left_fp_h.csv", "zzx"),
+        ("Link inflow", "network_zzx_link_inflow.csv", "zzx"),
+        ("Right FP h", "network_zzx_right_fp_h.csv", "zzx"),
+        ("Right FP mode", "network_zzx_right_fp_mode.csv", "zzx"),
+        ("Left FP mode", "network_zzx_left_fp_mode.csv", "zzx"),
+    ],
+)
+def test_all_timesteps(zzn: ZZN, zzx: ZZX, folder: Path, variable: str, csv: str, file: str):
+    file_obj = zzn if file == "zzn" else zzx
+    suffix = f"_{variable}"
+    expected = pd.read_csv(folder / csv, index_col=0)
+
+    actual_1 = file_obj.to_dataframe(variable=variable)
+    actual_1.index = actual_1.index.round(3)
+    pd.testing.assert_frame_equal(actual_1, expected, atol=1e-3, check_dtype=False)
+
+    actual_2 = file_obj.to_dataframe()[variable]
+    actual_2.index = actual_2.index.round(3)
+    pd.testing.assert_frame_equal(actual_2, expected, atol=1e-3, check_dtype=False)
+
+    actual_3 = file_obj.to_dataframe(multilevel_header=False).filter(like=suffix, axis=1)
+    actual_3.index = actual_3.index.round(3)
+    actual_3.columns = [x.removesuffix(suffix) for x in actual_3.columns]
+    pd.testing.assert_frame_equal(actual_3, expected, atol=1e-3, check_dtype=False)
+
+    actual_4 = file_obj.to_dataframe(variable=variable, multilevel_header=False)
+    actual_4.index = actual_4.index.round(3)
+    actual_4.columns = [x.removesuffix(suffix) for x in actual_4.columns]
+    pd.testing.assert_frame_equal(actual_4, expected, atol=1e-3, check_dtype=False)
+
+
+def test_zzn_include_time(zzn: ZZN):
+    zzn_df = zzn.to_dataframe(result_type="max", variable="flow", include_time=True)
+    actual = zzn_df.loc["resin", ["Max Flow", "Max Flow Time(hrs)"]].to_numpy()
+    assert actual[0] == pytest.approx(7.296, abs=0.001)
+    assert actual[1] == 9
+
+
+def test_zzn_from_ief(zzn: ZZN, ief: IEF):
+    zzn_df = zzn.to_dataframe()
+    zzn_from_ief = ief.get_results().to_dataframe()
+    pd.testing.assert_frame_equal(zzn_df, zzn_from_ief)
+
+
+def test_zzn_to_csv(zzn: ZZN, tmp_path: Path, test_workspace: Path):
+    # default
+    zzn.export_to_csv()
+    path = test_workspace / "network.csv"
+    assert path.exists()
+    path.unlink()
+
+    # absolute
+    zzn.export_to_csv(tmp_path / "test.csv")
+    path = tmp_path / "test.csv"
+    assert path.exists()
+    path.unlink()
+
+    # relative
+    zzn.export_to_csv("test.csv")
+    path = zzn.filepath.parent / "test.csv"
+    assert path.exists()
+    path.unlink()
+
+    # folder
+    zzn.export_to_csv(tmp_path)
+    path = tmp_path / "network.csv"
+    assert path.exists()
+    path.unlink()
+
+    # doesn't exist
+    zzn.export_to_csv("test")
+    path = test_workspace / "test/network.csv"
+    assert path.exists()
+    path.unlink()
+
+
+def test_meta_is_read_only(zzx: ZZN):
+    assert dict(zzx.meta) == zzx._meta
+
+    with pytest.raises(TypeError):
+        zzx.meta["variables"] = "hi"
+
+    zzx._meta["variables"] = "hi"

floodmodeller_api/to_from_json.py

@@ -162,15 +162,15 @@ def recursive_from_json(obj: dict | Any) -> Any:
         return api_class_mapping[class_type].from_json(obj)
 
     if "class" in obj and obj["class"] == "pandas.DataFrame":
-        df = pd.DataFrame.from_dict(obj["object"])
-        df.index = convert_dataframe_index(df.index)
-        return df
+        reconstructed_df = pd.DataFrame.from_dict(obj["object"])
+        reconstructed_df.index = convert_dataframe_index(reconstructed_df.index)
+        return reconstructed_df
     if "class" in obj and obj["class"] == "pandas.Series":
-        sr = pd.Series(obj["object"])
-        sr.index = convert_dataframe_index(sr.index)
-        sr.index.name = obj["index_name"]
-        sr.name = obj["variable_name"]
-        return sr
+        reconstructed_sr = pd.Series(obj["object"])
+        reconstructed_sr.index = convert_dataframe_index(reconstructed_sr.index)
+        reconstructed_sr.index.name = obj["index_name"]
+        reconstructed_sr.name = obj["variable_name"]
+        return reconstructed_sr
 
     if "python_set" in obj:
         return set(obj["python_set"])

floodmodeller_api/tool.py

@@ -4,6 +4,7 @@ import argparse
 import sys
 import tkinter as tk
 from dataclasses import dataclass
+from typing import ClassVar
 
 
 @dataclass()
@@ -150,7 +151,8 @@ class Gui:
                 entry = tk.Entry(self.master, validate="key")
                 entry.config(validatecommand=(entry.register(validate_float), "%P"))
             else:
-                raise ValueError("Invalid data type")
+                msg = "Invalid data type"
+                raise ValueError(msg)
             entry.pack()
             self.root_entries[name] = entry
 
@@ -209,28 +211,31 @@ class FMTool:
 
     """
 
-    parameters: list[Parameter] = []
+    parameters: ClassVar[list[Parameter]] = []
 
     @property
     def name(self):
         """
         A property method to ensure a tool name is provided in child class. Overwritten by child.
         """
-        raise NotImplementedError("Tools need a name")
+        msg = "Tools need a name"
+        raise NotImplementedError(msg)
 
     @property
     def description(self):
         """
         A property method to ensure a tool description is provided in child class. Overwritten by child.
         """
-        raise NotImplementedError("Tools need a description")
+        msg = "Tools need a description"
+        raise NotImplementedError(msg)
 
     @property
     def tool_function(self):
         """
         A property method to ensure an tool_function is provided in child class. Overwritten by child.
         """
-        raise NotImplementedError("You must provide an entry point function")
+        msg = "You must provide an entry point function"
+        raise NotImplementedError(msg)
 
     def __init__(self):
         self.check_parameters()
@@ -248,7 +253,8 @@ class FMTool:
         params = []
         for parameter in self.parameters:
             if parameter.name in params:
-                raise ValueError("Parameter names must be unique")
+                msg = "Parameter names must be unique"
+                raise ValueError(msg)
             params.append(parameter.name)
 
     # This is defined as a class method because of the use of **kwargs