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

floodmodeller_api/ief.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.
@@ -17,6 +17,7 @@ address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London
 from __future__ import annotations
 
 import csv
+import logging
 import subprocess
 import time
 from io import StringIO
@@ -32,19 +33,28 @@ from .diff import check_item_with_dataframe_equal
 from .ief_flags import flags
 from .logs import LF1, create_lf
 from .to_from_json import Jsonable
-from .util import handle_exception
+from .util import handle_exception, is_windows
 from .zz import ZZN
 
 
-def try_numeric(value: str) -> str | int | float:
+def try_converting(value: str) -> str | int | float:
     """Attempt to parse value as float or int if valid, else return the original string"""
     try:
         return int(value)
     except ValueError:
-        try:
-            return float(value)
-        except ValueError:
-            return value
+        pass
+
+    try:
+        return float(value)
+    except ValueError:
+        pass
+
+    if not is_windows() and "\\" in value:
+        # backslashes aren't valid in paths
+        logging.info("Changing '\\' in '%s' to '/' to be valid in Linux.", value)
+        return value.replace("\\", "/")
+
+    return value
 
 
 class IEF(FMFile):
@@ -74,13 +84,13 @@ class IEF(FMFile):
         if ief_filepath is not None:
             FMFile.__init__(self, ief_filepath)
             self._read()
-            self._log_path = self._get_result_filepath("lf1")
+            self._log_path = self._filepath.with_suffix(".lf1")
         else:
             self._create_from_blank()
 
     def _read(self):
         # Read IEF data
-        with open(self._filepath) as ief_file:
+        with open(self._filepath, encoding=self.ENCODING) as ief_file:
             raw_data = [line.rstrip("\n") for line in ief_file]
         # Clean data and add as class properties
         # Create a list to store the properties which are to be saved in IEF, so as to ignore any temp properties.
@@ -116,7 +126,7 @@ class IEF(FMFile):
                     self._ief_properties.append(prop)
                 else:
                     # Sets the property and value as class properties so they can be edited.
-                    setattr(self, prop, try_numeric(value))
+                    setattr(self, prop, try_converting(value))
                     self._ief_properties.append(prop)
                 prev_comment = None
             else:
@@ -208,7 +218,7 @@ class IEF(FMFile):
             if "=" in line:
                 prop, value = line.split("=")
                 # Sets the property and value as class properties so they can be edited.
-                setattr(self, prop, try_numeric(value))
+                setattr(self, prop, try_converting(value))
                 self._ief_properties.append(prop)
             else:
                 # This should add the [] bound headers
@@ -226,8 +236,9 @@ class IEF(FMFile):
             ):
                 # Check if valid flag
                 if prop.upper() not in flags:
