floodmodeller-api 0.5.2.post1__py3-none-any.whl → 0.5.3.post1__py3-none-any.whl

floodmodeller_api/_base.py

@@ -83,18 +83,24 @@ class FMFile(Jsonable):
     def _read(self):
         raise NotImplementedError
 
-    def _update(self):
+    def update(self) -> None:
+        raise NotImplementedError
+
+    def save(self, filepath: str | Path) -> None:
+        raise NotImplementedError
+
+    def _update(self) -> None:
         """Updates the existing self._filetype based on any altered attributes"""
         if self._filepath is None:
             msg = f"{self._filetype} must be saved to a specific filepath before update() can be called."
             raise UserWarning(msg)
 
         string = self._write()
-        with open(self._filepath, "w", encoding=self.ENCODING) as _file:
+        with open(self._filepath, "w", encoding=self.ENCODING, newline="\r\n") as _file:
             _file.write(string)
         logging.info("%s File Updated!", self._filepath)
 
-    def _save(self, filepath):
+    def _save(self, filepath: str | Path) -> None:
         filepath = Path(filepath).absolute()
         if filepath.suffix.lower() != self._suffix:
             msg = f'Given filepath does not point to a filepath suffixed "{self._suffix}". Please point to the full path to save the {self._filetype} file'
@@ -104,7 +110,7 @@ class FMFile(Jsonable):
             Path.mkdir(filepath.parent)
 
         string = self._write()
-        with open(filepath, "w", encoding=self.ENCODING) as _file:
+        with open(filepath, "w", encoding=self.ENCODING, newline="\r\n") as _file:
             _file.write(string)
         self._filepath = filepath  # Updates the filepath attribute to the given path
 

floodmodeller_api/dat.py

@@ -88,7 +88,7 @@ class DAT(FMFile):
         if self._gxy_data is not None:
             gxy_string = self._gxy_data
             new_gxy_path = filepath.with_suffix(".gxy")
-            with open(new_gxy_path, "w") as gxy_file:
+            with open(new_gxy_path, "w", encoding=self.ENCODING, newline="\r\n") as gxy_file:
                 gxy_file.write(gxy_string)
             self._gxy_filepath = new_gxy_path
 
@@ -571,9 +571,7 @@ class DAT(FMFile):
             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(
-            f"units.{unit_type_safe}({unit_data}, {self._label_len})",
-        )
+        unit_group[unit_name] = getattr(units, unit_type_safe)(unit_data, self._label_len)
         self._all_units.append(unit_group[unit_name])
 
     def _process_unsupported_unit(self, unit_type, unit_data) -> None:

floodmodeller_api/ied.py

@@ -183,7 +183,7 @@ class IED(FMFile):
                 if unit_name in unit_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})')
+                unit_group[unit_name] = getattr(units, block["Type"])(unit_data)
 
                 self._all_units.append(unit_group[unit_name])
 

floodmodeller_api/ief.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 
 import csv
 import logging
+import re
 import subprocess
 import time
 from io import StringIO
@@ -98,6 +99,8 @@ class IEF(FMFile):
         self._ief_properties: list[str] = []
         self.EventData: dict[str, str] = {}
         self.flowtimeprofiles: list[FlowTimeProfile] = []
+
+        raw_eventdata: list[tuple[str, str]] = []
         for line in raw_data:
             # Handle any comments here (prefixed with ;)
             if line.lstrip().startswith(";"):
@@ -116,7 +119,7 @@ class IEF(FMFile):
                             event_data_title = value
                     else:
                         event_data_title = prev_comment
-                    self.eventdata[event_data_title] = value
+                    raw_eventdata.append((event_data_title, value))
                     self._ief_properties.append("EventData")
 
                 elif prop.upper().startswith("FLOWTIMEPROFILE"):
@@ -134,6 +137,7 @@ class IEF(FMFile):
                 self._ief_properties.append(line)
                 prev_comment = None
 
+        self._eventdata_read_helper(raw_eventdata)
         self._check_formatting(raw_data)
         self._update_ief_properties()  # call this here to ensure ief properties is correct
 
@@ -179,7 +183,10 @@ class IEF(FMFile):
                 # Add multiple EventData if present
                 for idx, key in enumerate(event_data):
                     if idx == event_index:
