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

floodmodeller_api/units/units.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,16 +14,23 @@ 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
+
 from typing import TypedDict
 
 
-class UnitTypes(TypedDict):
+class SupportedUnitTypes(TypedDict):
     group: str
     has_subtype: bool
 
 
+class UnsupportedUnitTypes(TypedDict):
+    group: str | None
+    has_subtype: bool
+
+
 # Unit types and support
-SUPPORTED_UNIT_TYPES: dict[str, UnitTypes] = {
+SUPPORTED_UNIT_TYPES: dict[str, SupportedUnitTypes] = {
     "QTBDY": {"group": "boundaries", "has_subtype": False},
     "HTBDY": {"group": "boundaries", "has_subtype": False},
     "QHBDY": {"group": "boundaries", "has_subtype": False},
@@ -46,45 +53,39 @@ SUPPORTED_UNIT_TYPES: dict[str, UnitTypes] = {
     "REPLICATE": {"group": "sections", "has_subtype": False},
     "OUTFALL": {"group": "structures", "has_subtype": True},
     "COMMENT": {"group": "comments", "has_subtype": False},
+    "JUNCTION": {"group": "connectors", "has_subtype": True},
+    "LATERAL": {"group": "connectors", "has_subtype": False},
+    "RESERVOIR": {"group": "controls", "has_subtype": False},
 }
 
-UNSUPPORTED_UNIT_TYPES = {
-    "ABSTRACTION": {"has_subtype": False},
-    "BERNOULLI": {"has_subtype": False},
-    "BREACH": {"has_subtype": False},  # breach
+UNSUPPORTED_UNIT_TYPES: dict[str, UnsupportedUnitTypes] = {
+    "ABSTRACTION": {"group": None, "has_subtype": False},
+    "BERNOULLI": {"group": None, "has_subtype": False},
+    "BREACH": {"group": None, "has_subtype": False},  # breach
     "FEHBDY": {"group": "boundaries", "has_subtype": False},  # RAINFALL RUNOFF METHOD boundary
-    "FLOOD RELIEF": {"has_subtype": True},  # found in dat file
+    "FLOOD RELIEF": {"group": None, "has_subtype": True},  # found in dat file
     "FLOOD RELIEF ARCH": {"group": "structures", "has_subtype": True},  # found in FM help
-    "FLOODPLAIN": {"has_subtype": True},  # floodplain section culvert
+    "FLOODPLAIN": {"group": None, "has_subtype": True},  # floodplain section culvert
     "FRQSIM": {"group": "boundaries", "has_subtype": False},  # flood FReQuency SIMulation
-    "FSRBDY": {
-        "group": "boundaries",
-        "has_subtype": False,
-    },  # FEH Method (FEH Rainfall Runoff Method)
+    "FSRBDY": {"group": "boundaries", "has_subtype": False},  # FEH Rainfall Runoff Method
     "FSSR16BDY": {"group": "boundaries", "has_subtype": False},  # FSSR16 Method
     "GATED WEIR": {"group": "structures", "has_subtype": False},  # gated weir
-    "GAUGE": {"has_subtype": False},  # Gauge
+    "GAUGE": {"group": None, "has_subtype": False},  # Gauge
     "GERRBDY": {"group": "boundaries", "has_subtype": False},  # gen rainfall runoff
     "INVERTED SYPHON": {"group": "structures", "has_subtype": True},  # invert syphon
-    "JUNCTION": {"has_subtype": True},  # [connector]
     "LABYRINTH WEIR": {"group": "structures", "has_subtype": False},  # labyrinth weir
-    "LATERAL": {"has_subtype": False},  # [connector]
-    "LOSS": {"has_subtype": False},  # found in .dat
-    "LOSSID": {"has_subtype": False},  # found in .dat
-    "MANHOLE": {"has_subtype": False},  # Manhole [connector]
+    "LOSS": {"group": None, "has_subtype": False},  # found in .dat
+    "LOSSID": {"group": None, "has_subtype": False},  # found in .dat
+    "MANHOLE": {"group": None, "has_subtype": False},  # Manhole [connector]
     "NCDBDY": {"group": "boundaries", "has_subtype": False},  # Normal/Critical Depth Boundary
     "NOTWEIR": {"group": "structures", "has_subtype": False},  # Notional Weir
-    "OCPUMP": {"has_subtype": False},  # pump [junctions]
-    "POND": {"has_subtype": True},  # Pond units, online pond etc [connector]
+    "OCPUMP": {"group": None, "has_subtype": False},  # pump [junctions]
+    "POND": {"group": None, "has_subtype": True},  # Pond units, online pond etc [connector]
     "QH CONTROL": {"group": "structures", "has_subtype": False},  # Flow-head control weir
     "QRATING": {"group": "boundaries", "has_subtype": False},  # Rating Curves
     "REBDY": {"group": "boundaries", "has_subtype": False},  # Rainfall/Evaporation Boundary
     "REFH2BDY": {"group": "boundaries", "has_subtype": False},  # ReFH2 Method
-    "RESERVOIR": {"has_subtype": False},  # reservoir unit [connector]
-    "SCSBDY": {
-        "group": "boundaries",
-        "has_subtype": False,
-    },  # US SCS Method now SS for rainfall/runoff
+    "SCSBDY": {"group": "boundaries", "has_subtype": False},  # US SCS now SS for rainfall/runoff
     "SCWEIR": {"group": "structures", "has_subtype": False},  # sharp crested weir
     "SYPHON": {"group": "structures", "has_subtype": False},  # syphon unit
     "TIDBDY": {"group": "boundaries", "has_subtype": False},  # tidal

floodmodeller_api/units/unsupported.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.
@@ -15,7 +15,7 @@ address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London
 """
 
 from ._base import Unit
-from .helpers import split_n_char
+from ._helpers import split_n_char
 
 
 class UNSUPPORTED(Unit):
@@ -26,18 +26,16 @@ class UNSUPPORTED(Unit):
         self._unit = unit_type
         self._subtype = subtype
         self._raw_block = block
-        self.comment = block[0].replace(self._unit, "").strip()
+        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)
 
         else:
-            self._subtype = block[1].split(" ")[0].strip()
-            if self._unit == "JUNCTION":
-                self.labels = split_n_char(block[2], self._label_len)
+            self._subtype = self._get_first_word(block[1])
             self.labels = split_n_char(f"{block[2]:<{2*self._label_len}}", self._label_len)
 
-        if self.labels[1] != "" and self._unit != "JUNCTION":
+        if self.labels[1] != "":
             self.ds_label = self.labels[1]
 
     def _write(self):

floodmodeller_api/units/variables.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
+from ._helpers import join_10_char
 
 
 class Variables(Jsonable):

floodmodeller_api/urban1d/_base.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,6 +18,8 @@ from __future__ import annotations
 
 """ Holds the base unit class for all FM 1D units Units """
 
+import logging
+
 from ..diff import check_item_with_dataframe_equal
 from ..to_from_json import Jsonable
 
@@ -32,7 +34,6 @@ class UrbanUnit(Jsonable):
             return
         if unit_block is not None:
             self._read(unit_block)
-            # TODO: add functionality to read description
         else:
             self._create_from_blank(**kwargs)
 
@@ -51,9 +52,8 @@ class UrbanUnit(Jsonable):
         return None
 
     def _create_from_blank(self):
-        raise NotImplementedError(
-            f"Creating new {self._unit} units is not yet supported by floodmodeller_api, only existing units can be read",
-        )
+        msg = f"Creating new {self._unit} units is not yet supported by floodmodeller_api, only existing units can be read"
+        raise NotImplementedError(msg)
 
     def __str__(self):
         return self._write()
@@ -67,9 +67,9 @@ class UrbanUnit(Jsonable):
     def _diff(self, other):
         diff = self._get_diff(other)
         if diff[0]:
-            print("No difference, units are equivalent")
+            logging.info("No difference, units are equivalent")
         else:
-            print("\n".join([f"{name}:  {reason}" for name, reason in diff[1]]))
+            logging.info("\n".join([f"{name}:  {reason}" for name, reason in diff[1]]))
 
     def _get_diff(self, other):
         return self.__eq__(other, return_diff=True)  # pylint: disable=unnecessary-dunder-call
@@ -110,9 +110,8 @@ class UrbanSubsection(Jsonable):
         return f"<floodmodeller_api UrbanSubsection Class: {self._attribute}>"
 
     def _create_from_blank(self):
-        raise NotImplementedError(
-            f"Creating new {self._name} subsections is not yet supported by floodmodeller_api, only existing subsections can be read",
-        )
+        msg = f"Creating new {self._name} subsections is not yet supported by floodmodeller_api, only existing subsections can be read"
+        raise NotImplementedError(msg)
 
     def __str__(self):
         return "\n".join(self._write())
@@ -155,23 +154,20 @@ class UrbanSubsection(Jsonable):
                 # Miss-match found
                 # check that it is not an existing label in units
                 if unit.name in units:
-                    raise Exception(
-                        f'Error: Cannot update label "{name}" to "{unit.name}" beacuase "{unit.name}" already exists in the {self._attribute} subsection',
-                    )
+                    msg = f'Error: Cannot update label "{name}" to "{unit.name}" beacuase "{unit.name}" already exists in the {self._attribute} subsection'
+                    raise Exception(msg)
 
                 units[unit.name] = unit
                 del units[name]
 
-                # TODO: update label in any other units where required.
-
         return block
 
     def _diff(self, other):
         diff = self._get_diff(other)
         if diff[0]:
-            print("No difference, units are equivalent")
+            logging.info("No difference, units are equivalent")
         else:
-            print("\n".join([f"{name}:  {reason}" for name, reason in diff[1]]))
+            logging.info("\n".join([f"{name}:  {reason}" for name, reason in diff[1]]))
 
     def _get_diff(self, other):
         return self.__eq__(other, return_diff=True)  # pylint: disable=unnecessary-dunder-call

floodmodeller_api/urban1d/conduits.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,7 +14,7 @@ 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 floodmodeller_api.units.helpers import _to_float, _to_str, join_n_char_ljust
+from floodmodeller_api.units._helpers import join_n_char_ljust, to_float, to_str
 from floodmodeller_api.validation import _validate_unit
 
 from ._base import UrbanSubsection, UrbanUnit
@@ -44,37 +44,27 @@ class CONDUIT(UrbanUnit):
     def _read(self, line):
         """Function to read a given CONDUIT line and store data as class attributes"""
 
-        # TODO: add functionality to read comments
-        # TODO: considering raising an exception if any of the required parameters are missing
-
         unit_data = line.split()  # Get unit parameters
 
         # Extend length of unit_data if options variables not provided.
         while len(unit_data) < self.MIN_LENGTH:
             unit_data.append("")
 
-        # TODO: Update defaults.  Presently atrbitary defaults added to allow API to work.
-        # TODO: Consider re-naming variables to more intuitive names.  Currently as as per SWMM manual
-
-        self.name = _to_str(unit_data[0], "")
-        self.node1 = _to_str(unit_data[1], "")
-        self.node2 = _to_str(unit_data[2], "")
-        self.length = _to_float(unit_data[3], 0.0)
-        self.n = _to_float(unit_data[4], 0.0)
-        self.z1 = _to_float(unit_data[5], 0.0)
-        self.z2 = _to_float(unit_data[6], 0.0)
-        self.q0 = _to_float(unit_data[7], 0.0)  # Default as per FM
-        self.qmax = _to_float(unit_data[8], 999999)  # No limit
-
-        # TODO: Consider linkage with other associated subsections i.e. [XSECTIONS] and [LOSSES]
+        self.name = to_str(unit_data[0], "")
+        self.node1 = to_str(unit_data[1], "")
+        self.node2 = to_str(unit_data[2], "")
+        self.length = to_float(unit_data[3], 0.0)
+        self.n = to_float(unit_data[4], 0.0)
+        self.z1 = to_float(unit_data[5], 0.0)
+        self.z2 = to_float(unit_data[6], 0.0)
+        self.q0 = to_float(unit_data[7], 0.0)  # Default as per FM
+        self.qmax = to_float(unit_data[8], 999999)  # No limit
 
     def _write(self):
         """Function to write a valid CONDUIT line"""
 
         _validate_unit(self, urban=True)
 
-        # TODO:Improve indentation format when writing and include header for completeness
-
         return join_n_char_ljust(17, self.name, self.node1, self.node2) + join_n_char_ljust(
             15,
             self.length,

floodmodeller_api/urban1d/general_parameters.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.

floodmodeller_api/urban1d/junctions.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,7 +14,7 @@ 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 floodmodeller_api.units.helpers import _to_float, join_n_char_ljust
+from floodmodeller_api.units._helpers import join_n_char_ljust, to_float
 from floodmodeller_api.validation import _validate_unit
 
 from ._base import UrbanSubsection, UrbanUnit
@@ -41,8 +41,6 @@ class JUNCTION(UrbanUnit):
     def _read(self, line):
         """Function to read a given JUNCTION line and store data as class attributes"""
 
-        # TODO: add functionality to read comments
-
         unit_data = line.split()  # Get unit parameters
 
         # Extend length of unit_data if options variables not provided.
@@ -51,19 +49,17 @@ class JUNCTION(UrbanUnit):
 
         self.name = str(unit_data[0])
 
-        self.elevation = _to_float(unit_data[1], 0.0)
-        self.max_depth = _to_float(unit_data[2], 0.0)
-        self.initial_depth = _to_float(unit_data[3], 0.0)
-        self.surface_depth = _to_float(unit_data[4], 0.0)
-        self.area_ponded = _to_float(unit_data[5], 0.0)
+        self.elevation = to_float(unit_data[1], 0.0)
+        self.max_depth = to_float(unit_data[2], 0.0)
+        self.initial_depth = to_float(unit_data[3], 0.0)
+        self.surface_depth = to_float(unit_data[4], 0.0)
+        self.area_ponded = to_float(unit_data[5], 0.0)
 
     def _write(self):
         """Function to write a valid JUNCTION line"""
 
         _validate_unit(self, urban=True)
 
-        # TODO:Improve indentation format when writing and include header for completeness
-
         return join_n_char_ljust(17, self.name) + join_n_char_ljust(
             15,
             self.elevation,

floodmodeller_api/urban1d/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,7 +14,7 @@ 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 floodmodeller_api.units.helpers import _to_float, _to_str, join_n_char_ljust
+from floodmodeller_api.units._helpers import join_n_char_ljust, to_float, to_str
 from floodmodeller_api.validation import _validate_unit
 
 from ._base import UrbanSubsection, UrbanUnit
@@ -25,11 +25,11 @@ class LOSS(UrbanUnit):
 
     Args:
         name (str): Name of conduit. (required)
-        kentry (float): Entrance minor head loss coefficient. (required) # TODO: FM name - Entry Loss Coeff.
-        kexit (float): Exit minor head loss coefficient. (required) # TODO: FM name - Exit Loss Coeff.
-        kavg (float): Average minor head loss coefficient across lenght of culvert. (required) # TODO: FM name - Avg. Loss Coeff.
-        flap (str): YES/NO.  If conduit has a flat valve that prevents back flow. (optional, default NO ) # TODO: FM name - Flap Gate.
-        seepage (float): Rate of seepage loss into surrounding soil (in/hr or mm/hr). (optional, default is 0) # TODO: FM name - Seepage Loss Rate
+        kentry (float): Entrance minor head loss coefficient. (required)
+        kexit (float): Exit minor head loss coefficient. (required)
+        kavg (float): Average minor head loss coefficient across lenght of culvert. (required)
+        flap (str): YES/NO.  If conduit has a flat valve that prevents back flow. (optional, default NO )
+        seepage (float): Rate of seepage loss into surrounding soil (in/hr or mm/hr). (optional, default is 0)
 
 
     Returns:
@@ -42,28 +42,24 @@ class LOSS(UrbanUnit):
     def _read(self, line):
         """Function to read a given LOSS line and store data as class attributes"""
 
-        # TODO: add functionality to read comments
-
         unit_data = line.split()  # Get unit parameters
 
         # Extend length of unit_data if options variables not provided.
         while len(unit_data) < self.MIN_LENGTH:
             unit_data.append("")
 
-        self.name = _to_str(unit_data[0], "")
-        self.kentry = _to_float(unit_data[1], 0)
-        self.kexit = _to_float(unit_data[2], 0)
-        self.kavg = _to_float(unit_data[3], 0)
-        self.flap = _to_str(unit_data[4], "NO")
-        self.seepage = _to_float(unit_data[5], 0)
+        self.name = to_str(unit_data[0], "")
+        self.kentry = to_float(unit_data[1], 0)
+        self.kexit = to_float(unit_data[2], 0)
+        self.kavg = to_float(unit_data[3], 0)
+        self.flap = to_str(unit_data[4], "NO")
+        self.seepage = to_float(unit_data[5], 0)
 
     def _write(self):
         """Function to write a valid LOSS line"""
 
         _validate_unit(self, urban=True)
 
-        # TODO:Improve indentation format when writing and include header for completeness
-
         return join_n_char_ljust(17, self.name) + join_n_char_ljust(
             15,
             self.kentry,

floodmodeller_api/urban1d/outfalls.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,7 +14,7 @@ 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 floodmodeller_api.units.helpers import _to_float, _to_str, join_n_char_ljust
+from floodmodeller_api.units._helpers import join_n_char_ljust, to_float, to_str
 from floodmodeller_api.validation import _validate_unit
 
 from ._base import UrbanSubsection, UrbanUnit
@@ -30,25 +30,22 @@ class OUTFALL(UrbanUnit):
         stage (float): elevation of fixed stage for outfall (ft or m) (required when "FIXED" type)
         tcurve (string): name of curve in [CURVES] section containing tidal height (required when "TIDAL" type)
         tseries (string): name of timeseries in [TIMESERIES] section that describes how outfall stage varies with time (required when "TIMESERIES" type)
-        gated (sring): "YES" or "NO" depending on whether flat gate is present that prevents reverse flow. (optional for all types, default is "NO") TODO: is this required, or can it be missing
+        gated (sring): "YES" or "NO" depending on whether flat gate is present that prevents reverse flow. (optional for all types, default is "NO")
         routeto (string): Optional name of a subcatchment that recieves the outfall's discharge. (default is not be "", and to no route outfall's discharge)
 
     Returns:
-        OUTFALL: Flood Modeller OUTFALL Unit class object TODO: add urban 1d in to all instances within urban 1d API
+        OUTFALL: Flood Modeller OUTFALL Unit class object
     """
 
     _unit = "OUTFALL"
     MIN_LENGTH_FREE_NORMAL = 5
-    MIN_LENGTH_FIXED_NORMAL_TIMESERIES = 6
+    MIN_LENGTH_FIXED_TIDAL_TIMESERIES = 6
 
     def _read(self, line):
         unit_data = line.split()
 
-        # TODO: add functionality to read comments
-        # TODO: considering raising an exception if any of the required parameters are missing
-
         self.name = str(unit_data[0])
-        self.elevation = _to_float(unit_data[1], 0.0)
+        self.elevation = to_float(unit_data[1], 0.0)
         self.type = str(unit_data[2])
 
         if self.type in ("FREE", "NORMAL"):
@@ -56,33 +53,31 @@ class OUTFALL(UrbanUnit):
             while len(unit_data) < self.MIN_LENGTH_FREE_NORMAL:
                 unit_data.append("")
 
-            self.gated = _to_str(unit_data[3], "NO")
-            self.routeto = _to_str(unit_data[4], "")
+            self.gated = to_str(unit_data[3], "NO")
+            self.routeto = to_str(unit_data[4], "")
 
-        elif self.type in ("FIXED", "NORMAL", "TIMESERIES"):
+        elif self.type in ("FIXED", "TIDAL", "TIMESERIES"):
             # Extend length of unit_data to account for missing optional arguments.
-            while len(unit_data) < self.MIN_LENGTH_FIXED_NORMAL_TIMESERIES:
+            while len(unit_data) < self.MIN_LENGTH_FIXED_TIDAL_TIMESERIES:
                 unit_data.append("")
 
             if self.type == "FIXED":
-                self.stage = _to_float(unit_data[3], 0.0)
+                self.stage = to_float(unit_data[3], 0.0)
 
-            elif self.type == "NORMAL":
-                self.tcurve = _to_str(unit_data[3], "")
+            elif self.type == "TIDAL":
+                self.tcurve = to_str(unit_data[3], "")
 
             elif self.type == "TIMESERIES":
-                self.tseries = _to_str(unit_data[3], "")
+                self.tseries = to_str(unit_data[3], "")
 
-            self.gated = _to_str(unit_data[4], "NO")
-            self.routeto = _to_str(unit_data[5], "")
+            self.gated = to_str(unit_data[4], "NO")
+            self.routeto = to_str(unit_data[5], "")
 
     def _write(self):
         """Function to write a valid OUTFALL line"""
 
         _validate_unit(self, urban=True)
 
-        # TODO:Improve indentation format when writing and include header for completeness
-
         params1 = join_n_char_ljust(17, self.name) + join_n_char_ljust(
             15,
             self.elevation,
@@ -102,7 +97,8 @@ class OUTFALL(UrbanUnit):
             params2 = join_n_char_ljust(15, self.tseries, self.gated, self.routeto)
 
         else:
-            raise RuntimeError(f"{self.type} not supported")
+            msg = f"{self.type} not supported"
+            raise RuntimeError(msg)
 
         return params1 + params2
 

floodmodeller_api/urban1d/raingauges.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,7 +14,7 @@ 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 floodmodeller_api.units.helpers import _to_float, join_n_char_ljust
+from floodmodeller_api.units._helpers import join_n_char_ljust, to_float
 from floodmodeller_api.validation import _validate_unit
 
 from ._base import UrbanSubsection, UrbanUnit
@@ -43,8 +43,6 @@ class RAINGAUGE(UrbanUnit):
     def _read(self, line):
         """Function to read a given RAINGAUGE line and store data as class attributes"""
 
-        # TODO: add functionality to read comments
-
         unit_data = line.split()  # Get unit parameters
 
         self.name = str(unit_data[0])
@@ -55,7 +53,7 @@ class RAINGAUGE(UrbanUnit):
         except ValueError:
             self.interval = str(unit_data[2])  # HH:MM format
 
-        self.snow_catch_factor = _to_float(unit_data[3], 0.0)
+        self.snow_catch_factor = to_float(unit_data[3], 0.0)
         self.data_option = str(unit_data[4])
 
         # Check is raingauge data is provided as a TIMESERIES or as a FILE
@@ -79,8 +77,6 @@ class RAINGAUGE(UrbanUnit):
 
         _validate_unit(self, urban=True)
 
-        # TODO:Improve indentation format when writing and include header for completeness
-
         params1 = join_n_char_ljust(17, self.name) + join_n_char_ljust(
             15,
             self.format,
@@ -97,12 +93,11 @@ class RAINGAUGE(UrbanUnit):
             params2 = join_n_char_ljust(15, self.filename, self.station, self.units)
 
         else:
-            raise RuntimeError(f"{self.data_option} not supported")
+            msg = f"{self.data_option} not supported"
+            raise RuntimeError(msg)
 
         return params1 + params2
 
-        # TODO: Implement validation that does not allow spaces to be entered in attribute values
-
 
 class RAINGAUGES(UrbanSubsection):
     """Class to read/write the table of raingauges"""

floodmodeller_api/urban1d/subsections.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,7 +14,9 @@ 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 typing import Type, TypedDict
+from __future__ import annotations
+
+from typing import TypedDict
 
 from ._base import UrbanSubsection
 from .conduits import CONDUITS
@@ -26,11 +28,10 @@ from .xsections import XSECTIONS
 
 SupportedSubsections = TypedDict(
     "SupportedSubsections",
-    {"group": str, "attribute": str, "class": Type[UrbanSubsection]},
+    {"group": str, "attribute": str, "class": type[UrbanSubsection]},
 )
 
 # Unit types and support
-# TODO: Update functionality - SWMM manual indicates only first 4 characters of subsection heading are needed
 SUPPORTED_SUBSECTIONS: dict[str, SupportedSubsections] = {
     "[JUNCTIONS]": {"group": "units", "attribute": "_junctions", "class": JUNCTIONS},
     "[OUTFALLS]": {"group": "units", "attribute": "_outfalls", "class": OUTFALLS},