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

floodmodeller_api/units/conveyance.py

@@ -72,7 +72,7 @@ def calculate_cross_section_conveyance(
             total_length = np.where(in_panel_and_section, length, 0).sum(axis=1)
             total_mannings = np.where(in_panel_and_section, mannings, 0).sum(axis=1)
 
-            with np.errstate(invalid="ignore"):
+            with np.errstate(divide="ignore", invalid="ignore"):
                 conveyance += np.where(
                     total_length >= MINIMUM_PERIMETER_THRESHOLD,
                     total_area ** (5 / 3) * total_length ** (1 / 3) / (total_mannings * rpl_panel),

floodmodeller_api/units/iic.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.
@@ -18,7 +18,7 @@ import pandas as pd
 
 from ..diff import check_item_with_dataframe_equal
 from ..to_from_json import Jsonable
-from .helpers import join_10_char, split_10_char
+from ._helpers import join_10_char, split_10_char
 
 # Initial Conditions Class
 
@@ -65,15 +65,8 @@ class IIC(Jsonable):
                     float(z),
                 ],
             )
-        # AL is this storing the values as strings?
         self.data = pd.DataFrame(data_list, columns=header)
-        # JP Yes
-        # AL If it does, would it worth making it store the values instead?
-        # JP Yes I'll do that, only downside is that the updated values may not match notation
-        #   of original even if no changes. (i.e 2.0 -> 2.00 or 2. -> 2.00)
 
