floodmodeller-api 0.5.3.post2__py3-none-any.whl → 0.5.5__py3-none-any.whl

floodmodeller_api/test/test_gxy.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+import floodmodeller_api.units
+from floodmodeller_api import DAT
+from floodmodeller_api.units import (
+    FLOODPLAIN,
+    INTERPOLATE,
+    JUNCTION,
+    QTBDY,
+    REPLICATE,
+    RESERVOIR,
+    RIVER,
+    SPILL,
+)
+
+
+# this would be a fixture but doesnt work when used in parameterised test.
+def blank_with_location(unit_class, *args, **kwargs):
+    unit = unit_class(*args, **kwargs)
+    unit._location = (461193.10, 339088.74)
+    return unit
+
+
+@pytest.mark.parametrize(
+    ("unit", "expected_outcome"),
+    [
+        (RIVER(), None),
+        (QTBDY(), None),
+        (INTERPOLATE(), None),
+        (INTERPOLATE(easting=123.4, northing=987.6), (123.4, 987.6)),
+        (REPLICATE(), None),
+        (REPLICATE(easting=123.4, northing=987.6), (123.4, 987.6)),
+        (RESERVOIR(), None),
+        (RESERVOIR(easting=123.4, northing=987.6), (123.4, 987.6)),
+        (SPILL(), None),
+        (FLOODPLAIN(), None),
+        (blank_with_location(QTBDY), (461193.10, 339088.74)),
+        (blank_with_location(RIVER), (461193.10, 339088.74)),
+        (blank_with_location(INTERPOLATE), (461193.10, 339088.74)),
+        (blank_with_location(INTERPOLATE, easting=123.4, northing=987.6), (461193.10, 339088.74)),
+        (blank_with_location(SPILL), (461193.10, 339088.74)),
+        (blank_with_location(FLOODPLAIN), (461193.10, 339088.74)),
+    ],
+)
+def test_unit_location(unit, expected_outcome):
+    assert unit.location == expected_outcome
+
+
+def get_supported_unit_classes():
+    all_unit_classes = []
+    for unit_type, attributes in floodmodeller_api.units.SUPPORTED_UNIT_TYPES.items():
+        if attributes["group"] not in ("other", "comments"):
+            unit_type_safe = unit_type.replace(" ", "_").replace("-", "_")
+            # Borrowed replacing idea from .dat
+            unit_class = getattr(floodmodeller_api.units, unit_type_safe)
+            all_unit_classes.append(unit_class)
+    return all_unit_classes
+
+
+SUPPORTED_UNIT_CLASSES = get_supported_unit_classes()
+
+
+@pytest.mark.parametrize("unit_class", SUPPORTED_UNIT_CLASSES)
+def test_setting_location(unit_class):
+    # first check that we get the not implemented error, then check that the location is still unaffected.
+    # this test should be updated when location is read/write capable.
+    try:
+        # Junction units cannot be created from blank without at least one label.
+        unit = unit_class(labels=["label1"]) if unit_class == JUNCTION else unit_class()
+    except NotImplementedError as error:
+        pytest.skip(f"Creating unit {unit_class=} from blank not supported, skipping...\n{error=}")
+
+    with pytest.raises(NotImplementedError):
+        unit.location = (461382.54, 339188.26)
+
+    assert unit.location is None
+    assert unit._location is None
+
+
+@pytest.mark.parametrize(
+    ("dat_name", "group", "label", "expected_outcome"),
+    [
+        ("EX1.DAT", "sections", "S4", (-38203.94169253, 153846.153846154)),
+        ("River_Bridge_no_gxy.dat", "sections", "M029", (385029.200, 242717.100)),
+        ("River_Bridge_no_gxy.dat", "sections", "M030", (384689.300, 242345.700)),
+        ("River_Bridge_no_gxy.dat", "sections", "M031", (384545.000, 241937.000)),
+        ("River_Bridge_no_gxy.dat", "structures", "M047spU", (386710.9, 236857.85)),
+    ],
+)
+def test_unit_from_dat(test_workspace, dat_name, group, label, expected_outcome):
+    dat_path = Path(test_workspace, dat_name)
+    dat = DAT(dat_path)
+    unit = getattr(dat, group)[label]
+    assert unit.location == expected_outcome

