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

floodmodeller_api/units/sections.py

@@ -19,7 +19,7 @@ import pandas as pd
 from floodmodeller_api.validation import _validate_unit
 
 from ._base import Unit
-from .conveyance import calculate_cross_section_conveyance_chached
+from .conveyance import calculate_cross_section_conveyance_cached
 from .helpers import (
     _to_float,
     _to_int,
@@ -51,12 +51,21 @@ class RIVER(Unit):
 
     Returns:
         RIVER: Flood Modeller RIVER Unit class object
-
-    Methods:
-        convert_to_muskingham: Not currently supported but planned for future release
     """
 
     _unit = "RIVER"
+    _required_columns = [
+        "X",
+        "Y",
+        "Mannings n",
+        "Panel",
+        "RPL",
+        "Marker",
+        "Easting",
+        "Northing",
+        "Deactivation",
+        "SP. Marker",
+    ]
 
     def _create_from_blank(  # noqa: PLR0913
         self,
@@ -88,29 +97,18 @@ class RIVER(Unit):
             "dist_to_next": dist_to_next,
             "slope": slope,
             "density": density,
-            "data": data,
         }.items():
             setattr(self, param, val)
 
-        self.data = (
+        self._data = (
             data
             if isinstance(data, pd.DataFrame)
             else pd.DataFrame(
                 [],
-                columns=[
-                    "X",
-                    "Y",
-                    "Mannings n",
-                    "Panel",
-                    "RPL",
-                    "Marker",
-                    "Easting",
-                    "Northing",
-                    "Deactivation",
-                    "SP. Marker",
-                ],
+                columns=self._required_columns,
             )
         )
+        self._active_data = None
 
     def _read(self, riv_block):
         """Function to read a given RIVER block and store data as class attributes."""
@@ -171,20 +169,9 @@ class RIVER(Unit):
                         sp_marker,
                     ],
                 )
-            self.data = pd.DataFrame(
+            self._data = pd.DataFrame(
                 data_list,
-                columns=[
-                    "X",
-                    "Y",
-                    "Mannings n",
-                    "Panel",
-                    "RPL",
-                    "Marker",
-                    "Easting",
-                    "Northing",
-                    "Deactivation",
-                    "SP. Marker",
-                ],
+                columns=self._required_columns,
             )
 
         else:
@@ -195,6 +182,8 @@ class RIVER(Unit):
             self._raw_block = riv_block
             self.name = riv_block[2][: self._label_len].strip()
 
+        self._active_data = None
+
     def _write(self):
         """Function to write a valid RIVER block"""
 
@@ -214,7 +203,7 @@ class RIVER(Unit):
             )
             # Manual so slope can have more sf
             params = f'{self.dist_to_next:>10.3f}{"":>10}{self.slope:>10.6f}{self.density:>10.3f}'
-            self.nrows = len(self.data)
+            self.nrows = len(self._data)
             riv_block = [header, self.subtype, labels, params, f"{str(self.nrows):>10}"]
 
             riv_data = []
@@ -230,7 +219,7 @@ class RIVER(Unit):
                 northing,
                 deactivation,
                 sp_marker,
-            ) in self.data.itertuples():
+            ) in self._data.itertuples():
                 row = join_10_char(x, y, n)
                 if panel:
                     row += "*"
@@ -245,6 +234,36 @@ class RIVER(Unit):
 
         return self._raw_block
 
+    @property
+    def data(self) -> pd.DataFrame:
+        """Data table for the river cross section.
+
+        Returns:
+            pd.DataFrame: Pandas dataframe for the cross section data with columns: 'X', 'Y',
+            'Mannings n', 'Panel', 'RPL', 'Marker', 'Easting', 'Northing', 'Deactivation',
+            'SP. Marker'
+        """
+        if self._active_data is None:
+            return self._data
+
+        # Replace the active section with the self._active_data df
+        left_bank_idx, right_bank_idx = self._get_left_right_active_index()
+        self._data = pd.concat(
+            [self._data[:left_bank_idx], self._active_data, self._data[right_bank_idx + 1 :]],
+        ).reset_index(drop=True)
+        self._active_data = None
+        return self._data
+
+    @data.setter
+    def data(self, new_df: pd.DataFrame) -> None:
+        if not isinstance(new_df, pd.DataFrame):
+            raise ValueError(
+                "The updated data table for a cross section must be a pandas DataFrame.",
+            )
+        if new_df.columns != self._required_columns:
+            raise ValueError(f"The DataFrame must only contain columns: {self._required_columns}")
+        self._data = new_df
+
     @property
     def conveyance(self) -> pd.Series:
         """Calculate and return the conveyance curve of the cross-section.
@@ -257,14 +276,76 @@ class RIVER(Unit):
         Returns:
             pd.Series: A pandas Series containing the conveyance values indexed by water levels.
         """
-        return calculate_cross_section_conveyance_chached(
-            x=tuple(self.data.X.values),
-            y=tuple(self.data.Y.values),
-            n=tuple(self.data["Mannings n"].values),
-            rpl=tuple(self.data.RPL.values),
-            panel_markers=tuple(self.data.Panel.values),
+        return calculate_cross_section_conveyance_cached(
+            x=tuple(self._data.X.values),
+            y=tuple(self._data.Y.values),
+            n=tuple(self._data["Mannings n"].values),
+            rpl=tuple(self._data.RPL.values),
+            panel_markers=tuple(self._data.Panel.values),
         )
 
+    @property
+    def active_data(self) -> pd.DataFrame:
+        """Data table for active subset of the river cross section, defined by deactivation markers.
+
+        Returns:
+            pd.DataFrame: Pandas dataframe for the active cross section data with columns: 'X', 'Y',
+            'Mannings n', 'Panel', 'RPL', 'Marker', 'Easting', 'Northing', 'Deactivation',
+            'SP. Marker'
+
+        Example:
+            In this example we read in a river section that has deactivation markers
+
+            .. ipython:: python
+
+                from floodmodeller_api.units import RIVER
+                river_unit = RIVER(
+                    [
+                        "RIVER normal case",
+                        "SECTION",
+                        "SomeUnit",
+                        "     0.000            0.000100  1000.000",
+                        "        5",
+                        "     0.000        10     0.030     0.000                 0.0       0.0          ",
+                        "     1.000         9     0.030     0.000                 0.0       0.0      LEFT",
+                        "     2.000         5     0.030     0.000                 0.0       0.0          ",
+                        "     3.000         6     0.030     0.000                 0.0       0.0     RIGHT",
+                        "     4.000        10     0.030     0.000                 0.0       0.0          ",
+                    ]
+                )
+                river_unit.data
+                river_unit.active_data
+        """
+        if self._active_data is not None:
+            return self._active_data
+        left_bank_idx, right_bank_idx = self._get_left_right_active_index()
+        self._active_data = self._data.iloc[left_bank_idx : right_bank_idx + 1].copy()
+        return self._active_data
+
+    @active_data.setter
+    def active_data(self, new_df: pd.DataFrame) -> None:
+        if not isinstance(new_df, pd.DataFrame):
+            raise ValueError(
+                "The updated data table for a cross section must be a pandas DataFrame.",
+            )
+        if new_df.columns.to_list() != self._required_columns:
+            raise ValueError(f"The DataFrame must only contain columns: {self._required_columns}")
+
+        # Ensure activation markers are present
+        new_df = new_df.copy()
+        new_df.iloc[0, 8] = "LEFT"
+        new_df.iloc[-1, 8] = "RIGHT"
+        self._active_data = new_df
+
+    def _get_left_right_active_index(self) -> tuple[int, int]:
+        bank_data = self._data.Deactivation.to_list()
+        lb_flag = "LEFT" in bank_data
+        rb_flag = "RIGHT" in bank_data
+
+        left_bank_idx = (len(bank_data) - 1) - bank_data[::-1].index("LEFT") if lb_flag else 0
+        right_bank_idx = bank_data.index("RIGHT") if rb_flag else len(bank_data) - 1
+        return left_bank_idx, right_bank_idx
+
 
 class INTERPOLATE(Unit):
     """Class to hold and process INTERPOLATE unit type

floodmodeller_api/util.py

@@ -59,6 +59,7 @@ def read_file(filepath: str | Path) -> FMFile:
 
     """
     from . import DAT, IED, IEF, INP, LF1, LF2, XML2D, ZZN
+    from .hydrology_plus import HydrologyPlusExport
 
     suffix_to_class = {
         ".ief": IEF,
@@ -69,6 +70,7 @@ def read_file(filepath: str | Path) -> FMFile:
         ".inp": INP,
         ".lf1": LF1,
         ".lf2": LF2,
+        ".csv": HydrologyPlusExport,
     }
     filepath = Path(filepath)
     api_class = suffix_to_class.get(filepath.suffix.lower())

floodmodeller_api/version.py

@@ -1 +1 @@
-__version__ = "0.4.4.post1"
+__version__ = "0.5.0"

floodmodeller_api/xml2d.py

@@ -24,6 +24,7 @@ from pathlib import Path
 from subprocess import DEVNULL, Popen
 from typing import Callable
 
+import requests
 from lxml import etree
 from tqdm import trange
 
@@ -57,7 +58,7 @@ class XML2D(FMFile):
         xml_filepath (str, optional): Full filepath to xml file.
 
     Output:
-        Initiates 'XML' class object
+        Initiates 'XML2D' class object
 
     Raises:
         TypeError: Raised if xml_filepath does not point to a .xml file
@@ -66,7 +67,8 @@ class XML2D(FMFile):
 
     _filetype: str = "XML2D"
     _suffix: str = ".xml"
-    _xsd_loc: str = "http://schema.floodmodeller.com/6.2/2d.xsd"
+    _xsd_loc: str = "https://schema.floodmodeller.com/7.1/2d.xsd"
+    _w3_schema: str = "{http://www.w3.org/2001/XMLSchema}"
     OLD_FILE = 5
     GOOD_EXIT_CODE = 100
 
@@ -88,8 +90,13 @@ class XML2D(FMFile):
             self._xmltree = etree.parse(io.StringIO(xml2d_template))
         else:
             self._xmltree = etree.parse(self._filepath)
-        self._xsd = etree.parse(self._xsd_loc)
-        self._xsdschema = etree.XMLSchema(self._xsd)
+        try:
+            xsd_bin = requests.get(self._xsd_loc).content
+            self._xsd = etree.parse(io.BytesIO(xsd_bin))
+            self._xsdschema = etree.XMLSchema(self._xsd)
+        except Exception:
+            self._xsd = etree.parse(Path(__file__).parent / "xsd_backup.xml")
+            self._xsdschema = etree.XMLSchema(self._xsd)
         self._get_multi_value_keys()
 
         self._create_dict()
@@ -175,18 +182,18 @@ class XML2D(FMFile):
         # find element in schema
         parent_name = parent.tag.replace(self._ns, "")
         schema_elem = self._xsd.find(
-            f".//{{http://www.w3.org/2001/XMLSchema}}*[@name='{parent_name}']",
+            f".//{self._w3_schema}*[@name='{parent_name}']",
         )
         if "type" in schema_elem.attrib:
             schema_elem = self._xsd.find(
-                f".//{{http://www.w3.org/2001/XMLSchema}}*[@name='{schema_elem.attrib['type']}']",
+                f".//{self._w3_schema}*[@name='{schema_elem.attrib['type']}']",
             )
         else:
-            schema_elem = schema_elem.find("{http://www.w3.org/2001/XMLSchema}complexType")
+            schema_elem = schema_elem.find(f"{self._w3_schema}complexType")
         if schema_elem is None:
             return parent.getchildren()
 
-        seq = schema_elem.find("{http://www.w3.org/2001/XMLSchema}sequence")
+        seq = schema_elem.find(f"{self._w3_schema}sequence")
         if seq is None:
             return parent.getchildren()
 
@@ -311,7 +318,7 @@ class XML2D(FMFile):
             # Check schema to see if we should use parent.set for attribute
             # or etree.subelement() and set text
             schema_elem = self._xsd.findall(
-                f".//{{http://www.w3.org/2001/XMLSchema}}*[@name='{add_key}']",
+                f".//{self._w3_schema}*[@name='{add_key}']",
             )
             if len(schema_elem) == 1:
                 schema_elem = schema_elem[0]
@@ -319,14 +326,14 @@ class XML2D(FMFile):
                 # This is just here for when there's multiple schema elements with same
                 # name, e.g. 'frequency'
                 parent_schema_elem = self._xsd.find(
-                    f".//{{http://www.w3.org/2001/XMLSchema}}*[@name='{parent.tag.replace(self._ns, '')}']",
+                    f".//{self._w3_schema}*[@name='{parent.tag.replace(self._ns, '')}']",
                 )
                 if "type" in parent_schema_elem.attrib:
                     parent_schema_elem = self._xsd.find(
-                        f".//{{http://www.w3.org/2001/XMLSchema}}*[@name='{parent_schema_elem.attrib['type']}']",
+                        f".//{self._w3_schema}*[@name='{parent_schema_elem.attrib['type']}']",
                     )
                 schema_elem = parent_schema_elem.find(
-                    f".//{{http://www.w3.org/2001/XMLSchema}}*[@name='{add_key}']",
+                    f".//{self._w3_schema}*[@name='{add_key}']",
                 )
 
             if schema_elem.tag.endswith("attribute"):
@@ -403,7 +410,7 @@ class XML2D(FMFile):
     def _get_multi_value_keys(self):
         self._multi_value_keys = []
         root = self._xsd.getroot()
-        for elem in root.findall(".//{http://www.w3.org/2001/XMLSchema}element"):
+        for elem in root.findall(f".//{self._w3_schema}element"):
             if elem.attrib.get("maxOccurs") not in (None, "0", "1"):
                 self._multi_value_keys.append(elem.attrib["name"])
         self._multi_value_keys = set(self._multi_value_keys)