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

floodmodeller_api/mapping.py

@@ -0,0 +1,84 @@
+from typing import Any
+
+from . import DAT, IED, IEF, INP, LF1, LF2, XML2D, ZZN
+from .backup import File
+from .units import (
+    BLOCKAGE,
+    BRIDGE,
+    COMMENT,
+    CONDUIT,
+    CRUMP,
+    CULVERT,
+    FLAT_V_WEIR,
+    HTBDY,
+    IIC,
+    INTERPOLATE,
+    ORIFICE,
+    OUTFALL,
+    QHBDY,
+    QTBDY,
+    REFHBDY,
+    REPLICATE,
+    RIVER,
+    RNWEIR,
+    SLUICE,
+    SPILL,
+    UNSUPPORTED,
+    WEIR,
+    Variables,
+)
+from .urban1d.conduits import CONDUIT as CONDUIT_URBAN
+from .urban1d.conduits import CONDUITS as CONDUITS_URBAN
+from .urban1d.junctions import JUNCTION, JUNCTIONS
+from .urban1d.losses import LOSS, LOSSES
+from .urban1d.outfalls import OUTFALL as OUTFALL_URBAN
+from .urban1d.outfalls import OUTFALLS as OUTFALLS_URBAN
+from .urban1d.raingauges import RAINGAUGE, RAINGAUGES
+from .urban1d.xsections import XSECTION, XSECTIONS
+
+api_class_mapping: dict[str, Any] = {
+    "floodmodeller_api.dat.DAT": DAT,
+    "floodmodeller_api.ied.IED": IED,
+    "floodmodeller_api.ief.IEF": IEF,
+    "floodmodeller_api.inp.INP": INP,
+    "floodmodeller_api.lf.LF1": LF1,
+    "floodmodeller_api.lf.LF2": LF2,
+    "floodmodeller_api.xml2d.XML2D": XML2D,
+    "floodmodeller_api.zzn.ZZN": ZZN,
+    "floodmodeller_api.backup.File": File,
+    "floodmodeller_api.urban1d.junctions.JUNCTIONS": JUNCTIONS,
+    "floodmodeller_api.urban1d.junctions.JUNCTION": JUNCTION,
+    "floodmodeller_api.urban1d.outfalls.OUTFALLS": OUTFALLS_URBAN,
+    "floodmodeller_api.urban1d.outfalls.OUTFALL": OUTFALL_URBAN,
+    "floodmodeller_api.urban1d.raingauges.RAINGAUGES": RAINGAUGES,
+    "floodmodeller_api.urban1d.raingauges.RAINGAUGE": RAINGAUGE,
+    "floodmodeller_api.urban1d.conduits.CONDUITS": CONDUITS_URBAN,
+    "floodmodeller_api.urban1d.conduits.CONDUIT": CONDUIT_URBAN,
+    "floodmodeller_api.urban1d.losses.LOSSES": LOSSES,
+    "floodmodeller_api.urban1d.losses.LOSS": LOSS,
+    "floodmodeller_api.urban1d.xsections.XSECTIONS": XSECTIONS,
+    "floodmodeller_api.urban1d.xsections.XSECTION": XSECTION,
+    "floodmodeller_api.units.boundaries.HTBDY": HTBDY,
+    "floodmodeller_api.units.boundaries.QHBDY": QHBDY,
+    "floodmodeller_api.units.boundaries.QTBDY": QTBDY,
+    "floodmodeller_api.units.boundaries.REFHBDY": REFHBDY,
+    "floodmodeller_api.units.comment.COMMENT": COMMENT,
+    "floodmodeller_api.units.conduits.CONDUIT": CONDUIT,
+    "floodmodeller_api.units.iic.IIC": IIC,
+    "floodmodeller_api.units.losses.BLOCKAGE": BLOCKAGE,
+    "floodmodeller_api.units.losses.CULVERT": CULVERT,
+    "floodmodeller_api.units.sections.INTERPOLATE": INTERPOLATE,
+    "floodmodeller_api.units.sections.REPLICATE": REPLICATE,
+    "floodmodeller_api.units.sections.RIVER": RIVER,
+    "floodmodeller_api.units.structures.BRIDGE": BRIDGE,
+    "floodmodeller_api.units.structures.CRUMP": CRUMP,
+    "floodmodeller_api.units.structures.FLAT_V_WEIR": FLAT_V_WEIR,
+    "floodmodeller_api.units.structures.ORIFICE": ORIFICE,
+    "floodmodeller_api.units.structures.OUTFALL": OUTFALL,
+    "floodmodeller_api.units.structures.RNWEIR": RNWEIR,
+    "floodmodeller_api.units.structures.SLUICE": SLUICE,
+    "floodmodeller_api.units.structures.SPILL": SPILL,
+    "floodmodeller_api.units.structures.WEIR": WEIR,
+    "floodmodeller_api.units.unsupported.UNSUPPORTED": UNSUPPORTED,
+    "floodmodeller_api.units.variables.Variables": Variables,
+}