floodmodeller_api/test/test_json.py

@@ -8,6 +8,13 @@ import pytest
 
 from floodmodeller_api import DAT, IED, IEF, INP, XML2D
 from floodmodeller_api.to_from_json import is_jsonable
+from floodmodeller_api.units import (
+    FLOODPLAIN,
+    INTERPOLATE,
+    QTBDY,
+    RIVER,
+    SPILL,
+)
 from floodmodeller_api.util import read_file
 
 if TYPE_CHECKING:
@@ -65,6 +72,14 @@ def parameterised_objs_and_expected(test_workspace) -> list[tuple[FMFile, Path]]
         (IEF(test_workspace / "ex3.ief"), test_workspace / "EX3_IEF_expected.json"),
         (XML2D(test_workspace / "Domain1_Q.xml"), test_workspace / "Domain1_Q_xml_expected.json"),
         (XML2D(test_workspace / "Linked1D2D.xml"), test_workspace / "Linked1D2D_xml_expected.json"),
+        (
+            DAT(test_workspace / "River_Bridge.dat"),
+            test_workspace / "River_Bridge_DAT_expected.json",
+        ),
+        (
+            DAT(test_workspace / "River_Bridge_no_gxy.dat"),
+            test_workspace / "River_Bridge_no_gxy_DAT_expected.json",
+        ),
     ]
 
 
