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

simtools/utils/general.py

@@ -1,301 +1,62 @@
-"""
-General functions useful across different parts of the code.
-"""
+"""General functions useful across different parts of the code."""
 
 import copy
 import json
 import logging
 import os
-import re
 import tempfile
 import time
 import urllib.error
 import urllib.request
-from collections import namedtuple
 from pathlib import Path
 from urllib.parse import urlparse
 
-import astropy.units as u
-from astropy.io.misc import yaml
+import numpy as np
+import yaml
 
 __all__ = [
+    "InvalidConfigDataError",
     "change_dict_keys_case",
-    "collect_data_from_file_or_dict",
+    "collect_data_from_file",
     "collect_final_lines",
     "collect_kwargs",
-    "InvalidConfigData",
-    "InvalidConfigEntry",
-    "MissingRequiredConfigEntry",
-    "UnableToIdentifyConfigEntry",
+    "get_log_excerpt",
     "get_log_level_from_user",
     "remove_substring_recursively_from_dict",
-    "separate_args_and_config_data",
     "set_default_kwargs",
-    "validate_config_data",
-    "get_log_excerpt",
     "sort_arrays",
 ]
 
 _logger = logging.getLogger(__name__)
 
 
-class UnableToIdentifyConfigEntry(Exception):
-    """Exception for unable to indentify configuration entry."""
-
-
-class MissingRequiredConfigEntry(Exception):
-    """Exception for missing required configuration entry."""
-
-
-class InvalidConfigEntry(Exception):
-    """Exception for invalid configuration entry."""
-
-
-class InvalidConfigData(Exception):
+class InvalidConfigDataError(Exception):
     """Exception for invalid configuration data."""
 
 
-def validate_config_data(config_data, parameters, ignore_unidentified=False):
+def join_url_or_path(url_or_path, *args):
     """
-    Validate a generic config_data dict by using the info
-    given by the parameters dict. The entries will be validated
-    in terms of length, units and names.
-
-    See data/test-data/test_parameters.yml for an example of the structure
-    of the parameters dict.
-
-    Parameters
-    ----------
-    config_data: dict
-        Input config data.
-    parameters: dict
-        Parameter information necessary for validation.
-    ignore_unidentified: bool
-        If set to True, unidentified parameters provided in config_data are ignored
-        and a debug message is printed. Otherwise, an unidentified parameter leads to an error.
-
-    Raises
-    ------
-    UnableToIdentifyConfigEntry
-        When an entry in config_data cannot be identified among the parameters.
-    MissingRequiredConfigEntry
-        When a parameter without default value is not given in config_data.
-    InvalidConfigEntry
-        When an entry in config_data is invalid (wrong len, wrong unit, ...).
-
-    Returns
-    -------
-    namedtuple:
-        Containing the validated config data entries.
-    """
-
-    # Dict to be filled and returned
-    out_data = {}
-
-    if config_data is None:
-        config_data = {}
-
-    # Collecting all entries given as in config_data.
-    for key_data, value_data in config_data.items():
-        is_identified = False
-        # Searching for the key in the parameters.
-        for par_name, par_info in parameters.items():
-            names = par_info.get("names", [])
-            if key_data != par_name and key_data.lower() not in [n.lower() for n in names]:
-                continue
-            # Matched parameter
-            validated_value = _validate_and_convert_value(par_name, par_info, value_data)
-            out_data[par_name] = validated_value
-            is_identified = True
-
-        # Raising error for an unidentified input.
-        if not is_identified:
-            msg = f"Entry {key_data} in config_data cannot be identified"
-            if ignore_unidentified:
-                _logger.debug(f"{msg}, ignoring.")
-            else:
-                _logger.error(f"{msg}, stopping.")
-                raise UnableToIdentifyConfigEntry(msg)
-
-    # Checking for parameters with default option.
-    # If it is not given, filling it with the default value.
-    for par_name, par_info in parameters.items():
-        if par_name in out_data:
-            continue
-        if "default" in par_info.keys() and par_info["default"] is not None:
-            default_value = par_info["default"]
-            if not isinstance(default_value, u.Quantity) and "unit" in par_info:
-                default_value *= par_info["unit"]
-            validated_value = _validate_and_convert_value(par_name, par_info, default_value)
-            out_data[par_name] = validated_value
-        elif "default" in par_info.keys() and par_info["default"] is None:
-            out_data[par_name] = None
-        else:
-            msg = f"Required entry in config_data {par_name} was not given (there may be more)."
-            _logger.error(msg)
-            raise MissingRequiredConfigEntry(msg)
-
-    configuration_data = namedtuple("configuration_data", out_data)
-    return configuration_data(**out_data)
+    Join URL or path with additional subdirectories and file.
 
