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

floodmodeller_api/dat.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.
@@ -16,13 +16,14 @@ address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London
 
 from __future__ import annotations
 
+from collections import defaultdict
 from pathlib import Path
 from typing import Any
 
 from . import units
 from ._base import FMFile
 from .units._base import Unit
-from .units.helpers import _to_float, _to_int
+from .units._helpers import join_10_char, split_10_char, to_float, to_int
 from .util import handle_exception
 from .validation.validation import _validate_unit
 
@@ -110,8 +111,6 @@ class DAT(FMFile):
         """
         self._diff(other, force_print=force_print)
 
-    # def _get_unit_from_connectivity(self, method) #use this as method prev and next
-
     @handle_exception(when="calculate next unit in")
     def next(self, unit: Unit) -> Unit | list[Unit] | None:
         """Finds next unit in the reach.
@@ -189,7 +188,7 @@ class DAT(FMFile):
         _junction_match = [
             junction
             for junction in self._all_units
-            if junction._unit == "JUNCTION" and unit.name in junction.labels
+            if junction._unit == "JUNCTION" and unit.name in junction.labels  # type: ignore
         ]
 
         # Case 2: Previous unit has positive distance to next
@@ -253,13 +252,11 @@ class DAT(FMFile):
             Union[Unit, list[Unit], None]: Either a singular unit or list of units with ds_label matching, if none exist returns none.
         """
 
-        _ds_list = []
-        for item in self._all_units:
-            try:
-                if item.ds_label == current_unit.name:
-                    _ds_list.append(item)
-            except AttributeError:
-                continue
+        _ds_list = [
+            item
+            for item in self._all_units
+            if hasattr(item, "ds_label") and item.ds_label == current_unit.name
+        ]
 
         if len(_ds_list) == 0:
             return None
@@ -294,8 +291,8 @@ class DAT(FMFile):
 
     def _read(self) -> None:
         # Read DAT data
-        with open(self._filepath) as dat_file:
-            self._raw_data: list[str] = [line.rstrip("\n") for line in dat_file.readlines()]
+        with open(self._filepath, encoding=self.ENCODING) as dat_file:
+            self._raw_data: list[str] = [line.rstrip("\n") for line in dat_file]
 
         # Generate DAT structure
         self._update_dat_struct()
@@ -354,33 +351,33 @@ class DAT(FMFile):
         self.title = self._raw_data[0]
         self.general_parameters = {}
         line = f"{self._raw_data[2]:<70}"
-        params = units.helpers.split_10_char(line)
+        params = split_10_char(line)
         if params[6] == "":
             # Adds the measurements unit as DEFAULT if not specified
             params[6] = "DEFAULT"
         line = f"{self._raw_data[3]:<70}"
-        params.extend(units.helpers.split_10_char(line))
-
-        self.general_parameters["Node Count"] = _to_int(params[0], 0)
-        self.general_parameters["Lower Froude"] = _to_float(params[1], 0.75)
-        self.general_parameters["Upper Froude"] = _to_float(params[2], 0.9)
-        self.general_parameters["Min Depth"] = _to_float(params[3], 0.1)
-        self.general_parameters["Convergence Direct"] = _to_float(params[4], 0.001)
-        self._label_len = _to_int(params[5], 12)  # label length
+        params.extend(split_10_char(line))
+
+        self.general_parameters["Node Count"] = to_int(params[0], 0)
+        self.general_parameters["Lower Froude"] = to_float(params[1], 0.75)
+        self.general_parameters["Upper Froude"] = to_float(params[2], 0.9)
+        self.general_parameters["Min Depth"] = to_float(params[3], 0.1)
+        self.general_parameters["Convergence Direct"] = to_float(params[4], 0.001)
+        self._label_len = to_int(params[5], 12)  # label length
         self.general_parameters["Units"] = params[6]  # "DEFAULT" set during read above.
-        self.general_parameters["Water Temperature"] = _to_float(params[7], 10.0)
-        self.general_parameters["Convergence Flow"] = _to_float(params[8], 0.01)
-        self.general_parameters["Convergence Head"] = _to_float(params[9], 0.01)
-        self.general_parameters["Mathematical Damping"] = _to_float(params[10], 0.7)
-        self.general_parameters["Pivotal Choice"] = _to_float(params[11], 0.1)
-        self.general_parameters["Under-relaxation"] = _to_float(params[12], 0.7)
-        self.general_parameters["Matrix Dummy"] = _to_float(params[13], 0.0)
+        self.general_parameters["Water Temperature"] = to_float(params[7], 10.0)
+        self.general_parameters["Convergence Flow"] = to_float(params[8], 0.01)
+        self.general_parameters["Convergence Head"] = to_float(params[9], 0.01)
+        self.general_parameters["Mathematical Damping"] = to_float(params[10], 0.7)
+        self.general_parameters["Pivotal Choice"] = to_float(params[11], 0.1)
+        self.general_parameters["Under-relaxation"] = to_float(params[12], 0.7)
+        self.general_parameters["Matrix Dummy"] = to_float(params[13], 0.0)
         self.general_parameters["RAD File"] = self._raw_data[5]  # No default, optional
 
     def _update_general_parameters(self) -> None:
         self._raw_data[0] = self.title
         self._raw_data[5] = self.general_parameters["RAD File"]
-        general_params_1 = units.helpers.join_10_char(
+        general_params_1 = join_10_char(
             self.general_parameters["Node Count"],
             self.general_parameters["Lower Froude"],
             self.general_parameters["Upper Froude"],
@@ -391,7 +388,7 @@ class DAT(FMFile):
         general_params_1 += self.general_parameters["Units"]
         self._raw_data[2] = general_params_1
 
-        general_params_2 = units.helpers.join_10_char(
+        general_params_2 = join_10_char(
             self.general_parameters["Water Temperature"],
             self.general_parameters["Convergence Flow"],
             self.general_parameters["Convergence Head"],
@@ -409,21 +406,19 @@ class DAT(FMFile):
             (self.structures, "structures"),
             (self.conduits, "conduits"),
             (self.losses, "losses"),
+            (self.connectors, "connectors"),
+            (self.controls, "controls"),
         ]:
             for name, unit in unit_group.copy().items():
                 if name != unit.name:
                     # Check if new name already exists as a label
                     if unit.name in unit_group:
-                        raise Exception(
-                            f'Error: Cannot update label "{name}" to "{unit.name}" because "{unit.name}" already exists in the Network {unit_group_name} group',
-                        )
+                        msg = f'Error: Cannot update label "{name}" to "{unit.name}" because "{unit.name}" already exists in the Network {unit_group_name} group'
+                        raise Exception(msg)
                     unit_group[unit.name] = unit
                     del unit_group[name]
                     # Update label in ICs
                     if unit_group_name not in ["boundaries", "losses"]:
-                        # TODO: Need to do a more thorough check for whether a unit is one in the ICs
-                        # e.g. Culvert inlet and river section may have same label, but only river
-                        # section label should update in ICs
                         self.initial_conditions.update_label(name, unit.name)
 
                     # Update label in GISINFO and GXY data
@@ -456,66 +451,65 @@ class DAT(FMFile):
             "sections": [],
             "conduits": [],
             "losses": [],
+            "connectors": [],
+            "controls": [],
         }
 
         for block in self._dat_struct:
             # Check for all supported boundary types
-            if block["Type"] in units.SUPPORTED_UNIT_TYPES:
-                # clause for when unit has been inserted into the dat file
-                if "new_insert" in block:
-                    block["start"] = prev_block_end + 1
-                    block["end"] = block["start"] + len(block["new_insert"]) - 1
-                    self._raw_data[block["start"] : block["start"]] = block["new_insert"]
-                    block_shift += len(block["new_insert"])
-                    prev_block_end = block["end"]
-                    del block["new_insert"]
+            if block["Type"] not in units.SUPPORTED_UNIT_TYPES:
+                continue
+            # clause for when unit has been inserted into the dat file
+            if "new_insert" in block:
+                block["start"] = prev_block_end + 1
+                block["end"] = block["start"] + len(block["new_insert"]) - 1
+                self._raw_data[block["start"] : block["start"]] = block["new_insert"]
+                block_shift += len(block["new_insert"])
+                prev_block_end = block["end"]
+                del block["new_insert"]
 
-                else:
-                    unit_data = self._raw_data[
-                        block["start"] + block_shift : block["end"] + 1 + block_shift
-                    ]
-                    prev_block_len = len(unit_data)
+            else:
+                unit_data = self._raw_data[
+                    block["start"] + block_shift : block["end"] + 1 + block_shift
+                ]
+                prev_block_len = len(unit_data)
 
-                    if block["Type"] == "INITIAL CONDITIONS":
-                        new_unit_data = self.initial_conditions._write()
-                    elif block["Type"] == "COMMENT":
-                        comment = comment_units[comment_tracker]
-                        new_unit_data = comment._write()
-                        comment_tracker += 1
+                if block["Type"] == "INITIAL CONDITIONS":
+                    new_unit_data = self.initial_conditions._write()
+                elif block["Type"] == "COMMENT":
+                    comment = comment_units[comment_tracker]
+                    new_unit_data = comment._write()
+                    comment_tracker += 1
 
-                    elif block["Type"] == "VARIABLES":
-                        new_unit_data = self.variables._write()
+                elif block["Type"] == "VARIABLES":
+                    new_unit_data = self.variables._write()
 
+                else:
+                    if units.SUPPORTED_UNIT_TYPES[block["Type"]]["has_subtype"]:
+                        unit_name = unit_data[2][: self._label_len].strip()
                     else:
-                        if units.SUPPORTED_UNIT_TYPES[block["Type"]]["has_subtype"]:
-                            unit_name = unit_data[2][: self._label_len].strip()
-                        else:
-                            unit_name = unit_data[1][: self._label_len].strip()
-
-                        # Get unit object
-                        unit_group = getattr(
-                            self,
-                            units.SUPPORTED_UNIT_TYPES[block["Type"]]["group"],
-                        )
-                        if unit_name in unit_group:
-                            # block still exists
-                            new_unit_data = unit_group[unit_name]._write()
-                            existing_units[
-                                units.SUPPORTED_UNIT_TYPES[block["Type"]]["group"]
-                            ].append(unit_name)
-                        else:
-                            # Bdy block has been deleted
-                            new_unit_data = []
-
-                    new_block_len = len(new_unit_data)
-                    self._raw_data[
-                        block["start"] + block_shift : block["end"] + 1 + block_shift
-                    ] = new_unit_data
-                    # adjust block shift for change in number of lines in bdy block
-                    block_shift += new_block_len - prev_block_len
-                    prev_block_end = (
-                        block["end"] + block_shift
-                    )  # add in to keep a record of the last block read in
+                        unit_name = unit_data[1][: self._label_len].strip()
+
+                    # Get unit object
+                    unit_group_str = units.SUPPORTED_UNIT_TYPES[block["Type"]]["group"]
+                    unit_group = getattr(self, unit_group_str)
+                    if unit_name in unit_group:
+                        # block still exists
+                        new_unit_data = unit_group[unit_name]._write()
+                        existing_units[unit_group_str].append(unit_name)
+                    else:
+                        # Bdy block has been deleted
+                        new_unit_data = []
+
+                new_block_len = len(new_unit_data)
+                self._raw_data[block["start"] + block_shift : block["end"] + 1 + block_shift] = (
+                    new_unit_data
+                )
+                # adjust block shift for change in number of lines in bdy block
+                block_shift += new_block_len - prev_block_len
+                prev_block_end = (
+                    block["end"] + block_shift
+                )  # add in to keep a record of the last block read in
 
     def _get_unit_definitions(self):
         self._initialize_collections()
@@ -528,19 +522,22 @@ class DAT(FMFile):
             elif unit_type in units.UNSUPPORTED_UNIT_TYPES:
                 self._process_unsupported_unit(unit_type, unit_data)
             elif unit_type not in ("GENERAL", "GISINFO"):
-                raise Exception(f"Unexpected unit type encountered: {unit_type}")
+                msg = f"Unexpected unit type encountered: {unit_type}"
+                raise Exception(msg)
 
-    def _initialize_collections(self):
+    def _initialize_collections(self) -> None:
         # Initialize unit collections
-        self.sections = {}
-        self.boundaries = {}
-        self.structures = {}
-        self.conduits = {}
-        self.losses = {}
-        self._unsupported = {}
-        self._all_units = []
-
-    def _process_supported_unit(self, unit_type, unit_data):
+        self.sections: dict[str, units.TSections] = {}
+        self.boundaries: dict[str, units.TBoundaries] = {}
+        self.structures: dict[str, units.TStructures] = {}
+        self.conduits: dict[str, units.TConduits] = {}
+        self.losses: dict[str, units.TLosses] = {}
+        self.connectors: dict[str, units.TConnectors] = {}
+        self.controls: dict[str, units.TControls] = {}
+        self._unsupported: dict[str, units.TUnsupported] = {}
+        self._all_units: list[Unit] = []
+
+    def _process_supported_unit(self, unit_type, unit_data) -> None:
         # Handle initial conditions block
         if unit_type == "INITIAL CONDITIONS":
             self.initial_conditions = units.IIC(unit_data, n=self._label_len)
@@ -561,12 +558,17 @@ class DAT(FMFile):
             return unit_data[2][: self._label_len].strip()
         return unit_data[1][: self._label_len].strip()
 
-    def _add_unit_to_group(self, unit_group, unit_type, unit_name, unit_data):
+    def _add_unit_to_group(
+        self,
+        unit_group,
+        unit_type: str,
+        unit_name: str,
+        unit_data: list[str],
+    ) -> None:
         # Raise exception if a duplicate label is encountered
         if unit_name in unit_group:
-            raise Exception(
-                f'Duplicate label ({unit_name}) encountered within category: {units.SUPPORTED_UNIT_TYPES[unit_type]["group"]}',
-            )
+            msg = f'Duplicate label ({unit_name}) encountered within category: {units.SUPPORTED_UNIT_TYPES[unit_type]["group"]}'
+            raise Exception(msg)
         # Changes done to account for unit types with spaces/dashes eg Flat-V Weir
         unit_type_safe = unit_type.replace(" ", "_").replace("-", "_")
         unit_group[unit_name] = eval(
@@ -574,7 +576,7 @@ class DAT(FMFile):
         )
         self._all_units.append(unit_group[unit_name])
 
-    def _process_unsupported_unit(self, unit_type, unit_data):
+    def _process_unsupported_unit(self, unit_type, unit_data) -> None:
         # Check to see whether unit type has associated subtypes so that unit name can be correctly assigned
         unit_name, subtype = self._get_unsupported_unit_name(unit_type, unit_data)
         self._unsupported[f"{unit_name} ({unit_type})"] = units.UNSUPPORTED(
@@ -586,7 +588,7 @@ class DAT(FMFile):
         )
         self._all_units.append(self._unsupported[f"{unit_name} ({unit_type})"])
 
-    def _get_unsupported_unit_name(self, unit_type, unit_data):
+    def _get_unsupported_unit_name(self, unit_type: str, unit_data: list[str]) -> tuple[str, bool]:
         # Check if the unit type has associated subtypes
         if units.UNSUPPORTED_UNIT_TYPES[unit_type]["has_subtype"]:
             return unit_data[2][: self._label_len].strip(), True
@@ -720,7 +722,8 @@ class DAT(FMFile):
         """
         # catch if not valid unit
         if not isinstance(unit, Unit):
