floodmodeller-api 0.4.2__py3-none-any.whl → 0.4.3__py3-none-any.whl

floodmodeller_api/test/test_xml2d.py

@@ -1,156 +1,151 @@
-import os
-from pathlib import Path
-
-import pytest
-
-from floodmodeller_api import XML2D
-
-
-@pytest.fixture
-def xml_fp(test_workspace):
-    return os.path.join(test_workspace, "Domain1_Q.xml")
-
-
-@pytest.fixture
-def data_before(xml_fp):
-    return XML2D(xml_fp)._write()
-
-
-def test_xml2d_str_representation(xml_fp, data_before):
-    """XML2D: Test str representation equal to xml file with no changes"""
-    x2d = XML2D(xml_fp)
-    assert x2d._write() == data_before
-
-
-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]
-    prev_dtm = x2d.domains[domain]["topography"]
-
-    x2d.link1d[0]["link"] = ["new_link"]
-    x2d.domains[domain]["topography"] = ["new_dtm"]
-    assert x2d._write() != data_before
-
-    x2d.link1d[0]["link"] = prev_link
-    x2d.domains[domain]["topography"] = prev_dtm
-    assert x2d._write() == data_before
-
-
-def test_xml2d_all_files(test_workspace):
-    """XML2D: Check all '.xml' files in folder by reading the _write() output into a
-    new XML2D instance and checking it stays the same."""
-    for xmlfile in Path(test_workspace).glob("*.xml"):
-        x2d = XML2D(xmlfile)
-        first_output = x2d._write()
-        x2d.save("__temp.xml")
-        second_x2d = XML2D("__temp.xml")
-        assert x2d == second_x2d
-        second_output = second_x2d._write()
-        assert first_output == second_output
-        os.remove("__temp.xml")
-
-
-# New tests being added for the add/remove functionalility
-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))
-    orig_xml = x2d._write()
-    x2d.domains[domain]["topography"][0] = "my/new/topography"
-
-    assert x2d._write() != orig_xml
-    assert "my/new/topography" in x2d._write()
-    x2d.domains[domain]["topography"] = orig_topography
-    assert x2d._write() == orig_xml
-    assert "my/new/topography" not in x2d._write()
-
-
-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]
-    orig_xml = x2d._write()
-    x2d.domains[domain]["roughness"] = []
-    x2d.domains[domain]["roughness"].append(
-        {"type": "file", "law": "manning", "value": "my/roughness/file.shp"}
-    )
-    assert x2d._write() != orig_xml
-    assert "my/roughness/file.shp" in x2d._write()
-    del x2d.domains[domain]["roughness"]
-    assert x2d._write() == orig_xml
-    assert "my/roughness/file.shp" not in x2d._write()
-
-
-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]
-    x2d.domains[domain]["roughness"] = []
-    x2d.domains[domain]["roughness"].append(
-        {"type": "file", "law": "manning", "value": "my/roughness/file.shp"}
-    )
-    xml_1_roughness = x2d._write()
-    x2d.domains[domain]["roughness"].append(
-        {"type": "file", "law": "manning", "value": "new/roughness/file.shp"}
-    )
-
-    assert x2d._write() != xml_1_roughness
-    assert "new/roughness/file.shp" in x2d._write()
-
-    del x2d.domains[domain]["roughness"][1]
-
-    assert "new/roughness/file.shp" not in x2d._write()
-
-
-# validation/reordering tests
-
-
-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]
-    x2d.domains[domain]["computational_area"] = {
-        "yll": ...,
-        "xll": ...,
-        "dx": ...,
-        "active_area": ...,
-        "ncols": ...,
-        "nrows": ...,
-        "rotation": ...,
-    }
-    x2d.domains[domain]["computational_area"]["yll"] = float(1.1)
-    x2d.domains[domain]["computational_area"]["xll"] = float(2.6)
-    x2d.domains[domain]["computational_area"]["dx"] = float(2)
-    x2d.domains[domain]["computational_area"]["active_area"] = "path/to/asc/file.asc"
-    x2d.domains[domain]["computational_area"]["ncols"] = int(12)
-    x2d.domains[domain]["computational_area"]["nrows"] = int(42)
-    x2d.domains[domain]["computational_area"]["rotation"] = float(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?
-    # with pytest.raises(Exception) as e_info:
-    #     x2d._validate()
-
-    # assert "XML Validation Error for" in e_info
-
-    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]
-    x2d.domains[domain]["run_data"]["scheme"] = "TVD"
-
-    assert x2d._write()
+from pathlib import Path
+
+import pytest
+
+from floodmodeller_api import XML2D
+
+
+@pytest.fixture
+def xml_fp(test_workspace):
+    return Path(test_workspace, "Domain1_Q.xml")
+
+
+@pytest.fixture
+def data_before(xml_fp):
+    return XML2D(xml_fp)._write()
+
+
+def test_xml2d_str_representation(xml_fp, data_before):
+    """XML2D: Test str representation equal to xml file with no changes"""
+    x2d = XML2D(xml_fp)
+    assert x2d._write() == data_before
+
+
+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]
+    prev_dtm = x2d.domains[domain]["topography"]
+
+    x2d.link1d[0]["link"] = ["new_link"]
+    x2d.domains[domain]["topography"] = ["new_dtm"]
+    assert x2d._write() != data_before
+
+    x2d.link1d[0]["link"] = prev_link
+    x2d.domains[domain]["topography"] = prev_dtm
+    assert x2d._write() == data_before
+
+
+def test_xml2d_all_files(test_workspace, tmpdir):
+    """XML2D: Check all '.xml' files in folder by reading the _write() output into a
+    new XML2D instance and checking it stays the same."""
+    for xmlfile in Path(test_workspace).glob("*.xml"):
+        x2d = XML2D(xmlfile)
+        first_output = x2d._write()
+        new_path = Path(tmpdir) / "tmp.xml"
+        x2d.save(new_path)
+        second_x2d = XML2D(new_path)
+        assert x2d == second_x2d
+        second_output = second_x2d._write()
+        assert first_output == second_output
+
+
+# New tests being added for the add/remove functionalility
+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))
+    orig_xml = x2d._write()
+    x2d.domains[domain]["topography"][0] = "my/new/topography"
+
+    assert x2d._write() != orig_xml
+    assert "my/new/topography" in x2d._write()
+    x2d.domains[domain]["topography"] = orig_topography
+    assert x2d._write() == orig_xml
+    assert "my/new/topography" not in x2d._write()
+
+
+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]
+    orig_xml = x2d._write()
+    x2d.domains[domain]["roughness"] = []
+    x2d.domains[domain]["roughness"].append(
+        {"type": "file", "law": "manning", "value": "my/roughness/file.shp"},
+    )
+    assert x2d._write() != orig_xml
+    assert "my/roughness/file.shp" in x2d._write()
+    del x2d.domains[domain]["roughness"]
+    assert x2d._write() == orig_xml
+    assert "my/roughness/file.shp" not in x2d._write()
+
+
+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]
+    x2d.domains[domain]["roughness"] = []
+    x2d.domains[domain]["roughness"].append(
+        {"type": "file", "law": "manning", "value": "my/roughness/file.shp"},
+    )
+    xml_1_roughness = x2d._write()
+    x2d.domains[domain]["roughness"].append(
+        {"type": "file", "law": "manning", "value": "new/roughness/file.shp"},
+    )
+
+    assert x2d._write() != xml_1_roughness
+    assert "new/roughness/file.shp" in x2d._write()
+
+    del x2d.domains[domain]["roughness"][1]
+
+    assert "new/roughness/file.shp" not in x2d._write()
+
+
+# validation/reordering tests
+
+
+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]
+    x2d.domains[domain]["computational_area"] = {
+        "yll": ...,
+        "xll": ...,
+        "dx": ...,
+        "active_area": ...,
+        "ncols": ...,
+        "nrows": ...,
+        "rotation": ...,
+    }
+    x2d.domains[domain]["computational_area"]["yll"] = 1.1
+    x2d.domains[domain]["computational_area"]["xll"] = 2.6
+    x2d.domains[domain]["computational_area"]["dx"] = float(2)
+    x2d.domains[domain]["computational_area"]["active_area"] = "path/to/asc/file.asc"
+    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()
+
+
+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]
+    x2d.domains[domain]["run_data"]["scheme"] = "TVD"
+
+    assert x2d._write()

