floodmodeller-api 0.5.1__py3-none-any.whl → 0.5.2.post1__py3-none-any.whl

floodmodeller_api/test/test_integrated_bridge.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pandas as pd
+import pytest
+
+from floodmodeller_api.units import BRIDGE
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def create_bridge(path: Path) -> BRIDGE:
+    with open(path) as file:
+        lines = [line.rstrip("\n") for line in file]
+    return BRIDGE(lines)
+
+
+@pytest.fixture()
+def folder(test_workspace: Path) -> Path:
+    return test_workspace / "integrated_bridge"
+
+
+def test_read_bridge(folder: Path):  # noqa: PLR0915 (all needed)
+    unit = create_bridge(folder / "US_vSP_NoBl_2O_Para.ied")
+
+    assert unit.comment == "prototype for rev 3 / No Spill data, no blockage"
+
+    assert unit.name == "Label11"
+    assert unit.ds_label == "Label12"
+    assert unit.us_remote_label == "CH0001"
+    assert unit.ds_remote_label == "CH0002"
+
+    assert unit.revision == 3
+    assert unit.bridge_name == "Clifton Suspension Bridge"
+    assert unit.integrated_subtype == "USBPR"
+
+    assert unit.calibration_coefficient == 1
+    assert unit.skew == 0
+    assert unit.bridge_width_dual == 0
+    assert unit.bridge_dist_dual == 0
+    assert unit.total_pier_width == 0
+    assert unit.orifice_flow is True
+    assert unit.orifice_lower_transition_dist == 0.3
+    assert unit.orifice_upper_transition_dist == 0.1
+    assert unit.orifice_discharge_coefficient == 1
+
+    assert unit.abutment_type == 3
+    assert unit.specify_piers is False
+    assert unit.soffit_shape == "FLAT"
+
+    assert unit.aligned is True
+
+    assert unit.section_nrows_list == [4, 0, 0, 0]
+
+    assert unit.opening_type == "PARABOLA1"
+    assert unit.opening_nrows == 2
+    assert unit.opening_nsubrows_list == [3, 3]
+
+    assert unit.culvert_nrows == 0
+
+    assert unit.spill_nrows == 3
+    assert unit.weir_coefficient == 1.7
+    assert unit.modular_limit == 0.9
+
+    assert unit.block_nrows == 0
+    assert unit.inlet_loss == 0.5
+    assert unit.outlet_loss == 1
+    assert unit.block_method == "USDEPTH"
+    assert unit.override is False
+
+    expected = pd.DataFrame(
+        {
+            "X": [-10.0, -10.0, 10.0, 10.0],
+            "Y": [5.0, 0.0, 0.0, 5.0],
+            "Mannings n": [0.035, 0.035, 0.035, 0.035],
+            "Panel": ["*", "", "", "*"],
+            "Embankments": ["LEFT", "", "", "RIGHT"],
+        },
+    )
+    pd.testing.assert_frame_equal(unit.section_data_list[0], expected)
+
+    expected = pd.DataFrame({"X": [], "Y": [], "Mannings n": [], "Panel": [], "Embankments": []})
+    pd.testing.assert_frame_equal(unit.section_data_list[1], expected, check_dtype=False)
+    pd.testing.assert_frame_equal(unit.section_data_list[2], expected, check_dtype=False)
+    pd.testing.assert_frame_equal(unit.section_data_list[3], expected, check_dtype=False)
+
+    expected = pd.DataFrame({"X": [-7.5, -5.0, -2.5], "Z": [0.0, 5.0, 0.0]})
+    pd.testing.assert_frame_equal(unit.opening_data_list[0], expected)
+
+    expected = pd.DataFrame({"X": [2.5, 5.0, 7.5], "Z": [0.0, 5.0, 0.0]})
+    pd.testing.assert_frame_equal(unit.opening_data_list[1], expected)
+
+    expected = pd.DataFrame(
+        {
+            "Invert": [],
+            "Soffit": [],
+            "Section Area": [],
+            "Cd Part Full": [],
+            "Cd Full": [],
+            "Drowning Coefficient": [],
+            "X": [],
+        },
+    )
+    pd.testing.assert_frame_equal(unit.culvert_data, expected, check_dtype=False)
+
+    expected = pd.DataFrame(
+        {
+            "X": [-10.0, 0.0, 10.0],
+            "Y": [7.0, 9.0, 7.0],
+            "Easting": [0.0, 0.0, 0.0],
+            "Northing": [0.0, 0.0, 0.0],
+        },
+    )
+    pd.testing.assert_frame_equal(unit.spill_data, expected)
+
+    expected = pd.DataFrame({"percentage": [], "time": [], "datetime": []})
+    pd.testing.assert_frame_equal(unit.block_data, expected, check_dtype=False)
+
+
+def test_write_bridge(folder: Path):
+    for file in folder.glob("*.ied"):
+        unit = create_bridge(folder / file)
+        output = unit._write()
+
+        new_unit = BRIDGE(output)
+        new_output = new_unit._write()
+        assert unit == new_unit, f"unit objects not equal for {file=}"
+        assert output == new_output, f"unit outputs not equal for {file=}"
+        for line in output:
+            assert isinstance(line, str), f"{line=} is not a string"
+
+
+def test_valid_change(folder: Path):
+    unit = create_bridge(folder / "US_vSP_NoBl_2O_Para.ied")
+
+    assert unit.calibration_coefficient == 1
+    unit.calibration_coefficient = 10
+    assert unit.calibration_coefficient == 10
+
+    output = unit._write()
+    new_unit = BRIDGE(output)
+    assert new_unit.calibration_coefficient == 10
+
+
+def test_invalid_change(folder: Path):
+    unit = create_bridge(folder / "US_vSP_NoBl_2O_Para.ied")
+    unit.calibration_coefficient = "hi"  # type: ignore
+    # ignoring typing as this mistake is on purpose
+    msg = (
+        "One or more parameters in <floodmodeller_api Unit Class:"
+        " BRIDGE(name=Label11, type=INTEGRATED)> are invalid:"
+        "\n     calibration_coefficient -> Expected: (<class 'float'>, <class 'int'>)"
+    )
+    with pytest.raises(ValueError, match=re.escape(msg)):
+        unit._write()

