koswat 0.16.2__tar.gz

koswat-0.16.2/.gitignore

@@ -0,0 +1,32 @@
+__pycache__/
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.vscode/
+
+# IDEs
+.vscode
+
+# Coverages
+.scannerwork/
+*-reports/**
+.coverage
+coverage.xml
+
+# Koswat ignore
+tests/test_results/
+tests/test_data/issues/
+site/
+*.log
+
+# Local configurations files covered in pyproject.toml
+pytest.ini
+
+# pixi environments
+.pixi/*
+!.pixi/config.toml

koswat-0.16.2/LICENSE

@@ -0,0 +1,18 @@
+                    GNU GENERAL PUBLIC LICENSE
+                      Version 3, 29 June 2007
+
+    KOSWAT, from the dutch combination of words `Kosts-Wat` (what are the costs)
+    Copyright (C) 2025 Stichting Deltares
+
+    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.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.

koswat-0.16.2/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: koswat
+Version: 0.16.2
+Summary: Koswat, from the dutch combination of words `Kosts-Wat` (what are the costs). Analyzes all the possible dikes reinforcements based on a provided traject, with surrounding constructions, and what their related costs will be.
+Project-URL: homepage, https://github.com/Deltares/koswat
+Project-URL: documentation, https://deltares.github.io/Koswat/
+Project-URL: repository, https://github.com/Deltares/koswat
+Project-URL: issues, https://github.com/Deltares/koswat/issues
+Author-email: Peter de Grave <peter.degrave@deltares.nl>
+Maintainer-email: "Carles S. Soriano Pérez" <carles.sorianoperez@deltares.nl>, Ardt Klapwijk <ardt.klapwijk@deltares.nl>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE
+Keywords: civil-engineering,deltares,dikes,flood-defence
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Scientific/Engineering :: Hydrology
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <3.15,>=3.11
+Requires-Dist: click
+Requires-Dist: geopandas
+Requires-Dist: matplotlib
+Requires-Dist: more-itertools
+Requires-Dist: pyshp
+Requires-Dist: shapely
+Description-Content-Type: text/markdown
+
+# KOSWAT
+
+[![Python 3.11](https://img.shields.io/badge/Python-3.11-blue.svg)](https://www.python.org/downloads/release/python-31110/)
+[![Python 3.12](https://img.shields.io/badge/Python-3.12-blue.svg)](https://www.python.org/downloads/release/python-31212/)
+[![Python 3.13](https://img.shields.io/badge/Python-3.13-blue.svg)](https://www.python.org/downloads/release/python-31311/)
+[![Python 3.14](https://img.shields.io/badge/Python-3.14-blue.svg)](https://www.python.org/downloads/release/python-3143/)
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![ci-install-package](https://github.com/Deltares/Koswat/actions/workflows/ci_installation.yml/badge.svg)](https://github.com/Deltares/Koswat/actions/workflows/ci_installation.yml)
+![TeamCity build status](https://dpcbuild.deltares.nl/app/rest/builds/buildType:id:Koswat_ContinuousIntegrationBuild_RunFastTests/statusIcon.svg)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Deltares_Koswat&metric=alert_status&token=87fdd0648c19800b4b5fc11334461a7fb602bf20)](https://sonarcloud.io/summary/new_code?id=Deltares_Koswat)
+[![GitHub Pages documentation](https://github.com/Deltares/koswat/actions/workflows/deploy_docs.yml/badge.svg)](https://github.com/Deltares/koswat/actions/workflows/deploy_docs.yml)
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Deltares/koswat/jupyter-binder)
+<!-- ![GitHub release (latest by date)](https://img.shields.io/github/v/release/Deltares/Koswat)
+![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/Deltares/Koswat) -->
+<!-- [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/Deltares/Koswat?quickstart=1) -->
+
+Quick documentation reference:
+- [Contributing wiki page](https://github.com/Deltares/Koswat/wiki/Contributing)
+- [Installation](https://deltares.github.io/Koswat/installation.html)
+- [User manual](https://deltares.github.io/Koswat/user_manual.html)
+    - [Examples](https://deltares.github.io/Koswat/examples.html)
+- [Docker](https://deltares.github.io/Koswat/docker.html)
+
+## Features
+
+- Dike profile generation based on data from the koswat `json` file.
+- Calculation of all possible reinforcement profiles.
+- Filtering of reinforcement profiles based on their surroundings.
+- Cost calculation for added and removed material per layer per reinforcement.
+- Plotting of reinforcements and layer cross section.
+- Export of results to `csv`.
+- Logging of analysis.
+
+## Intended audience
+Koswat targets two types of users:
+- Sandbox users. This target group are users acquianted with `Python` scripting. For them we envision two main interests when using the tool as a sandbox:
+    - Extending its functionality, or _correcting_ the existing one via pull-requests. This requires them to adhere to our __Development Guidelines__ (not yet present) and to use the Koswat repository in [Development mode](#development-mode).
+    - Creating their own scripts. It is possible to use the full extent of Koswat features on custom scripts, of course under your own responsibility. In this case the user only requires to install the most convinient version of the package as a [sandbox / endpoint](https://deltares.github.io/Koswat/user_manual.html#as-a-sandbox).
+- Single endpoint users. These users are only interested in running the tool via command line or other User Interfaces. For them, it is advised to install the tool as a [sandbox / endpoint](https://deltares.github.io/Koswat/user_manual.html#as-a-sandbox) and to check the tool's [endpoint usage](https://deltares.github.io/Koswat/user_manual.html#as-a-command-line-tool).

koswat-0.16.2/README.md

@@ -0,0 +1,40 @@
+# KOSWAT
+
+[![Python 3.11](https://img.shields.io/badge/Python-3.11-blue.svg)](https://www.python.org/downloads/release/python-31110/)
+[![Python 3.12](https://img.shields.io/badge/Python-3.12-blue.svg)](https://www.python.org/downloads/release/python-31212/)
+[![Python 3.13](https://img.shields.io/badge/Python-3.13-blue.svg)](https://www.python.org/downloads/release/python-31311/)
+[![Python 3.14](https://img.shields.io/badge/Python-3.14-blue.svg)](https://www.python.org/downloads/release/python-3143/)
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![ci-install-package](https://github.com/Deltares/Koswat/actions/workflows/ci_installation.yml/badge.svg)](https://github.com/Deltares/Koswat/actions/workflows/ci_installation.yml)
+![TeamCity build status](https://dpcbuild.deltares.nl/app/rest/builds/buildType:id:Koswat_ContinuousIntegrationBuild_RunFastTests/statusIcon.svg)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Deltares_Koswat&metric=alert_status&token=87fdd0648c19800b4b5fc11334461a7fb602bf20)](https://sonarcloud.io/summary/new_code?id=Deltares_Koswat)
+[![GitHub Pages documentation](https://github.com/Deltares/koswat/actions/workflows/deploy_docs.yml/badge.svg)](https://github.com/Deltares/koswat/actions/workflows/deploy_docs.yml)
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Deltares/koswat/jupyter-binder)
+<!-- ![GitHub release (latest by date)](https://img.shields.io/github/v/release/Deltares/Koswat)
+![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/Deltares/Koswat) -->
+<!-- [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/Deltares/Koswat?quickstart=1) -->
+
+Quick documentation reference:
+- [Contributing wiki page](https://github.com/Deltares/Koswat/wiki/Contributing)
+- [Installation](https://deltares.github.io/Koswat/installation.html)
+- [User manual](https://deltares.github.io/Koswat/user_manual.html)
+    - [Examples](https://deltares.github.io/Koswat/examples.html)
+- [Docker](https://deltares.github.io/Koswat/docker.html)
+
+## Features
+
+- Dike profile generation based on data from the koswat `json` file.
+- Calculation of all possible reinforcement profiles.
+- Filtering of reinforcement profiles based on their surroundings.
+- Cost calculation for added and removed material per layer per reinforcement.
+- Plotting of reinforcements and layer cross section.
+- Export of results to `csv`.
+- Logging of analysis.
+
+## Intended audience
+Koswat targets two types of users:
+- Sandbox users. This target group are users acquianted with `Python` scripting. For them we envision two main interests when using the tool as a sandbox:
+    - Extending its functionality, or _correcting_ the existing one via pull-requests. This requires them to adhere to our __Development Guidelines__ (not yet present) and to use the Koswat repository in [Development mode](#development-mode).
+    - Creating their own scripts. It is possible to use the full extent of Koswat features on custom scripts, of course under your own responsibility. In this case the user only requires to install the most convinient version of the package as a [sandbox / endpoint](https://deltares.github.io/Koswat/user_manual.html#as-a-sandbox).
+- Single endpoint users. These users are only interested in running the tool via command line or other User Interfaces. For them, it is advised to install the tool as a [sandbox / endpoint](https://deltares.github.io/Koswat/user_manual.html#as-a-sandbox) and to check the tool's [endpoint usage](https://deltares.github.io/Koswat/user_manual.html#as-a-command-line-tool).

koswat-0.16.2/koswat/README.md

@@ -0,0 +1,13 @@
+# Koswat
+
+Koswat module is divided in submodules, each focusing on a specific set of tasks. On the root you will find the fundamental __init__.py and __main__.py as well as a the `KoswatHandler` class in the file koswat_handler.py.
+
+Available modules as for the time of writing of this file:
+
+- [configuration](./configuration/README.md) Module related to the settings and setup of a Koswat analysis.
+- [core](./core/README.md) Module containing the core functionality (mostly protocols and generic functionality).
+- [cost_report](./cost_report/README.md) Module containing the analysis of KOSWAT. Here we trigger the generation of reinforcement profiles that will be applied to the analysis when and if suitable for the given koswat environment.
+- [dike](./dike/README.md) Module containing the representation of a Dike in Koswat and its related types and properties.
+- [dike_reinforcements](./dike_reinforcements//README.md) Module related to the definition and calculation of reinforcement profiles.
+- [strategies](./strategies/README.md) Module containing the different selection criteria of reinforcement profile for a location.
+- [plots](./plots/README.md) Module containing plotting export functionality.

koswat-0.16.2/koswat/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.16.2"

koswat-0.16.2/koswat/__main__.py

@@ -0,0 +1,55 @@
+"""
+                    GNU GENERAL PUBLIC LICENSE
+                      Version 3, 29 June 2007
+
+    KOSWAT, from the dutch combination of words `Kosts-Wat` (what are the costs)
+    Copyright (C) 2025 Stichting Deltares
+
+    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.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+import logging
+
+import click
+
+from koswat import __version__
+from koswat.koswat_handler import KoswatHandler
+
+
+### Below is the documentation for the commandline interface, see the CLICK-package.
+
+@click.command()
+@click.option("--input_file", default=None, help="Full path to the config input file.")
+@click.option(
+    "--log_output",
+    default=None,
+    help="Directory location where to generate the Koswat log file.",
+)
+@click.version_option(__version__)
+def run_analysis(input_file: str, log_output: str):
+    """
+    CLI call to execute a Koswat analysis given a settings files (`input_file`). The log is generated by default in the execute path, unless otherwise specified in the `log_output` argument.
+
+    Args:
+        input_file (str): Location of the `*.json` file containing the execution settings for Koswat.
+        log_output (str): Optional argument to specify where will be created the `koswat.log` file.
+    """
+    with KoswatHandler(log_output) as _handler:
+        _handler.run_analysis(input_file)
+
+if __name__ == "__main__":
+    try:
+        run_analysis()
+    except Exception as e_info:
+        logging.error(str(e_info))

koswat-0.16.2/koswat/configuration/README.md

@@ -0,0 +1,13 @@
+# Configuration
+
+Represents all settings related to the data required by `Koswat` to generate a `KoswatSummary`, this includes the definition of an initial `KoswatProfile`, the `KoswatScenario`s etc.
+
+A `KoswatConfigurationProtocol` is a concrete definition of a `DataObjectModelProtocol`.
+
+## Design decisions. 
+Because not all files can be imported 1:1 it is important to remind of how Koswat import functionality is thought:
+- A __file__ is __read__ into a __FOM__ and __built__ into a __DOM__
+- `File` -> `KoswatReaderProtocol` -> `FileObjectModelProtocol` -> `BuilderProtocol` -> `DataObjectModelProtocol`
+- `File` -> `KoswatImporterProtocol` -> `DOM`
+
+This implies that a `KoswatImporterProtocol` will be responsible of providing a `DataObjectModelProtocol`. Inside the instance of the `KoswatImporterProtocol` other importers can also take place. Either way, an importer will ensure that the correct `FileReaderProtocol` is selected to get the `FileObjectModel` from a `File` and together with any other related data transformed into said `DOM` by using an instance of a `BuilderProtocol`.

koswat-0.16.2/koswat/configuration/io/README.md

@@ -0,0 +1,7 @@
+# Koswat configuration Input / Output
+
+This module is responsible to define all _FOMs_, _readers_ and _importers_ needed directly or indirectly by a `KoswatRunSettings` instance.
+
+Each module represents a file type and contains the associated instances of `FileObjectModelProtocol` and their related `KoswatReaderProtocol`.
+
+On the root level we find (for now) the importers transforming all the `FileObjectModelProtocol` instances into `KoswatConfigProtocol` ones.

koswat-0.16.2/koswat/configuration/io/config_sections/__init__.py

@@ -0,0 +1,27 @@
+from koswat.configuration.io.config_sections.analysis_section_fom import (
+    AnalysisSectionFom,
+)
+from koswat.configuration.io.config_sections.cofferdam_reinforcement_section_fom import (
+    CofferdamReinforcementSectionFom,
+)
+from koswat.configuration.io.config_sections.dike_profile_section_fom import (
+    DikeProfileSectionFom,
+)
+from koswat.configuration.io.config_sections.infrastructure_section_fom import (
+    InfrastructureSectionFom,
+)
+from koswat.configuration.io.config_sections.piping_wall_reinforcement_section_fom import (
+    PipingWallReinforcementSectionFom,
+)
+from koswat.configuration.io.config_sections.soil_reinforcement_section_fom import (
+    SoilReinforcementSectionFom,
+)
+from koswat.configuration.io.config_sections.stability_wall_reinforcement_section_fom import (
+    StabilitywallReinforcementSectionFom,
+)
+from koswat.configuration.io.config_sections.surroundings_section_fom import (
+    SurroundingsSectionFom,
+)
+from koswat.configuration.io.config_sections.vps_reinforcement_section_fom import (
+    VPSReinforcementSectionFom,
+)

koswat-0.16.2/koswat/configuration/io/config_sections/analysis_section_fom.py

@@ -0,0 +1,62 @@
+"""
+                    GNU GENERAL PUBLIC LICENSE
+                      Version 3, 29 June 2007
+
+    KOSWAT, from the dutch combination of words `Kosts-Wat` (what are the costs)
+    Copyright (C) 2025 Stichting Deltares
+
+    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.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath, PureWindowsPath
+from typing import Any
+
+from koswat.configuration.io.config_sections.config_section_helper import (
+    SectionConfigHelper,
+)
+from koswat.core.io.json.koswat_json_fom_protocol import KoswatJsonFomProtocol
+
+
+@dataclass
+class AnalysisSectionFom(KoswatJsonFomProtocol):
+    dike_section_location_shp_file: Path
+    dike_selection_txt_file: Path
+    input_profiles_json_dir: Path
+    scenarios_json_dir: Path
+    costs_json_file: Path
+    surroundings_database_dir: Path
+    analysis_output_dir: Path
+    include_taxes: bool
+
+    @classmethod
+    def from_config(cls, input_config: dict[str, Any], parent_path: Path) -> "AnalysisSectionFom":
+        # We build the paths relative to the parent path of the main config file.
+        # UNLESS they are already absolute paths.
+        def resolve_path(input_path: str) -> Path:
+            if PureWindowsPath(input_path).is_absolute() or PurePosixPath(input_path).is_absolute():
+                return Path(input_path)
+            
+            return parent_path.joinpath(input_path)
+        
+        return cls(
+            dike_section_location_shp_file=resolve_path(input_config["dijksectie_ligging"]),
+            dike_selection_txt_file=resolve_path(input_config["dijksecties_selectie"]),
+            input_profiles_json_dir=resolve_path(input_config["dijksectie_invoer"]),
+            scenarios_json_dir=resolve_path(input_config["scenario_invoer"]),
+            costs_json_file=resolve_path(input_config["eenheidsprijzen"]),
+            surroundings_database_dir=resolve_path(input_config["omgevingsdatabases"]),
+            analysis_output_dir=resolve_path(input_config["uitvoerfolder"]),
+            include_taxes=SectionConfigHelper.get_bool(input_config["btw"]),
+        )

koswat-0.16.2/koswat/configuration/io/config_sections/cofferdam_reinforcement_section_fom.py

@@ -0,0 +1,74 @@
+"""
+                    GNU GENERAL PUBLIC LICENSE
+                      Version 3, 29 June 2007
+
+    KOSWAT, from the dutch combination of words `Kosts-Wat` (what are the costs)
+    Copyright (C) 2025 Stichting Deltares
+
+    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.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+from typing import Any, Optional
+
+from koswat.configuration.io.config_sections.config_section_fom_protocol import (
+    ConfigSectionFomProtocol,
+)
+from koswat.configuration.io.config_sections.config_section_helper import (
+    SectionConfigHelper,
+)
+from koswat.configuration.settings.koswat_general_settings import SurtaxFactorEnum
+from koswat.configuration.settings.reinforcements.koswat_cofferdam_settings import (
+    KoswatCofferdamSettings,
+)
+
+
+class CofferdamReinforcementSectionFom(
+    ConfigSectionFomProtocol, KoswatCofferdamSettings
+):
+    @classmethod
+    def from_config(
+        cls, input_dict: dict[str, Any], set_defaults: bool
+    ) -> "CofferdamReinforcementSectionFom":
+        _section = cls()
+
+        _active = input_dict.get("actief", None)
+        if set_defaults:
+            _section.active = SectionConfigHelper.get_bool(_active)
+        else:
+            _section.active = SectionConfigHelper.get_bool_without_default(_active)
+
+        def _get_enum(input_val: Optional[str]) -> SurtaxFactorEnum:
+            if set_defaults:
+                return SectionConfigHelper.get_enum(input_val)
+            return SectionConfigHelper.get_enum_without_default(input_val)
+
+        _section.soil_surtax_factor = _get_enum(
+            input_dict.get("opslagfactor_grond", None)
+        )
+        _section.constructive_surtax_factor = _get_enum(
+            input_dict.get("opslagfactor_constructief", None)
+        )
+
+        def _get_float(input_val: Optional[str]) -> float:
+            if set_defaults:
+                return SectionConfigHelper.get_float(input_val)
+            return SectionConfigHelper.get_float_without_default(input_val)
+
+        _section.min_length_cofferdam = _get_float(
+            input_dict.get("min_lengte_kistdam", None)
+        )
+        _section.max_length_cofferdam = _get_float(
+            input_dict.get("max_lengte_kistdam", None)
+        )
+        return _section

koswat-0.16.2/koswat/configuration/io/config_sections/config_section_fom_protocol.py

@@ -0,0 +1,45 @@
+"""
+                    GNU GENERAL PUBLIC LICENSE
+                      Version 3, 29 June 2007
+
+    KOSWAT, from the dutch combination of words `Kosts-Wat` (what are the costs)
+    Copyright (C) 2025 Stichting Deltares
+
+    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.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+from typing import Any, Protocol, runtime_checkable
+
+from koswat.core.io.file_object_model_protocol import FileObjectModelProtocol
+
+
+@runtime_checkable
+class ConfigSectionFomProtocol(FileObjectModelProtocol, Protocol):
+    """
+    Protocol for configuration section file object models.
+    """
+
+    @classmethod
+    def from_config(
+        cls, input_dict: dict[str, Any], set_defaults: bool
+    ) -> "ConfigSectionFomProtocol":
+        """
+        Create an instance of the class from a dictionary, not setting defaults.
+
+        Args:
+            input_dict (dict): Dictionary containing the configuration.
+
+        Returns:
+            FileObjectModelProtocol: The created instance.
+        """

koswat-0.16.2/koswat/configuration/io/config_sections/config_section_helper.py

@@ -0,0 +1,155 @@
+"""
+                    GNU GENERAL PUBLIC LICENSE
+                      Version 3, 29 June 2007
+
+    KOSWAT, from the dutch combination of words `Kosts-Wat` (what are the costs)
+    Copyright (C) 2025 Stichting Deltares
+
+    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.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+import math
+from typing import Optional
+
+from koswat.configuration.settings.koswat_general_settings import SurtaxFactorEnum
+
+
+class SectionConfigHelper:
+    """
+    Class with helper methods for configuration sections.
+    """
+
+    @staticmethod
+    def get_string_without_default(input_val: Optional[str]) -> Optional[str]:
+        """
+        Returns the input string or None.
+
+        Args:
+            input_val (Optional[str]): Input string.
+
+        Returns:
+            Optional[str]: Input string or None.
+        """
+        if input_val is not None:
+            return input_val
+        return None
+
+    @staticmethod
+    def get_string(input_val: Optional[str]) -> str:
+        """
+        Returns the input string or a default value.
+
+        Args:
+            input_val (Optional[str]): Input string.
+
+        Returns:
+            str: Input string. Default is an empty string.
+        """
+        _val = SectionConfigHelper.get_string_without_default(input_val)
+        return _val if _val is not None else ""
+
+    @staticmethod
+    def get_enum_without_default(
+        input_val: Optional[str],
+    ) -> Optional[SurtaxFactorEnum]:
+        """
+        Converts a string to an enum value or None.
+
+        Args:
+            input_val (Optional[str]): Input string.
+
+        Returns:
+            Optional[SurtaxFactorEnum]: Corresponding enum value or None.
+        """
+        if input_val:
+            return SurtaxFactorEnum[input_val.upper()]
+        return None
+
+    @staticmethod
+    def get_enum(input_val: Optional[str]) -> SurtaxFactorEnum:
+        """
+        Converts a string to an enum value.
+
+        Args:
+            input_val (Optional[str]): Input string.
+
+        Returns:
+            SurtaxFactorEnum: Corresponding enum value. Default is SurtaxFactorEnum.NORMAAL.
+        """
+        _val = SectionConfigHelper.get_enum_without_default(input_val)
+        return _val if _val is not None else SurtaxFactorEnum.NORMAAL
+
+    @staticmethod
+    def get_float_without_default(
+        input_val: Optional[str | float],
+    ) -> Optional[float]:
+        """
+        Converts a string to a float value or None.
+
+        Args:
+            input_val (Optional[str | float]): Input string or float.
+
+        Returns:
+            Optional[float]: Corresponding float value or None.
+        """
+        if input_val is not None:
+            return float(input_val)
+        return None
+
+    @staticmethod
+    def get_float(input_val: Optional[str | float]) -> float:
+        """
+        Converts a string to a float value.
+
+        Args:
+            input_val (Optional[str | float]): Input string or float.
+
+        Returns:
+            float: Corresponding float value. Default is math.nan.
+        """
+        _val = SectionConfigHelper.get_float_without_default(input_val)
+        return _val if _val is not None else math.nan
+
+    @staticmethod
+    def get_bool_without_default(
+        input_val: Optional[str | bool],
+    ) -> Optional[bool]:
+        """
+        Converts a string to a boolean value or None.
+
+        Args:
+            input_val (Optional[str | bool]): Input string or boolean.
+
+        Returns:
+            Optional[bool]: Corresponding boolean value or None.
+        """
+        if input_val is not None:
+            if isinstance(input_val, bool):
+                return input_val
+            return input_val.lower() == "true"
+        return None
+
+    @staticmethod
+    def get_bool(input_val: Optional[str | bool]) -> bool:
+        """
+        Converts a string to a boolean value.
+
+        Args:
+            input_val (Optional[str | bool]): Input string or boolean.
+
+        Returns:
+            bool: Corresponding boolean value. Default is False.
+        """
+        _val = SectionConfigHelper.get_bool_without_default(input_val)
+        return _val if _val is not None else False