-            raise TypeError("unit isn't a unit")
+            msg = "unit isn't a unit"
+            raise TypeError(msg)
 
         # remove from all units
         index = self._all_units.index(unit)
@@ -768,17 +771,17 @@ class DAT(FMFile):
         # catch errors
         provided_params = sum(arg is not None for arg in (add_before, add_after, add_at))
         if provided_params == 0:
-            raise SyntaxError(
-                "No positional argument given. Please provide either add_before, add_at or add_after",
-            )
+            msg = "No positional argument given. Please provide either add_before, add_at or add_after"
+            raise SyntaxError(msg)
         if provided_params > 1:
-            raise SyntaxError("Only one of add_at, add_before, or add_after required")
+            msg = "Only one of add_at, add_before, or add_after required"
+            raise SyntaxError(msg)
         if not isinstance(unit, Unit):
-            raise TypeError("unit isn't a unit")
+            msg = "unit isn't a unit"
+            raise TypeError(msg)
         if add_at is None and not (isinstance(add_before, Unit) or isinstance(add_after, Unit)):
-            raise TypeError(
-                "add_before or add_after argument must be a Flood Modeller Unit type",
-            )
+            msg = "add_before or add_after argument must be a Flood Modeller Unit type"
+            raise TypeError(msg)
 
         unit_class = unit._unit
         if unit_class != "COMMENT":