-                    print(
-                        f"Warning: '{prop}' is not a valid IEF flag, it will be ommited from the IEF\n",
+                    logging.warning(
+                        "'%s' is not a valid IEF flag, it will be ommited from the IEF\n",
+                        prop,
                     )
                     continue
 
@@ -435,6 +446,7 @@ class IEF(FMFile):
             filepath (string): Full filepath to new location for ief file (including '.ief' extension)
         """
         self._save(filepath)
+        self._log_path = self._filepath.with_suffix(".lf1")
 
     @handle_exception(when="simulate")
     def simulate(  # noqa: C901, PLR0912, PLR0913
@@ -501,10 +513,10 @@ class IEF(FMFile):
             msg = f"Flood Modeller engine not found! Expected location: {isis32_fp}"
             raise Exception(msg)
 
-        run_command = f'"{isis32_fp}" -sd "{self._filepath}"'
+        run_command = f'"{isis32_fp}" -sd "{self._filepath.resolve()}"'
 
         if method.upper() == "WAIT":
-            print("Executing simulation...")
+            logging.info("Executing simulation...")
             # execute simulation
             process = Popen(run_command, cwd=Path(self._filepath).parent)
 
@@ -521,10 +533,10 @@ class IEF(FMFile):
 
             if result == 1 and raise_on_failure:
                 raise RuntimeError(summary)
-            print(summary)
+            logging.info(summary)
 
         elif method.upper() == "RETURN_PROCESS":
-            print("Executing simulation...")
+            logging.info("Executing simulation...")
             # execute simulation
             return Popen(run_command, cwd=Path(self._filepath).parent)
 

floodmodeller_api/ief_flags.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/inp.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.
@@ -20,7 +20,7 @@ from pathlib import Path
 
 from . import units
 from ._base import FMFile
-from .units.helpers import _to_str, join_n_char_ljust
+from .units._helpers import join_n_char_ljust, to_str
 from .urban1d import subsections
 from .urban1d.general_parameters import DEFAULT_OPTIONS
 from .util import handle_exception
@@ -59,7 +59,7 @@ class INP(FMFile):
 
     def _read(self):
         # Read INP file
-        with open(self._filepath) as inp_file:
+        with open(self._filepath, encoding=self.ENCODING) as inp_file:
             self._raw_data = [line.rstrip("\n") for line in inp_file]
 
         # Generate INP file structure
@@ -158,7 +158,7 @@ class INP(FMFile):
                                 data = units.helpers.split_n_char(line, 21)
 
                                 # Set type to Float or Stirng, as appropirate.
-                                self.options[data[0].lower()] = _to_str(
+                                self.options[data[0].lower()] = to_str(
                                     data[1],
                                     None,
                                     check_float=True,
@@ -197,8 +197,6 @@ class INP(FMFile):
         in_block = False
         unit_block = {}
         for idx, line in enumerate(self._raw_data):
-            # TODO: Add functionality to compare first four characters only (alphanumeric) - need to consider names shorter than 4 characters, and those with _ within name
-
             # Check if subsection is known
             if line.upper() in subsections.ALL_SUBSECTIONS:
                 if in_block is True:

floodmodeller_api/logs/lf.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.
@@ -17,6 +17,7 @@ address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London
 from __future__ import annotations
 
 import datetime as dt
+import logging
 import time
 from typing import TYPE_CHECKING
 
@@ -55,7 +56,7 @@ class LF(FMFile):
     def __init__(
         self,
         lf_filepath: str | Path | None,
-        data_to_extract: dict,
+        data_to_extract: dict[str, dict],
         steady: bool = False,
     ):
         FMFile.__init__(self, lf_filepath)
@@ -175,7 +176,7 @@ class LF(FMFile):
 
         delattr(self, "info")
 
-    def to_dataframe(self, *, include_tuflow: bool = False) -> pd.DataFrame:
+    def to_dataframe(self, variable: str = "all", *, include_tuflow: bool = False) -> pd.DataFrame:
         """Collects parameter values that change throughout simulation into a dataframe
 
         Args:
@@ -185,17 +186,22 @@ class LF(FMFile):
             pd.DataFrame: DataFrame of log file parameters indexed by simulation time (unsteady) or network iterations (steady)
         """
 
-        # TODO: make more like ZZN.to_dataframe
-
-        data_type_all = {
+        lf_df_data = {
             k: getattr(self, k)
             for k, v in self._data_to_extract.items()
-            if v["data_type"] == "all" and (include_tuflow or "tuflow" not in k)
+            if v["data_type"] == "all"  # with entries every iteration
+            and (include_tuflow or "tuflow" not in k)  # tuflow-related only if requested
+            and (variable in ("all", k, *v.get("subheaders", [])))  # if it or all are requested
         }
 
-        lf_df = pd.concat(data_type_all, axis=1)
-        lf_df.columns = lf_df.columns.droplevel()
+        if lf_df_data == {}:
+            msg = f"No data extracted for variable '{variable}'"
+            raise ValueError(msg)
 
+        lf_df = pd.concat(lf_df_data, axis=1)
+        lf_df.columns = lf_df.columns.droplevel()
+        if variable != "all":
+            lf_df = lf_df[variable]  # otherwise subheaders result in extra columns
         return lf_df.sort_index()
 
     def _sync_cols(self):
@@ -217,7 +223,7 @@ class LF(FMFile):
     def _print_no_lines(self):
         """Prints number of lines that have been read so far"""
 
-        print("Last line read: " + str(self._no_lines))
+        logging.info("Last line read: %s", self._no_lines)
 
     def report_progress(self) -> float:
         """Returns progress for unsteady simulations
@@ -316,7 +322,7 @@ def create_lf(filepath: Path, suffix: str) -> LF1 | LF2 | None:
     """Checks for a new log file, waiting for its creation if necessary"""
 
     def _no_log_file(reason: str) -> None:
-        print(f"No progress bar as {reason}. Simulation will continue as usual.")
+        logging.warning("No progress bar as %s. Simulation will continue as usual.", reason)
 
     # ensure progress bar is supported
     if suffix not in {"lf1", "lf2"}:
@@ -349,7 +355,7 @@ def create_lf(filepath: Path, suffix: str) -> LF1 | LF2 | None:
         last_modified = dt.datetime.fromtimestamp(last_modified_timestamp)
         time_diff_sec = (dt.datetime.now() - last_modified).total_seconds()
 
-        # it's old if it's over OLD_FILE seconds old (TODO: is this robust?)
+        # it's old if it's over OLD_FILE seconds old
         old_log_file = time_diff_sec > OLD_FILE
 
         # timeout

floodmodeller_api/logs/lf_helpers.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.
@@ -264,7 +264,7 @@ class TimeDeltaSParser(Parser):
     def _process_line(self, raw: str) -> dt.timedelta:
         """Converts string S (with decimal place and "s") to timedelta"""
 
-        s = raw.split("s")[0]  # TODO: not necessary for simulation time
+        s = raw.split("s")[0]  # not necessary for simulation time
         return dt.timedelta(seconds=float(s))
 
 

floodmodeller_api/logs/lf_params.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.
@@ -390,10 +390,6 @@ lf1_steady_data_to_extract = {
     },
 }
 
