floodmodeller-api 0.4.2__py3-none-any.whl → 0.4.3__py3-none-any.whl

floodmodeller_api/urban1d/_base.py

@@ -1,177 +1,188 @@
-"""
-Flood Modeller Python API
-Copyright (C) 2023 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.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program.  If not, see https://www.gnu.org/licenses/.
-
-If you have any query about this program or this License, please contact us at support@floodmodeller.com or write to the following
-address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London, SE1 2QG, United Kingdom.
-"""
-
-""" Holds the base unit class for all FM 1D units Units """
-
-from ..diff import check_item_with_dataframe_equal
-
-
-class UrbanUnit:
-    _unit = None
-    _subtype = None
-    _name = None
-
-    def __init__(self, unit_block=None, **kwargs):
-        if unit_block is not None:
-            self._read(unit_block)
-            # TODO: add functionality to read description
-        else:
-            self._create_from_blank(**kwargs)
-
-    @property
-    def name(self):
-        return self._name
-
-    @name.setter
-    def name(self, new_name):
-        self._name = new_name
-
-    # Update this bit
-    def __repr__(self):
-        if self._subtype is None:
-            return f"<floodmodeller_api UrbanUnit Class: {self._unit}(name={self._name})>"
-
-    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"
-        )
-
-    def __str__(self):
-        return self._write()
-
-    def _read(self):
-        raise NotImplementedError
-
-    def _write(self):
-        raise NotImplementedError
-
-    def _diff(self, other):
-        diff = self._get_diff(other)
-        if diff[0]:
-            print("No difference, units are equivalent")
-        else:
-            print("\n".join([f"{name}:  {reason}" for name, reason in diff[1]]))
-
-    def _get_diff(self, other):
-        return self.__eq__(other, return_diff=True)
-
-    def __eq__(self, other, return_diff=False):
-        result = True
-        diff = []
-        result, diff = check_item_with_dataframe_equal(
-            self.__dict__,
-            other.__dict__,
-            name=f"{self._unit}.{self._subtype or ''}.{self._name}",
-            diff=diff,
-        )
-        return (result, diff) if return_diff else result
-
-
-class UrbanSubsection:
-    _name = None
-    _urban_unit_class = None
-
-    def __init__(self, subsection_block=None, **kwargs):
-        if subsection_block is not None:
-            self._read(subsection_block)
-        else:
-            self._create_from_blank(**kwargs)
-
-    @property
-    def name(self):
-        return self._name
-
-    @name.setter
-    def name(self, new_name):
-        self._name = new_name
-
-    def __repr__(self):
-        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"
-        )
-
-    def __str__(self):
-        return "\n".join(self._write())
-
-    def _read(self, block):
-        setattr(self, self._attribute, {})
-        units = getattr(self, self._attribute)
-
-        self._struct = []
-
-        for line in block[1:]:  # first line is subsection name
-            if line.strip() != "" and not line.startswith(";"):
-                unit = self._urban_unit_class(line)
-                units[unit.name] = unit
-                self._struct.append(unit)
-
-            else:
-                self._struct.append(line)
-
-    def _write(self):
-        block = []
-
-        if self._attribute == "raingauges":
-            # handle required miss-spelling of raingauge in subsection header
-            block.append("[" + "RAINGAGES" + "]")
-
-        else:
-            block.append("[" + self._attribute.upper() + "]")
-
-        for line in self._struct:
-            if isinstance(line, self._urban_unit_class):
-                block.append(line._write())
-            else:
-                block.append(line)
-
-        units = getattr(self, self._attribute)
-
-        for name, unit in units.copy().items():
-            if name != unit.name:
-                # 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'
-                    )
-
-                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")
-        else:
-            print("\n".join([f"{name}:  {reason}" for name, reason in diff[1]]))
-
-    def _get_diff(self, other):
-        return self.__eq__(other, return_diff=True)
-
-    def __eq__(self, other, return_diff=False):
-        result = True
-        diff = []
-        result, diff = check_item_with_dataframe_equal(
-            self.__dict__, other.__dict__, name=f"{self._attribute.upper()}", diff=diff
-        )
-        return (result, diff) if return_diff else result
+"""
+Flood Modeller Python API
+Copyright (C) 2024 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.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program.  If not, see https://www.gnu.org/licenses/.
+
+If you have any query about this program or this License, please contact us at support@floodmodeller.com or write to the following
+address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London, SE1 2QG, United Kingdom.
+"""
+
+from __future__ import annotations
+
+""" Holds the base unit class for all FM 1D units Units """
+
+from ..diff import check_item_with_dataframe_equal
+from ..to_from_json import Jsonable
+
+
+class UrbanUnit(Jsonable):
+    _unit: str | None = None
+    _subtype: str | None = None
+    _name: str | None = None
+
+    def __init__(self, unit_block=None, from_json: bool = False, **kwargs):
+        if from_json:
+            return
+        if unit_block is not None:
+            self._read(unit_block)
+            # TODO: add functionality to read description
+        else:
+            self._create_from_blank(**kwargs)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, new_name):
+        self._name = new_name
+
+    # Update this bit
+    def __repr__(self):
+        if self._subtype is None:
+            return f"<floodmodeller_api UrbanUnit Class: {self._unit}(name={self._name})>"
+        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",
+        )
+
+    def __str__(self):
+        return self._write()
+
+    def _read(self, unit_block):
+        raise NotImplementedError
+
+    def _write(self):
+        raise NotImplementedError
+
+    def _diff(self, other):
+        diff = self._get_diff(other)
+        if diff[0]:
+            print("No difference, units are equivalent")
+        else:
+            print("\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
+
+    def __eq__(self, other, return_diff=False):
+        result = True
+        diff = []
+        result, diff = check_item_with_dataframe_equal(
+            self.__dict__,
+            other.__dict__,
+            name=f"{self._unit}.{self._subtype or ''}.{self._name}",
+            diff=diff,
+        )
+        return (result, diff) if return_diff else result
+
+
+class UrbanSubsection(Jsonable):
+    _name: str | None = None
+    _urban_unit_class: type[UrbanUnit] | None = None
+
+    def __init__(self, subsection_block=None, from_json: bool = False, **kwargs):
+        if from_json:
+            return
+        if subsection_block is not None:
+            self._read(subsection_block)
+        else:
+            self._create_from_blank(**kwargs)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, new_name):
+        self._name = new_name
+
+    def __repr__(self):
+        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",
+        )
+
+    def __str__(self):
+        return "\n".join(self._write())
+
+    def _read(self, block):
+        setattr(self, self._attribute, {})
+        units = getattr(self, self._attribute)
+
+        self._struct = []
+
+        for line in block[1:]:  # first line is subsection name
+            if line.strip() != "" and not line.startswith(";"):
+                unit = self._urban_unit_class(line)
+                units[unit.name] = unit
+                self._struct.append(unit)
+
+            else:
+                self._struct.append(line)
+
+    def _write(self):
+        block = []
+
+        if self._attribute == "raingauges":
+            # handle required miss-spelling of raingauge in subsection header
+            block.append("[" + "RAINGAGES" + "]")
+
+        else:
+            block.append("[" + self._attribute.upper() + "]")
+
+        for line in self._struct:
+            if isinstance(line, self._urban_unit_class):
+                block.append(line._write())
+            else:
+                block.append(line)
+
+        units = getattr(self, self._attribute)
+
+        for name, unit in units.copy().items():
+            if name != unit.name:
+                # 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',
+                    )
+
+                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")
+        else:
+            print("\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
+
+    def __eq__(self, other, return_diff=False):
+        result = True
+        diff = []
+        result, diff = check_item_with_dataframe_equal(
+            self.__dict__,
+            other.__dict__,
+            name=f"{self._attribute.upper()}",
+            diff=diff,
+        )
+        return (result, diff) if return_diff else result

floodmodeller_api/urban1d/conduits.py

@@ -1,85 +1,93 @@
-"""
-Flood Modeller Python API
-Copyright (C) 2023 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.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program.  If not, see https://www.gnu.org/licenses/.
-
-If you have any query about this program or this License, please contact us at support@floodmodeller.com or write to the following
-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.validation import _validate_unit
-
-from ._base import UrbanSubsection, UrbanUnit
-
-
-class CONDUIT(UrbanUnit):
-    """Class to hold and process CONDUIT unit type
-
-    Args:
-        name (str): Unit name. (required)
-        node1 (str): Name of upstream node. (required)
-        node2 (str): Name of downstream node. (required)
-        length (float): Conduit length (ft or m). (required)
-        n (float): Mannings n value. (required)
-        z1 (float): Offset of upstream end of conduit invert above the invert elevation of it's upstream node (ft or m). (required)
-        z1 (float): Offset of downstream end of conduit invert above the invert elevation of it's downstream node (ft or m). (required)
-        q0 (float): Flow in conduit at start of simulation (flow units).(optional, default 0)
-        qmax (float): maximum flow allowed in the conduit (flow units) (optional, default unlimited)
-
-    Returns:
-        CONDUIT: Flood Modeller CONDUIT Unit class object
-    """
-
-    _unit = "CONDUIT"
-
-    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) < 9:
-            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]
-
-    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, self.n, self.z1, self.z2, self.q0, self.qmax
-        )
-
-
-class CONDUITS(UrbanSubsection):
-    """Class to read/write the table of conduits"""
-
-    _urban_unit_class = CONDUIT
-    _attribute = "conduits"
+"""
+Flood Modeller Python API
+Copyright (C) 2024 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.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program.  If not, see https://www.gnu.org/licenses/.
+
+If you have any query about this program or this License, please contact us at support@floodmodeller.com or write to the following
+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.validation import _validate_unit
+
+from ._base import UrbanSubsection, UrbanUnit
+
+
+class CONDUIT(UrbanUnit):
+    """Class to hold and process CONDUIT unit type
+
+    Args:
+        name (str): Unit name. (required)
+        node1 (str): Name of upstream node. (required)
+        node2 (str): Name of downstream node. (required)
+        length (float): Conduit length (ft or m). (required)
+        n (float): Mannings n value. (required)
+        z1 (float): Offset of upstream end of conduit invert above the invert elevation of it's upstream node (ft or m). (required)
+        z1 (float): Offset of downstream end of conduit invert above the invert elevation of it's downstream node (ft or m). (required)
+        q0 (float): Flow in conduit at start of simulation (flow units).(optional, default 0)
+        qmax (float): maximum flow allowed in the conduit (flow units) (optional, default unlimited)
+
+    Returns:
+        CONDUIT: Flood Modeller CONDUIT Unit class object
+    """
+
+    _unit = "CONDUIT"
+    MIN_LENGTH = 9
+
+    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]
+
+    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,
+            self.n,
+            self.z1,
+            self.z2,
+            self.q0,
+            self.qmax,
+        )
+
+
+class CONDUITS(UrbanSubsection):
+    """Class to read/write the table of conduits"""
+
+    _urban_unit_class = CONDUIT
+    _attribute = "conduits"