gammasimtools 0.8.2__py3-none-any.whl → 0.10.0__py3-none-any.whl

simtools/testing/configuration.py

@@ -3,7 +3,6 @@
 import logging
 from pathlib import Path
 
-import pytest
 import yaml
 
 import simtools.utils.general as gen
@@ -11,6 +10,10 @@ import simtools.utils.general as gen
 _logger = logging.getLogger(__name__)
 
 
+class VersionError(Exception):
+    """Raise if model version requested is not supported."""
+
+
 def get_list_of_test_configurations(config_files):
     """
     Return list of test configuration dictionaries or test names.
@@ -121,7 +124,7 @@ def _skip_test_for_model_version(config, model_version_requested):
         return
     model_version_config = config["CONFIGURATION"]["MODEL_VERSION"]
     if model_version_requested != model_version_config:
-        pytest.skip(
+        raise VersionError(
             f"Model version requested {model_version_requested} not supported for this test"
         )
 
@@ -158,13 +161,14 @@ def _prepare_test_options(config, output_path, model_version=None):
 
     tmp_config_file = output_path / "tmp_config.yml"
     config_file_model_version = config.get("MODEL_VERSION")
-    if model_version is not None and "MODEL_VERSION" in config:
+    if model_version and "MODEL_VERSION" in config:
         config.update({"MODEL_VERSION": model_version})
-    if "OUTPUT_PATH" in config:
-        config.update({"OUTPUT_PATH": str(Path(output_path).joinpath(config["OUTPUT_PATH"]))})
-        config.update({"USE_PLAIN_OUTPUT_PATH": True})
-    if "DATA_DIRECTORY" in config:
-        config.update({"DATA_DIRECTORY": str(Path(output_path).joinpath(config["DATA_DIRECTORY"]))})
+
+    for key in ["OUTPUT_PATH", "DATA_DIRECTORY", "PACK_FOR_GRID_REGISTER"]:
+        if key in config:
+            config[key] = str(Path(output_path).joinpath(config[key]))
+            if key == "OUTPUT_PATH":
+                config["USE_PLAIN_OUTPUT_PATH"] = True
 
     _logger.info(f"Writing config file: {tmp_config_file}")
     with open(tmp_config_file, "w", encoding="utf-8") as file:

simtools/testing/helpers.py

@@ -1,25 +1,18 @@
 """Helper functions for integration testing."""
 
 import os
-
-import pytest
+from pathlib import Path
 
 
 def skip_camera_efficiency(config):
     """Skip camera efficiency tests if the old version of testeff is used."""
-    if "camera-efficiency" in config["APPLICATION"]:
-        if not _new_testeff_version():
-            pytest.skip(
-                "Any applications calling the old version of testeff are skipped "
-                "due to a limitation of the old testeff not allowing to specify "
-                "the include directory. Please update your sim_telarray tarball."
-            )
-        full_test_name = f"{config['APPLICATION']}_{config['TEST_NAME']}"
-        if "simtools-validate-camera-efficiency_SSTS" == full_test_name:
-            pytest.skip(
-                "The test simtools-validate-camera-efficiency_SSTS is skipped "
-                "since the fake SST mirrors are not yet implemented (#1155)"
-            )
+    if "camera-efficiency" in config["APPLICATION"] and not _new_testeff_version():
+        return (
+            "Any applications calling the old version of testeff are skipped "
+            "due to a limitation of the old testeff not allowing to specify "
+            "the include directory. Please update your sim_telarray tarball."
+        )
+    return None
 
 
 def _new_testeff_version():
@@ -28,7 +21,7 @@ def _new_testeff_version():
 
     This test checks if the new version is used.
     """
-    testeff_path = os.path.join(os.getenv("SIMTOOLS_SIMTEL_PATH"), "sim_telarray/testeff.c")
+    testeff_path = Path(os.getenv("SIMTOOLS_SIMTEL_PATH")) / "sim_telarray/testeff.c"
     try:
         with open(testeff_path, encoding="utf-8") as file:
             file_content = file.read()

simtools/testing/validate_output.py

@@ -12,39 +12,22 @@ from simtools.testing import assertions
 _logger = logging.getLogger(__name__)
 
 