floodmodeller_api/test/test_json.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import json
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import pytest
 
@@ -7,6 +10,9 @@ from floodmodeller_api import DAT, IED, IEF, INP, XML2D
 from floodmodeller_api.to_from_json import is_jsonable
 from floodmodeller_api.util import read_file
 
+if TYPE_CHECKING:
+    from floodmodeller_api._base import FMFile
+
 
 def create_expected_json_files():
     """Helper function to recreate all the expected JSON files if needed at any point due to updates
@@ -48,7 +54,7 @@ def test_dat_json(dat_obj):
 
 
 @pytest.fixture()
-def parameterised_objs_and_expected(test_workspace):
+def parameterised_objs_and_expected(test_workspace) -> list[tuple[FMFile, Path]]:
     """JSON:  expected after passing to_json method"""
     return [
         (DAT(test_workspace / "EX18.DAT"), test_workspace / "EX18_DAT_expected.json"),
@@ -62,7 +68,7 @@ def parameterised_objs_and_expected(test_workspace):
     ]
 
 
-def test_to_json_matches_expected(parameterised_objs_and_expected):
+def test_to_json_matches_expected(parameterised_objs_and_expected: list[tuple[FMFile, Path]]):
     """JSON:  To test if the json object produced in to_json is identical to the expected json file"""
     for obj, json_expected in parameterised_objs_and_expected:
         # First, to create and handle the json (str) object
@@ -79,7 +85,7 @@ def test_to_json_matches_expected(parameterised_objs_and_expected):
             json_dict_from_obj.pop(key, None)
             json_dict_from_file.pop(key, None)
 
-        assert json_dict_from_obj == json_dict_from_file
+        assert json_dict_from_obj == json_dict_from_file, f"object not equal for {obj.filepath!s}"
 
 
 @pytest.mark.parametrize(

floodmodeller_api/test/test_logs_lf.py

@@ -1,3 +1,4 @@
+import logging
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
@@ -10,11 +11,11 @@ from floodmodeller_api.logs import create_lf
 
 
 @pytest.fixture()
-def lf1_fp(test_workspace):
+def lf1_fp(test_workspace: Path) -> Path:
     return Path(test_workspace, "ex3.lf1")
 
 
-def test_lf1_info_dict(lf1_fp):
+def test_lf1_info_dict(lf1_fp: Path):
     """LF1: Check info dictionary"""
     lf1 = LF1(lf1_fp)
     assert lf1.info["version"] == "5.0.0.7752"
@@ -23,23 +24,40 @@ def test_lf1_info_dict(lf1_fp):
     assert lf1.info["progress"] == 100
 
 
-def test_lf1_report_progress(lf1_fp):
+def test_lf1_report_progress(lf1_fp: Path):
     """LF1: Check report_progress()"""
     lf1 = LF1(lf1_fp)
     assert lf1.report_progress() == 100
 
 
-def test_lf1_to_dataframe(lf1_fp):
+def test_lf1_to_dataframe(lf1_fp: Path):
     """LF1: Check to_dataframe()"""
     lf1 = LF1(lf1_fp)
-    lf1_df = lf1.to_dataframe()
+    lf1_df = lf1.to_dataframe(variable="all")
+
     assert lf1_df.loc[lf1_df.index[0], "iter"] == 6
+    assert lf1.to_dataframe(variable="iter").iloc[0] == 6
+
     assert lf1_df.loc[lf1_df.index[-1], "outflow"] == 21.06
+    assert lf1.to_dataframe(variable="outflow").iloc[-1] == 21.06
+
     assert lf1_df.loc[lf1_df.index[4], "mass_error"] == -0.07
+    assert lf1.to_dataframe(variable="mass_error").iloc[4] == -0.07
+
+    lf1_tuflow_df = lf1.to_dataframe(variable="all", include_tuflow=True)
+    non_tuflow_columns = [col for col in lf1_tuflow_df.columns if "tuflow" not in col]
+    pd.testing.assert_frame_equal(lf1_tuflow_df[non_tuflow_columns], lf1_df)
+
+    tuflow_columns = [col for col in lf1_tuflow_df.columns if "tuflow" in col]
+    expected_tuflow_columns = ["tuflow_vol", "tuflow_n_wet", "tuflow_dt"]
+    assert set(tuflow_columns) == set(expected_tuflow_columns)
+
+    for col in tuflow_columns:
+        assert lf1_tuflow_df[col].isna().all()  # there is no tuflow in this lf1
 
 
-def test_lf1_from_ief(lf1_fp, test_workspace):
-    """LF1: Check IEF.get_lf1()"""
+def test_lf1_from_ief(lf1_fp: Path, test_workspace: Path):
+    """LF1: Check IEF.get_log()"""
     lf1 = LF1(lf1_fp)
 
     ief_fp = Path(test_workspace, "ex3.ief")
@@ -51,41 +69,44 @@ def test_lf1_from_ief(lf1_fp, test_workspace):
     pd.testing.assert_frame_equal(lf1.to_dataframe(), lf1_from_ief.to_dataframe())
 
 
-def test_log_file_unsupported(capsys):
-    lf = create_lf(None, "lf3")
+def test_log_file_unsupported(caplog):
+    with caplog.at_level(logging.WARNING):
+        lf = create_lf(None, "lf3")
 
     assert lf is None
     assert (
-        capsys.readouterr().out
-        == "No progress bar as log file must have suffix lf1 or lf2. Simulation will continue as usual.\n"
+        caplog.text
+        == "WARNING  root:lf.py:325 No progress bar as log file must have suffix lf1 or lf2. Simulation will continue as usual.\n"
     )
 
 
 @pytest.mark.usefixtures("log_timeout")
-def test_log_file_timeout(capsys):
-    lf_filepath = MagicMock()
-    lf_filepath.is_file.return_value = False
-    lf = create_lf(lf_filepath, "lf1")
+def test_log_file_timeout(caplog):
+    with caplog.at_level(logging.WARNING):
+        lf_filepath = MagicMock()
+        lf_filepath.is_file.return_value = False
+        lf = create_lf(lf_filepath, "lf1")
 
     assert lf is None
     assert (
-        capsys.readouterr().out
-        == "No progress bar as log file is expected but not detected. Simulation will continue as usual.\n"
+        caplog.text
+        == "WARNING  root:lf.py:325 No progress bar as log file is expected but not detected. Simulation will continue as usual.\n"
     )
 
 
 @pytest.mark.usefixtures("log_timeout")
 @freeze_time("1970-01-01 00:00:00", tick=True)
-def test_log_file_from_old_run(capsys):
-    lf_filepath = MagicMock()
-    lf_filepath.is_file.return_value = True
-    lf_filepath.stat.return_value.st_mtime = -10
-    lf = create_lf(lf_filepath, "lf1")
+def test_log_file_from_old_run(caplog):
+    with caplog.at_level(logging.WARNING):
+        lf_filepath = MagicMock()
+        lf_filepath.is_file.return_value = True
+        lf_filepath.stat.return_value.st_mtime = -10
+        lf = create_lf(lf_filepath, "lf1")
 
     assert lf is None
     assert (
-        capsys.readouterr().out
-        == "No progress bar as log file is from previous run. Simulation will continue as usual.\n"
+        caplog.text
+        == "WARNING  root:lf.py:325 No progress bar as log file is from previous run. Simulation will continue as usual.\n"
     )
 
 

floodmodeller_api/test/test_river.py

@@ -120,7 +120,7 @@ def test_create_from_blank():
     assert len(blank_unit.data) == 0
     assert len(blank_unit.active_data) == 0
     assert blank_unit._write() == [
-        "RIVER ",
+        "RIVER",
         "SECTION",
         "new_section                                                                         ",
         "     0.000            0.000100  1000.000",

floodmodeller_api/test/test_toolbox_structure_log.py

@@ -108,7 +108,6 @@ def conduit_chain_dat(conduit_filled):
 
 @pytest.fixture()
 def ex18_dat_path(test_workspace):
-    # TODO: Source a better test case that can be opened to public repo.
     return Path(test_workspace, "EX18.DAT")
 
 

floodmodeller_api/test/test_xml2d.py

@@ -3,6 +3,7 @@ from pathlib import Path
 import pytest
 
 from floodmodeller_api import XML2D
+from floodmodeller_api.util import FloodModellerAPIError
 
 
 @pytest.fixture()
@@ -130,15 +131,14 @@ def test_xml2d_reorder_elem_computational_area_wrong_position():
     x2d.domains[domain]["computational_area"]["ncols"] = 12
     x2d.domains[domain]["computational_area"]["nrows"] = 42
     x2d.domains[domain]["computational_area"]["rotation"] = 3.14159
-
     x2d.domains[domain]["run_data"]["upwind"] = "upwind value"
     x2d.domains[domain]["run_data"]["wall"] = "Humpty Dumpty"
-
-    # TODO: Add check that this should fail validation if in the wrong order
-    # # how do I check that something fails?
-
     assert x2d._write()
 
+    x2d.domains[domain]["run_data"]["upwind123"] = "upwind value"
+    with pytest.raises(FloodModellerAPIError):
+        assert x2d._write()
+
 
 def test_xml2d_update_value(xml_fp, data_before):
     """XML2D: Test changing and reverting link1d file and dtm makes no changes"""

floodmodeller_api/to_from_json.py

@@ -1,6 +1,6 @@
 """
 Flood Modeller Python API