-                        ief_string += f";{key}\nEventData{eq}{event_data[key]!s}\n"
+                        # we enter this block if we're ready to write the event data
+                        # scrub off any extra bits we've added as part of the make-unique bit of reading.
+                        title = re.sub(r"<\d>$", "", key)
+                        ief_string += f";{title}\nEventData{eq}{event_data[key]!s}\n"
                         break
                 event_index += 1
 
@@ -328,6 +335,16 @@ class IEF(FMFile):
                     if removed == to_remove:
                         break
 
+    def _eventdata_read_helper(self, raw_eventdata: list[tuple[str, str]]) -> None:
+        # now we deal with the event data, and convert it into the dict-based .eventdata
+        for title, ied_path in raw_eventdata:
+            n = 0
+            new_title = title or "<0>"  # set empty string to placeholder
+            while new_title in self.eventdata:
+                new_title = f"{title}<{n}>"
+                n += 1
+            self.eventdata[new_title] = ied_path
+
     def _update_flowtimeprofile_info(self) -> None:
         """Update the flowtimeprofile data stored in ief properties"""
         if not hasattr(self, "flowtimeprofiles") or len(self.flowtimeprofiles) == 0:
@@ -570,7 +587,7 @@ class IEF(FMFile):
 
         return ZZN(result_path)
 
-    def get_log(self):
+    def get_log(self) -> LF1:
         """If log files for the simulation exist, this function returns them as a LF1 class object
 
         Returns:

floodmodeller_api/logs/lf.py

@@ -124,16 +124,23 @@ class LF(FMFile):
             for key in self._data_to_extract:
                 parser = self._extracted_data[key]
 
-                # lines which start with prefix
-                if raw_line.startswith(parser.prefix):
+                if parser.use_regex:
+                    if not (match := parser.prefix.match(raw_line)):
+                        continue
+                    end_of_line = match.group(1).lstrip()
+
+                elif raw_line.startswith(parser.prefix):
                     # store everything after prefix
                     end_of_line = raw_line.split(parser.prefix)[1].lstrip()
-                    parser.process_line(end_of_line)
 
-                    # index marks the end of an iteration
-                    if parser.is_index is True:
-                        self._sync_cols()
-                        self._no_iters += 1
+                else:
+                    continue
+                parser.process_line(end_of_line)
+
+                # index marks the end of an iteration
+                if parser.is_index is True:
+                    self._sync_cols()
+                    self._no_iters += 1
 
             # update counter
             self._no_lines += 1

floodmodeller_api/logs/lf_helpers.py

@@ -171,6 +171,7 @@ class Parser(ABC):
         exclude: str | None = None,
         is_index: bool | None = False,
         before_index: bool | None = False,
+        use_regex: bool | None = False,
     ):
         self._name = name
 
@@ -184,6 +185,7 @@ class Parser(ABC):
 
         self.data_type = data_type
         self.data = data_factory(data_type, name)
+        self.use_regex = use_regex
 
     def process_line(self, raw_line: str) -> None:
         """self._process_line with exception handling of expected nan values"""

floodmodeller_api/logs/lf_params.py

@@ -14,6 +14,8 @@ If you have any query about this program or this License, please contact us at s
 address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London, SE1 2QG, United Kingdom.
 """
 