-# TODO for LF2:
-# - "start" only works for v6
-# - what if there are multiple domains?
-
 lf2_data_to_extract = {
     # start
     "version": {

floodmodeller_api/mapping.py

@@ -16,12 +16,15 @@ from .units import (
     HTBDY,
     IIC,
     INTERPOLATE,
+    JUNCTION,
+    LATERAL,
     ORIFICE,
     OUTFALL,
     QHBDY,
     QTBDY,
     REFHBDY,
     REPLICATE,
+    RESERVOIR,
     RIVER,
     RNWEIR,
     SLUICE,
@@ -32,7 +35,8 @@ from .units import (
 )
 from .urban1d.conduits import CONDUIT as CONDUIT_URBAN
 from .urban1d.conduits import CONDUITS as CONDUITS_URBAN
-from .urban1d.junctions import JUNCTION, JUNCTIONS
+from .urban1d.junctions import JUNCTION as JUNCTION_URBAN
+from .urban1d.junctions import JUNCTIONS
 from .urban1d.losses import LOSS, LOSSES
 from .urban1d.outfalls import OUTFALL as OUTFALL_URBAN
 from .urban1d.outfalls import OUTFALLS as OUTFALLS_URBAN
@@ -51,7 +55,7 @@ api_class_mapping: dict[str, Any] = {
     "floodmodeller_api.zzn.ZZN": ZZN,
     "floodmodeller_api.backup.File": File,
     "floodmodeller_api.urban1d.junctions.JUNCTIONS": JUNCTIONS,
-    "floodmodeller_api.urban1d.junctions.JUNCTION": JUNCTION,
+    "floodmodeller_api.urban1d.junctions.JUNCTION": JUNCTION_URBAN,
     "floodmodeller_api.urban1d.outfalls.OUTFALLS": OUTFALLS_URBAN,
     "floodmodeller_api.urban1d.outfalls.OUTFALL": OUTFALL_URBAN,
     "floodmodeller_api.urban1d.raingauges.RAINGAUGES": RAINGAUGES,
@@ -68,6 +72,9 @@ api_class_mapping: dict[str, Any] = {
     "floodmodeller_api.units.boundaries.REFHBDY": REFHBDY,
     "floodmodeller_api.units.comment.COMMENT": COMMENT,
     "floodmodeller_api.units.conduits.CONDUIT": CONDUIT,
+    "floodmodeller_api.units.connectors.JUNCTION": JUNCTION,
+    "floodmodeller_api.units.connectors.LATERAL": LATERAL,
+    "floodmodeller_api.units.controls.RESERVOIR": RESERVOIR,
     "floodmodeller_api.units.iic.IIC": IIC,
     "floodmodeller_api.units.losses.BLOCKAGE": BLOCKAGE,
     "floodmodeller_api.units.losses.CULVERT": CULVERT,

floodmodeller_api/test/test_conveyance.py

@@ -57,7 +57,9 @@ def from_gui(test_workspace: Path):
 def test_results_close_to_gui(section: str, dat: DAT, from_gui: pd.DataFrame):
     threshold = 6
 
-    actual = dat.sections[section].conveyance
+    actual = dat.sections[section].conveyance  # type: ignore
+    # ignored because we know that these all have type RIVER
+
     expected = (
         from_gui.set_index(f"{section}_stage")[f"{section}_conveyance"].dropna().drop_duplicates()
     )
@@ -74,14 +76,17 @@ def test_results_close_to_gui(section: str, dat: DAT, from_gui: pd.DataFrame):
 
 @pytest.mark.parametrize("section", ["a", "a2", "b", "b2", "c", "d", "d2", "e", "e2", "e3"])
 def test_results_match_gui_at_shared_points(section: str, dat: DAT, from_gui: pd.DataFrame):
-    tolerance = 1e-2  # 0.001
-    actual = dat.sections[section].conveyance
+    tolerance = 1e-2  # 0.01
+
+    actual = dat.sections[section].conveyance  # type: ignore
+    # ignored because we know that these all have type RIVER
+
     expected = (
         from_gui.set_index(f"{section}_stage")[f"{section}_conveyance"].dropna().drop_duplicates()
     )
     shared_index = sorted(set(actual.index).intersection(expected.index))
     diff = expected[shared_index] - actual[shared_index]
-    assert (abs(diff) < tolerance).all()  # asserts all conveyance values within 0.001 difference
+    assert (abs(diff) < tolerance).all()  # asserts all conveyance values within 0.01 difference
 
 
 def test_calculate_geometry():

floodmodeller_api/test/test_dat.py

@@ -1,10 +1,11 @@
+import logging
 from pathlib import Path
 from unittest.mock import patch
 
 import pytest
 
 from floodmodeller_api import DAT
-from floodmodeller_api.units import QTBDY
+from floodmodeller_api.units import JUNCTION, LATERAL, QTBDY, RESERVOIR
 from floodmodeller_api.util import FloodModellerAPIError
 
 
@@ -41,13 +42,6 @@ def dat_ex6(test_workspace):
         yield dat
 
 
-def test_dat_str_not_changed_by_write(dat_fp, data_before):
-    # TODO: Update this test - it isn't really testing anything since the behaviour of the fixture is exactly the same
-    """DAT: Test str representation equal to dat file with no changes"""
-    dat = DAT(dat_fp)
-    assert dat._write() == data_before
-
-
 def test_changing_section_and_dist_works(dat_fp, data_before):
     """DAT: Test changing and reverting section name and dist to next makes no changes"""
     dat = DAT(dat_fp)
@@ -77,17 +71,17 @@ def test_changing_and_reverting_qtbdy_hydrograph_works(dat_fp, data_before):
     assert dat._write() == data_before
 
 
-def test_dat_read_doesnt_change_data(test_workspace, tmpdir):
+def test_dat_read_doesnt_change_data(test_workspace, tmp_path):
     """DAT: Check all '.dat' files in folder by reading the _write() output into a new DAT instance and checking it stays the same."""
     for datfile in Path(test_workspace).glob("*.dat"):
         dat = DAT(datfile)
         first_output = dat._write()
-        new_path = Path(tmpdir) / "tmp.dat"
+        new_path = tmp_path / "tmp.dat"
         dat.save(new_path)
         second_dat = DAT(new_path)
-        assert dat == second_dat  # Checks equivalence on the class itself
+        assert dat == second_dat, f"dat objects not equal for {datfile=}"
         second_output = second_dat._write()
-        assert first_output == second_output
+        assert first_output == second_output, f"dat outputs not equal for {datfile=}"
 
 
 def test_insert_unit_before(units, dat_ex6):
@@ -201,12 +195,14 @@ def test_remove_unit(dat_ex3):
     assert (prev_dat_struct_len - len(dat_ex3._dat_struct)) == 1
 
 
-def test_diff(test_workspace, capsys):
-    dat_ex4 = DAT(Path(test_workspace, "ex4.DAT"))
-    dat_ex4_changed = DAT(Path(test_workspace, "ex4_changed.DAT"))
-    dat_ex4.diff(dat_ex4_changed)
-    assert capsys.readouterr().out == (
-        "Files not equivalent, 12 difference(s) found:\n"
+def test_diff(test_workspace, caplog):
+    with caplog.at_level(logging.INFO):
+        dat_ex4 = DAT(Path(test_workspace, "ex4.DAT"))
+        dat_ex4_changed = DAT(Path(test_workspace, "ex4_changed.DAT"))
+        dat_ex4.diff(dat_ex4_changed)
+
+    assert caplog.text == (
+        "INFO     root:_base.py:135 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"
@@ -220,3 +216,155 @@ def test_diff(test_workspace, capsys):
         "  DAT->_all_units->itm[61]->RNWEIR..CSRD01u->upstream_crest_height:  0.81 != 1.11\n"
         "  DAT->_all_units->itm[73]->RNWEIR..FOOTa->upstream_crest_height:  2.47 != 2.77\n"
     )
+
+
+def test_valid_network(test_workspace: Path):
+    """Test against network derived manually."""
+    dat = DAT(test_workspace / "network.dat")
+    actual_nodes, actual_edges = dat.get_network()
+
+    expected_edges = [
+        ("FSSR16BDY_resin", "RIVER_resin"),
+        ("QTBDY_CS26", "RIVER_CS26"),
+        ("RIVER_CS26", "RIVER_CS25"),
+        ("RIVER_CS25", "RIVER_CS24"),
+        ("RIVER_CS25", "SPILL_RD25Su"),
+        ("RIVER_CS24", "RIVER_CS23"),
+        ("RIVER_CS24", "SPILL_RD24Su"),
+        ("RIVER_CS23", "RIVER_CS22"),
+        ("RIVER_CS23", "SPILL_RD23Su"),
+        ("RIVER_CS22", "RIVER_CS21"),
+        ("RIVER_CS22", "SPILL_RD22Su"),
+        ("RIVER_CS21", "RIVER_CS20"),
+        ("RIVER_CS21", "SPILL_RD21Su"),
+        ("RIVER_CS20", "RIVER_CS19"),
+        ("RIVER_CS20", "SPILL_RD20Su"),
+        ("RIVER_CS19", "RIVER_CS18"),
+        ("RIVER_CS19", "SPILL_RD19Su"),
+        ("RIVER_CS18", "RIVER_RESOUT2a"),
+        ("RIVER_CS18", "SPILL_RD18Su"),
+        ("RIVER_RESOUT2a", "RIVER_RESOUT2b"),
+        ("RIVER_RESOUT2b", "JUNCTION_RESOUT2b"),
+        ("JUNCTION_RESOUT2b", "RIVER_RESOUT2u"),
+        ("JUNCTION_RESOUT2b", "RIVER_RESOUT2d"),
+        ("RIVER_resin", "RIVER_CSRD25"),
+        ("RIVER_CSRD25", "RIVER_CSRD24"),
+        ("RIVER_CSRD25", "SPILL_RD25Su"),
+        ("RIVER_CSRD24", "RIVER_CSRD23"),
+        ("RIVER_CSRD24", "SPILL_RD24Su"),
+        ("RIVER_CSRD23", "RIVER_CSRD22"),
+        ("RIVER_CSRD23", "SPILL_RD23Su"),
+        ("RIVER_CSRD22", "RIVER_CSRD21"),
+        ("RIVER_CSRD22", "SPILL_RD22Su"),
+        ("RIVER_CSRD21", "RIVER_CSRD20"),
+        ("RIVER_CSRD21", "SPILL_RD21Su"),
+        ("RIVER_CSRD20", "RIVER_CSRD19"),
+        ("RIVER_CSRD20", "SPILL_RD20Su"),
+        ("RIVER_CSRD19", "RIVER_CSRD18"),
+        ("RIVER_CSRD19", "SPILL_RD19Su"),
+        ("RIVER_CSRD18", "RIVER_CSRD17"),
+        ("RIVER_CSRD18", "SPILL_RD18Su"),
+        ("RIVER_CSRD17", "RIVER_CSRD16"),
+        ("RIVER_CSRD16", "RIVER_CSRD15"),
+        ("RIVER_CSRD15", "RIVER_CSRD14u"),
+        ("RIVER_CSRD14u", "JUNCTION_CSRD14u"),
+        ("JUNCTION_CSRD14u", "RNWEIR_MILLBu"),
+        ("JUNCTION_CSRD14u", "RNWEIR_MILLAu"),
+        ("RNWEIR_MILLAu", "RIVER_MILLAd"),
+        ("RIVER_MILLAd", "RIVER_RESOUT2u"),
+        ("RIVER_RESOUT2d", "RIVER_CSRD13"),
+        ("RIVER_CSRD13", "RIVER_CSRD12u"),
+        ("RIVER_CSRD12u", "JUNCTION_CSRD12u"),
+        ("RNWEIR_MILLBu", "JUNCTION_CSRD12u"),
+        ("JUNCTION_CSRD12u", "RIVER_CSRD12d"),
+        ("RIVER_CSRD12d", "RIVER_CSRD10"),
+        ("RIVER_CSRD10", "RIVER_CSRD09"),
+        ("RIVER_CSRD09u", "RIVER_CSRD09a"),
+        ("RIVER_CSRD09", "JUNCTION_CSRD09"),
+        ("RIVER_CSRD09u", "JUNCTION_CSRD09"),
+        ("JUNCTION_CSRD09", "RNWEIR_ROAD1"),
+        ("RIVER_CSRD09a", "BERNOULLI_CSRD09a"),
+        ("BERNOULLI_CSRD09a", "RIVER_CSRD08u"),
+        ("RIVER_CSRD08u", "RIVER_CSRD08a"),
+        ("RIVER_CSRD08a", "JUNCTION_CSRD08a"),
+        ("JUNCTION_CSRD08a", "RIVER_CSRD08"),
+        ("RNWEIR_ROAD1", "JUNCTION_CSRD08a"),
+        ("RIVER_CSRD08", "RIVER_CSRD07"),
+        ("RIVER_CSRD07", "RIVER_CSRD06"),
+        ("RIVER_CSRD06", "RIVER_CSRD05"),
+        ("RIVER_CSRD05", "RIVER_CSRD04"),
+        ("RIVER_CSRD04", "RIVER_CSRD03"),
+        ("RIVER_CSRD03", "RIVER_CSRD02"),
+        ("RIVER_CSRD02", "RIVER_CSRD02d"),
+        ("RIVER_CSRD02d", "JUNCTION_CSRD02d"),
+        ("JUNCTION_CSRD02d", "RNWEIR_RAILRDu"),
+        ("JUNCTION_CSRD02d", "BERNOULLI_RAILBRu"),
+        ("BERNOULLI_RAILBRu", "JUNCTION_RAILBRd"),
+        ("RNWEIR_RAILRDu", "JUNCTION_RAILBRd"),
+        ("JUNCTION_RAILBRd", "RIVER_CSRD01a"),
+        ("RIVER_CSRD01a", "RIVER_CSRD01u"),
+        ("RIVER_CSRD01u", "RNWEIR_CSRD01u"),
+        ("RNWEIR_CSRD01u", "RIVER_CSRD01d"),
+        ("RIVER_CSRD01d", "RIVER_CSRD01"),
+        ("RIVER_CSRD01", "INTERPOLATE_DS.001"),
+        ("INTERPOLATE_DS.001", "INTERPOLATE_DS.002"),
+        ("INTERPOLATE_DS.002", "INTERPOLATE_DS.003"),
+        ("INTERPOLATE_DS.003", "INTERPOLATE_DS.004"),
+        ("INTERPOLATE_DS.004", "INTERPOLATE_DS.005"),
+        ("INTERPOLATE_DS.005", "INTERPOLATE_DS.006"),
+        ("INTERPOLATE_DS.006", "RIVER_DS2"),
+        ("RIVER_DS2", "JUNCTION_DS2"),
+        ("JUNCTION_DS2", "RNWEIR_FOOTa"),
+        ("JUNCTION_DS2", "BERNOULLI_FOOTBRu"),
+        ("RNWEIR_FOOTa", "JUNCTION_FOOTb"),
+        ("BERNOULLI_FOOTBRu", "JUNCTION_FOOTb"),
+        ("JUNCTION_FOOTb", "RIVER_DS3"),
+        ("RIVER_DS3", "RIVER_DS4"),
+        ("RIVER_DS4", "QHBDY_DS4"),
+    ]
+
+    actual = {tuple(x.unique_name for x in y) for y in actual_edges}
+    expected = set(expected_edges)
+    assert expected == actual
+    assert len(actual_nodes) == 86
+
+
+def test_invalid_network(test_workspace: Path):
+    """Test dat file that cannot be made into a valid network."""
+    dat = DAT(test_workspace / "All Units 4_6.DAT")
+    with pytest.raises(RuntimeError):
+        dat.get_network()
+
+
+def test_create_and_insert_connectors():
+    dat = DAT()
+    junction = JUNCTION(comment="hi", labels=["A", "B"])
+    lateral = LATERAL(name="lat", comment="bye")
+    reservoir = RESERVOIR(
+        easting=0,
+        northing=0,
+        runoff=0,
+        name="res",
+        comment="hello",
+        lateral_inflow_labels=["C", "D"],
+    )
+    dat.insert_units([junction, lateral, reservoir], add_at=-1)
+    assert dat.connectors == {"A": junction, "lat": lateral}
+    assert dat.controls == {"res": reservoir}
+
+
+@pytest.mark.parametrize(
+    ("dat_str", "label"),
+    [
+        ("encoding_test_utf8.dat", "d\xc3\xa5rek"),  # because it's initially saved as utf8
+        ("encoding_test_cp1252.dat", "d\xe5rek"),
+    ],
+)
+def test_encoding(test_workspace: Path, dat_str: str, label: str, tmp_path: Path):
+    dat_read = DAT(test_workspace / dat_str)
+    new_path = tmp_path / "tmp_encoding.dat"
+    dat_read.save(new_path)
+    dat_write = DAT(new_path)
+
+    assert label in dat_read.sections
+    assert label in dat_write.sections  # remains as \xc3\xa5 even for utf8