-Copyright (C) 2024 Jacobs U.K. Limited
+Copyright (C) 2025 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.

floodmodeller_api/tool.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import argparse
+import logging
 import sys
 import tkinter as tk
 from dataclasses import dataclass
@@ -156,9 +157,6 @@ class Gui:
             entry.pack()
             self.root_entries[name] = entry
 
-        # TODO: Add a progress bar if appropriate
-        # TODO: Present some useful information: either tool outputs or logs
-
     def run_gui_callback(self):
         """
         Method to run the gui callback function.
@@ -308,9 +306,9 @@ class FMTool:
             value = getattr(args, input_param.name)
             input_kwargs[input_param.name] = input_param.dtype(value)
 
-        print(f"Running {self.name}")
+        logging.info("Running %s", self.name)
         self.run(**input_kwargs)
-        print("Completed")
+        logging.info("Completed")
         # Return nothing
 
     def generate_gui(self):

floodmodeller_api/toolbox/model_build/add_siltation_definition.py

@@ -1,4 +1,4 @@
-""" This function allows you to raise the minimum bed level 300mm across all sections in a DAT file (i.e siltation) """
+"""This function allows you to raise the minimum bed level 300mm across all sections in a DAT file (i.e siltation)"""
 
 from __future__ import annotations
 

floodmodeller_api/toolbox/model_build/structure_log/structure_log.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import copy
 import csv
+import logging
 from typing import TYPE_CHECKING
 
 from floodmodeller_api import DAT
@@ -224,7 +225,6 @@ class StructureLogBuilder:
 
         return {"dimensions": dimensions}
 
-    # TODO: a refactor to combine the _add_conduits and _add_structures together would be nice for clarity
     def add_conduits(self):
         conduit_stack = copy.deepcopy(list(self.dat.conduits.values()))
 
@@ -245,8 +245,9 @@ class StructureLogBuilder:
                 ("CONDUIT", "SPRUNG"),
                 ("REPLICATE", None),
             ]:
-                print(
-                    f'Conduit sub-type "{conduit.subtype}" is currently unsupported in structure log',
+                logging.warning(
+                    "Conduit subtype: %s not currently supported in structure log",
+                    conduit.subtype,
                 )
                 continue
             conduit_dict, add_to_conduit_stack = self._conduit_data(conduit)
@@ -339,7 +340,7 @@ class StructureLogBuilder:
 
         culvert_data = []
         if hasattr(structure, "culvert_data") and structure.culvert_data.shape[0] > 1:
-            for _, row in structure.culvert_data:
+            for _, row in structure.culvert_data.iterrows():
                 culvert = {
                     "invert": row["Invert"],
                     "soffit": row["Soffit"],
@@ -357,7 +358,6 @@ class StructureLogBuilder:
         }
 
     def _sluice_data(self, structure: SLUICE) -> dict:
-        # TODO: these could do with more attention, given more time
         dimensions = extract_attrs(structure, {"crest_elevation", "weir_breadth", "weir_length"})
 
         return {"dimensions": dimensions}
@@ -395,7 +395,10 @@ class StructureLogBuilder:
             elif structure._unit == "BRIDGE":
                 self.unit_store[(structure.name, structure._unit)] |= self._bridge_data(structure)
             else:
-                print(f'Structure "{structure._unit}" is currently unsupported in structure log')
+                logging.warning(
+                    "Structure: %s not currently supported in structure log",
+                    structure._unit,
+                )
                 continue
 
     def _format_friction(self, unit_dict):
@@ -422,7 +425,6 @@ class StructureLogBuilder:
         return text
 
     def _format_bridge_dimensions(self, unit_dict):
-
         if len(unit_dict["opening_data"]) == 1:
             opening = unit_dict["opening_data"][0]
             height = opening["opening_height"]
@@ -545,7 +547,7 @@ class StructureLogBuilder:
 
             culvert_loss = ""
 
-            match (unit_type):
+            match unit_type:
                 case "BRIDGE":
                     dimensions = self._format_bridge_dimensions(unit_dict)
                 case "ORIFICE":

floodmodeller_api/units/__init__.py

@@ -1,6 +1,10 @@
+from typing import TypeAlias
+
 from .boundaries import HTBDY, QHBDY, QTBDY, REFHBDY
 from .comment import COMMENT
 from .conduits import CONDUIT
+from .connectors import JUNCTION, LATERAL
+from .controls import RESERVOIR
 from .iic import IIC
 from .losses import BLOCKAGE, CULVERT
 from .sections import INTERPOLATE, REPLICATE, RIVER
@@ -18,3 +22,14 @@ from .structures import (
 from .units import ALL_UNIT_TYPES, SUPPORTED_UNIT_TYPES, UNSUPPORTED_UNIT_TYPES
 from .unsupported import UNSUPPORTED
 from .variables import Variables
+
+TBoundaries: TypeAlias = HTBDY | QHBDY | QTBDY | REFHBDY
+TSections: TypeAlias = INTERPOLATE | REPLICATE | RIVER
+TConduits: TypeAlias = CONDUIT
+TConnectors: TypeAlias = JUNCTION | LATERAL
+TControls: TypeAlias = RESERVOIR
+TLosses: TypeAlias = BLOCKAGE | CULVERT
+TStructures: TypeAlias = (
+    BRIDGE | CRUMP | FLAT_V_WEIR | ORIFICE | OUTFALL | RNWEIR | SLUICE | SPILL | WEIR
+)
+TUnsupported: TypeAlias = UNSUPPORTED

floodmodeller_api/units/_base.py

@@ -1,6 +1,6 @@
 """
 Flood Modeller Python API