-
-def _validate_and_convert_value_without_units(value, value_keys, par_name, par_info):
-    """
-    Validate input user parameter for input values without units.
+    This is the equivalent to Path.join(), with extended functionality
+    working also for URLs.
 
     Parameters
     ----------
-    value: list
-       list of user input values.
-    value_keys: list
-       list of keys if user input was a dict; otherwise None.
-    par_name: str
-       name of parameter.
-    par_info: dict
-        dictionary with parameter info.
+    url_or_path: str or Path
+        URL or path to be extended.
+    args: list
+        Additional arguments to be added to the URL or path.
 
     Returns
     -------
-    list, dict
-        validated and converted input data
+    str or Path
+        Extended URL or path.
 
     """
-
-    _, undefined_length = _check_value_entry_length(value, par_name, par_info)
-
-    # Checking if values have unit and raising error, if so.
-    if all(isinstance(v, str) for v in value):
-        # In case values are string, e.g. mirror_numbers = 'all'
-        # This is needed otherwise the elif condition will break
-        pass
-    elif any(u.Quantity(v).unit != u.dimensionless_unscaled for v in value):
-        msg = f"Config entry {par_name} should not have units"
-        _logger.error(msg)
-        raise InvalidConfigEntry(msg)
-
-    if value_keys:
-        return dict(zip(value_keys, value))
-    return value if len(value) > 1 or undefined_length else value[0]
-
-
-def _check_value_entry_length(value, par_name, par_info):
-    """
-    Validate length of user input parameters
-
-    Parameters
-    ----------
-    value: list
-        list of user input values
-    par_name: str
-        name of parameter
-    par_info: dict
-        dictionary with parameter info
-
-    Returns
-    -------
-    value_length: int
-        length of input list
-    undefined_length: bool
-        state of input list
-
-    """
-
-    # Checking the entry length
-    value_length = len(value)
-    _logger.debug(f"Value len of {par_name}: {value_length}")
-    undefined_length = False
-    try:
-        if par_info["len"] is None:
-            undefined_length = True
-        elif value_length != par_info["len"]:
-            msg = f"Config entry with wrong len: {par_name}"
-            _logger.error(msg)
-            raise InvalidConfigEntry(msg)
-    except KeyError:
-        _logger.error("Missing len entry in par_info")
-        raise
-
-    return value_length, undefined_length
-
-
-def _validate_and_convert_value_with_units(value, value_keys, par_name, par_info):
-    """
-    Validate input user parameter for input values with units.
-
-    Parameters
-    ----------
-    value: list
-       list of user input values
-    value_keys: list
-       list of keys if user input was a dict; otherwise None
-    par_name: str
-       name of parameter
-
-    Returns
-    -------
-    list, dict
-        validated and converted input data
-
-    """
-
-    value_length, undefined_length = _check_value_entry_length(value, par_name, par_info)
-
-    par_unit = copy_as_list(par_info["unit"])
-
-    if undefined_length and len(par_unit) != 1:
-        msg = f"Config entry with undefined length should have a single unit: {par_name}"
-        _logger.error(msg)
-        raise InvalidConfigEntry(msg)
-    if len(par_unit) == 1:
-        par_unit *= value_length
-
-    # Checking units and converting them, if needed.
-    value_with_units = []
-    for arg, unit in zip(value, par_unit):
-        # In case a entry is None, None should be returned.
-        if unit is None or arg is None:
-            value_with_units.append(arg)
-            continue
-
-        # Converting strings to Quantity
-        if isinstance(arg, str):
-            arg = u.quantity.Quantity(arg)
-
-        if not isinstance(arg, u.quantity.Quantity):
-            msg = f"Config entry given without unit: {par_name}"
-            _logger.error(msg)
-            raise InvalidConfigEntry(msg)
-        if not arg.unit.is_equivalent(unit):
-            msg = f"Config entry given with wrong unit: {par_name}"
-            _logger.error(msg)
-            raise InvalidConfigEntry(msg)
-        value_with_units.append(arg.to(unit).value)
-
-    if value_keys:
-        return dict(zip(value_keys, value_with_units))
-
-    return (
-        value_with_units if len(value_with_units) > 1 or undefined_length else value_with_units[0]
-    )
-
-
-def _validate_and_convert_value(par_name, par_info, value_in):
-    """
-    Validate input user parameter and convert it to the right units, if needed.
-    Returns the validated arguments in a list.
-    """
-
-    if isinstance(value_in, dict):
-        value = [d for (k, d) in value_in.items()]
-        value_keys = [k for (k, d) in value_in.items()]
-    else:
-        value = copy_as_list(value_in)
-        value_keys = None
-
-    if "unit" not in par_info.keys():
-        return _validate_and_convert_value_without_units(value, value_keys, par_name, par_info)
-
-    return _validate_and_convert_value_with_units(value, value_keys, par_name, par_info)
+    if "://" in str(url_or_path):
+        return "/".join([url_or_path.rstrip("/"), *args])
+    return Path(url_or_path).joinpath(*args)
 
 
 def is_url(url):
