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

floodmodeller_api/units/helpers.py

@@ -1,132 +1,123 @@
-"""
-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 typing import Optional
-
-# Helper Functions
-
-
-def split_10_char(line):
-    return [line[i : i + 10].strip() for i in range(0, len(line), 10)]
-
-
-def split_12_char(line):
-    return [line[i : i + 12].strip() for i in range(0, len(line), 12)]
-
-
-def split_n_char(line, n):
-    return [line[i : i + n].strip() for i in range(0, len(line), n)]
-
-
-def join_10_char(*itms, dp=3):
-    """Joins a set of values with a 10 character buffer and right-justified"""
-    string = ""
-    for itm in itms:
-        if isinstance(itm, float):
-            # save to 3 dp
-            if len(f"{itm:.{dp}f}") > 10:
-                # Use scientific notation if number greater than 10 characters
-                itm = f"{itm:.{dp}e}"
-            else:
-                itm = f"{itm:.{dp}f}"
-        itm = str(itm)
-        itm = itm[:10]
-        string += f"{itm:>10}"
-    return string
-
-
-def join_12_char_ljust(*itms, dp=3):
-    """Joins a set of values with a 12 character buffer and left-justified"""
-    string = ""
-    for itm in itms:
-        if isinstance(itm, float):
-            # save to 3 dp
-            if len(f"{itm:.{dp}f}") > 10:
-                # Use scientific notation if number greater than 10 characters
-                itm = f"{itm:.{dp}e}"
-            else:
-                itm = f"{itm:.{dp}f}"
-        itm = str(itm)
-        itm = itm[:12]
-        string += f"{itm:<12}"
-    return string
-
-
-def join_n_char_ljust(n, *itms, dp=3):
-    """Joins a set of values with a n character buffer and left-justified"""
-    string = ""
-    for itm in itms:
-        if isinstance(itm, float):
-            # save to 3 dp
-            if len(f"{itm:.{dp}f}") > 10:
-                # Use scientific notation if number greater than 10 characters
-                itm = f"{itm:.{dp}e}"
-            else:
-                itm = f"{itm:.{dp}f}"
-        itm = str(itm)
-        itm = itm[:n]
-        string += f"{itm:<{n}}"
-    return string
-
-
-def _to_float(itm, default=0.0):
-    try:
-        return float(itm)
-    except ValueError:
-        return default
-
-
-def _to_int(itm, default=0):
-    try:
-        return int(itm)
-    except ValueError:
-        return default
-
-
-def _to_str(itm, default, check_float=False):
-    if check_float:
-        try:
-            return float(itm)
-        except ValueError:
-            pass
-    if itm == "":
-        return default
-    else:
-        return itm
-
-
-def _to_data_list(block: list[str], num_cols: Optional[int] = None, date_col: Optional[int] = None):
-    if num_cols is not None:
-        num_cols += 1 if date_col is not None else 0
-    data_list = []
-    for row in block:
-        row_split = split_10_char(row) if num_cols is None else split_10_char(row)[:num_cols]
-        if date_col is not None:
-            date_time = " ".join(row_split[date_col : date_col + 2])
-            row_split = [
-                _to_float(itm)
-                for idx, itm in enumerate(row_split)
-                if idx != date_col and idx != date_col + 1
-            ]
-            row_split.insert(date_col, date_time)
-        else:
-            row_split = [_to_float(itm) for itm in row_split]
-
-        row = []
-        for var in row_split:
-            row.append(var)
-        data_list.append(row)
-    return data_list
+"""
+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
+
+# Helper Functions
+NOTATION_THRESHOLD = 10
+
+
+def split_10_char(line):
+    return [line[i : i + 10].strip() for i in range(0, len(line), 10)]
+
+
+def split_12_char(line):
+    return [line[i : i + 12].strip() for i in range(0, len(line), 12)]
+
+
+def split_n_char(line, n):
+    return [line[i : i + n].strip() for i in range(0, len(line), n)]
+
+
+def join_10_char(*itms, dp=3):
+    """Joins a set of values with a 10 character buffer and right-justified"""
+    string = ""
+    for itm in itms:
+        if isinstance(itm, float):
+            # save to 3 dp
+            # Use scientific notation if number greater than NOTATION_THRESHOLD characters
+            itm = f"{itm:.{dp}e}" if len(f"{itm:.{dp}f}") > NOTATION_THRESHOLD else f"{itm:.{dp}f}"
+        itm = str(itm)
+        itm = itm[:10]
+        string += f"{itm:>10}"
+    return string
+
+
+def join_12_char_ljust(*itms, dp=3):
+    """Joins a set of values with a 12 character buffer and left-justified"""
+    string = ""
+    for itm in itms:
+        if isinstance(itm, float):
+            # save to 3 dp
+            # Use scientific notation if number greater than 10 characters
+            itm = f"{itm:.{dp}e}" if len(f"{itm:.{dp}f}") > NOTATION_THRESHOLD else f"{itm:.{dp}f}"
+        itm = str(itm)
+        itm = itm[:12]
+        string += f"{itm:<12}"
+    return string
+
+
+def join_n_char_ljust(n, *itms, dp=3):
+    """Joins a set of values with a n character buffer and left-justified"""
+    string = ""
+    for itm in itms:
+        if isinstance(itm, float):
+            # save to 3 dp
+            # Use scientific notation if number greater than 10 characters
+            itm = f"{itm:.{dp}e}" if len(f"{itm:.{dp}f}") > NOTATION_THRESHOLD else f"{itm:.{dp}f}"
+        itm = str(itm)
+        itm = itm[:n]
+        string += f"{itm:<{n}}"
+    return string
+
+
+def _to_float(itm, default=0.0):
+    try:
+        return float(itm)
+    except ValueError:
+        return default
+
+
+def _to_int(itm, default=0):
+    try:
+        return int(itm)
+    except ValueError:
+        return default
+
+
+def _to_str(itm, default, check_float=False):
+    if check_float:
+        try:
+            return float(itm)
+        except ValueError:
+            pass
+    if itm == "":
+        return default
+    return itm
+
+
+def _to_data_list(block: list[str], num_cols: int | None = None, date_col: int | None = None):
+    if num_cols is not None:
+        num_cols += 1 if date_col is not None else 0
+    data_list = []
+    for row in block:
+        row_split = split_10_char(row) if num_cols is None else split_10_char(row)[:num_cols]
+        if date_col is not None:
+            date_time = " ".join(row_split[date_col : date_col + 2])
+            row_split = [
+                _to_float(itm)
+                for idx, itm in enumerate(row_split)
+                if idx not in (date_col, date_col + 1)
+            ]
+            row_split.insert(date_col, date_time)
+        else:
+            row_split = [_to_float(itm) for itm in row_split]
+
+        row_list = []
+        for var in row_split:
+            row_list.append(var)
+        data_list.append(row_list)
+    return data_list