-def validate_all_tests(config, request, config_file_model_version):
-    """
-    Validate test output for all integration tests.
-
-    Parameters
-    ----------
-    config: dict
-        Integration test configuration dictionary.
-    request: request
-        Request object.
-    config_file_model_version: str
-        Model version from the configuration file.
-
-    """
-    if request.config.getoption("--model_version") is None:
-        validate_application_output(config)
-    elif config_file_model_version is not None:
-        _from_command_line = request.config.getoption("--model_version")
-        _from_config_file = config_file_model_version
-        if _from_command_line == _from_config_file:
-            validate_application_output(config)
-
-
-def validate_application_output(config):
+def validate_application_output(config, from_command_line=None, from_config_file=None):
     """
     Validate application output against expected output.
 
     Expected output is defined in configuration file.
+    Some tests run only if the model version from the command line
+    equals the model version from the configuration file.
 
     Parameters
     ----------
     config: dict
         dictionary with the configuration for the application test.
+    from_command_line: str
+        Model version from the command line.
+    from_config_file: str
+        Model version from the configuration file.
 
     """
     if "INTEGRATION_TESTS" not in config:
@@ -52,19 +35,37 @@ def validate_application_output(config):
 
     for integration_test in config["INTEGRATION_TESTS"]:
         _logger.info(f"Testing application output: {integration_test}")
-        if "REFERENCE_OUTPUT_FILE" in integration_test:
-            _validate_reference_output_file(config, integration_test)
-
-        if "OUTPUT_FILE" in integration_test:
-            _validate_output_path_and_file(config, integration_test)
-
-        if "FILE_TYPE" in integration_test:
-            assert assertions.assert_file_type(
-                integration_test["FILE_TYPE"],
-                Path(config["CONFIGURATION"]["OUTPUT_PATH"]).joinpath(
-                    config["CONFIGURATION"]["OUTPUT_FILE"]
-                ),
-            )
+
+        if from_command_line == from_config_file:
+            if "REFERENCE_OUTPUT_FILE" in integration_test:
+                _validate_reference_output_file(config, integration_test)
+
+            if "TEST_OUTPUT_FILES" in integration_test:
+                _validate_output_path_and_file(config, integration_test["TEST_OUTPUT_FILES"])
+
+            if "OUTPUT_FILE" in integration_test:
+                _validate_output_path_and_file(
+                    config,
+                    [{"PATH_DESCRIPTOR": "OUTPUT_PATH", "FILE": integration_test["OUTPUT_FILE"]}],
+                )
+
+            if "FILE_TYPE" in integration_test:
+                assert assertions.assert_file_type(
+                    integration_test["FILE_TYPE"],
+                    Path(config["CONFIGURATION"]["OUTPUT_PATH"]).joinpath(
+                        config["CONFIGURATION"]["OUTPUT_FILE"]
+                    ),
+                )
+        _test_simtel_cfg_files(config, integration_test, from_command_line, from_config_file)
+
+
+def _test_simtel_cfg_files(config, integration_test, from_command_line, from_config_file):
+    """Test simtel cfg files."""
+    test_simtel_cfg_file = integration_test.get("TEST_SIMTEL_CFG_FILES", {}).get(
+        from_command_line or from_config_file
+    )
+    if test_simtel_cfg_file:
+        _validate_simtel_cfg_files(config, test_simtel_cfg_file)
 
 
 def _validate_reference_output_file(config, integration_test):
@@ -79,31 +80,25 @@ def _validate_reference_output_file(config, integration_test):
     )
 
 