@@ -313,7 +74,6 @@ def is_url(url):
         True if url is a valid URL.
 
     """
-
     try:
         result = urlparse(url)
         return all([result.scheme, result.netloc])
@@ -324,6 +84,7 @@ def is_url(url):
 def collect_data_from_http(url):
     """
     Download yaml or json file from url and return it contents as dict.
+
     File is downloaded as a temporary file and deleted afterwards.
 
     Parameters
@@ -340,76 +101,69 @@ def collect_data_from_http(url):
     ------
     TypeError
         If url is not a valid URL.
-    urllib.error.HTTPError
+    FileNotFoundError
         If downloading the yaml file fails.
 
     """
-
-    _logger.debug(f"Downloaded yaml file from {url}")
     try:
-        with tempfile.NamedTemporaryFile() as tmp_file:
+        with tempfile.NamedTemporaryFile(mode="w+t") as tmp_file:
             urllib.request.urlretrieve(url, tmp_file.name)
             if url.endswith("yml") or url.endswith("yaml"):
-                data = yaml.load(tmp_file)
+                try:
+                    data = yaml.safe_load(tmp_file)
+                except yaml.constructor.ConstructorError:
+                    data = _load_yaml_using_astropy(tmp_file)
             elif url.endswith("json"):
                 data = json.load(tmp_file)
+            elif url.endswith("list"):
+                lines = tmp_file.readlines()
+                data = [line.strip() for line in lines]
             else:
                 msg = f"File extension of {url} not supported (should be json or yaml)"
                 _logger.error(msg)
                 raise TypeError(msg)
-    except TypeError:
+    except TypeError as exc:
         msg = "Invalid url {url}"
         _logger.error(msg)
-        raise
-    except urllib.error.HTTPError:
-        msg = f"Failed to download yaml file from {url}"
+        raise TypeError(msg) from exc
+    except urllib.error.HTTPError as exc:
+        msg = f"Failed to download file from {url}"
         _logger.error(msg)
-        raise
+        raise FileNotFoundError(msg) from exc
 
+    _logger.debug(f"Downloaded file from {url}")
     return data
 
 
-def collect_data_from_file_or_dict(file_name, in_dict, allow_empty=False):
+def collect_data_from_file(file_name):
     """
-    Collect input data that can be given either as a dict or as a yaml/json file.
+    Collect data from file based on its extension.
 
     Parameters
     ----------
     file_name: str
-        Name of the yaml/json file.
-    in_dict: dict
-        Data as dict.
-    allow_empty: bool
-        If True, an error won't be raised in case both yaml and dict are None.
+        Name of the yaml/json/ascii file.
 
     Returns
     -------
-    data: dict
-        Data as dict.
-    """
-
-    if file_name is not None:
-        if in_dict is not None:
-            _logger.warning("Both in_dict and file_name were given - file_name will be used")
-        if is_url(str(file_name)):
-            data = collect_data_from_http(file_name)
-        elif Path(file_name).suffix.lower() == ".json":
-            with open(file_name, encoding="utf-8") as file:
-                data = json.load(file)
-        else:
-            with open(file_name, encoding="utf-8") as file:
-                data = yaml.load(file)
-        return data
-    if in_dict is not None:
-        return dict(in_dict)
+    data: dict or list
+        Data as dict or list.
+    """
+    if is_url(file_name):
+        return collect_data_from_http(file_name)
 