floodmodeller_api/test/test_zzn.py

@@ -1,34 +1,36 @@
-import os
-
-import pandas as pd
-import pytest
-
-from floodmodeller_api import ZZN
-
-
-@pytest.fixture
-def zzn_fp(test_workspace):
-    return os.path.join(test_workspace, "network.zzn")
-
-
-@pytest.fixture
-def tab_csv_output(test_workspace):
-    tab_csv_output = pd.read_csv(os.path.join(test_workspace, "network_from_tabularCSV.csv"))
-    tab_csv_output["Max State"] = tab_csv_output["Max State"].astype("float64")
-    return tab_csv_output
-
-
-def test_load_zzn_using_dll(zzn_fp, tab_csv_output, test_workspace):
-    """ZZN: Check loading zzn okay using dll"""
-    zzn = ZZN(zzn_fp)
-    zzn.export_to_csv(
-        result_type="max",
-        save_location=os.path.join(test_workspace, "test_output.csv"),
-    )
-    output = pd.read_csv(os.path.join(test_workspace, "test_output.csv"))
-    output = round(output, 3)  # Round to 3dp
-    # https://stackoverflow.com/questions/20274987/how-to-use-pytest-to-check-that-error-is-not-raised
-    try:
-        pd.testing.assert_frame_equal(output, tab_csv_output, rtol=0.0001)
-    except Exception:
-        pytest.fail("data frames not equal")
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from floodmodeller_api import IEF, ZZN
+
+
+@pytest.fixture
+def zzn_fp(test_workspace):
+    return Path(test_workspace, "network.zzn")
+
+
+@pytest.fixture
+def tab_csv_output(test_workspace):
+    tab_csv_output = pd.read_csv(Path(test_workspace, "network_from_tabularCSV.csv"))
+    tab_csv_output["Max State"] = tab_csv_output["Max State"].astype("float64")
+    return tab_csv_output
+
+
+def test_load_zzn_using_dll(zzn_fp, tab_csv_output, tmpdir):
+    """ZZN: Check loading zzn okay using dll"""
+    zzn = ZZN(zzn_fp)
+    zzn.export_to_csv(
+        result_type="max",
+        save_location=Path(tmpdir, "test_output.csv"),
+    )
+    output = pd.read_csv(Path(tmpdir, "test_output.csv"))
+    output = round(output, 3)
+    pd.testing.assert_frame_equal(output, tab_csv_output, rtol=0.0001)
+
+
+def test_load_zzn_using_ief(zzn_fp):
+    zzn = ZZN(zzn_fp).to_dataframe()
+    zzn_from_ief = IEF(zzn_fp.with_suffix(".ief")).get_results().to_dataframe()
+    pd.testing.assert_frame_equal(zzn, zzn_from_ief)