+import re
+
 from .lf_helpers import (
     DateTimeParser,
     FloatParser,
@@ -185,93 +187,108 @@ lf1_unsteady_data_to_extract = {
     },
     "initial_volume": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Initial volume:",
+        "prefix": re.compile(r"^!!output1\s+Initial volume\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "final_volume": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Final volume:",
+        "prefix": re.compile(r"^!!output1\s+Final volume\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "total_boundary_inflow": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Total boundary inflow :",
+        "prefix": re.compile(r"^!!output1\s+Total boundary inflow\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "total_boundary_outflow": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Total boundary outflow:",
+        "prefix": re.compile(r"^!!output1\s+Total boundary outflow\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "total_lat_link_inflow": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Total lat. link inflow:",
+        "prefix": re.compile(r"^!!output1\s+Total lat. link inflow\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "total_lat_link_outflow": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Total lat. link outflow:",
+        "prefix": re.compile(r"^!!output1\s+Total lat. link outflow\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "max_system_volume": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Max. system volume:",
+        "prefix": re.compile(r"^!!output1\s+Max. system volume\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "max_volume_increase": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Max. |volume| increase:",
+        "prefix": re.compile(r"^!!output1\s+Max. \|volume\| increase\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "max_boundary_inflow": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Max. boundary inflow:",
+        "prefix": re.compile(r"^!!output1\s+Max. boundary inflow\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "max_boundary_outflow": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Max. boundary outflow:",
+        "prefix": re.compile(r"^!!output1\s+Max. boundary outflow\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "net_volume_increase": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Net increase in volume:",
+        "prefix": re.compile(r"^!!output1\s+Net increase in volume\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "net_inflow_volume": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Net inflow volume:",
+        "prefix": re.compile(r"^!!output1\s+Net inflow volume\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "volume_discrepancy": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Volume discrepancy:",
+        "prefix": re.compile(r"^!!output1\s+Volume discrepancy\s*:(.*)"),
         "data_type": "last",
         "split": "m3",
+        "use_regex": True,
     },
     "mass_balance_error": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Mass balance error:",
+        "prefix": re.compile(r"^!!output1\s+Mass balance error\s*:(.*)"),
         "data_type": "last",
         "split": "%",
+        "use_regex": True,
     },
     "mass_balance_error_2": {
         "class": FloatSplitParser,
-        "prefix": "!!output1  Mass balance error [2]:",
+        "prefix": re.compile(r"^!!output1\s+Mass balance error \[2\]\s*:(.*)"),
         "data_type": "last",
         "split": "%",
+        "use_regex": True,
     },
     "tuflow_start_time": {
         "class": FloatParser,
@@ -453,43 +470,51 @@ lf2_data_to_extract = {
     },
     "timestep": {
         "class": FloatParser,
-        "prefix": "!!output2     Model timestep             :",
+        "prefix": re.compile(r"^!!output2\s+Model timestep\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
     },
     "wetting_drying_depth": {
         "class": FloatParser,
-        "prefix": "!!output2     Wetting/drying depth       :",
+        "prefix": re.compile(r"^!!output2\s+Wetting/drying depth\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
     },
     "beta": {
         "class": FloatParser,
-        "prefix": "!!output2     Beta                       :",
+        "prefix": re.compile(r"^!!output2\s+Beta\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
     },
     "number_of_iterations": {
         "class": FloatParser,
-        "prefix": "!!output2     Number of iterations       :",
+        "prefix": re.compile(r"^!!output2\s+Number of iterations\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
     },
     "calculation_depth": {
         "class": FloatParser,
-        "prefix": "!!output2     Calculation depth          :",
+        "prefix": re.compile(r"^!!output2\s+Calculation depth\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
     },
     "friction_depth": {
         "class": FloatParser,
-        "prefix": "!!output2     Friction depth             :",
+        "prefix": re.compile(r"^!!output2\s+Friction depth\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
     },
     "eddy_viscosity": {
         "class": FloatParser,
-        "prefix": "!!output2     Eddy Viscosity             :",
+        "prefix": re.compile(r"^!!output2\s+Eddy Viscosity\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
     },
     "velocity_head_threshold": {
         "class": FloatParser,
-        "prefix": "!!output2     Velocity head threshold    :",
+        "prefix": re.compile(r"^!!output2\s+Velocity head threshold\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
     },
     "rainfall_accumulation_depth": {
         "class": FloatParser,
@@ -498,8 +523,9 @@ lf2_data_to_extract = {
     },
     "negative_depth_threshold": {
         "class": FloatParser,
-        "prefix": "!!output2     Negative depth threshold   :",
+        "prefix": re.compile(r"^!!output2\s+Negative depth threshold\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
     },
     "memory_use_estimate": {
         "class": FloatSplitParser,
@@ -509,8 +535,9 @@ lf2_data_to_extract = {
     },
     "friction_depth_threshold": {
         "class": FloatParser,
-        "prefix": "!!output2     Friction depth threshold   :",
+        "prefix": re.compile(r"^!!output2\s+Friction depth threshold\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
     },
     "number_of_cells": {
         "class": FloatParser,
@@ -529,8 +556,9 @@ lf2_data_to_extract = {
     },
     "final_mass_error": {
         "class": FloatSplitParser,
-        "prefix": "!!output2    Final mass error            :",
+        "prefix": re.compile(r"^!!output2\s+Final mass error\s*:(.*)"),
         "data_type": "last",
+        "use_regex": True,
         "split": "%",
     },
     "combined_mass_error": {

floodmodeller_api/mapping.py

@@ -13,6 +13,7 @@ from .units import (
     CRUMP,
     CULVERT,
     FLAT_V_WEIR,
+    FLOODPLAIN,
     HTBDY,
     IIC,
     INTERPOLATE,
@@ -81,6 +82,7 @@ api_class_mapping: dict[str, Any] = {
     "floodmodeller_api.units.sections.INTERPOLATE": INTERPOLATE,
     "floodmodeller_api.units.sections.REPLICATE": REPLICATE,
     "floodmodeller_api.units.sections.RIVER": RIVER,
+    "floodmodeller_api.units.structures.FLOODPLAIN": FLOODPLAIN,
     "floodmodeller_api.units.structures.BRIDGE": BRIDGE,
     "floodmodeller_api.units.structures.CRUMP": CRUMP,
     "floodmodeller_api.units.structures.FLAT_V_WEIR": FLAT_V_WEIR,

floodmodeller_api/test/test_dat.py

@@ -202,7 +202,7 @@ def test_diff(test_workspace, caplog):
         dat_ex4.diff(dat_ex4_changed)
 
     assert caplog.text == (
-        "INFO     root:_base.py:135 Files not equivalent, 12 difference(s) found:\n"
+        "INFO     root:_base.py:141 Files not equivalent, 12 difference(s) found:\n"
         "  DAT->structures->MILLAu->RNWEIR..MILLAu->upstream_crest_height:  1.07 != 1.37\n"
         "  DAT->structures->MILLBu->RNWEIR..MILLBu->upstream_crest_height:  0.43 != 0.73\n"
         "  DAT->structures->ROAD1->RNWEIR..ROAD1->upstream_crest_height:  2.02 != 2.32\n"
@@ -218,6 +218,18 @@ def test_diff(test_workspace, caplog):
     )
 
 
+def test_diff_active_data(test_workspace):
+    dat = DAT(Path(test_workspace, "ex4.DAT"))
+    dat_copy = DAT(Path(test_workspace, "ex4.DAT"))
+    assert dat == dat_copy
+
+    for section in dat.sections.values():
+        if section.unit == "RIVER":
+            _ = section.active_data
+
+    assert dat == dat_copy
+
+
 def test_valid_network(test_workspace: Path):
     """Test against network derived manually."""
     dat = DAT(test_workspace / "network.dat")

floodmodeller_api/test/test_data/floodplain.dat

@@ -0,0 +1,52 @@
+
+#REVISION#1
+         4     0.750     0.900     0.100     0.001        12SI
+    10.000     0.010     0.010     0.700     0.100     0.700     0.000
+RAD FILE
+
+END GENERAL
+RIVER
+SECTION
+1
+     5.000              0.0001      1000
+         1
+     0.000     0.000     0.000     1.000               0.000     0.000          
+RIVER
+SECTION
+2
+     5.000              0.0001      1000
+         1
+     0.000     0.000     0.000     1.000               0.000     0.000          
+RIVER
+SECTION
+3
+     0.000                      1000.000
+         1
+     0.000     0.000     0.000     1.000
+FLOODPLAIN floodplain comment
+SECTION
+3           down
+     1.000     0.800   150.000    75.000  FRICTION     0.100
+         3
+     0.000     1.000     0.030      0.00      0.00
+    10.000     1.500     0.030      0.00      0.00
+    90.000     1.800     0.030      0.00      0.00
+RIVER
+SECTION
+down
+     0.000                      1000.000
+         1
+     0.000     0.000     0.000     1.000
+INITIAL CONDITIONS
+ label   ?      flow     stage froude no  velocity     umode    ustate         z
+3            y     0.000     0.000     0.000     0.000     0.000     0.000     0.000
+1            y     0.000     0.000     0.000     0.000     0.000     0.000     0.000
+2            y     0.000     0.000     0.000     0.000     0.000     0.000     0.000
+down         y     0.000     0.000     0.000     0.000     0.000     0.000     0.000
+GISINFO
+RIVER SECTION 1 0 0 0 0 0
+RIVER SECTION 2 0 0 0 0 0
+RIVER SECTION 3 0 0 0 0 0
+FLOODPLAIN SECTION 3 0 0 0 0 0
+RIVER SECTION down 0 0 0 0 0
+down 0 0 0 0 0