-    msg = "Input has not been provided (neither by file, nor by dict)"
-    if allow_empty:
-        _logger.debug(msg)
-        return None
+    with open(file_name, encoding="utf-8") as file:
+        if Path(file_name).suffix.lower() == ".json":
+            return json.load(file)
+
+        if Path(file_name).suffix.lower() == ".list":
+            lines = file.readlines()
+            return [line.strip() for line in lines]
 
-    _logger.debug(msg)
-    raise InvalidConfigData(msg)
+        try:
+            return yaml.safe_load(file)
+        except yaml.constructor.ConstructorError:
+            return _load_yaml_using_astropy(file)
 
 
 def collect_kwargs(label, in_kwargs):
@@ -422,6 +176,7 @@ def collect_kwargs(label, in_kwargs):
         Label to be collected in kwargs.
     in_kwargs: dict
         kwargs.
+
     Returns
     -------
     dict
@@ -528,7 +283,6 @@ def get_log_level_from_user(log_level):
     logging.LEVEL
         The requested logging level to be used as input to logging.setLevel().
     """
-
     possible_levels = {
         "info": logging.INFO,
         "debug": logging.DEBUG,
@@ -537,7 +291,10 @@ def get_log_level_from_user(log_level):
         "error": logging.ERROR,
         "critical": logging.CRITICAL,
     }
-    log_level_lower = log_level.lower()
+    try:
+        log_level_lower = log_level.lower()
+    except AttributeError:
+        log_level_lower = log_level
     if log_level_lower not in possible_levels:
         raise ValueError(
             f"'{log_level}' is not a logging level, "
@@ -569,37 +326,9 @@ def copy_as_list(value):
         return [value]
 
 
-def separate_args_and_config_data(expected_args, **kwargs):
-    """
-    Separate kwargs into the arguments expected for instancing a class and the dict to be given as
-    config_data. This function is specific for methods from_kwargs in classes which use the
-    validate_config_data system.
-
-    Parameters
-    ----------
-    expected_args: list of str
-        List of arguments expected for the class.
-    **kwargs
-
-    Returns
-    -------
-    dict, dict
-        A dict with the args collected and another one with config_data.
-    """
-    args = {}
-    config_data = {}
-    for key, value in kwargs.items():
-        if key in expected_args:
-            args[key] = value
-        else:
-            config_data[key] = value
-
-    return args, config_data
-
-
 def program_is_executable(program):
     """
-    Checks if program exists and is executable
+    Check if program exists and is executable.
 
     Follows https://stackoverflow.com/questions/377017/
 
@@ -619,12 +348,31 @@ def program_is_executable(program):
                 if is_exe(exe_file):
                     return exe_file
         except KeyError:
-            _logger.debug("PATH environment variable is not set.")
+            _logger.warning("PATH environment variable is not set.")
             return None
 
     return None
 
 
+def _search_directory(directory, filename, rec=False):
+    if not Path(directory).exists():
+        _logger.debug(f"Directory {directory} does not exist")
+        return None
+
+    file = Path(directory).joinpath(filename)
+    if file.exists():
+        _logger.debug(f"File {filename} found in {directory}")
+        return file
+
+    if rec:
+        for subdir in Path(directory).iterdir():
+            if subdir.is_dir():
+                file = _search_directory(subdir, filename, True)
+                if file:
+                    return file
+    return None
+
+
 def find_file(name, loc):
     """
     Search for files inside of given directories, recursively, and return its full path.
@@ -633,7 +381,7 @@ def find_file(name, loc):
     ----------
     name: str
         File name to be searched for.
-    loc: Path
+    loc: Path or list of Path
         Location of where to search for the file.
 
     Returns
@@ -646,40 +394,19 @@ def find_file(name, loc):
     FileNotFoundError
         If the desired file is not found.
     """
-
-    all_locations = copy.copy(loc)
-    all_locations = [all_locations] if not isinstance(all_locations, list) else all_locations
-
-    def _search_directory(directory, filename, rec=False):
-        if not Path(directory).exists():
-            msg = f"Directory {directory} does not exist"
-            _logger.debug(msg)
-            return None
-
-        file = Path(directory).joinpath(filename)
-        if file.exists():
-            _logger.debug(f"File {filename} found in {directory}")
-            return file
-        if not rec:  # Not recursively
-            return None
-
-        for subdir in Path(directory).iterdir():
-            if not subdir.is_dir():
-                continue
-            file = _search_directory(subdir, filename, True)
-            if file is not None:
-                return file
-        return None
+    all_locations = [loc] if not isinstance(loc, list) else loc
 
     # Searching file locally
     file = _search_directory(".", name)