floodmodeller_api/units/iic.py

@@ -1,101 +1,107 @@
-"""
-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.
-"""
-
-import pandas as pd
-
-from ..diff import check_item_with_dataframe_equal
-from .helpers import join_10_char, split_10_char
-
-# Initial Conditions Class
-
-
-class IIC:
-    """Class to hold initial conditions data"""
-
-    def __init__(self, ic_block, n=12):
-        self._label_len = n
-        self._read(ic_block)
-
-    def __repr__(self):
-        return "<floodmodeller_api Initial Conditions Class: IIC()>"
-
-    def _read(self, ic_block):
-        header = [
-            "label",
-            "?",
-            "flow",
-            "stage",
-            "froude no",
-            "velocity",
-            "umode",
-            "ustate",
-            "z",
-        ]
-        data_list = []
-        for line in ic_block[2:]:
-            lbl = line[: self._label_len + 1].strip()
-            incl = line[self._label_len + 1 : self._label_len + 3].strip()
-            q, h, fr, v, um, us, z = split_10_char(line[self._label_len + 3 :])
-            data_list.append(
-                [
-                    lbl,
-                    incl,
-                    float(q),
-                    float(h),
-                    float(fr),
-                    float(v),
-                    float(um),
-                    float(us),
-                    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",
-            " label   ?      flow     stage froude no  velocity     umode    ustate         z",
-        ]
-        rows = []
-        for _, lbl, incl, q, h, fr, v, um, us, z in self.data.itertuples():
-            string = f"{lbl:<{self._label_len}}{incl:>2}"
-            string += join_10_char(q, h, fr, v, um, us, z)
-            rows.append(string)
-
-        ic_block.extend(rows)
-
-        return ic_block
-
-    def update_label(self, old, new):
-        self.data.loc[self.data["label"] == old, "label"] = new
-
-    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="Initial Conditions", 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.
+"""
+
+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
+
+# Initial Conditions Class
+
+
+class IIC(Jsonable):
+    """Class to hold initial conditions data"""
+
+    def __init__(self, ic_block=None, n=12, from_json: bool = False):
+        if from_json:
+            return
+        self._label_len = n
+        self._read(ic_block)
+
+    def __repr__(self):
+        return "<floodmodeller_api Initial Conditions Class: IIC()>"
+
+    def _read(self, ic_block):
+        header = [
+            "label",
+            "?",
+            "flow",
+            "stage",
+            "froude no",
+            "velocity",
+            "umode",
+            "ustate",
+            "z",
+        ]
+        data_list = []
+        for line in ic_block[2:]:
+            lbl = line[: self._label_len + 1].strip()
+            incl = line[self._label_len + 1 : self._label_len + 3].strip()
+            q, h, fr, v, um, us, z = split_10_char(line[self._label_len + 3 :])
+            data_list.append(
+                [
+                    lbl,
+                    incl,
+                    float(q),
+                    float(h),
+                    float(fr),
+                    float(v),
+                    float(um),
+                    float(us),
+                    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",
+            " label   ?      flow     stage froude no  velocity     umode    ustate         z",
+        ]
+        rows = []
+        for _, lbl, incl, q, h, fr, v, um, us, z in self.data.itertuples():
+            string = f"{lbl:<{self._label_len}}{incl:>2}"
+            string += join_10_char(q, h, fr, v, um, us, z)
+            rows.append(string)
+
+        ic_block.extend(rows)
+
+        return ic_block
+
+    def update_label(self, old, new):
+        self.data.loc[self.data["label"] == old, "label"] = new
+
+    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="Initial Conditions",
+            diff=diff,
+        )
+        return (result, diff) if return_diff else result