-def _validate_output_path_and_file(config, integration_test):
-    """Check if output path and file exist."""
-    _logger.info(f"PATH {config['CONFIGURATION']['OUTPUT_PATH']}")
-    _logger.info(f"File {integration_test['OUTPUT_FILE']}")
-
-    data_path = config["CONFIGURATION"].get(
-        "DATA_DIRECTORY", config["CONFIGURATION"]["OUTPUT_PATH"]
-    )
-    output_file_path = Path(data_path) / integration_test["OUTPUT_FILE"]
-
-    _logger.info(f"Checking path: {output_file_path}")
-    assert output_file_path.exists()
-
-    expected_output = [
-        d["EXPECTED_OUTPUT"] for d in config["INTEGRATION_TESTS"] if "EXPECTED_OUTPUT" in d
-    ]
-    if expected_output and "log_hist" not in integration_test["OUTPUT_FILE"]:
-        # Get the expected output from the configuration file
-        expected_output = expected_output[0]
-        _logger.info(
-            f"Checking the output of {integration_test['OUTPUT_FILE']} "
-            "complies with the expected output: "
-            f"{expected_output}"
-        )
-        assert assertions.check_output_from_sim_telarray(output_file_path, expected_output)
+def _validate_output_path_and_file(config, integration_file_tests):
+    """Check if output paths and files exist."""
+    for file_test in integration_file_tests:
+        try:
+            output_path = config["CONFIGURATION"][file_test["PATH_DESCRIPTOR"]]
+        except KeyError as exc:
+            raise KeyError(
+                f"Path {file_test['PATH_DESCRIPTOR']} not found in integration test configuration."
+            ) from exc
+
+        output_file_path = Path(output_path) / file_test["FILE"]
+        _logger.info(f"Checking path: {output_file_path}")
+        assert output_file_path.exists()
+
+        if "EXPECTED_OUTPUT" in file_test:
+            assert assertions.check_output_from_sim_telarray(
+                output_file_path,
+                file_test["EXPECTED_OUTPUT"],
+            )
 
 
 def compare_files(file1, file2, tolerance=1.0e-5, test_columns=None):
@@ -129,12 +124,13 @@ def compare_files(file1, file2, tolerance=1.0e-5, test_columns=None):
     """
     _file1_suffix = Path(file1).suffix
     _file2_suffix = Path(file2).suffix
+    _logger.info("Comparing files: %s and %s", file1, file2)
     if _file1_suffix != _file2_suffix:
         raise ValueError(f"File suffixes do not match: {file1} and {file2}")
     if _file1_suffix == ".ecsv":
         return compare_ecsv_files(file1, file2, tolerance, test_columns)
     if _file1_suffix in (".json", ".yaml", ".yml"):
-        return compare_json_or_yaml_files(file1, file2)
+        return compare_json_or_yaml_files(file1, file2, tolerance)
 
     _logger.warning(f"Unknown file type for files: {file1} and {file2}")
     return False
@@ -169,11 +165,35 @@ def compare_json_or_yaml_files(file1, file2, tolerance=1.0e-2):
     if data1 == data2:
         return True
 
-    if "value" in data1 and isinstance(data1["value"], str):
-        value_list_1 = gen.convert_string_to_list(data1.pop("value"))
-        value_list_2 = gen.convert_string_to_list(data2.pop("value"))
-        return np.allclose(value_list_1, value_list_2, rtol=tolerance)
-    return data1 == data2
+    if data1.keys() != data2.keys():
+        _logger.error(f"Keys do not match: {data1.keys()} and {data2.keys()}")
+        return False
+    _comparison = all(
+        (
+            _compare_value_from_parameter_dict(data1[k], data2[k], tolerance)
+            if k == "value"
+            else data1[k] == data2[k]
+        )
+        for k in data1
+    )
+    if not _comparison:
+        _logger.error(f"Values do not match: {data1} and {data2} (tolerance: {tolerance})")
+    return _comparison
+
+
+def _compare_value_from_parameter_dict(data1, data2, tolerance):
+    """Compare value fields given in different formats."""
+
+    def _as_list(value):
+        if isinstance(value, str):
+            return gen.convert_string_to_list(value)
+        if isinstance(value, list | np.ndarray):
+            return value
+        return [value]
+
+    _logger.info(f"Comparing values: {data1} and {data2} (tolerance: {tolerance})")
+
+    return np.allclose(_as_list(data1), _as_list(data2), rtol=tolerance)
 
 
 def compare_ecsv_files(file1, file2, tolerance=1.0e-5, test_columns=None):
@@ -235,6 +255,70 @@ def compare_ecsv_files(file1, file2, tolerance=1.0e-5, test_columns=None):
 
         if np.issubdtype(table1_masked[col_name].dtype, np.floating):
             if not np.allclose(table1_masked[col_name], table2_masked[col_name], rtol=tolerance):
+                _logger.warning(f"Column {col_name} outside of relative tolerance {tolerance}")
                 return False
 
     return True
+
+
+def _validate_simtel_cfg_files(config, simtel_cfg_file):
+    """
+    Check sim_telarray configuration files and compare with reference file.
+
+    Note the finetuned naming of configuration files by simtools.
+
+    """
+    reference_file = Path(simtel_cfg_file)
+    test_file = Path(config["CONFIGURATION"]["OUTPUT_PATH"]) / reference_file.name.replace(
+        "_test", f"_{config['CONFIGURATION']['LABEL']}"
+    )
+    _logger.info(
+        f"Comparing simtel cfg files: {reference_file} and {test_file} "
+        f"for model version {config['CONFIGURATION']['MODEL_VERSION']}"
+    )
+    return _compare_simtel_cfg_files(reference_file, test_file)
+
+
+def _compare_simtel_cfg_files(reference_file, test_file):
+    """
+    Compare two sim_telarray configuration files.
+
+    Line-by-line string comparison. Requires similar sequence of
+    parameters in the files. Ignore lines containing 'config_release'
+    (as it contains the simtools package version).
+
+    Parameters
+    ----------
+    reference_file: Path
+        Reference sim_telarray configuration file.
+    test_file: Path
+        Test sim_telarray configuration file.
+
+    Returns
+    -------
+    bool
+        True if the files are equal.
+
+    """
+    with open(reference_file, encoding="utf-8") as f1, open(test_file, encoding="utf-8") as f2:
+        reference_cfg = [line.rstrip() for line in f1 if line.strip()]
+        test_cfg = [line.rstrip() for line in f2 if line.strip()]
+
+    if len(reference_cfg) != len(test_cfg):
+        _logger.error(
+            f"Line counts differ: {reference_file} ({len(reference_cfg)} lines), "
+            f"{test_file} ({len(test_cfg)} lines)."
+        )
+        return False
+
+    for ref_line, test_line in zip(reference_cfg, test_cfg):
+        if any(ignore in ref_line for ignore in ("config_release", "Label")):
+            continue
+        if ref_line != test_line:
+            _logger.error(
+                f"Configuration files {reference_file} and {test_file} do not match: "
+                f"'{ref_line}' and '{test_line}'"
+            )
+            return False
+
+    return True

simtools/utils/general.py

@@ -17,6 +17,7 @@ import yaml
 __all__ = [
     "InvalidConfigDataError",
     "change_dict_keys_case",
+    "clear_default_sim_telarray_cfg_directories",
     "collect_data_from_file",
     "collect_final_lines",
     "collect_kwargs",
@@ -81,6 +82,28 @@ def is_url(url):
         return False
 
 
+def url_exists(url):
+    """
+    Check if a URL exists.
+
+    Parameters
+    ----------
+    url: str
+        URL to be checked.
+
+    Returns
+    -------
+    bool
+        True if URL exists.
+    """
+    try:
+        with urllib.request.urlopen(url, timeout=5) as response:
+            return response.status == 200
+    except (urllib.error.URLError, AttributeError) as e:
+        _logger.error(f"URL {url} does not exist: {e}")
+        return False
+
+
 def collect_data_from_http(url):
     """
     Download yaml or json file from url and return it contents as dict.