-    if file is not None:
+    if file:
         return file
+
     # Searching file in given locations
-    for location_now in all_locations:
-        file = _search_directory(location_now, name, True)
-        if file is not None:
+    for location in all_locations:
+        file = _search_directory(location, name, True)
+        if file:
             return file
+
     msg = f"File {name} could not be found in {all_locations}"
     _logger.error(msg)
     raise FileNotFoundError(msg)
@@ -701,7 +428,6 @@ def get_log_excerpt(log_file, n_last_lines=30):
     str
         Excerpt from log file with header/footer
     """
-
     return (
         "\n\nRuntime error - See below the relevant part of the log/err file.\n\n"
         f"{log_file}\n"
@@ -712,9 +438,7 @@ def get_log_excerpt(log_file, n_last_lines=30):
 
 
 def get_file_age(file_path):
-    """
-    Get the age of a file in seconds since the last modification.
-    """
+    """Get the age of a file in seconds since the last modification."""
     if not Path(file_path).is_file():
         raise FileNotFoundError(f"'{file_path}' does not exist or is not a file.")
 
@@ -722,14 +446,44 @@ def get_file_age(file_path):
     modification_time = file_stats.st_mtime
     current_time = time.time()
 
-    file_age_minutes = (current_time - modification_time) / 60
-    return file_age_minutes
+    return (current_time - modification_time) / 60
+
+
+def _process_dict_keys(input_dict, case_func):
+    """
+    Process dictionary keys recursively.
+
+    Parameters
+    ----------
+    input_dict: dict
+        Dictionary to be processed.
+    case_func: function
+        Function to change case of keys (e.g., str.lower, str.upper).
+
+    Returns
+    -------
+    dict
+        Processed dictionary with keys changed.
+    """
+    output_dict = {}
+    for key, value in input_dict.items():
+        processed_key = case_func(key)
+        if isinstance(value, dict):
+            output_dict[processed_key] = _process_dict_keys(value, case_func)
+        elif isinstance(value, list):
+            processed_list = [
+                _process_dict_keys(item, case_func) if isinstance(item, dict) else item
+                for item in value
+            ]
+            output_dict[processed_key] = processed_list
+        else:
+            output_dict[processed_key] = value
+    return output_dict
 
 
 def change_dict_keys_case(data_dict, lower_case=True):
     """
-    Change keys of a dictionary to lower or upper case. Crawls through the dictionary and changes\
-    all keys. Takes into account list of dictionaries, as e.g. found in the top level data model.
+    Change keys of a dictionary to lower or upper case recursively.
 
     Parameters
     ----------
@@ -737,37 +491,28 @@ def change_dict_keys_case(data_dict, lower_case=True):
         Dictionary to be converted.
     lower_case: bool
         Change keys to lower (upper) case if True (False).
+
+    Returns
+    -------
+    dict
+        Dictionary with keys converted to lower or upper case.
     """
+    # Determine which case function to use
+    case_func = str.lower if lower_case else str.upper
 
-    _return_dict = {}
     try:
-        for key in data_dict.keys():
-            if lower_case:
-                _key_changed = key.lower()
-            else:
-                _key_changed = key.upper()
-            if isinstance(data_dict[key], dict):
-                _return_dict[_key_changed] = change_dict_keys_case(data_dict[key], lower_case)
-            elif isinstance(data_dict[key], list):
-                _tmp_list = []
-                for _list_entry in data_dict[key]:
-                    if isinstance(_list_entry, dict):
-                        _tmp_list.append(change_dict_keys_case(_list_entry, lower_case))
-                    else:
-                        _tmp_list.append(_list_entry)
-                _return_dict[_key_changed] = _tmp_list
-            else:
-                _return_dict[_key_changed] = data_dict[key]
-    except AttributeError:
+        return _process_dict_keys(data_dict, case_func)
+    except AttributeError as exc:
         _logger.error(f"Input is not a proper dictionary: {data_dict}")
-        raise
-    return _return_dict
+        raise AttributeError from exc
 
 
 def remove_substring_recursively_from_dict(data_dict, substring="\n"):
     """