floodmodeller_api/test/__init__.py

@@ -1,4 +1,4 @@
-import os
-import sys
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))

floodmodeller_api/test/conftest.py

@@ -1,8 +1,16 @@
-import os
-
-import pytest
-
-
-@pytest.fixture(scope="session")
-def test_workspace():
-    return os.path.join(os.path.dirname(__file__), "test_data")
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+
+@pytest.fixture(scope="session")
+def test_workspace():
+    return Path(os.path.dirname(__file__), "test_data")
+
+
+@pytest.fixture()
+def log_timeout():
+    with patch("floodmodeller_api.logs.lf.LOG_TIMEOUT", new=0):
+        yield

floodmodeller_api/test/test_backup.py

@@ -1,117 +1,117 @@
-from pathlib import Path
-
-import pandas as pd
-import pytest
-
-from floodmodeller_api.backup import BackupControl, File
-
-
-@pytest.fixture
-def backup_control():
-    # Use a different directory for testing
-    return BackupControl()
-
-
-@pytest.fixture
-def file(test_workspace):
-    test_file = Path(test_workspace, "EX1.DAT")
-    file = File(test_file)
-    # Make a backup to clear in test
-    file.backup()
-    return file
-
-
-def test_init_backup(backup_control):
-    """Has the backup been initialised correctly?"""
-    assert backup_control.backup_dir.exists()
-    assert backup_control.backup_csv_path.exists()
-
-
-def test_generate_file_id(file, test_workspace):
-    """Does this generate a consistent file ID for the same file on disk?"""
-    # Test that the file ID is the same for the same path input
-    file1 = File(Path(test_workspace, "EX1.DAT"))
-    file2 = File(Path(test_workspace, "EX1.DAT"))
-    assert file1.file_id == file2.file_id
-
-
-def test_clear_backup(file, test_workspace):
-    """
-    Does the the clear_backup method work correctly
-    """
-    # Clearing backup -------------------
-    # Load a different file to check it isn't affected by the
-    other_file = File(Path(test_workspace, "EX3.DAT"))
-    # Assert there is a backup for the other file
-    other_file.backup()
-    # Clear the backups for the file to test backup functionality
-    file.clear_backup()
-    # Assert that clearing the backup has worked - there aren't any backups for the file
-    assert len(file.list_backups()) == 0
-    # And that clearing it hasn't affected backups for the other file
-    assert len(other_file.list_backups()) > 0
-
-
-def test_backup_locations(file):
-    """
-    Does it make a backup in the right place?
-    """
-    # Making a backup --------------------
-    file.clear_backup()
-    # make a backup and check if file exists
-    file.backup()
-    backup_file_path = Path(file.backup_dir, file.backup_filename)
-    assert backup_file_path.exists()
-    # check if contents of backup file match the original file
-    with open(backup_file_path, "r") as f1, open(file.path, "r") as f2:
-        assert f1.read() == f2.read()
-
-
-def test_no_duplicate_backup(file, test_workspace):
-    """The backup method should only backup if the file has changed"""
-    # Don't Make Duplicate -------------------
-    # Check that the file isn't backed up again if it hasn't changed
-    the_same_file = File(Path(test_workspace, "EX1.DAT"))
-    # Append something to the dttm string to ensure the filename is different to the previous backup
-    # If the two File objects are created in the same second then then will have identical file names
-    # The function should check for equivalence between file contents.
-    the_same_file.dttm_str = the_same_file.dttm_str + "_1"
-    # Generate a new file name
-    the_same_file._generate_file_name()
-    # Attempt a backup
-    the_same_file.backup()
-    # Check that the file hasn't been created
-    duplicate_backup_path = Path(the_same_file.backup_dir, the_same_file.backup_filename)
-    assert not duplicate_backup_path.exists()
-
-
-def test_backup_logs(file):
-    """Are backups being logged in the CSV?"""
-    # Clear the backup
-    file.clear_backup()
-    # There shouldn't be any edits in the csv
-    backup_logs = pd.read_csv(file.backup_csv_path)
-    backup_count = backup_logs[
-        (backup_logs.file_id == file.file_id) & (backup_logs.dttm == file.dttm_str)
-    ].shape[0]
-    assert backup_count == 0
-    # Make a backup and assert it is in the CSV
-    file.backup()
-    # Check edits to the backup CSV
-    # Check a row has been added to the csv for the file & version
-    backup_logs = pd.read_csv(file.backup_csv_path)
-    backup_count = backup_logs[
-        (backup_logs.file_id == file.file_id) & (backup_logs.dttm == file.dttm_str)
-    ].shape[0]
-    assert backup_count == 1
-
-
-def test_list_backups(file):
-    """Does the list backups method work correctly?"""
-    # First clear any backups that exist
-    file.clear_backup()
-    # make a backup and check if it appears in the backup list
-    file.backup()
-    backups = file.list_backups()
-    expected_backup = Path(file.backup_dir, file.backup_filename)
-    assert expected_backup in [backup.path for backup in backups]
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from floodmodeller_api.backup import BackupControl, File
+
+
+@pytest.fixture
+def backup_control():
+    # Use a different directory for testing
+    return BackupControl()
+
+
+@pytest.fixture
+def file(test_workspace):
+    test_file = Path(test_workspace, "EX1.DAT")
+    file = File(test_file)
+    # Make a backup to clear in test
+    file.backup()
+    return file
+
+
+def test_init_backup(backup_control):
+    """Has the backup been initialised correctly?"""
+    assert backup_control.backup_dir.exists()
+    assert backup_control.backup_csv_path.exists()
+
+
+def test_generate_file_id(file, test_workspace):
+    """Does this generate a consistent file ID for the same file on disk?"""
+    # Test that the file ID is the same for the same path input
+    file1 = File(Path(test_workspace, "EX1.DAT"))
+    file2 = File(Path(test_workspace, "EX1.DAT"))
+    assert file1.file_id == file2.file_id
+
+
+def test_clear_backup(file, test_workspace):
+    """
+    Does the the clear_backup method work correctly
+    """
+    # Clearing backup -------------------
+    # Load a different file to check it isn't affected by the
+    other_file = File(Path(test_workspace, "EX3.DAT"))
+    # Assert there is a backup for the other file
+    other_file.backup()
+    # Clear the backups for the file to test backup functionality
+    file.clear_backup()
+    # Assert that clearing the backup has worked - there aren't any backups for the file
+    assert len(file.list_backups()) == 0
+    # And that clearing it hasn't affected backups for the other file
+    assert len(other_file.list_backups()) > 0
+
+
+def test_backup_locations(file):
+    """
+    Does it make a backup in the right place?
+    """
+    # Making a backup --------------------
+    file.clear_backup()
+    # make a backup and check if file exists
+    file.backup()
+    backup_file_path = Path(file.backup_dir, file.backup_filename)
+    assert backup_file_path.exists()
+    # check if contents of backup file match the original file
+    with open(backup_file_path) as f1, open(file.path) as f2:
+        assert f1.read() == f2.read()
+
+
+def test_no_duplicate_backup(file, test_workspace):
+    """The backup method should only backup if the file has changed"""
+    # Don't Make Duplicate -------------------
+    # Check that the file isn't backed up again if it hasn't changed
+    the_same_file = File(Path(test_workspace, "EX1.DAT"))
+    # Append something to the dttm string to ensure the filename is different to the previous backup
+    # If the two File objects are created in the same second then then will have identical file names
+    # The function should check for equivalence between file contents.
+    the_same_file.dttm_str = the_same_file.dttm_str + "_1"
+    # Generate a new file name
+    the_same_file._generate_file_name()
+    # Attempt a backup
+    the_same_file.backup()
+    # Check that the file hasn't been created
+    duplicate_backup_path = Path(the_same_file.backup_dir, the_same_file.backup_filename)
+    assert not duplicate_backup_path.exists()
+
+
+def test_backup_logs(file):
+    """Are backups being logged in the CSV?"""
+    # Clear the backup
+    file.clear_backup()
+    # There shouldn't be any edits in the csv
+    backup_logs = pd.read_csv(file.backup_csv_path)
+    backup_count = backup_logs[
+        (backup_logs.file_id == file.file_id) & (backup_logs.dttm == file.dttm_str)
+    ].shape[0]
+    assert backup_count == 0
+    # Make a backup and assert it is in the CSV
+    file.backup()
+    # Check edits to the backup CSV
+    # Check a row has been added to the csv for the file & version
+    backup_logs = pd.read_csv(file.backup_csv_path)
+    backup_count = backup_logs[
+        (backup_logs.file_id == file.file_id) & (backup_logs.dttm == file.dttm_str)
+    ].shape[0]
+    assert backup_count == 1
+
+
+def test_list_backups(file):
+    """Does the list backups method work correctly?"""
+    # First clear any backups that exist
+    file.clear_backup()
+    # make a backup and check if it appears in the backup list
+    file.backup()
+    backups = file.list_backups()
+    expected_backup = Path(file.backup_dir, file.backup_filename)
+    assert expected_backup in [backup.path for backup in backups]