@@ -135,7 +158,7 @@ def collect_data_from_http(url):
     return data
 
 
-def collect_data_from_file(file_name):
+def collect_data_from_file(file_name, yaml_document=None):
     """
     Collect data from file based on its extension.
 
@@ -143,6 +166,8 @@ def collect_data_from_file(file_name):
     ----------
     file_name: str
         Name of the yaml/json/ascii file.
+    yaml_document: None, int
+        Return list of yaml documents or a single document (for yaml files with several documents).
 
     Returns
     -------
@@ -152,18 +177,34 @@ def collect_data_from_file(file_name):
     if is_url(file_name):
         return collect_data_from_http(file_name)
 
+    suffix = Path(file_name).suffix.lower()
     with open(file_name, encoding="utf-8") as file:
-        if Path(file_name).suffix.lower() == ".json":
+        if suffix == ".json":
             return json.load(file)
+        if suffix == ".list":
+            return [line.strip() for line in file.readlines()]
+        if suffix in [".yml", ".yaml"]:
+            return _collect_data_from_yaml_file(file, file_name, yaml_document)
+    return None
 
-        if Path(file_name).suffix.lower() == ".list":
-            lines = file.readlines()
-            return [line.strip() for line in lines]
 
-        try:
-            return yaml.safe_load(file)
-        except yaml.constructor.ConstructorError:
-            return _load_yaml_using_astropy(file)
+def _collect_data_from_yaml_file(file, file_name, yaml_document):
+    """Collect data from a yaml file."""
+    try:
+        return yaml.safe_load(file)
+    except yaml.constructor.ConstructorError:
+        return _load_yaml_using_astropy(file)
+    except yaml.composer.ComposerError:
+        pass
+    file.seek(0)
+    if yaml_document is None:
+        return list(yaml.safe_load_all(file))
+    try:
+        return list(yaml.safe_load_all(file))[yaml_document]
+    except IndexError as exc:
+        raise InvalidConfigDataError(
+            f"YAML file {file_name} does not contain {yaml_document} documents."
+        ) from exc
 
 
 def collect_kwargs(label, in_kwargs):
@@ -333,9 +374,10 @@ def program_is_executable(program):
     Follows https://stackoverflow.com/questions/377017/
 
     """