@@ -80,7 +95,7 @@ def test_to_json_matches_expected(parameterised_objs_and_expected: list[tuple[FM
             json_dict_from_file = json.load(file)["Object Attributes"]
 
         # keys to ignore when testing for equivalence
-        keys_to_remove = ["_filepath", "file", "_log_path"]
+        keys_to_remove = ["_filepath", "file", "_log_path", "_gxy_filepath"]
         for key in keys_to_remove:
             json_dict_from_obj.pop(key, None)
             json_dict_from_file.pop(key, None)
@@ -104,11 +119,31 @@ def test_obj_reproduces_from_json_for_all_test_api_files(
     file_extension_glob,
 ):
     """JSON:  To test the from_json function,  It should produce the same dat file from a json file"""
+    fail_list = []
     for file in Path(test_workspace).glob(file_extension_glob):
         if file.name.startswith("duplicate_unit_test"):
             # Skipping as invalid DAT (duplicate units)
             continue
-        assert api_class(file) == api_class.from_json(api_class(file).to_json())
+
+        if api_class(file) != api_class.from_json(api_class(file).to_json()):
+            fail_list.append(str(file))
+    failures = "\n".join(fail_list)
+    assert len(fail_list) == 0, f"The following files did not reproduce:\n{failures}"
+
+
+@pytest.mark.parametrize(
+    "unit",
+    [
+        RIVER(),
+        QTBDY(),
+        INTERPOLATE(),
+        INTERPOLATE(easting=123.4, northing=987.6),
+        SPILL(),
+        FLOODPLAIN(),
+    ],
+)
+def test_obj_reproduces_from_json_for_units(unit):
+    assert unit == unit.from_json(unit.to_json())
 
 
 def test_is_jsonable_with_jsonable_object():

floodmodeller_api/test/test_unit.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import pandas as pd
 import pytest
 
+from floodmodeller_api.units import QTBDY
 from floodmodeller_api.units._base import Unit  # update this import path to match your repo
 
 
@@ -55,3 +57,13 @@ def test_remove_unit_name(unit: str, header: str, remove_revision: bool, expecte
     dummy_unit = DummyUnit(unit)
     result = dummy_unit._remove_unit_name(header, remove_revision=remove_revision)
     assert result == expected_result
+
+
+def test_partially_defined_unit():
+    actual = QTBDY(["QTBDY comment", "test", "1", "0"]).data
+    expected = pd.Series(
+        [0],
+        index=pd.Index([0], name="Time"),
+        name="Flow",
+    )
+    pd.testing.assert_series_equal(expected, actual)

floodmodeller_api/to_from_json.py

@@ -82,6 +82,11 @@ def recursive_to_json(obj: Any, is_top_level: bool = True) -> Any:  # noqa: PLR0
     from .units._base import Unit
     from .urban1d._base import UrbanSubsection, UrbanUnit
 
+    if isinstance(obj, tuple):
+        return {
+            "python_tuple": [recursive_to_json(item, is_top_level=False) for item in obj],
+        }
+
     if is_jsonable(obj):
         return obj
 
@@ -144,7 +149,7 @@ def from_json(obj: str | dict) -> dict:
     return recursive_from_json(obj_dict)
 
 
-def recursive_from_json(obj: dict | Any) -> Any:
+def recursive_from_json(obj: dict | Any) -> Any:  # noqa: C901
     """
     Function to undertake a recursion through the different elements of the JSON object
 
@@ -173,7 +178,16 @@ def recursive_from_json(obj: dict | Any) -> Any:
         return reconstructed_sr
 
     if "python_set" in obj:
-        return set(obj["python_set"])
+        return {
+            recursive_from_json(item) if isinstance(item, dict) else item
+            for item in obj["python_set"]
+        }
+
+    if "python_tuple" in obj:
+        return tuple(
+            recursive_from_json(item) if isinstance(item, dict) else item
+            for item in obj["python_tuple"]
+        )
 
     for key, value in obj.items():
         if isinstance(value, dict):

floodmodeller_api/toolbox/model_build/structure_log/structure_log.py

@@ -437,7 +437,7 @@ class StructureLogBuilder:
             height = opening["opening_height"]
             width = opening["width"]
 
-            text += f"Opening {n+1}: h: {height:.2f} x w: {width:.2f} "
+            text += f"Opening {n + 1}: h: {height:.2f} x w: {width:.2f} "
 
         return text.rstrip()
 
@@ -480,24 +480,24 @@ class StructureLogBuilder:
         culvert_loss = ""
         match unit_dict["subtype"]:
             case "CIRCULAR":
-                text += f'dia: {unit_dict["dimensions"]["diameter"]:.2f} x l: {unit_dict["conduit_data"]["length"]:.2f}'
+                text += f"dia: {unit_dict['dimensions']['diameter']:.2f} x l: {unit_dict['conduit_data']['length']:.2f}"
             case "SPRUNGARCH" | "SPRUNG":
-                text += f'(Springing: {unit_dict["dimensions"]["height_springing"]:.2f}, Crown: {unit_dict["dimensions"]["height_crown"]:.2f}) x w: {unit_dict["dimensions"]["width"]:.2f} x l: {unit_dict["conduit_data"]["length"]:.2f}'
+                text += f"(Springing: {unit_dict['dimensions']['height_springing']:.2f}, Crown: {unit_dict['dimensions']['height_crown']:.2f}) x w: {unit_dict['dimensions']['width']:.2f} x l: {unit_dict['conduit_data']['length']:.2f}"
             case "RECTANGULAR":
-                text += f'h: {unit_dict["dimensions"]["height"]:.2f} x w: {unit_dict["dimensions"]["width"]:.2f} x l: {unit_dict["conduit_data"]["length"]:.2f}'
+                text += f"h: {unit_dict['dimensions']['height']:.2f} x w: {unit_dict['dimensions']['width']:.2f} x l: {unit_dict['conduit_data']['length']:.2f}"
             case "SECTION":
-                text += f'h: {unit_dict["dimensions"]["height"]:.2f} x w: {unit_dict["dimensions"]["width"]:.2f} x l: {unit_dict["conduit_data"]["length"]:.2f}'
+                text += f"h: {unit_dict['dimensions']['height']:.2f} x w: {unit_dict['dimensions']['width']:.2f} x l: {unit_dict['conduit_data']['length']:.2f}"
             case _:
                 return "", ""
 
         if "total_length" in unit_dict["conduit_data"]:
-            text += f' (Total conduit length: {unit_dict["conduit_data"]["total_length"]:.2f})'
+            text += f" (Total conduit length: {unit_dict['conduit_data']['total_length']:.2f})"
 
         if "inlet" in unit_dict["conduit_data"]:
-            culvert_loss += f'Ki: {unit_dict["conduit_data"]["inlet"]}, '
+            culvert_loss += f"Ki: {unit_dict['conduit_data']['inlet']}, "
 
         if "outlet" in unit_dict["conduit_data"]:
-            culvert_loss += f'Ko: {unit_dict["conduit_data"]["outlet"]}, '
+            culvert_loss += f"Ko: {unit_dict['conduit_data']['outlet']}, "
 
         culvert_loss = culvert_loss.rstrip(", ")
 

floodmodeller_api/units/_base.py

@@ -35,6 +35,7 @@ class Unit(Jsonable):
     _unit: str
     _subtype: str | None = None
     _name: str | None = None
+    _location: tuple[float, float] | None = None
 
     def __init__(self, unit_block=None, n=12, from_json: bool = False, **kwargs):
         if from_json:
@@ -104,6 +105,35 @@ class Unit(Jsonable):
         msg = "You cannot change the subtype of a unit once it has been instantiated"
         raise ValueError(msg)
 
+    @property
+    def location(self) -> tuple[float, float] | None:
+        # gxy data (_location) written upon instantiation when opening DAT.
+        # default priority is as follows:
+        # 1. gxy data if not None
+        # 2. easting and northing attributes if the unit has them (Interpolates, replicates and reservoirs)
+        # 3. None
+        if self._location is not None:
+            return self._location
+
+        if hasattr(self, "easting") and hasattr(self, "northing"):
+            location = (self.easting, self.northing)
+            if location != (0, 0):
+                return location
+
+        return None
+
+    @location.setter
+    def location(self, new_value):
+        msg = "Currently unit location is read-only."
+        raise NotImplementedError(msg)
+
+    def set_cached_location_from_gxy(self, location):
+        """Used by DAT to set the _location attribute when reading a gxy.
+
+        This is not a setter, and will not make .gxy modifications.
+        """
+        self._location = location
+
     def __repr__(self):
         if self._subtype is None:
             return f"<floodmodeller_api Unit Class: {self._unit}(name={self._name})>"

floodmodeller_api/units/boundaries.py

@@ -106,7 +106,8 @@ class QTBDY(Unit):
             if self.timeunit == "DATES"
             else to_data_list(qtbdy_block[3:])
         )
-
+        if data_list == [[0]]:
+            data_list = [[0, 0]]
         self.data = pd.DataFrame(data_list, columns=["Flow", "Time"])
         self.data = self.data.set_index("Time")
         self.data = self.data["Flow"]  # Convert to series
@@ -200,6 +201,8 @@ class HTBDY(Unit):
             if self.timeunit == "DATES"
             else to_data_list(htbdy_block[3:])
         )
+        if data_list == [[0]]:
+            data_list = [[0, 0]]
 
         self.data = pd.DataFrame(data_list, columns=["Stage", "Time"])
         self.data = self.data.set_index("Time")

floodmodeller_api/units/conduits.py

@@ -183,7 +183,7 @@ class CONDUIT(Unit):
         """Function to read a given CONDUIT block and store data as class attributes"""
         self._subtype = self._get_first_word(c_block[1])
         # Extends label line to be correct length before splitting to pick up blank labels
-        labels = split_n_char(f"{c_block[2]:<{2*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{c_block[2]:<{2 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.spill = labels[1]
         self.comment = self._remove_unit_name(c_block[0])

floodmodeller_api/units/losses.py

@@ -79,7 +79,7 @@ class CULVERT(Unit):
         # Extract common attributes
         self._subtype = self._get_first_word(block[1])
         self.comment = self._remove_unit_name(block[0])
-        labels = split_n_char(f"{block[2]:<{4*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{block[2]:<{4 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.us_remote_label = labels[2]
@@ -195,7 +195,7 @@ class BLOCKAGE(Unit):
         self._revision, self.comment = self._get_revision_and_comment(block[0])
 
         # Extract labels
-        labels = split_n_char(f"{block[1]:<{5*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{block[1]:<{5 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.us_reference_label = labels[2]

floodmodeller_api/units/sections.py

@@ -235,6 +235,42 @@ class RIVER(Unit):
 
         return self._raw_block
 
+    @property
+    def location(self) -> tuple[float, float] | None:
+        # for RIVER units, source priority is as follows:
+        # 1. GXY location if defined
+        # 2. BED marker location if not (0,0)
+        # 3. Y-min location if not (0,0)
+        # 4. None
+        if self._location is not None:
+            return self._location
+
+        try:
+            bed_rows = self.active_data["Marker"] == "BED"
+            bed_points = self.active_data.loc[bed_rows]
+            first_bed = bed_points[["Easting", "Northing"]].iloc[0]
+            location = (float(first_bed["Easting"]), float(first_bed["Northing"]))
+            if location != (0, 0):
+                return location
+        except (ValueError, IndexError):
+            pass
+
+        try:
+            min_idx = self.active_data.Y.idxmin()
+            min_row = self.active_data.loc[min_idx]
+            location = (float(min_row["Easting"]), float(min_row["Northing"]))
+            if location != (0, 0):
+                return location
+        except (ValueError, IndexError):
+            pass
+
+        return None
+
+    @location.setter
+    def location(self, new_value: tuple[float, float] | None) -> None:
+        msg = "Currently unit location is read-only."
+        raise NotImplementedError(msg)
+
     @property
     def data(self) -> pd.DataFrame:
         """Data table for the river cross section.

floodmodeller_api/units/structures.py

@@ -47,6 +47,15 @@ from ._helpers import (
 )
 
 
+def _get_median_coordinate(data):
+    # trim rows that have invalid coordinates (0,0)
+    data = data[(data["Easting"] != 0) | (data["Northing"] != 0)]
+    median_coords = data[["Easting", "Northing"]].median()
+    if median_coords.isna().any():
+        return None
+    return (float(median_coords["Easting"]), float(median_coords["Northing"]))
+
+
 class BRIDGE(Unit):
     """Class to hold and process BRIDGE unit type. The Bridge class supports the three main bridge sub-types in
     Flood Modeller: Arch, USBPR1978 and Pierloss. Each of these sub-types forms a unique instance of the class
@@ -163,7 +172,7 @@ class BRIDGE(Unit):
         self.comment = self._remove_unit_name(br_block[0])
         self._subtype = self._get_first_word(br_block[1])
         # Extends label line to be correct length before splitting to pick up blank labels
-        labels = split_n_char(f"{br_block[2]:<{4*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{br_block[2]:<{4 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.us_remote_label = labels[2]
@@ -374,7 +383,7 @@ class BRIDGE(Unit):
             )
             if self.specify_piers:
                 if self.pier_use_calibration_coeff:
-                    pier_params = f'{self.npiers:>10}{"COEFF":<10}{"":>10}{self.pier_calibration_coeff:>10.3f}'
+                    pier_params = f"{self.npiers:>10}{'COEFF':<10}{'':>10}{self.pier_calibration_coeff:>10.3f}"
                 else:
                     pier_params = f"{self.npiers:>10}{self.pier_shape:<10}{self.pier_faces:<10}"
             else:
@@ -589,7 +598,7 @@ class SLUICE(Unit):
         self._subtype = self._get_first_word(block[1])
 
         # Extends label line to be correct length before splitting to pick up blank labels
-        labels = split_n_char(f"{block[2]:<{3*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{block[2]:<{3 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.remote_label = labels[2]
@@ -675,8 +684,8 @@ class SLUICE(Unit):
             self.weir_length,
         )
         if self.subtype == "RADIAL":
-            params1 += f'{"DEGREES":<10}' if self.use_degrees else f'{"":<10}'
-            params1 += "FREESLUICE" if self.allow_free_flow_under else f'{"":<10}'
+            params1 += f"{'DEGREES':<10}" if self.use_degrees else f"{'':<10}"
+            params1 += "FREESLUICE" if self.allow_free_flow_under else f"{'':<10}"
 
         # Second parameter line
         params2 = join_10_char(
@@ -726,7 +735,7 @@ class SLUICE(Unit):
             # ADD GATES
             block.append(
                 join_10_char(
-                    f'{"LOGICAL":<10}',
+                    f"{'LOGICAL':<10}",
                     self.max_movement_rate,
                     self.max_setting,
                     self.min_setting,
@@ -827,7 +836,7 @@ class ORIFICE(Unit):
         self.flapped = self.subtype == "FLAPPED"
 
         # Extends label line to be correct length before splitting to pick up blank labels
-        labels = split_n_char(f"{block[2]:<{2*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{block[2]:<{2 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.comment = self._remove_unit_name(block[0])
@@ -928,7 +937,7 @@ class SPILL(Unit):
     def _read(self, block):
         """Function to read a given SPILL block and store data as class attributes"""
         # Extends label line to be correct length before splitting to pick up blank labels
-        labels = split_n_char(f"{block[1]:<{2*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{block[1]:<{2 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.comment = self._remove_unit_name(block[0])
@@ -984,6 +993,25 @@ class SPILL(Unit):
             else pd.DataFrame([[0.0, 0.0, 0.0, 0.0]], columns=["X", "Y", "Easting", "Northing"])
         )
 
+    @property
+    def location(self) -> tuple[float, float] | None:
+        # for SPILL units, source priority is as follows:
+        # 1. GXY location if defined
+        # 2. median location if not (0,0)
+        # 3. None
+        if self._location is not None:
+            return self._location
+
+        try:
+            return _get_median_coordinate(self.data)
+        except (ValueError, IndexError):
+            return None
+
+    @location.setter
+    def location(self, new_value: tuple[float, float] | None) -> None:
+        msg = "Currently unit location is read-only."
+        raise NotImplementedError(msg)
+
 
 class RNWEIR(Unit):
     """Class to hold and process RNWEIR unit type
@@ -1009,7 +1037,7 @@ class RNWEIR(Unit):
     def _read(self, block):
         """Function to read a given RNWEIR block and store data as class attributes"""
         # Extends label line to be correct length before splitting to pick up blank labels
-        labels = split_n_char(f"{block[1]:<{2*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{block[1]:<{2 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.comment = self._remove_unit_name(block[0])
@@ -1110,7 +1138,7 @@ class WEIR(Unit):
     def _read(self, block):
         """Function to read a given WEIR block and store data as class attributes"""
         # Extends label line to be correct length before splitting to pick up blank labels
-        labels = split_n_char(f"{block[1]:<{2*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{block[1]:<{2 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.comment = self._remove_unit_name(block[0])
@@ -1202,7 +1230,7 @@ class CRUMP(Unit):
     def _read(self, block):
         """Function to read a given CRUMP block and store data as class attributes"""
         # Extends label line to be correct length before splitting to pick up blank labels
-        labels = split_n_char(f"{block[1]:<{4*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{block[1]:<{4 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.us_remote_label = labels[2]
@@ -1311,7 +1339,7 @@ class FLAT_V_WEIR(Unit):  # noqa: N801
     def _read(self, block):
         """Function to read a given FLAT-V WEIR block and store data as class attributes"""
         # Extends label line to be correct length before splitting to pick up blank labels
-        labels = split_n_char(f"{block[1]:<{4*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{block[1]:<{4 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.us_remote_label = labels[2]
@@ -1440,7 +1468,7 @@ class OUTFALL(Unit):
         self.flapped = self.subtype == "FLAPPED"
 
         # Extends label line to be correct length before splitting to pick up blank labels
-        labels = split_n_char(f"{block[2]:<{2*self._label_len}}", self._label_len)
+        labels = split_n_char(f"{block[2]:<{2 * self._label_len}}", self._label_len)
         self.name = labels[0]
         self.ds_label = labels[1]
         self.comment = self._remove_unit_name(block[0])
@@ -1660,3 +1688,22 @@ class FLOODPLAIN(Unit):
             msg = f"The DataFrame must only contain columns: {self._required_columns}"
             raise ValueError(msg)
         self._data = new_df
+
+    @property
+    def location(self) -> tuple[float, float] | None:
+        # for FLOODPLAIN units, source priority is as follows:
+        # 1. GXY location if defined
+        # 2. median location if not (0,0)
+        # 3. None
+        if self._location is not None:
+            return self._location
+
+        try:
+            return _get_median_coordinate(self.data)
+        except (ValueError, IndexError):
+            return None
+
+    @location.setter
+    def location(self, new_value: tuple[float, float] | None) -> None:
+        msg = "Currently unit location is read-only."
+        raise NotImplementedError(msg)

floodmodeller_api/units/unsupported.py

@@ -29,11 +29,11 @@ class UNSUPPORTED(Unit):
         self.comment = self._remove_unit_name(block[0])
 
         if self._subtype is False:
-            self.labels = split_n_char(f"{block[1]:<{2*self._label_len}}", self._label_len)
+            self.labels = split_n_char(f"{block[1]:<{2 * self._label_len}}", self._label_len)
 
         else:
             self._subtype = self._get_first_word(block[1])
-            self.labels = split_n_char(f"{block[2]:<{2*self._label_len}}", self._label_len)
+            self.labels = split_n_char(f"{block[2]:<{2 * self._label_len}}", self._label_len)
 
         if self.labels[1] != "":
             self.ds_label = self.labels[1]

floodmodeller_api/validation/validation.py

@@ -46,12 +46,12 @@ def _validate_unit(unit, urban=False):
 
 def _validate_parameter(param, value):  # noqa: C901, PLR0911, PLR0912
     if param["type"] == "type-match":
-        return isinstance(value, param["options"]), f'-> Expected: {param["options"]}'
+        return isinstance(value, param["options"]), f"-> Expected: {param['options']}"
 
     if param["type"] == "value-match":
         if isinstance(value, str):
-            return value.upper() in param["options"], f'-> Expected: {param["options"]}'
-        return value in param["options"], f'-> Expected: {param["options"]}'
+            return value.upper() in param["options"], f"-> Expected: {param['options']}"
+        return value in param["options"], f"-> Expected: {param['options']}"
 
     if param["type"] == "end-value-match":
         if value.strip().upper().endswith(tuple(param["options"])):
@@ -70,7 +70,7 @@ def _validate_parameter(param, value):  # noqa: C901, PLR0911, PLR0912
 
         return (
             type_match_result or value_match_result,
-            f'-> Expected: Type {param["options"][0]} or Value {param["options"][1]}',
+            f"-> Expected: Type {param['options'][0]} or Value {param['options'][1]}",
         )
 
     if param["type"] == "value-range":
@@ -84,13 +84,13 @@ def _validate_parameter(param, value):  # noqa: C901, PLR0911, PLR0912
     if param["type"] == "string-length":
         return (
             len(value) <= param["max_length"],
-            f'-> Exceeds {param["max_length"]} characters',
+            f"-> Exceeds {param['max_length']} characters",
         )
 
     if param["type"] == "list-string-length":
         return (
             all(len(item) <= param["max_length"] for item in value),
-            f'-> Contains labels exceeding {param["max_length"]} characters',
+            f"-> Contains labels exceeding {param['max_length']} characters",
         )
 
     if param["type"] == "dict-match":

floodmodeller_api/version.py

@@ -1 +1 @@
-__version__ = "0.5.3.post2"
+__version__ = "0.5.5"

{floodmodeller_api-0.5.3.post2.dist-info → floodmodeller_api-0.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: floodmodeller_api
-Version: 0.5.3.post2
+Version: 0.5.5
 Summary: Extends the functionality of Flood Modeller to python users
 Author: Jacobs
 Author-email: joe.pierce@jacobs.com