@@ -786,9 +789,8 @@ class DAT(FMFile):
             unit_group_name = units.SUPPORTED_UNIT_TYPES[unit._unit]["group"]
             unit_group = getattr(self, unit_group_name)
             if unit.name in unit_group:
-                raise NameError(
-                    "Name already appears in unit group. Cannot have two units with same name in same group",
-                )
+                msg = "Name already appears in unit group. Cannot have two units with same name in same group"
+                raise NameError(msg)
 
         # positional argument
         if add_at is not None:
@@ -796,7 +798,8 @@ class DAT(FMFile):
             if insert_index < 0:
                 insert_index += len(self._all_units) + 1
                 if insert_index < 0:
-                    raise Exception(f"invalid add_at index: {add_at}")
+                    msg = f"invalid add_at index: {add_at}"
+                    raise Exception(msg)
         else:
             check_unit = add_before or add_after
             for index, thing in enumerate(self._all_units):
@@ -805,9 +808,10 @@ class DAT(FMFile):
                     insert_index += 1 if add_after else 0
                     break
             else:
-                raise Exception(
-                    f"{check_unit} not found in dat network, so cannot be used to add before/after",
+                msg = (
+                    f"{check_unit} not found in dat network, so cannot be used to add before/after"
                 )
+                raise Exception(msg)
 
         unit_data = unit._write()
         self._all_units.insert(insert_index, unit)
@@ -908,3 +912,69 @@ class DAT(FMFile):
             new = f"{unit_type}_{unit_subtype}_{new_lbl}"
 
             self._gxy_data = self._gxy_data.replace(old, new)
+
+    def get_network(self) -> tuple[list[Unit], list[tuple[Unit, Unit]]]:
+        """Generates a network representation of units and their connections.
+
+        This method creates a directed network where nodes represent units
+        and edges represent labeled connections between them. The edges are
+        directional, determined by the order of appearance in the `.dat` file.
+
+        Raises:
+            ValueError: If a unit has no name when an implicit label is assigned.
+            RuntimeError: If the constructed network contains labels that do not
+                form valid two-unit connections.
+
+        Returns:
+            tuple[list[Unit], list[tuple[Unit, Unit]]]:
+                - A list of `Unit` objects representing the nodes.
+                - A list of tuples, each containing two `Unit` objects representing
+                  a directed edge."""
+
+        # collect all relevant units and labels
+        units = [unit for unit in self._all_units if unit._unit != "COMMENT"]
+        label_lists = [list(unit.all_labels) for unit in units]
+
+        # connect units for each label
+        label_to_unit_list: dict[str, list[Unit]] = defaultdict(list)
+        for idx, (unit, label_list) in enumerate(zip(units, label_lists)):
+            in_reach = hasattr(unit, "dist_to_next") and unit.dist_to_next > 0
+            if in_reach:  # has implicit downstream labels
+                next_unit = units[idx + 1]
+                next_next_unit = units[idx + 2]
+
+                if next_unit.name is None:
+                    msg = "Unit has no name."
+                    raise ValueError(msg)
+
+                end_of_reach = (
+                    (not hasattr(next_unit, "dist_to_next"))
+                    or (next_unit.dist_to_next == 0)
+                    or (not hasattr(next_next_unit, "dist_to_next"))
+                )
+
+                if end_of_reach:
+                    renamed_label = next_unit.name + "_dummy"
+                    label_list.append(renamed_label)
+                    label_lists[idx + 1].append(renamed_label)  # why label_lists is made first
+                else:
+                    label_list.append(next_unit.name)
+
+            for label in label_list:
+                label_to_unit_list[label].append(unit)
+
+        # check validity of network
+        units_per_edge = 2
+        invalid_labels = [k for k, v in label_to_unit_list.items() if len(v) != units_per_edge]
+        no_invalid_labels = len(invalid_labels)
+        no_labels = len(label_to_unit_list)
+        if no_invalid_labels > 0:
+            msg = (
+                "Unable to create a valid network with the current algorithm and/or data."
+                f" {no_invalid_labels}/{no_labels} labels do not join two units: {invalid_labels}."
+            )
+            raise RuntimeError(msg)
+
+        # the labels themselves are no longer needed
+        unit_pairs = [(unit_pair[0], unit_pair[1]) for unit_pair in label_to_unit_list.values()]
+        return units, unit_pairs

floodmodeller_api/diff.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.
@@ -59,8 +59,8 @@ def check_item_with_dataframe_equal(  # noqa: C901, PLR0912
                 row_diffs = []
                 for row in rows:
                     for col in df_diff.columns:
-                        if True not in df_diff.loc[row, col].duplicated().values:
-                            vals = df_diff.loc[row, col].values
+                        if True not in df_diff.loc[row, col].duplicated().to_numpy():
+                            vals = df_diff.loc[row, col].to_numpy()
                             row_diffs.append(
                                 f"    Row: {row}, Col: '{col}' - left: {vals[0]}, right: {vals[1]}",
                             )
@@ -96,7 +96,7 @@ def check_dict_with_dataframe_equal(dict_a, dict_b, name, diff, special_types):
                 )
                 if not _result:
                     result = False
-            except KeyError as ke:
+            except KeyError as ke:  # noqa: PERF203
                 result = False
                 diff.append((name, f"Key: '{ke.args[0]}' missing in other"))
                 continue

floodmodeller_api/hydrology_plus/hydrology_plus_export.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.
@@ -51,7 +51,8 @@ class HydrologyPlusExport(FMFile):
         with self._filepath.open("r") as file:
             header = file.readline().strip(" ,\n\r")
             if header != "Flood Modeller Hydrology+ hydrograph file":
-                raise ValueError("Input file is not the correct format for Hydrology+ export data.")
+                msg = "Input file is not the correct format for Hydrology+ export data."
+                raise ValueError(msg)
 
         self._data_file = pd.read_csv(self._filepath)
         self._metadata = self._get_metadata()
@@ -85,20 +86,21 @@ class HydrologyPlusExport(FMFile):
             return next(col for col in self.data.columns if col.lower().startswith(event.lower()))
 
         if not (return_period and storm_duration and scenario):
-            raise ValueError(
+            msg = (
                 "Missing required inputs to find event, if no event string is passed then a "
                 "return_period, storm_duration and scenario are needed. You provided: "
-                f"{return_period=}, {storm_duration=}, {scenario=}",
+                f"{return_period=}, {storm_duration=}, {scenario=}"
             )
+            raise ValueError(msg)
         for column in self.data.columns:
             s, sd, rp, *_ = column.split(" - ")
             if s == scenario and float(sd) == storm_duration and float(rp) == return_period:
                 return column
-        else:
-            raise ValueError(
-                "No matching event was found based on "
-                f"{return_period=}, {storm_duration=}, {scenario=}",
-            )
+        msg = (
+            "No matching event was found based on "
+            f"{return_period=}, {storm_duration=}, {scenario=}"
+        )
+        raise ValueError(msg)
 
     def get_event_flow(
         self,
@@ -197,11 +199,10 @@ class HydrologyPlusExport(FMFile):
         elif isinstance(template_ief, (Path, str)):
             template_ief = IEF(template_ief)
 
-        generated_iefs = []
-        for column in self.data.columns:
-            generated_iefs.append(self.generate_ief(node_label, template_ief, event=column))
-
-        return generated_iefs
+        return [
+            self.generate_ief(node_label, template_ief, event=column)
+            for column in self.data.columns
+        ]
 
     def generate_ief(  # noqa: PLR0913
         self,

floodmodeller_api/ied.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.
@@ -60,8 +60,8 @@ class IED(FMFile):
 
     def _read(self):
         # Read IED data
-        with open(self._filepath) as ied_file:
-            self._raw_data = [line.rstrip("\n") for line in ied_file.readlines()]
+        with open(self._filepath, encoding=self.ENCODING) as ied_file:
+            self._raw_data = [line.rstrip("\n") for line in ied_file]
 
         # Generate IED structure
         self._update_ied_struct()
@@ -87,10 +87,11 @@ class IED(FMFile):
                 if name != unit.name:
                     # Check if new name already exists as a label
                     if unit.name in unit_group:
-                        raise Exception(
+                        msg = (
                             f'Error: Cannot update label "{name}" to "{unit.name}" because '
-                            f'"{unit.name}" already exists in the Network {unit_group_name} group',
+                            f'"{unit.name}" already exists in the Network {unit_group_name} group'
                         )
+                        raise Exception(msg)
                     unit_group[unit.name] = unit
                     del unit_group[name]
 
@@ -180,9 +181,8 @@ class IED(FMFile):
                 # Create instance of unit and add to relevant group
                 unit_group = getattr(self, units.SUPPORTED_UNIT_TYPES[block["Type"]]["group"])
                 if unit_name in unit_group:
-                    raise Exception(
-                        f'Duplicate label ({unit_name}) encountered within category: {units.SUPPORTED_UNIT_TYPES[block["Type"]]["group"]}',
-                    )
+                    msg = f'Duplicate label ({unit_name}) encountered within category: {units.SUPPORTED_UNIT_TYPES[block["Type"]]["group"]}'
+                    raise Exception(msg)
                 unit_group[unit_name] = eval(f'units.{block["Type"]}({unit_data})')
 
                 self._all_units.append(unit_group[unit_name])
@@ -206,8 +206,6 @@ class IED(FMFile):
                 )
                 self._all_units.append(self._unsupported[f"{unit_name} ({block['Type']})"])
 
-        print()
-
     def _update_ied_struct(self):  # noqa: C901, PLR0912
         # Generate IED structure
         ied_struct = []