+    program = Path(program)
 
     def is_exe(fpath):
-        return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
+        return fpath.is_file() and os.access(fpath, os.X_OK)
 
     fpath, _ = os.path.split(program)
     if fpath:
@@ -344,7 +386,7 @@ def program_is_executable(program):
     else:
         try:
             for path in os.environ["PATH"].split(os.pathsep):
-                exe_file = os.path.join(path, program)
+                exe_file = Path(path) / program
                 if is_exe(exe_file):
                     return exe_file
         except KeyError:
@@ -442,7 +484,7 @@ def get_file_age(file_path):
     if not Path(file_path).is_file():
         raise FileNotFoundError(f"'{file_path}' does not exist or is not a file.")
 
-    file_stats = os.stat(file_path)
+    file_stats = Path(file_path).stat()
     modification_time = file_stats.st_mtime
     current_time = time.time()
 
@@ -785,3 +827,98 @@ def read_file_encoded_in_utf_or_latin(file_name):
             raise UnicodeDecodeError("Unable to decode file using UTF-8 or Latin-1.") from exc
 
     return lines
+
+
+def get_structure_array_from_table(table, column_names):
+    """
+    Get a structured array from an astropy table for a selected list of columns.
+
+    Parameters
+    ----------
+    table: astropy.table.Table
+        Table to be converted.
+    column_names: list
+        List of column names to be included in the structured array.
+
+    Returns
+    -------
+    numpy.ndarray
+        Structured array containing the table data.
+    """
+    return np.array(
+        list(zip(*[np.array(table[col]) for col in column_names])),
+        dtype=[(col, np.array(table[col]).dtype) for col in column_names],
+    )
+
+
+def convert_keys_in_dict_to_lowercase(data):
+    """
+    Recursively convert all dictionary keys to lowercase.
+
+    Parameters
+    ----------
+    data: dict
+        Dictionary to be converted.
+
+    Returns
+    -------
+    dict
+        Dictionary with all keys converted to lowercase.
+    """
+    if isinstance(data, dict):
+        return {k.lower(): convert_keys_in_dict_to_lowercase(v) for k, v in data.items()}
+    if isinstance(data, list):
+        return [convert_keys_in_dict_to_lowercase(i) for i in data]
+    return data
+
+
+def clear_default_sim_telarray_cfg_directories(command):
+    """Prefix the command to clear default sim_telarray configuration directories.
+
+    Parameters
+    ----------
+    command: str
+        Command to be prefixed.
+
+    Returns
+    -------
+    str
+        Prefixed command.
+
+    """
+    return f"SIM_TELARRAY_CONFIG_PATH='' {command}"
+
+
+def get_list_of_files_from_command_line(file_names, suffix_list):
+    """
+    Get a list of files from the command line.
+
+    Files can be given as a list of file names or as a text file containing the list of files.
+    The list of suffixes restrict the files types to be returned. Note that a file list must
+    have a different suffix than those in the suffix list.
+
+    Parameters
+    ----------
+    file_names: list
+        List of file names to be checked.
+    suffix_list: list
+        List of suffixes to be checked.
+
+    Returns
+    -------
+    list
+        List of files with the given suffixes.
+    """
+    _files = []
+    for one_file in file_names:
+        path = Path(one_file)
+        try:
+            if path.suffix in suffix_list:
+                _files.append(one_file)
+            elif len(file_names) == 1:
+                with open(one_file, encoding="utf-8") as file:
+                    _files.extend(line.strip() for line in file)
+        except FileNotFoundError as exc:
+            _logger.error(f"{one_file} is not a file.")
+            raise FileNotFoundError from exc
+    return _files