floodmodeller_api/to_from_json.py

@@ -0,0 +1,218 @@
+"""
+Flood Modeller Python API
+Copyright (C) 2024 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.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program.  If not, see https://www.gnu.org/licenses/.
+
+If you have any query about this program or this License, please contact us at support@floodmodeller.com or write to the following
+address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London, SE1 2QG, United Kingdom.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Union
+
+import pandas as pd
+from pandas import Index
+
+from .version import __version__
+
+
+def to_json(obj: Any) -> str:
+    """
+    Function to convert any flood modeller object into a JSON object
+
+    Args:
+        obj (object):  Any flood modeller object (dat, ied, ief, cross sections...)
+
+    Returns:
+        A JSON formatted string.
+    """
+    return json.dumps(recursive_to_json(obj), indent=2)
+
+
+def is_jsonable(obj: Any) -> bool:
+    try:
+        json.dumps(obj)
+        return True
+    except Exception:
+        return False
+
+
+def recursive_to_json(obj: Any, is_top_level: bool = True) -> Any:  # noqa: PLR0911
+    """
+    Function to undertake a recursion through the different elements of the python object
+
+    Args:
+        Obj (object):  Any flood modeller object (dat, ied, ief, cross sections...)
+
+    Returns:
+        if the object is serializable, it creates the object to go to the function to_json and to create the JSON file,
+        otherwise, it will move back through this function recursively until the object is finally serializable.
+    """
+    from ._base import FMFile
+    from .backup import File
+    from .units import IIC
+    from .units._base import Unit
+    from .urban1d._base import UrbanSubsection, UrbanUnit
+
+    if is_jsonable(obj):
+        return obj
+
+    if isinstance(obj, pd.DataFrame):
+        return {"class": "pandas.DataFrame", "object": obj.to_dict()}
+    if isinstance(obj, pd.Series):
+        return {
+            "class": "pandas.Series",
+            "variable_name": obj.name,
+            "index_name": obj.index.name,
+            "object": obj.to_dict(),
+        }
+
+    # To convert WindowsPath, no serializable, objects to string, serializable.
+    if isinstance(obj, Path):
+        return str(obj)
+
+    if isinstance(obj, set):
+        # create list and append
+        return {"python_set": [recursive_to_json(item, is_top_level=False) for item in sorted(obj)]}
+
+    # Case list or dict of non-jsonable stuff
+    if isinstance(obj, list):
+        # create list and append
+        return [recursive_to_json(item, is_top_level=False) for item in obj]
+
+    # Dictionary to the all the serializable objects
+    if isinstance(obj, dict):
+        return {key: recursive_to_json(value, is_top_level=False) for key, value in obj.items()}
+
+    # Either a type of FM API Class
+    if isinstance(obj, (FMFile, Unit, IIC, File, UrbanSubsection, UrbanUnit)):  # noqa: RET503
+        # Information from the flood modeller object will be included in the JSON output
+        # slicing undertaken to remove quotation marks
+        return_dict: dict[str, Any] = {"API Class": str(obj.__class__)[8:-2]}
+        if is_top_level:
+            return_dict["API Version"] = __version__
+
+        return_dict["Object Attributes"] = {
+            key: recursive_to_json(value, is_top_level=False) for key, value in obj.__dict__.items()
+        }
+
+        return return_dict
+
+
+def from_json(obj: Union[str, dict]) -> dict:
+    """
+    Function to convert a JSON string back into Python objects
+
+    Args:
+        json_str (str): A JSON string
+
+    Returns:
+        A FMP object
+    """
+    # To convert a JSON string into a python dictionary
+    if isinstance(obj, str):
+        obj_dict = json.loads(obj)["Object Attributes"]
+    else:
+        obj_dict = obj["Object Attributes"]
+
+    return recursive_from_json(obj_dict)
+
+
+def recursive_from_json(obj: Union[dict, Any]) -> Any:
+    """
+    Function to undertake a recursion through the different elements of the JSON object
+
+    Args:
+        obj (dict):  A JSON dict.  IT was converted from str to dict in from_json
+
+    Returns:
+        A FMP object
+    """
+
+    if "API Class" in obj:
+        class_type = obj["API Class"]
+        from .mapping import api_class_mapping
+
+        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
+    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
+
+    if "python_set" in obj:
+        return set(obj["python_set"])
+
+    for key, value in obj.items():
+        if isinstance(value, dict):
+            obj[key] = recursive_from_json(value)
+        elif isinstance(value, list):
+            new_list = []
+            for item in value:
+                if isinstance(item, dict):
+                    new_list.append(recursive_from_json(item))
+                else:
+                    new_list.append(item)
+
+            obj[key] = new_list
+
+    return obj
+
+
+def convert_dataframe_index(index: Index) -> Index:
+    try:
+        return index.astype("int")
+    except ValueError:
+        pass
+    try:
+        return index.astype("float")
+    except ValueError:
+        return index
+
+
+class Jsonable:
+    """Base class used to provide underlying to_json and from_json methods"""
+
+    def __init__(self, **kwargs):
+        pass
+
+    def to_json(self) -> str:
+        """Converts the object instance into a JSON string representation.
+
+        Returns:
+            str: A JSON string representing the object instance.
+        """
+        return to_json(self)
+
+    @classmethod
+    def from_json(cls, json_string: str):
+        """Creates an object instance from a JSON string.
+
+        Args:
+            json_string (str): A JSON string representation of the object.
+
+        Returns:
+            An object instance of the class.
+        """
+        object_dict = from_json(json_string)
+        api_object = cls(from_json=True)
+
+        # Loop through the dictionary and update the object
+        for key, value in object_dict.items():
+            setattr(api_object, key, value)
+
+        return api_object