-Copyright (C) 2024 Jacobs U.K. Limited
+Copyright (C) 2025 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.
@@ -18,11 +18,15 @@ from __future__ import annotations
 
 """ Holds the base unit class for all FM Units """
 
+import logging
+from itertools import chain
+from typing import Any
+
 import pandas as pd
 
 from ..diff import check_item_with_dataframe_equal
 from ..to_from_json import Jsonable
-from .helpers import _to_float, _to_str, join_10_char, join_n_char_ljust, split_10_char
+from ._helpers import join_10_char, join_n_char_ljust, split_10_char, to_float, to_int, to_str
 
 
 class Unit(Jsonable):
@@ -59,6 +63,36 @@ class Unit(Jsonable):
             msg = f'Failed to set unit name to "{new_name}" due to error: {e}'
             raise Exception(msg) from e
 
+    @property
+    def all_labels(self) -> set[str]:
+        """All explicit labels associated with a unit."""
+        label_attrs = [
+            "name",
+            "spill",
+            "spill1",
+            "spill2",
+            "first_spill",
+            "second_spill",
+            "lat1",
+            "lat2",
+            "lat3",
+            "lat4",
+            "ds_label",
+        ]
+        label_list_attrs = ["labels", "lateral_inflow_labels"]
+
+        labels = {getattr(self, x) for x in label_attrs if hasattr(self, x)}
+        label_lists = [getattr(self, x) for x in label_list_attrs if hasattr(self, x)]
+
+        return (labels | set(chain(*label_lists))) - {""}
+
+    @property
+    def unique_name(self) -> str:
+        if self._name is None:
+            msg = "No unique name available."
+            raise ValueError(msg)
+        return f"{self._unit}_{self._name}"
+
     @property
     def subtype(self) -> str | None:
         return self._subtype
