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

floodmodeller_api/test/test_xml2d.py

@@ -3,14 +3,15 @@ from pathlib import Path
 import pytest
 
 from floodmodeller_api import XML2D
+from floodmodeller_api.util import FloodModellerAPIError
 
 
-@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 +26,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 +57,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 +73,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 +90,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 +114,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": ...,
@@ -132,20 +131,19 @@ def test_xml2d_reorder_elem_computational_area_wrong_position():
     x2d.domains[domain]["computational_area"]["ncols"] = 12
     x2d.domains[domain]["computational_area"]["nrows"] = 42
     x2d.domains[domain]["computational_area"]["rotation"] = 3.14159
-
     x2d.domains[domain]["run_data"]["upwind"] = "upwind value"
     x2d.domains[domain]["run_data"]["wall"] = "Humpty Dumpty"
-
-    # TODO: Add check that this should fail validation if in the wrong order
-    # # how do I check that something fails?
-
     assert x2d._write()
 
+    x2d.domains[domain]["run_data"]["upwind123"] = "upwind value"
+    with pytest.raises(FloodModellerAPIError):
+        assert x2d._write()
+
 
 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

@@ -1,6 +1,6 @@
 """
 Flood Modeller Python API
-Copyright (C) 2024 Jacobs U.K. Limited
+Copyright (C) 2025 Jacobs U.K. Limited
 
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
@@ -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

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import argparse
+import logging
 import sys
 import tkinter as tk
 from dataclasses import dataclass
+from typing import ClassVar
 
 
 @dataclass()
@@ -150,13 +152,11 @@ 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
 
-        # TODO: Add a progress bar if appropriate
-        # TODO: Present some useful information: either tool outputs or logs
-
     def run_gui_callback(self):
         """
         Method to run the gui callback function.
@@ -209,28 +209,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 +251,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
@@ -302,9 +306,9 @@ class FMTool:
             value = getattr(args, input_param.name)
             input_kwargs[input_param.name] = input_param.dtype(value)
 
-        print(f"Running {self.name}")
+        logging.info("Running %s", self.name)
         self.run(**input_kwargs)
-        print("Completed")
+        logging.info("Completed")
         # Return nothing
 
     def generate_gui(self):

floodmodeller_api/toolbox/example_tool.py

@@ -1,4 +1,8 @@
 # Import the FMTool and Parameter classes to define the tool and parameters
+from __future__ import annotations
+
+from typing import ClassVar
+
 from floodmodeller_api.tool import FMTool, Parameter
 
 
@@ -19,7 +23,7 @@ class SumTool(FMTool):
     # Add the tool description (required)
     description = "A basic tool to add two numbers together"
     # Add the parameters (one per function argument):
-    parameters = [
+    parameters: ClassVar[list[Parameter]] = [
         # Add parameters using the Parameter class
         Parameter(
             name="a",

floodmodeller_api/toolbox/model_build/add_siltation_definition.py

@@ -1,26 +1,30 @@
-""" This function allows you to raise the minimum bed level 300mm across all sections in a DAT file (i.e siltation) """
+"""This function allows you to raise the minimum bed level 300mm across all sections in a DAT file (i.e siltation)"""
 
-# Import modules
-from pathlib import Path
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
 
 from floodmodeller_api import DAT
 from floodmodeller_api.tool import FMTool, Parameter
 from floodmodeller_api.units import RIVER
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 
 # Define the function
 def raise_section_bed_levels(dat_input: Path, dat_output: Path, siltation: float):
     dat = DAT(dat_input)  # Initialise DAT class
 
-    for _, section in dat.sections.items():  # iterate through all river sections
+    for section in dat.sections.values():  # iterate through all river sections
         if not isinstance(section, RIVER):
             # Skip any non river type units (e.g. interpolates)
             continue
-        df = section.data  # get section data
-        min_elevation = df["Y"].min()  # get minimum cross section elevation
+        section_data = section.data  # get section data
+        min_elevation = section_data["Y"].min()  # get minimum cross section elevation
         raised_bed = min_elevation + siltation  # define new lowest bed level
-        df.loc[
-            df["Y"] < raised_bed,
+        section_data.loc[
+            section_data["Y"] < raised_bed,
             "Y",
         ] = raised_bed  # Raise any levels lower than this to the new lowest level
 
@@ -70,7 +74,7 @@ class AddSiltation(FMTool):
     description = (
         "Tool to add a set amount of siltation to raise bed levels of river sections in a DAT file"
     )
-    parameters = [
+    parameters: ClassVar[list[Parameter]] = [
         Parameter(
             name="dat_input",
             dtype=str,