-    Remove substrings from all strings in a dictionary. Recursively crawls through the dictionary
-    This e.g., allows to remove all newline characters from a dictionary.
+    Remove substrings from all strings in a dictionary.
+
+    Recursively crawls through the dictionary This e.g., allows to remove all newline characters
+    from a dictionary.
 
     Parameters
     ----------
@@ -790,9 +535,11 @@ def remove_substring_recursively_from_dict(data_dict, substring="\n"):
                     item.replace(substring, "") if isinstance(item, str) else item for item in value
                 ]
                 modified_items = [
-                    remove_substring_recursively_from_dict(item, substring)
-                    if isinstance(item, dict)
-                    else item
+                    (
+                        remove_substring_recursively_from_dict(item, substring)
+                        if isinstance(item, dict)
+                        else item
+                    )
                     for item in modified_items
                 ]
                 data_dict[key] = modified_items
@@ -804,18 +551,18 @@ def remove_substring_recursively_from_dict(data_dict, substring="\n"):
 
 
 def sort_arrays(*args):
-    """Sort arrays
+    """Sort arrays.
 
     Parameters
     ----------
     *args
         Arguments to be sorted.
+
     Returns
     -------
     list
         Sorted args.
     """
-
     if len(args) == 0:
         return args
     order_array = copy.copy(args[0])
@@ -826,59 +573,215 @@ def sort_arrays(*args):
     return new_args
 
 
-def extract_type_of_value(value) -> str:
+def user_confirm():
+    """
+    Ask the user to enter y or n (case-insensitive) on the command line.
+
+    Returns
+    -------
+    bool:
+        True if the answer is Y/y.
+
+    """
+    while True:
+        try:
+            answer = input("Is this OK? [y/n]").lower()
+            return answer == "y"
+        except EOFError:
+            break
+    return False
+
+
+def _get_value_dtype(value):
+    """
+    Get the data type of the given value.
+
+    Parameters
+    ----------
+        Value to determine the data type.
+
+    Returns
+    -------
+    type:
+        Data type of the value.
+    """
+    if isinstance(value, (list | np.ndarray)):
+        value = np.array(value)
+        return value.dtype
+
+    return type(value)
+
+
+def validate_data_type(reference_dtype, value=None, dtype=None, allow_subtypes=True):
+    """
+    Validate data type of value or type object against a reference data type.
+
+    Allow to check for exact data type or allow subtypes (e.g. uint is accepted for int).
+    Take into account 'file' type as used in the model parameter database.
+
+    Parameters
+    ----------
+    reference_dtype: str
+        Reference data type to be checked against.
+    value: any, optional
+        Value to be checked (if dtype is None).
+    dtype: type, optional
+        Type object to be checked (if value is None).
+    allow_subtypes: bool, optional
+        If True, allow subtypes to be accepted.
+
+    Returns
+    -------
+    bool:
+        True if the data type is valid.
     """
-    Extract the string representation of the the type of a value.
-    For example, for a string, it returns 'str' rather than '<class 'str'>'.
-    Take into account also the case where the value is a numpy type.
+    if value is None and dtype is None:
+        raise ValueError("Either value or dtype must be given.")
+
+    if value is not None and dtype is None:
+        dtype = _get_value_dtype(value)
+
+    # Strict comparison
+    if not allow_subtypes:
+        return np.issubdtype(dtype, reference_dtype)
+
+    # Allow any sub-type of integer or float for success
+    if (np.issubdtype(dtype, np.str_) or np.issubdtype(dtype, "object")) and reference_dtype in (
+        "string",
+        "str",
+        "file",
+    ):
+        return True
+
+    if np.issubdtype(dtype, np.bool_) and reference_dtype in ("boolean", "bool"):
+        return True
+
+    if np.issubdtype(dtype, np.integer) and (
+        np.issubdtype(reference_dtype, np.integer) or np.issubdtype(reference_dtype, np.floating)
+    ):
+        return True
+
+    if np.issubdtype(dtype, np.floating) and np.issubdtype(reference_dtype, np.floating):
+        return True
+
+    return False
+
+
+def convert_list_to_string(data, comma_separated=False, shorten_list=False, collapse_list=False):
     """
