Add validation of parsed general input

The existing validation is validating the config dict generated
by various steps when parsing the excel file to a config dict.

It makes sense to have a validation step earlier in the loop which
validates the raw input from the excel file to give a more relevant
exception feedback to unchanged values.

This validation should not edit any values, only validate the input.

Author: SAKavli

src/semeio/fmudesign/_excel_to_dict.py

@@ -17,7 +17,8 @@
 import yaml
 
 from semeio.fmudesign.design_distributions import read_correlations
-from semeio.fmudesign.utils import seeds_from_extern
+from semeio.fmudesign.general_input_validation import validate_general_input
+from semeio.fmudesign.utils import resolve_path, seeds_from_extern
 
 
 def excel_to_dict(
@@ -150,35 +151,6 @@ def _check_for_mixed_sensitivities(sens_name: str, sens_group: pd.DataFrame) ->
         )
 
 
-def resolve_path(input_filename: str, reference: str | None) -> str | None:
-    """The path `input_filename` is an Excel sheet, and `reference` is a cell
-    value that *might* be a reference to another file. Resolve the path to
-    `reference` and return. If no such file exists, return `reference`.
-    """
-    # The reference is None, so just return it back
-    if reference is None:
-        return reference
-
-    # It's a string but not a reference to another file
-    if not str(reference).endswith(("xlsx", "csv")):
-        return reference
-
-    # If the reference is e.g. 'C:/Users/USER/files/doe1.xlsx'
-    reference_path = Path(reference)
-    if reference_path.is_absolute() and reference_path.exists():
-        return str(reference_path.resolve())
-
-    # If the reference is e.g. 'doe1.xlsx'
-    full_path = Path(input_filename).parent / reference_path
-    if full_path.exists():
-        return str(full_path.resolve())
-
-    if reference_path.exists():
-        return str(reference_path.resolve())
-
-    raise ValueError(f"Failed to resolve path for file: {reference}")
-
-
 def _excel_to_dict_onebyone(
     input_filename: str,
     *,
@@ -202,7 +174,7 @@ def _excel_to_dict_onebyone(
     }  # This is the config that we read and return
 
     # Read the general input sheet to a dictionary
-    generalinput = (
+    raw_generalinput = (
         pd.read_excel(
             input_filename,
             general_input_sheet,
@@ -223,29 +195,12 @@ def parse_value(value: object) -> object:
             return value.strip()
         return value
 
-    # Convert NaN values to None and strip other values
     generalinput = {
-        str(key).strip(): parse_value(value) for (key, value) in generalinput.items()
+        str(key).strip(): parse_value(value)
+        for (key, value) in raw_generalinput.items()
     }
 
-    # Check that there are no wrong keys or typos, e.g. 'repets'
-    ALLOWED_KEYS = {
-        "designtype",
-        "repeats",
-        "correlation_iterations",
-        "distribution_seed",
-        "seed_strategy",
-        "rms_seeds",
-        "background",
-    }
-    extra_keys = set(generalinput.keys()) - set(ALLOWED_KEYS)
-    if extra_keys:
-        msg = (
-            "In the general input sheet, the following parameter(s) are not"
-            f"recognized and cannot be parsed:\n{extra_keys!r}\n"
-            f"Allowed keys:{ALLOWED_KEYS!r}"
-        )
-        raise LookupError(msg)
+    validate_general_input(generalinput, input_filename)
 
     # Copy keys over if they exist
     keys = [

src/semeio/fmudesign/general_input_validation.py

@@ -0,0 +1,175 @@
+from typing import Any
+
+from semeio.fmudesign.config_validation import SeedStrategy
+from semeio.fmudesign.utils import resolve_path
+
+
+class GeneralInputError(Exception):
+    pass
+
+
+class MissingGeneralInputKeyError(Exception):
+    def __init__(self, key: str) -> None:
+        msg = f"key(s): '{key}' must be specified in general input sheet."
+        super().__init__(msg)
+
+
+class ValidationError(Exception):
+    def __init__(self, val: Any, key: str, type_str: str) -> None:  # ruff: ignore[any-type]
+        super().__init__(
+            f"Could not validate '{val}' as {type_str} for key '{key}'. "
+            f"Failed to validate '{val}'."
+        )
+
+
+class IntValidationError(ValidationError):
+    pass
+
+
+class PositiveIntValidationError(ValidationError):
+    pass
+
+
+class StrValidationError(ValidationError):
+    pass
+
+
+class NoneValidationError(ValidationError):
+    pass
+
+
+class PathValidationError(ValidationError):
+    pass
+
+
+def validate_string(maybe_string: Any, key: str) -> str:  # ruff: ignore[any-type]
+    try:
+        return str(maybe_string)
+    except Exception as e:
+        raise StrValidationError(maybe_string, key, "str") from e
+
+
+def validate_int(maybe_int: Any, key: str) -> int:  # ruff: ignore[any-type]
+    try:
+        return int(maybe_int)
+    except (TypeError, ValueError) as e:
+        raise IntValidationError(maybe_int, key, "int") from e
+
+
+def validate_positive_int(maybe_int: Any, key: str) -> int:  # ruff: ignore[any-type]
+    try:
+        int_ = int(maybe_int)
+    except (TypeError, ValueError) as e:
+        raise PositiveIntValidationError(maybe_int, key, "positive int") from e
+
+    if int_ < 0:
+        raise PositiveIntValidationError(maybe_int, key, "positive int")
+
+    return int_
+
+
+def validate_file(maybe_file: Any, input_file: str, key: str) -> None:  # ruff: ignore[any-type]
+    try:
+        resolve_path(maybe_file, input_file)
+    except (ValueError, TypeError) as e:
+        raise GeneralInputError(
+            f"Could not resolve file '{maybe_file}' to an existing "
+            f"file for key '{key}'. "
+            f"Failed to validate '{maybe_file}'."
+        ) from e
+
+
+def validate_none(maybe_none: Any, key: str) -> None:  # ruff: ignore[any-type]
+    if maybe_none is None:
+        return
+    if isinstance(maybe_none, str) and maybe_none.lower() == "none":
+        return
+    raise NoneValidationError(maybe_none, key, "None")
+
+
+REQUIRED_KEYS = {"designtype", "repeats", "distribution_seed", "rms_seeds"}
+ALLOWED_KEYS = REQUIRED_KEYS | {"correlation_iterations", "seed_strategy", "background"}
+
+
+def _validate_required_keys(config: dict[str, Any]) -> None:
+    missing_keys = REQUIRED_KEYS - set(config.keys())
+    if missing_keys:
+        raise MissingGeneralInputKeyError(", ".join(missing_keys))
+
+
+def _validate_no_extra_keys(config: dict[str, Any]) -> None:
+    extra_keys = set(config.keys()) - set(ALLOWED_KEYS)
+    if extra_keys:
+        raise GeneralInputError(
+            "In the general input sheet, the following parameter(s) are not "
+            f"recognized and cannot be parsed:\n{extra_keys!r}\n"
+            f"Allowed keys:{ALLOWED_KEYS!r}"
+        )
+
+
+def _validate_designtype(config: dict[str, Any]) -> None:
+    if config["designtype"] != "onebyone":
+        raise GeneralInputError(
+            "Generation of DesignMatrix only implemented for designtype 'onebyone', "
+            f"not '{config['designtype']}'"
+        )
+
+
+def _validate_repeats(config: dict[str, Any]) -> None:
+    validate_positive_int(config["repeats"], "repeats")
+
+
+def _validate_correlation_iterations(config: dict[str, Any]) -> None:
+    key = "correlation_iterations"
+    if key in config:
+        validate_positive_int(config["correlation_iterations"], key)
+
+
+def _validate_distribution_seed(config: dict[str, Any]) -> None:
+    key = "distribution_seed"
+    value = config["distribution_seed"]
+    try:
+        validate_positive_int(value, key)
+    except PositiveIntValidationError:
+        try:
+            validate_none(value, key)
+        except NoneValidationError as e:
+            raise ValidationError(value, key, "positive int or None") from e
+
+
+def _validate_seed_strategy(config: dict[str, Any]) -> None:
+    key = "seed_strategy"
+    if key in config:
+        value = validate_string(config[key], key).lower()
+        if value.strip().lower() not in {*SeedStrategy, "none"}:
+            raise ValidationError(
+                value, key, f"SeedStrategy ({'/'.join(SeedStrategy)})"
+            )
+
+
+def _validate_rms_seeds(config: dict[str, Any], input_file: str) -> None:
+    key = "rms_seeds"
+    value = config[key]
+    try:
+        validate_file(value, input_file, key)
+    except (PathValidationError, GeneralInputError):
+        try:
+            s = validate_string(value, key)
+            if s != "default":
+                raise StrValidationError(s, key, s)
+        except StrValidationError:
+            try:
+                validate_none(value, key)
+            except NoneValidationError as e:
+                raise ValidationError(value, key, "str, path or None") from e
+
+
+def validate_general_input(config: dict[str, Any], input_filename: str) -> None:
+    _validate_no_extra_keys(config)
+    _validate_required_keys(config)
+    _validate_designtype(config)
+    _validate_repeats(config)
+    _validate_correlation_iterations(config)
+    _validate_distribution_seed(config)
+    _validate_seed_strategy(config)
+    _validate_rms_seeds(config, input_filename)

src/semeio/fmudesign/utils.py

@@ -2,6 +2,7 @@
 Module for utility functions that do not belong elsewhere.
 """
 
+from pathlib import Path
 from typing import Any
 
 import pandas as pd
@@ -214,3 +215,32 @@ def map_dependencies(
                     print(f" {from_} => {to_}")
 
     return df
+
+
+def resolve_path(input_filename: str, reference: str | None) -> str | None:
+    """The path `input_filename` is an Excel sheet, and `reference` is a cell
+    value that *might* be a reference to another file. Resolve the path to
+    `reference` and return. If no such file exists, return `reference`.
+    """
+    # The reference is None, so just return it back
+    if reference is None:
+        return reference
+
+    # It's a string but not a reference to another file
+    if not str(reference).endswith(("xlsx", "csv")):
+        return reference
+
+    # If the reference is e.g. 'C:/Users/USER/files/doe1.xlsx'
+    reference_path = Path(reference)
+    if reference_path.is_absolute() and reference_path.exists():
+        return str(reference_path.resolve())
+
+    # If the reference is e.g. 'doe1.xlsx'
+    full_path = Path(input_filename).parent / reference_path
+    if full_path.exists():
+        return str(full_path.resolve())
+
+    if reference_path.exists():
+        return str(reference_path.resolve())
+
+    raise ValueError(f"Failed to resolve path for file: {reference}")