floodmodeller-api 0.4.4.post1__tar.gz → 0.5.0.post1__tar.gz

{floodmodeller_api-0.4.4.post1 → floodmodeller_api-0.5.0.post1}/MANIFEST.in

@@ -1,6 +1,7 @@
 include license.txt
 include code-of-conduct.md
 include requirements.txt
+include floodmodeller_api/xsd_backup.xml
 include floodmodeller_api/test/test_data/*
 include floodmodeller_api/toolbox/gui/*
 recursive-include floodmodeller_api *.dll

{floodmodeller_api-0.4.4.post1/floodmodeller_api.egg-info → floodmodeller_api-0.5.0.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: floodmodeller_api
-Version: 0.4.4.post1
+Version: 0.5.0.post1
 Summary: Extends the functionality of Flood Modeller to python users
 Author: Jacobs
 Author-email: joe.pierce@jacobs.com
@@ -18,6 +18,7 @@ Requires-Dist: pytest-mock==3.*
 Requires-Dist: shapely==2.*
 Requires-Dist: scipy==1.*
 Requires-Dist: freezegun==1.*
+Requires-Dist: requests>2.23
 
 ![FM Logo](https://raw.githubusercontent.com/People-Places-Solutions/floodmodeller-api/main/docs/source/_static/flood-modeller-logo-hero-image.png)
 

{floodmodeller_api-0.4.4.post1 → floodmodeller_api-0.5.0.post1}/floodmodeller_api/__init__.py

@@ -3,6 +3,7 @@ from .ied import IED
 from .ief import IEF
 from .inp import INP
 from .logs import LF1, LF2
+from .util import read_file
 from .version import __version__
 from .xml2d import XML2D
 from .zzn import ZZN

{floodmodeller_api-0.4.4.post1 → floodmodeller_api-0.5.0.post1}/floodmodeller_api/dat.py

@@ -292,10 +292,10 @@ class DAT(FMFile):
             return _name_list[0]
         return _name_list
 
-    def _read(self):
+    def _read(self) -> None:
         # Read DAT data
         with open(self._filepath) as dat_file:
-            self._raw_data = [line.rstrip("\n") for line in dat_file.readlines()]
+            self._raw_data: list[str] = [line.rstrip("\n") for line in dat_file.readlines()]
 
         # Generate DAT structure
         self._update_dat_struct()
@@ -305,7 +305,7 @@ class DAT(FMFile):
         if gxy_path.exists():
             self._gxy_filepath = gxy_path
             with open(self._gxy_filepath) as gxy_file:
-                self._gxy_data = gxy_file.read()
+                self._gxy_data: str | None = gxy_file.read()
         else:
             self._gxy_filepath = None
             self._gxy_data = None
@@ -327,7 +327,7 @@ class DAT(FMFile):
     def _create_from_blank(self, with_gxy: bool = False) -> None:
         # No filepath specified, create new 'blank' DAT in memory
         # ** Update these to have minimal data needed (general header, empty IC header)
-        self._dat_struct = [
+        self._dat_struct: list[dict[str, Any]] = [
             {"start": 0, "Type": "GENERAL", "end": 6},
             {"Type": "INITIAL CONDITIONS", "start": 7, "end": 8},
         ]
@@ -517,8 +517,21 @@ class DAT(FMFile):
                         block["end"] + block_shift
                     )  # add in to keep a record of the last block read in
 
-    def _get_unit_definitions(self):  # noqa: C901
-        # Get unit definitions
+    def _get_unit_definitions(self):
+        self._initialize_collections()
+        for block in self._dat_struct:
+            unit_data = self._raw_data[block["start"] : block["end"] + 1]
+            unit_type = block["Type"]
+
+            if unit_type in units.SUPPORTED_UNIT_TYPES:
+                self._process_supported_unit(unit_type, unit_data)
+            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}")
+
+    def _initialize_collections(self):
+        # Initialize unit collections
         self.sections = {}
         self.boundaries = {}
         self.structures = {}
@@ -526,96 +539,90 @@ class DAT(FMFile):
         self.losses = {}
         self._unsupported = {}
         self._all_units = []
-        for block in self._dat_struct:
-            unit_data = self._raw_data[block["start"] : block["end"] + 1]
-            if block["Type"] in units.SUPPORTED_UNIT_TYPES:
-                # Deal with initial conditions block
-                if block["Type"] == "INITIAL CONDITIONS":
-                    self.initial_conditions = units.IIC(unit_data, n=self._label_len)
-                    continue
-
-                if block["Type"] == "COMMENT":
-                    self._all_units.append(units.COMMENT(unit_data, n=self._label_len))
-                    continue
-
-                if block["Type"] == "VARIABLES":
-                    self.variables = units.Variables(unit_data)
-                    continue
-
-                # Check to see whether unit type has associated subtypes so that unit name can be correctly assigned
-                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()
 
-                # 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"]}',
-                    )
-                # Changes done to account for unit types with spaces/dashes eg Flat-V Weir
-                unit_type = block["Type"].replace(" ", "_").replace("-", "_")
-                unit_group[unit_name] = eval(
-                    f"units.{unit_type}({unit_data}, {self._label_len})",  # append to our _all._units as well???
-                )
-                self._all_units.append(unit_group[unit_name])
+    def _process_supported_unit(self, unit_type, unit_data):
+        # Handle initial conditions block
+        if unit_type == "INITIAL CONDITIONS":
+            self.initial_conditions = units.IIC(unit_data, n=self._label_len)
+        elif unit_type == "COMMENT":
+            self._all_units.append(units.COMMENT(unit_data, n=self._label_len))
+        elif unit_type == "VARIABLES":
+            self.variables = units.Variables(unit_data)
+        else:
+            # Check to see whether unit type has associated subtypes so that unit name can be correctly assigned
+            unit_name = self._get_unit_name(unit_type, unit_data)
+            # Create instance of unit and add to relevant group
+            unit_group = getattr(self, units.SUPPORTED_UNIT_TYPES[unit_type]["group"])
+            self._add_unit_to_group(unit_group, unit_type, unit_name, unit_data)
+
+    def _get_unit_name(self, unit_type, unit_data):
+        # Check if the unit type has associated subtypes
+        if units.SUPPORTED_UNIT_TYPES[unit_type]["has_subtype"]:
+            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):
+        # 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"]}',
+            )
+        # 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})",
+        )
+        self._all_units.append(unit_group[unit_name])
 
-            elif block["Type"] in units.UNSUPPORTED_UNIT_TYPES:
-                # Check to see whether unit type has associated subtypes so that unit name can be correctly assigned
-                if units.UNSUPPORTED_UNIT_TYPES[block["Type"]]["has_subtype"]:
-                    unit_name = unit_data[2][: self._label_len].strip()
-                    subtype = True
-                else:
-                    unit_name = unit_data[1][: self._label_len].strip()
-                    subtype = False
-
-                self._unsupported[f"{unit_name} ({block['Type']})"] = units.UNSUPPORTED(
-                    unit_data,
-                    self._label_len,
-                    unit_name=unit_name,
-                    unit_type=block["Type"],
-                    subtype=subtype,
-                )
-                self._all_units.append(self._unsupported[f"{unit_name} ({block['Type']})"])
+    def _process_unsupported_unit(self, unit_type, unit_data):
+        # 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(
+            unit_data,
+            self._label_len,
+            unit_name=unit_name,
+            unit_type=unit_type,
+            subtype=subtype,
+        )
+        self._all_units.append(self._unsupported[f"{unit_name} ({unit_type})"])
 
-            elif block["Type"] not in ("GENERAL", "GISINFO"):
-                raise Exception(f"Unexpected unit type encountered: {block['Type']}")
+    def _get_unsupported_unit_name(self, unit_type, unit_data):
+        # 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
+        return unit_data[1][: self._label_len].strip(), False
 
-    def _update_dat_struct(self) -> None:  # noqa: C901, PLR0912
+    def _update_dat_struct(self) -> None:
         """Internal method used to update self._dat_struct which details the overall structure of the dat file as a list of blocks, each of which
         are a dictionary containing the 'start', 'end' and 'type' of the block.
-
         """
-        # Generate DAT structure
-        dat_struct = []
+        self._dat_struct = []
         in_block = False
         in_general = True
         in_comment = False
-        comment_n = None  # Used as counter for number of lines in a comment block
+        comment_n: int | None = None  # Used as counter for number of lines in a comment block
         gisinfo_block = False
         general_block = {"start": 0, "Type": "GENERAL"}
         unit_block: dict[str, Any] = {}
+
         for idx, line in enumerate(self._raw_data):
             # Deal with 'general' header
-            if in_general is True:
-                if line == "END GENERAL":
-                    general_block["end"] = idx
-                    dat_struct.append(general_block)
-                    in_general = False
+            if in_general:
+                self._process_general_block(line, idx, general_block)
+                in_general = False if line == "END GENERAL" else in_general
                 continue
 
             # Deal with comment blocks explicitly as they could contain unit keywords
             if in_comment and comment_n is None:
                 comment_n = int(line.strip())
                 continue
-            if in_comment:
+            if in_comment and comment_n is not None:
                 comment_n -= 1
                 if comment_n <= 0:
                     unit_block["end"] = idx + comment_n  # add ending index
-                    # append existing bdy block to the dat_struct
-                    dat_struct.append(unit_block)
-                    unit_block = {}  # reset bdy block
+                    # append existing block to the dat_struct
+                    self._dat_struct.append(unit_block)
+                    unit_block = {}  # reset block
                     in_comment = False
                     in_block = False
                     comment_n = None
@@ -624,7 +631,6 @@ class DAT(FMFile):
             if line == "COMMENT":
                 in_comment = True
                 unit_block, in_block = self._close_struct_block(
-                    dat_struct,
                     "COMMENT",
                     unit_block,
                     in_block,
@@ -635,7 +641,6 @@ class DAT(FMFile):
             if line == "GISINFO":
                 gisinfo_block = True
                 unit_block, in_block = self._close_struct_block(
-                    dat_struct,
                     "GISINFO",
                     unit_block,
                     in_block,
@@ -643,33 +648,49 @@ class DAT(FMFile):
                 )
 
             if not gisinfo_block:
-                if line.split(" ")[0] in units.ALL_UNIT_TYPES:
-                    # The " " is needed here in case of empty string
-                    unit_type = line.split()[0]
-                elif " ".join(line.split()[:2]) in units.ALL_UNIT_TYPES:
-                    unit_type = " ".join(line.split()[:2])
-                else:
-                    continue
+                unit_type = self._identify_unit_type(line)
+                if unit_type:
+                    unit_block, in_block = self._close_struct_block(
+                        unit_type,
+                        unit_block,
+                        in_block,
+                        idx,
+                    )
 
-                unit_block, in_block = self._close_struct_block(
-                    dat_struct,
-                    unit_type,
-                    unit_block,
-                    in_block,
-                    idx,
-                )
+        self._finalize_last_block(unit_block)
 
+    def _process_general_block(
+        self,
+        line: str,
+        idx: int,
+        general_block: dict[str, Any],
+    ) -> None:
+        # Deal with 'general' header
+        if line == "END GENERAL":
+            general_block["end"] = idx
+            self._dat_struct.append(general_block)
+
+    def _identify_unit_type(self, line: str) -> str | None:
+        # Check to see whether unit type has associated subtypes so that unit name can be correctly assigned
+        if line.split(" ")[0] in units.ALL_UNIT_TYPES:
+            # The " " is needed here in case of empty string
+            return line.split()[0]
+        if " ".join(line.split()[:2]) in units.ALL_UNIT_TYPES:
+            return " ".join(line.split()[:2])
+        return None
+
+    def _finalize_last_block(
+        self,
+        unit_block: dict[str, Any],
+    ) -> None:
         if len(unit_block) != 0:
             # Only adds end block if there is a block present (i.e. an empty DAT stays empty)
             # add ending index for final block
             unit_block["end"] = len(self._raw_data) - 1
-            dat_struct.append(unit_block)  # add final block
-
-        self._dat_struct = dat_struct
+            self._dat_struct.append(unit_block)  # add final block
 
-    def _close_struct_block(  # noqa: PLR0913
+    def _close_struct_block(
         self,
-        dat_struct: list[dict],
         unit_type: str,
         unit_block: dict,
         in_block: bool,
@@ -679,7 +700,7 @@ class DAT(FMFile):
         if in_block is True:
             unit_block["end"] = idx - 1  # add ending index
             # append existing bdy block to the dat_struct
-            dat_struct.append(unit_block)
+            self._dat_struct.append(unit_block)
             unit_block = {}  # reset bdy block
         in_block = True
         unit_block["Type"] = unit_type  # start new bdy block
@@ -722,7 +743,7 @@ class DAT(FMFile):
         self.general_parameters["Node Count"] -= 1
 
     @handle_exception(when="insert unit into")
-    def insert_unit(  # noqa: C901, PLR0912, PLR0913
+    def insert_unit(  # noqa: C901, PLR0912
         self,
         unit: Unit,
         add_before: Unit | None = None,
@@ -833,7 +854,7 @@ class DAT(FMFile):
         self._update_raw_data()
         self._update_dat_struct()
 
-    def _update_gisinfo_label(  # noqa: PLR0913
+    def _update_gisinfo_label(
         self,
         unit_type,
         unit_subtype,

floodmodeller_api-0.5.0.post1/floodmodeller_api/hydrology_plus/__init__.py

@@ -0,0 +1,2 @@
+from .helper import load_hydrology_plus_csv_export
+from .hydrology_plus_export import HydrologyPlusExport

floodmodeller_api-0.5.0.post1/floodmodeller_api/hydrology_plus/helper.py

@@ -0,0 +1,23 @@
+"""Helps to create the class for the hydrology plus"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .hydrology_plus_export import HydrologyPlusExport
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def load_hydrology_plus_csv_export(file: str | Path) -> HydrologyPlusExport:
+    """
+    Loads a CSV containing exported Hydrology+ flow data and returns a HydrologyPlusExport object.
+
+    Args:
+        file (str | Path): The path to the Hydrology+ export CSV file.
+
+    Returns:
+        HydrologyPlusExport: An object representing the data from the Hydrology+ export.
+    """
+    return HydrologyPlusExport(file)