-    _type = str(type(value))
-    if "numpy" in _type:
-        return re.sub(r"\d+", "", _type.split("'")[1].split(".")[-1])
-    if "astropy" in _type:
-        raise NotImplementedError("Astropy types are not supported yet.")
+    Convert arrays to string (if required).
+
+    Parameters
+    ----------
+    data: object
+        Object of data to convert (e.g., double or list)
+    comma_separated: bool
+        If True, returns elements as a comma-separated string (default is space-separated).
+    shorten_list: bool
+        If True and all elements in the list are identical, returns a summary string
+        like "all: value".  This is useful to make the configuration files more readable.
+    collapse_list: bool
+        If True and all elements in the list are identical, returns a single value
+        instead of the entire list.
+
+    Returns
+    -------
+    object or str:
+        Converted data as string (if required)
+
+    """
+    if data is None or not isinstance(data, list | np.ndarray):
+        return data
+    if shorten_list and len(data) > 10 and all(np.isclose(item, data[0]) for item in data):
+        return f"all: {data[0]}"
+    if collapse_list and len(sorted(set(data))) == 1:
+        data = [data[0]]
+    if comma_separated:
+        return ", ".join(str(item) for item in data)
+    return " ".join(str(item) for item in data)
+
+
+def convert_string_to_list(data_string, is_float=True):
+    """
+    Convert string (as used e.g. in sim_telarray) to list.
+
+    Allow coma or space separated strings.
 
-    _type = _type.split("'")[1]
-    return _type
+    Parameters
+    ----------
+    data_string: object
+        String to be converted
 
+    Returns
+    -------
+    list, str
+        Converted data from string (if required).
+        Return data_string if conversion fails.
 
-def get_value_unit_type(value):
     """
-    Get the value, unit and type of a value.
-    The value is stripped of its unit and the unit is returned
-    in its string form (i.e., to_string()).
-    The type is returned as a string representation of the type.
-    For example, for a string, it returns 'str' rather than '<class 'str'>'.
+    try:
+        if is_float:
+            return [float(v) for v in data_string.split()]
+        return [int(v) for v in data_string.split()]
+    except ValueError:
+        pass
+    if "," in data_string:
+        result = data_string.split(",")
+        return [item.strip() for item in result]
+    if " " in data_string:
+        return data_string.split()
+    return data_string
+
 
-    Note that Quantities are always floats, even if the original value is represented as an int.
+def _load_yaml_using_astropy(file):
+    """
+    Load a yaml file using astropy's yaml loader.
 
     Parameters
     ----------
-    value: str, int, float, bool, u.Quantity
-        Value to be parsed.
+    file: file
+        File to be loaded.
 
     Returns
     -------
-    type of value, str, str
-        Value, unit in string representation (to_string())),
-        and string representation of the type of the value.
+    dict
+        Dictionary containing the file content.
+    """
+    # pylint: disable=import-outside-toplevel
+    import astropy.io.misc.yaml as astropy_yaml
+
+    file.seek(0)
+    return astropy_yaml.load(file)
+
+
+def read_file_encoded_in_utf_or_latin(file_name):
     """
+    Read a file encoded in UTF-8 or Latin-1.
 
-    base_value = value
-    base_unit = None
-    base_type = ""
-    if isinstance(value, (str, u.Quantity)):
+    Parameters
+    ----------
+    file_name: str
+        Name of the file to be read.
+
+    Returns
+    -------
+    list
+        List of lines read from the file.
+
+    Raises
+    ------
+    UnicodeDecodeError
+        If the file cannot be decoded using UTF-8 or Latin-1.
+    """
+    try:
+        with open(file_name, encoding="utf-8") as file:
+            lines = file.readlines()
+    except UnicodeDecodeError:
+        logging.debug("Unable to decode file using UTF-8. Trying Latin-1.")
         try:
-            _quantity_value = u.Quantity(value)
-            base_value = _quantity_value.value
-            base_type = extract_type_of_value(base_value)
-            if _quantity_value.unit.to_string() != "":
-                base_unit = _quantity_value.unit.to_string()
-        except TypeError:
-            base_value = value
-            base_type = "str"
-    else:
-        base_value = value
-        base_type = extract_type_of_value(base_value)
+            with open(file_name, encoding="latin-1") as file:
+                lines = file.readlines()
+        except UnicodeDecodeError as exc:
+            raise UnicodeDecodeError("Unable to decode file using UTF-8 or Latin-1.") from exc
 
-    return base_value, base_unit, base_type
+    return lines