-    # AL Is this only to transform the table of data into a string-like array?
-    # JP Yes it just transforms the dataframe back into valid DAT format
     def _write(self):
         ic_block = [
             "INITIAL CONDITIONS",

floodmodeller_api/units/losses.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.
@@ -14,20 +14,21 @@ If you have any query about this program or this License, please contact us at s
 address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London, SE1 2QG, United Kingdom.
 """
 
+import logging
+
 import pandas as pd
 
 from floodmodeller_api.validation import _validate_unit
 
 from ._base import Unit
-from .helpers import (
-    _to_data_list,
-    _to_float,
-    _to_int,
-    _to_str,
+from ._helpers import (
     join_10_char,
     join_n_char_ljust,
     split_10_char,
     split_n_char,
+    to_data_list,
+    to_float,
+    to_str,
 )
 
 
@@ -76,8 +77,8 @@ class CULVERT(Unit):
         """Function to read a given CULVERT block and store data as class attributes"""
 
         # Extract common attributes
-        self._subtype = block[1].split(" ")[0].strip()
-        self.comment = block[0].replace("CULVERT", "").strip()
+        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)
         self.name = labels[0]
         self.ds_label = labels[1]
@@ -91,44 +92,43 @@ class CULVERT(Unit):
 
             # Read first set of general parameters
             params = split_10_char(f"{block[3]:<60}")
-            self.k = _to_float(params[0], 0.0)
-            self.m = _to_float(params[1], 0.0)
-            self.c = _to_float(params[2], 0.0)
-            self.y = _to_float(params[3], 0.0)
-            self.ki = _to_float(params[4], 0.0)
-            self.type_code = _to_str(params[5], "A")
+            self.k = to_float(params[0], 0.0)
+            self.m = to_float(params[1], 0.0)
+            self.c = to_float(params[2], 0.0)
+            self.y = to_float(params[3], 0.0)
+            self.ki = to_float(params[4], 0.0)
+            self.type_code = to_str(params[5], "A")
 
             # Read trash screen and remaining general parameters
             params1 = split_10_char(f"{block[4]:<70}")
-            self.screen_width = _to_float(params1[0], 0.0)
-            self.bar_proportion = _to_float(params1[1], 0.0)
-            self.debris_proportion = _to_float(params1[2], 0.0)
-            self.loss_coefficient = _to_float(params1[3], 0.0)
-            self.reverse_flow_mode = _to_str(params1[4], "CALCULATED", check_float=True)
-            self.headloss_type = _to_str(params1[5], "TOTAL")
-            self.max_screen_height = _to_float(params1[6], 0.0)
+            self.screen_width = to_float(params1[0], 0.0)
+            self.bar_proportion = to_float(params1[1], 0.0)
+            self.debris_proportion = to_float(params1[2], 0.0)
+            self.loss_coefficient = to_float(params1[3], 0.0)
+            self.reverse_flow_mode = to_str(params1[4], "CALCULATED", check_float=True)
+            self.headloss_type = to_str(params1[5], "TOTAL")
+            self.max_screen_height = to_float(params1[6], 0.0)
 
         elif self.subtype == "OUTLET":
             params = split_10_char(f"{block[3]:<30}")
-            self.loss_coefficient = _to_float(params[0], 1.0)
-            self.reverse_flow_mode = _to_str(params[1], "CALCULATED")
-            self.headloss_type = _to_str(params[2], "TOTAL")
+            self.loss_coefficient = to_float(params[0], 1.0)
+            self.reverse_flow_mode = to_str(params[1], "CALCULATED")
+            self.headloss_type = to_str(params[2], "TOTAL")
 
         else:
-            # This else block is triggered for culvert subtypes which aren't yet supported, and just keeps the '_block' in it's raw state to write back.
-            print(
-                f'This Culvert sub-type: "{self.subtype}" is currently unsupported for reading/editing',
+            # This else block is triggered for culvert subtypes which aren't yet supported, and just keeps the '_block' in its raw state to write back.
+            logging.warning(
+                "This Culvert sub-type: '%s' is currently unsupported for reading/editing",
+                self.subtype,
             )
             self._raw_block = block
 
-        # TODO: Create from blank.  Not supported currently as CULVERT has multiple subtypes
-
     def _write(self):
         """Function to write a valid CULVERT block"""
 
         _validate_unit(self)
 
-        header = "CULVERT " + self.comment
+        header = self._create_header()
         labels = join_n_char_ljust(
             self._label_len,
             self.name,
@@ -192,9 +192,7 @@ class BLOCKAGE(Unit):
         """Function to read a given BLOCKAGE block and store data as class attributes"""
 
         # Extract comment and revision number
-        b = block[0].replace("BLOCKAGE #revision#", " ").strip()
-        self._revision = _to_int(b[0], 1)
-        self.comment = b[1:].strip()
+        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)
@@ -206,25 +204,27 @@ class BLOCKAGE(Unit):
 
         # Extract inlet and outlet loss coefficients
         params = split_10_char(f"{block[2]:<20}")
-        self.inlet_loss = _to_float(params[0], 1.5)
-        self.outlet_loss = _to_float(params[1], 1.0)
+        self.inlet_loss = to_float(params[0], 1.5)
+        self.outlet_loss = to_float(params[1], 1.0)
 
         # Extract blockage timeseries parameters
         params1 = split_10_char(f"{block[3]:<40}")
         self.nrows = int(params1[0])
-        self.timeoffset = _to_float(params1[1])
+        self.timeoffset = to_float(params1[1])
 
-        self.timeunit = _to_str(params1[2], "HOURS", check_float=True)
+        self.timeunit = to_str(params1[2], "HOURS", check_float=True)
         if self.timeunit == "DATE":
-            self.timeunit = "DATES"  # Parameter value updated to 'DATES' for consistency with other unit types.  'DATE' and 'DATES' both accepted for blockage unit ONLY
+            self.timeunit = "DATES"
+            # Parameter value updated to 'DATES' for consistency with other unit types.
+            # 'DATE' and 'DATES' both accepted for blockage unit ONLY
 
-        self.extendmethod = _to_str(params1[3], "NOEXTEND")
+        self.extendmethod = to_str(params1[3], "NOEXTEND")
 
         # Extract blockage to timeseries
         data_list = (
-            _to_data_list(block[4:], num_cols=2, date_col=0)
+            to_data_list(block[4:], num_cols=2, date_col=0)
             if self.timeunit == "DATES"
-            else _to_data_list(block[4:], num_cols=2)
+            else to_data_list(block[4:], num_cols=2)
         )  # Enforced two columns as Flood Modeller saves old parameters when using DATES (also to avoid extra 'HOURS' bug)
 
         self.data = pd.DataFrame(data_list, columns=["Time", "Blockage"])
@@ -238,11 +238,10 @@ class BLOCKAGE(Unit):
 
         # Custom validation for blockage percentage
         if self.data.max() > 1 or self.data.min() < 0:
-            raise ValueError(
-                f"Parameter error with {repr(self)} - blockage percentage must be between 0 and 1",
-            )
+            msg = f"Parameter error with {self!r} - blockage percentage must be between 0 and 1"
+            raise ValueError(msg)
 
-        header = f"BLOCKAGE #revision#{self._revision} {self.comment}"
+        header = self._create_header(include_revision=True)
         labels = join_n_char_ljust(
             self._label_len,
             self.name,

floodmodeller_api/units/sections.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.
@@ -14,20 +14,24 @@ If you have any query about this program or this License, please contact us at s
 address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London, SE1 2QG, United Kingdom.
 """
 
+from __future__ import annotations
+
+import logging
+
 import pandas as pd
 
 from floodmodeller_api.validation import _validate_unit
 
 from ._base import Unit
-from .conveyance import calculate_cross_section_conveyance_cached
-from .helpers import (
-    _to_float,
-    _to_int,
+from ._helpers import (
     join_10_char,
     join_n_char_ljust,
     split_10_char,
     split_n_char,
+    to_float,
+    to_int,
 )
+from .conveyance import calculate_cross_section_conveyance_cached
 
 
 class RIVER(Unit):
@@ -54,7 +58,7 @@ class RIVER(Unit):
     """
 
     _unit = "RIVER"
-    _required_columns = [
+    _required_columns = (
         "X",
         "Y",
         "Mannings n",
@@ -65,7 +69,7 @@ class RIVER(Unit):
         "Northing",
         "Deactivation",
         "SP. Marker",
-    ]
+    )
 
     def _create_from_blank(  # noqa: PLR0913
         self,
@@ -100,24 +104,18 @@ class RIVER(Unit):
         }.items():
             setattr(self, param, val)
 
-        self._data = (
-            data
-            if isinstance(data, pd.DataFrame)
-            else pd.DataFrame(
-                [],
-                columns=self._required_columns,
-            )
-        )
+        self._data = self._enforce_dataframe(data, self._required_columns)
         self._active_data = None
 
     def _read(self, riv_block):
         """Function to read a given RIVER block and store data as class attributes."""
 
         self._subtype = riv_block[1].split(" ")[0].strip()
+        # Extends label line to be correct length before splitting to pick up blank labels
+        labels = split_n_char(f"{riv_block[2]:<{7*self._label_len}}", self._label_len)
+
         # Only supporting 'SECTION' subtype for now
         if self.subtype == "SECTION":
-            # Extends label line to be correct length before splitting to pick up blank labels
-            labels = split_n_char(f"{riv_block[2]:<{7*self._label_len}}", self._label_len)
             self.name = labels[0]
             self.spill1 = labels[1]
             self.spill2 = labels[2]
@@ -125,19 +123,19 @@ class RIVER(Unit):
             self.lat2 = labels[4]
             self.lat3 = labels[5]
             self.lat4 = labels[6]
-            self.comment = riv_block[0].replace("RIVER", "").strip()
+            self.comment = self._remove_unit_name(riv_block[0])
 
             params = split_10_char(f"{riv_block[3]:<40}")
-            self.dist_to_next = _to_float(params[0])
-            self.slope = _to_float(params[2], 0.0001)
-            self.density = _to_float(params[3], 1000.0)
+            self.dist_to_next = to_float(params[0])
+            self.slope = to_float(params[2], 0.0001)
+            self.density = to_float(params[3], 1000.0)
             self.nrows = int(split_10_char(riv_block[4])[0])
             data_list = []
             for row in riv_block[5:]:
                 row_split = split_10_char(f"{row:<100}")
-                x = _to_float(row_split[0])  # chainage
-                y = _to_float(row_split[1])  # elevation
-                n = _to_float(row_split[2])  # Mannings
+                x = to_float(row_split[0])  # chainage
+                y = to_float(row_split[1])  # elevation
+                n = to_float(row_split[2])  # Mannings
                 try:
                     # panel marker
                     panel = row_split[3][0] == "*"
@@ -146,15 +144,15 @@ class RIVER(Unit):
 
                 try:
                     # relative path length
-                    rpl = _to_float(row_split[3][1 if panel else 0 :].strip())
+                    rpl = to_float(row_split[3][1 if panel else 0 :].strip())
                 except IndexError:
                     rpl = 0.000
                 marker = row_split[4]  # Marker
-                easting = _to_float(row_split[5])  # easting
-                northing = _to_float(row_split[6])  # northing
+                easting = to_float(row_split[5])  # easting
+                northing = to_float(row_split[6])  # northing
 
                 deactivation = row_split[7]  # deactivation marker
-                sp_marker = _to_int(row_split[8])  # special marker
+                sp_marker = to_int(row_split[8])  # special marker
                 data_list.append(
                     [
                         x,
@@ -176,11 +174,14 @@ class RIVER(Unit):
 
         else:
             # This else block is triggered for river subtypes which aren't yet supported, and just keeps the 'riv_block' in it's raw state to write back.
-            print(
-                f'This River sub-type: "{self.subtype}" is currently unsupported for reading/editing',
+            logging.warning(
+                "This River sub-type: '%s' is currently unsupported for reading/editing",
+                self.subtype,
             )
             self._raw_block = riv_block
             self.name = riv_block[2][: self._label_len].strip()
+            self.dist_to_next = to_float(riv_block[3][:10])
+            self.labels = labels
 
         self._active_data = None
 
@@ -190,7 +191,7 @@ class RIVER(Unit):
         if self.subtype == "SECTION":
             # Function to check the params are valid for RIVER SECTION unit
             _validate_unit(self)
-            header = "RIVER " + self.comment
+            header = self._create_header()
             labels = join_n_char_ljust(
                 self._label_len,
                 self.name,
@@ -204,7 +205,7 @@ class RIVER(Unit):
             # Manual so slope can have more sf
             params = f'{self.dist_to_next:>10.3f}{"":>10}{self.slope:>10.6f}{self.density:>10.3f}'
             self.nrows = len(self._data)
-            riv_block = [header, self.subtype, labels, params, f"{str(self.nrows):>10}"]
+            riv_block = [header, self.subtype, labels, params, f"{self.nrows!s:>10}"]
 
             riv_data = []
             for (
@@ -257,11 +258,11 @@ class RIVER(Unit):
     @data.setter
     def data(self, new_df: pd.DataFrame) -> None:
         if not isinstance(new_df, pd.DataFrame):
-            raise ValueError(
-                "The updated data table for a cross section must be a pandas DataFrame.",
-            )
+            msg = "The updated data table for a cross section must be a pandas DataFrame."
+            raise ValueError(msg)
         if list(map(str.lower, new_df.columns)) != list(map(str.lower, self._required_columns)):
-            raise ValueError(f"The DataFrame must only contain columns: {self._required_columns}")
+            msg = f"The DataFrame must only contain columns: {self._required_columns}"
+            raise ValueError(msg)
         self._data = new_df
 
     @property
@@ -325,11 +326,11 @@ class RIVER(Unit):
     @active_data.setter
     def active_data(self, new_df: pd.DataFrame) -> None:
         if not isinstance(new_df, pd.DataFrame):
-            raise ValueError(
-                "The updated data table for a cross section must be a pandas DataFrame.",
-            )
+            msg = "The updated data table for a cross section must be a pandas DataFrame."
+            raise ValueError(msg)
         if new_df.columns.to_list() != self._required_columns:
-            raise ValueError(f"The DataFrame must only contain columns: {self._required_columns}")
+            msg = f"The DataFrame must only contain columns: {self._required_columns}"
+            raise ValueError(msg)
 
         # Ensure activation markers are present
         new_df = new_df.copy()
@@ -380,19 +381,19 @@ class INTERPOLATE(Unit):
         self.lat2 = labels[4]
         self.lat3 = labels[5]
         self.lat4 = labels[6]
-        self.comment = block[0].replace("INTERPOLATE", "").strip()
+        self.comment = self._remove_unit_name(block[0])
 
         # First parameter line
         params1 = split_10_char(f"{block[2]:<30}")
-        self.dist_to_next = _to_float(params1[0])
-        self.easting = _to_float(params1[1])
-        self.northing = _to_float(params1[2])
+        self.dist_to_next = to_float(params1[0])
+        self.easting = to_float(params1[1])
+        self.northing = to_float(params1[2])
 
     def _write(self):
         """Function to write a valid INTERPOLATE block"""
 
         _validate_unit(self)
-        header = "INTERPOLATE " + self.comment
+        header = self._create_header()
         labels = join_n_char_ljust(
             self._label_len,
             self.name,
@@ -476,20 +477,20 @@ class REPLICATE(Unit):
         self.lat3 = labels[5]
         self.lat4 = labels[6]
 
-        self.comment = block[0].replace("REPLICATE", "").strip()
+        self.comment = self._remove_unit_name(block[0])
 
         # First parameter line
         params1 = split_10_char(f"{block[2]:<40}")
-        self.dist_to_next = _to_float(params1[0])
-        self.bed_level_drop = _to_float(params1[1])
-        self.easting = _to_float(params1[2])
-        self.northing = _to_float(params1[3])
+        self.dist_to_next = to_float(params1[0])
+        self.bed_level_drop = to_float(params1[1])
+        self.easting = to_float(params1[2])
+        self.northing = to_float(params1[3])
 
     def _write(self):
         """Function to write a valid REPLICATE block"""
 
         _validate_unit(self)
-        header = "REPLICATE " + self.comment
+        header = self._create_header()
         labels = join_n_char_ljust(
             self._label_len,
             self.name,