floodmodeller_api/test/test_conveyance.py

@@ -0,0 +1,107 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+from scipy.spatial.distance import directed_hausdorff
+from shapely.geometry import LineString, Polygon
+
+from floodmodeller_api import DAT
+from floodmodeller_api.units.conveyance import (
+    calculate_conveyance_by_panel,
+    calculate_conveyance_part,
+    calculate_cross_section_conveyance,
+    insert_intermediate_wls,
+)
+
+
+def test_calculate_cross_section_conveyance():
+    x = np.array([0, 1, 2, 3, 4])
+    y = np.array([5, 3, 1, 2, 6])
+    n = np.array([0.03, 0.03, 0.03, 0.03, 0.03])
+    panel_markers = np.array([False, False, False, False, False])
+    rpl = np.array([1.0, 1.0, 1.0, 1.0, 1.0])
+    result = calculate_cross_section_conveyance(x, y, n, rpl, panel_markers)
+
+    assert isinstance(result, pd.Series), "Result should be a pandas Series"
+    assert not result.empty, "Result should not be empty"
+
+
+def test_calculate_conveyance_by_panel():
+    x = np.array([0, 1, 2])
+    y = np.array([5, 3, 1])
+    n = np.array([0.03, 0.03])
+    rpl = 1.0
+    wls = np.array([1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0])
+
+    result = calculate_conveyance_by_panel(x, y, n, rpl, wls)
+
+    assert isinstance(result, list), "Result should be a list"
+    assert len(result) == len(wls), "Result length should match the length of water levels"
+    assert all(isinstance(val, float) for val in result), "All conveyance values should be floats"
+
+
+def test_calculate_conveyance_part():
+    wetted_polygon = Polygon([(1, 3), (2, 1), (3, 2), (4, 6), (1, 3)])
+    water_plane = LineString([(0, 3), (5, 3)])
+    glass_walls = LineString([(1, 3), (1, 7)]), LineString([(4, 6), (4, 7)])
+    x = np.array([1, 2, 3, 4])
+    n = np.array([0.03, 0.03, 0.03, 0.03])
+    rpl = 1.0
+
+    result = calculate_conveyance_part(wetted_polygon, water_plane, glass_walls, x, n, rpl)
+
+    assert isinstance(result, float), "Result should be a float"
+    assert result >= 0, "Conveyance should be non-negative"
+
+
+def test_insert_intermediate_wls():
+    arr = np.array([1.0, 2.0, 3.0])
+    threshold = 0.5
+
+    result = insert_intermediate_wls(arr, threshold)
+
+    assert isinstance(result, np.ndarray), "Result should be a numpy array"
+    assert result[0] == 1.0 and result[-1] == 3.0, "First and last elements should match the input"
+    assert all(np.diff(result) <= threshold), "All gaps should be <= to the threshold"
+
+
+@pytest.fixture(scope="module")
+def dat(test_workspace: Path):
+    return DAT(test_workspace / "conveyance_test.dat")
+
+
+@pytest.fixture(scope="module")
+def from_gui(test_workspace: Path):
+    return pd.read_csv(test_workspace / "expected_conveyance.csv")
+
+
+@pytest.mark.parametrize("section", ("a", "a2", "b", "b2", "c", "d", "d2", "e", "e2", "e3"))
+def test_results_close_to_gui(section: str, dat: DAT, from_gui: pd.DataFrame):
+    threshold = 6
+
+    actual = dat.sections[section].conveyance
+    expected = (
+        from_gui.set_index(f"{section}_stage")[f"{section}_conveyance"].dropna().drop_duplicates()
+    )
+    common_index = sorted(set(actual.index).union(expected.index))
+    actual_interpolated = actual.reindex(common_index).interpolate(method="slinear")
+    expected_interpolated = expected.reindex(common_index).interpolate(method="slinear")
+
+    u = np.array(list(zip(actual_interpolated.index, actual_interpolated)))
+    v = np.array(list(zip(expected_interpolated.index, expected_interpolated)))
+    hausdorff_distance = directed_hausdorff(u, v)[0]
+
+    assert hausdorff_distance < threshold
+
+
+@pytest.mark.parametrize("section", ("a", "a2", "b", "b2", "c", "d", "d2", "e", "e2", "e3"))
+def test_results_match_gui_at_shared_points(section: str, dat: DAT, from_gui: pd.DataFrame):
+    tolerance = 1e-2  # 0.001
+    actual = dat.sections[section].conveyance
+    expected = (
+        from_gui.set_index(f"{section}_stage")[f"{section}_conveyance"].dropna().drop_duplicates()
+    )
+    shared_index = sorted(set(actual.index).intersection(expected.index))
+    diff = expected[shared_index] - actual[shared_index]
+    assert (abs(diff) < tolerance).all()  # asserts all conveyance values within 0.001 difference