@@ -91,14 +125,17 @@ class Unit(Jsonable):
     def _diff(self, other):
         diff = self._get_diff(other)
         if diff[0]:
-            print("No difference, units are equivalent")
+            logging.info("No difference, units are equivalent")
         else:
-            print("\n".join([f"{name}:  {reason}" for name, reason in diff[1]]))
+            logging.info("\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):
+        if not isinstance(other, Unit):
+            return NotImplemented if not return_diff else (False, ["Type mismatch"])
+
         result = True
         diff = []
         result, diff = check_item_with_dataframe_equal(
@@ -114,16 +151,16 @@ class Unit(Jsonable):
     def _read_rules(self, block):
         rule_params = split_10_char(block[self._last_gate_row + 1])
         self.nrules = int(rule_params[0])
-        self.rule_sample_time = _to_float(rule_params[1])
-        self.timeunit = _to_str(rule_params[2], "SECONDS", check_float=False)
-        self.extendmethod = _to_str(rule_params[3], "EXTEND")
+        self.rule_sample_time = to_float(rule_params[1])
+        self.timeunit = to_str(rule_params[2], "SECONDS", check_float=False)
+        self.extendmethod = to_str(rule_params[3], "EXTEND")
         self.rules = self._get_logical_rules(self.nrules, block, self._last_gate_row + 2)
         # Get time rule data set
         nrows = int(split_10_char(block[self._last_rule_row + 1])[0])
         data_list = []
         for row in block[self._last_rule_row + 2 : self._last_rule_row + 2 + nrows]:
             row_split = split_10_char(f"{row:<20}")
-            x = _to_float(row_split[0])  # time
+            x = to_float(row_split[0])  # time
             y = row[10:].strip()  # operating rules
             data_list.append([x, y])
         self._last_time_row = self._last_rule_row + nrows + 1
@@ -139,14 +176,14 @@ class Unit(Jsonable):
             self.has_varrules = True
             varrule_params = split_10_char(block[self._last_time_row + 2])
             self.nvarrules = int(varrule_params[0])
-            self.varrule_sample_time = _to_float(rule_params[1])
+            self.varrule_sample_time = to_float(rule_params[1])
             self.varrules = self._get_logical_rules(self.nvarrules, block, self._last_time_row + 3)
             # Get time rule data set
             var_nrows = int(split_10_char(block[self._last_rule_row + 1])[0])
             data_list = []
             for row in block[self._last_rule_row + 2 : self._last_rule_row + 2 + var_nrows]:
                 row_split = split_10_char(f"{row:<20}")
-                x = _to_float(row_split[0])  # time
+                x = to_float(row_split[0])  # time
                 y = row[10:].strip()  # operating rules
                 data_list.append([x, y])
 
@@ -216,3 +253,29 @@ class Unit(Jsonable):
         self._last_rule_row = rule_row
 
         return rules
+
+    def _remove_unit_name(self, line: str, *, remove_revision: bool = False) -> str:
+        line = line.replace(self._unit, "", 1)
+        if remove_revision:
+            line = line.replace("#revision#", "", 1)
+        return line.strip()
+
+    def _create_header(self, *, include_revision: bool = False) -> str:
+        header = self._unit
+        if include_revision and hasattr(self, "_revision"):
+            header += f" #revision#{self._revision}"
+        if hasattr(self, "comment") and self.comment != "":
+            header += f" {self.comment}"
+        return header
+
+    def _get_first_word(self, line: str) -> str:
+        return line.split(" ")[0].strip()
+
+    def _get_revision_and_comment(self, line: str) -> tuple[int | None, str]:
+        line_without_name = self._remove_unit_name(line, remove_revision=True)
+        revision = to_int(line_without_name[0], None) if line_without_name != "" else None
+        comment = line_without_name[1:].strip()
+        return revision, comment
+
+    def _enforce_dataframe(self, data: Any, columns: tuple[str, ...]) -> pd.DataFrame:
+        return data if isinstance(data, pd.DataFrame) else pd.DataFrame([], columns=columns)