fameio 1.8.1__tar.gz → 1.8.2__tar.gz

{fameio-1.8.1/src/fameio.egg-info → fameio-1.8.2}/PKG-INFO

@@ -1,20 +1,25 @@
 Metadata-Version: 2.1
 Name: fameio
-Version: 1.8.1
+Version: 1.8.2
 Summary: Python scripts for operation of FAME models
 Home-page: https://gitlab.com/fame-framework/fame-io/
 Author: Felix Nitsch, Christoph Schimeczek, Ulrich Frey, Marc Deissenroth-Uhrig, Benjamin Fuchs, A. Achraf El Ghazi
 Author-email: fame@dlr.de
 License: Apache License 2.0
 Keywords: FAME,agent-based modelling
-Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: dev
 License-File: LICENSE.txt
+Requires-Dist: pandas
+Requires-Dist: fameprotobuf<1.3,>=1.2
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: mockito; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
 
 <!-- SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 
@@ -653,4 +658,3 @@ To use them, install `dev` packages and then initialise pre-commit in FAME-Io's
     pip install fameio[dev]
     pre-commit install -t pre-commit -t pre-push
 ```
-

{fameio-1.8.1 → fameio-1.8.2}/setup.py

@@ -26,7 +26,7 @@ def readme():
 
 setup(
     name="fameio",
-    version="1.8.1",
+    version="1.8.2",
     description="Python scripts for operation of FAME models",
     long_description=readme(),
     long_description_content_type="text/markdown",

{fameio-1.8.1 → fameio-1.8.2}/src/fameio/source/results/conversion.py

@@ -37,7 +37,7 @@ def apply_time_merging(data: Dict[Optional[str], pd.DataFrame], config: Optional
             index_columns = df.index.names
             df.reset_index(inplace=True)
             df["TimeStep"] = df["TimeStep"].apply(lambda t: merge_time(t, first_positive_focal_point, offset, period))
-            data[key] = df.groupby(by=index_columns, axis=0).sum()
+            data[key] = df.groupby(by=index_columns).sum()
 
 
 def merge_time(time_step: int, focal_time: int, offset: int, period: int) -> int:

{fameio-1.8.1 → fameio-1.8.2/src/fameio.egg-info}/PKG-INFO

@@ -1,20 +1,25 @@
 Metadata-Version: 2.1
 Name: fameio
-Version: 1.8.1
+Version: 1.8.2
 Summary: Python scripts for operation of FAME models
 Home-page: https://gitlab.com/fame-framework/fame-io/
 Author: Felix Nitsch, Christoph Schimeczek, Ulrich Frey, Marc Deissenroth-Uhrig, Benjamin Fuchs, A. Achraf El Ghazi
 Author-email: fame@dlr.de
 License: Apache License 2.0
 Keywords: FAME,agent-based modelling
-Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: dev
 License-File: LICENSE.txt
+Requires-Dist: pandas
+Requires-Dist: fameprotobuf<1.3,>=1.2
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: mockito; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
 
 <!-- SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 
@@ -653,4 +658,3 @@ To use them, install `dev` packages and then initialise pre-commit in FAME-Io's
     pip install fameio[dev]
     pre-commit install -t pre-commit -t pre-push
 ```
-

{fameio-1.8.1 → fameio-1.8.2}/src/fameio.egg-info/SOURCES.txt

@@ -41,4 +41,11 @@ src/fameio/source/schema/__init__.py
 src/fameio/source/schema/agenttype.py
 src/fameio/source/schema/attribute.py
 src/fameio/source/schema/exception.py
-src/fameio/source/schema/schema.py
+src/fameio/source/schema/schema.py
+tests/test_cli.py
+tests/test_load_save_reload_compare_outputs.py
+tests/test_loader.py
+tests/test_series.py
+tests/test_time.py
+tests/test_tools.py
+tests/test_validator.py

fameio-1.8.2/tests/test_cli.py

@@ -0,0 +1,324 @@
+# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+import argparse
+from pathlib import Path
+from typing import List
+
+import pytest
+
+from fameio.source.cli import (
+    update_default_config,
+    non_negative_int,
+    ERR_NEGATIVE_INT,
+    add_file_argument,
+    add_select_agents_argument,
+    add_logfile_argument,
+    add_output_argument,
+    add_log_level_argument,
+    add_single_export_argument,
+    add_memory_saving_argument,
+    add_resolve_complex_argument,
+    ResolveOptions,
+    add_time_argument,
+    TimeOptions,
+    add_focal_point_argument,
+    add_steps_before_argument,
+    add_steps_after_argument,
+    add_merge_time_parser,
+    get_merging_args,
+    MergingOptions,
+)
+from tests.utils import assert_exception_contains
+
+
+class TestParser:
+    @pytest.fixture
+    def parser(self):
+        return argparse.ArgumentParser()
+
+    def test_add_file_argument_exit_on_missing_argument(self, parser):
+        add_file_argument(parser, "")
+        with pytest.raises(SystemExit):
+            parser.parse_args([])
+
+    def test_add_file_argument_exit_on_missing_value(self, parser):
+        add_file_argument(parser, "")
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-f"])
+
+    @pytest.mark.parametrize("value", ["a", "file.x", "path/to/file", "./rel/path.x", "/abs/path/file.b"])
+    def test_add_file_argument_creates_path_for_any_value(self, parser, value: str):
+        add_file_argument(parser, "")
+        result = parser.parse_args(["-f", value])
+        assert result.file == Path(value)
+
+    def test_add_select_agents_argument_missing_argument_yields_none(self, parser):
+        add_select_agents_argument(parser)
+        result = parser.parse_args([])
+        assert result.agents is None
+
+    def test_add_select_agents_value_missing_yields_empty_list(self, parser):
+        add_select_agents_argument(parser)
+        result = parser.parse_args(["-a"])
+        assert result.agents == []
+
+    @pytest.mark.parametrize("values", [["a"], ["x", "b"], ["some", "names", "of", "agents"]])
+    def test_add_select_agents_values_added_to_list(self, parser, values: List[str]):
+        add_select_agents_argument(parser)
+        args = ["-a", *values]
+        result = parser.parse_args(args)
+        assert len(result.agents) == len(values)
+        assert set(result.agents).issubset(values)
+
+    def test_add_logfile_argument_missing_yields_none(self, parser):
+        add_logfile_argument(parser)
+        result = parser.parse_args([])
+        assert result.logfile is None
+
+    def test_add_logfile_argument_value_missing_raises(self, parser):
+        add_logfile_argument(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-lf"])
+
+    @pytest.mark.parametrize("value", ["a", "file.x", "path/to/file", "./rel/path.x", "/abs/path/file.b"])
+    def test_add_logfile_argument_creates_path_from_any_value(self, parser, value):
+        add_logfile_argument(parser)
+        result = parser.parse_args(["-lf", value])
+        assert result.logfile == Path(value)
+
+    @pytest.mark.parametrize("default", ["some", "/path/to/a", "./default/output.file"])
+    def test_add_output_argument_missing_yields_default(self, parser, default):
+        add_output_argument(parser, default, "")
+        result = parser.parse_args([])
+        assert result.output == Path(default)
+
+    def test_add_output_argument_missing_value_raises(self, parser):
+        add_output_argument(parser, "default", "")
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-o"])
+
+    @pytest.mark.parametrize("value", ["a", "file.x", "path/to/file", "./rel/path.x", "/abs/path/file.b"])
+    def test_add_output_argument_value_overrides_default(self, parser, value):
+        add_output_argument(parser, "default", "")
+        result = parser.parse_args(["-o", value])
+        assert result.output == Path(value)
+
+    @pytest.mark.parametrize("default", ["ERROR", "DEBUG", "INFO"])
+    def test_add_log_level_argument_missing_argument_yields_default(self, parser, default):
+        add_log_level_argument(parser, default)
+        result = parser.parse_args([])
+        assert result.log == default.lower()
+
+    def test_add_log_level_argument_missing_value_raises(self, parser):
+        add_log_level_argument(parser, "ERROR")
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-l"])
+
+    def test_add_log_level_argument_unknown_level_raises(self, parser):
+        add_log_level_argument(parser, "ERROR")
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-l", "'not-an-error-level'"])
+
+    @pytest.mark.parametrize("value", ["error", "ERROR", "eRRoR", "Critical", "WARN", "inFo", "dEbUg"])
+    def test_add_log_level_argument_overrides_default_with_valid_value(self, parser, value):
+        add_log_level_argument(parser, "warning")
+        result = parser.parse_args(["-l", value])
+        assert result.log == value.lower()
+
+    @pytest.mark.parametrize("default", [True, False])
+    def test_add_single_export_argument_missing_yields_default(self, parser, default):
+        add_single_export_argument(parser, default)
+        result = parser.parse_args([])
+        assert result.single_export == default
+
+    def test_add_single_export_argument_present_yields_true(self, parser):
+        add_single_export_argument(parser, False)
+        result = parser.parse_args(["-se"])
+        assert result.single_export
+
+    @pytest.mark.parametrize("default", [True, False])
+    def test_add_memory_saving_argument_missing_yields_default(self, parser, default):
+        add_memory_saving_argument(parser, default)
+        result = parser.parse_args([])
+        assert result.memory_saving == default
+
+    def test_add_memory_saving_argument_present_yields_true(self, parser):
+        add_memory_saving_argument(parser, False)
+        result = parser.parse_args(["-m"])
+        assert result.memory_saving
+
+    @pytest.mark.parametrize("default", [e.name for e in ResolveOptions])
+    def test_add_resolve_complex_argument_missing_yields_default(self, parser, default: str):
+        add_resolve_complex_argument(parser, default)
+        result = parser.parse_args([])
+        assert result.complex_column == default.upper()
+
+    def test_add_resolve_complex_argument_missing_value_raises(self, parser):
+        add_resolve_complex_argument(parser, ResolveOptions.IGNORE.name)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-cc"])
+
+    def test_add_resolve_complex_argument_invalid_value_raises(self, parser):
+        add_resolve_complex_argument(parser, ResolveOptions.IGNORE.name)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-cc", "not_a_valid_value"])
+
+    @pytest.mark.parametrize("value", [e.name for e in ResolveOptions])
+    def test_add_resolve_complex_argument_override_default_on_valid_values(self, parser, value: str):
+        add_resolve_complex_argument(parser, ResolveOptions.IGNORE.name)
+        result = parser.parse_args(["-cc", value])
+        assert result.complex_column == value.upper()
+
+    @pytest.mark.parametrize("default", [e.name for e in TimeOptions])
+    def test_add_time_argument_missing_yields_default(self, parser, default):
+        add_time_argument(parser, default)
+        result = parser.parse_args([])
+        assert result.time == default.upper()
+
+    def test_add_time_argument_missing_value_raises(self, parser):
+        add_time_argument(parser, TimeOptions.INT.name)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-t"])
+
+    def test_add_time_argument_invalid_value_raises(self, parser):
+        add_time_argument(parser, TimeOptions.INT.name)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-t", "not_a_valid_value"])
+
+    @pytest.mark.parametrize("value", [e.name for e in TimeOptions])
+    def test_add_time_argument_valid_value_overrides_default(self, parser, value: str):
+        add_time_argument(parser, TimeOptions.INT.name)
+        result = parser.parse_args(["-t", value])
+        assert result.time == value.upper()
+
+    def test_add_focal_point_argument_missing_raises(self, parser):
+        add_focal_point_argument(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args([])
+
+    def test_add_focal_point_argument_value_missing_raises(self, parser):
+        add_focal_point_argument(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-fp"])
+
+    @pytest.mark.parametrize("value", ["", "not_an_int", "(5,8)", "[88]"])
+    def test_add_focal_point_argument_non_int_raises(self, parser, value: str):
+        add_focal_point_argument(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-fp", value])
+
+    @pytest.mark.parametrize("value", ["-10", "0", "1", "10000"])
+    def test_add_focal_point_argument_valid_values(self, parser, value: str):
+        add_focal_point_argument(parser)
+        result = parser.parse_args(["-fp", value])
+        assert result.focal_point == int(value)
+
+    def test_add_steps_before_argument_missing_raises(self, parser):
+        add_steps_before_argument(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args([])
+
+    def test_add_steps_before_argument_missing_value_raises(self, parser):
+        add_steps_before_argument(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-sb"])
+
+    @pytest.mark.parametrize("value", ["", "not_an_int", "(5)", "[8]", "-2"])
+    def test_add_steps_before_argument_invalid_value_raises(self, parser, value):
+        add_steps_before_argument(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-sb", value])
+
+    @pytest.mark.parametrize("value", ["0", "1", "15", "12123123"])
+    def test_add_steps_before_argument_valid_values(self, parser, value):
+        add_steps_before_argument(parser)
+        result = parser.parse_args(["-sb", value])
+        assert result.steps_before == int(value)
+
+    def test_add_steps_after_argument_missing_raises(self, parser):
+        add_steps_after_argument(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args([])
+
+    def test_add_steps_after_argument_missing_value_raises(self, parser):
+        add_steps_after_argument(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-sa"])
+
+    @pytest.mark.parametrize("value", ["", "not_an_int", "(5)", "[8]", "-2"])
+    def test_add_steps_after_argument_invalid_values_raise(self, parser, value: str):
+        add_steps_after_argument(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["-sa", value])
+
+    @pytest.mark.parametrize("value", ["0", "1", "15", "12123123"])
+    def test_add_steps_after_argument_valid_values(self, parser, value: str):
+        add_steps_after_argument(parser)
+        result = parser.parse_args(["-sa", value])
+        assert result.steps_after == int(value)
+
+    @pytest.mark.parametrize("args", [["-sa", "0", "-sb", "0"], ["-fp", "0", "-sb", "0"], ["-fp", "0", "-sa", "0"]])
+    def test_add_merge_time_parser_argument_missing_raises(self, parser, args):
+        add_merge_time_parser(parser)
+        with pytest.raises(SystemExit):
+            parser.parse_args(["merge-times", *args])
+
+    def test_get_merging_args_missing_key_returns_empty_dict(self):
+        assert get_merging_args(argparse.Namespace()) == {}
+
+    def test_get_merging_args_no_merge_times(self):
+        args = argparse.Namespace(**{"time_merging": None})
+        assert get_merging_args(args) == {}
+
+    @pytest.mark.parametrize("args", [["-fp", "-1", "-sb", "0", "-sa", "20"], ["-fp", "5", "-sb", "10", "-sa", "5"]])
+    def test_add_merge_time_parser_and_get_merging_args(self, parser, args):
+        add_merge_time_parser(parser)
+        parsed = parser.parse_args(["merge-times", *args])
+        result = get_merging_args(parsed)
+        assert result[MergingOptions.FOCAL_POINT] == int(args[1])
+        assert result[MergingOptions.STEPS_BEFORE] == int(args[3])
+        assert result[MergingOptions.STEPS_AFTER] == int(args[5])
+
+
+class TestHelpers:
+    _default = {"a": 1, "b": 2, "c": 3}
+
+    def test_get_config_or_default_update_a(self):
+        config = {"a": 42}
+        expected = {"a": 42, "b": 2, "c": 3}
+        assert update_default_config(config, self._default) == expected
+
+    def test_get_config_or_default_update_abc(self):
+        config = {"a": 42, "b": 42, "c": 42}
+        expected = {"a": 42, "b": 42, "c": 42}
+        assert update_default_config(config, self._default) == expected
+
+    def test_get_config_or_default_update_abcd(self):
+        config = {"d": 42}
+        expected = {"a": 1, "b": 2, "c": 3, "d": 42}
+        assert update_default_config(config, self._default) == expected
+
+    def test_get_config_or_default_none(self):
+        config = None
+        expected = {"a": 1, "b": 2, "c": 3}
+        assert update_default_config(config, self._default) == expected
+
+    def test_non_negative_int_positive(self):
+        assert non_negative_int(1) == 1
+
+    def test_non_negative_int_zero(self):
+        assert non_negative_int(0) == 0
+
+    def test_non_negative_int_err_on_negative_arg(self):
+        with pytest.raises(argparse.ArgumentTypeError) as e_info:
+            non_negative_int(-1)
+        assert_exception_contains(ERR_NEGATIVE_INT, e_info)
+
+    def test_non_negative_int_err_on_none(self):
+        with pytest.raises(TypeError):
+            non_negative_int(None)
+
+    def test_non_negative_int_err_on_string(self):
+        with pytest.raises(ValueError):
+            non_negative_int("Test")

fameio-1.8.2/tests/test_load_save_reload_compare_outputs.py

@@ -0,0 +1,107 @@
+# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import shutil
+from pathlib import Path
+from typing import Optional
+
+import pytest
+import yaml
+from fameprotobuf import DataStorage_pb2
+from google.protobuf import text_format
+
+from fameio.source.loader import load_yaml
+from fameio.source.path_resolver import PathResolver
+from fameio.source.scenario import Scenario
+from fameio.source.validator import SchemaValidator
+from fameio.source.writer import ProtoWriter
+
+
+class CustomPathResolver(PathResolver):
+    def __init__(self, root_dir: str):
+        super().__init__()
+        self._root_dir = root_dir
+
+    def resolve_series_file_path(self, file_name: str) -> Optional[str]:
+        if not os.path.isabs(file_name):
+            file_path = os.path.join(self._root_dir, file_name)
+            if os.path.exists(file_path):
+                return file_path
+        return super().resolve_series_file_path(file_name)
+
+
+def _load_and_validate_yaml_file(file_path: str, path_resolver: PathResolver) -> Scenario:
+    """Returns validated scenario parsed in `file_path`"""
+    scenario = Scenario.from_dict(load_yaml(Path(file_path), path_resolver))
+    SchemaValidator.ensure_is_valid_scenario(scenario)
+    return scenario
+
+
+def _write_protobuf_file(scenario: Scenario, path_resolver: PathResolver, output_file_name: str) -> None:
+    """Writes `scenario` using `path_resolver` as given `output_file_name`"""
+    writer = ProtoWriter(Path(output_file_name), path_resolver)
+    writer.write_validated_scenario(scenario)
+
+
+def _convert_protobuf_to_text(file_path: Path) -> str:
+    """Returns protobuf file in `file_path` as str"""
+    file_path = str(file_path)
+    msg = DataStorage_pb2.DataStorage()
+    with open(file_path, "rb") as file:
+        protobuf_data = file.read()
+        msg.ParseFromString(protobuf_data)
+    text = text_format.MessageToString(msg)
+    return text
+
+
+class TestLoadSaveReload:
+    scenario_name = "scenario.yaml"
+    protobuf_name = "scenario.pb"
+    scenario_copy_name = "scenario_copy.yaml"
+    protobuf_copy_name = "scenario_copy.pb"
+    path_to_examples = "../examples/Germany2019"
+
+    @pytest.fixture(scope="session")
+    def _cache_dir(self, tmp_path_factory):
+        """Creates temporary directory where files for all tests in this Class are written to"""
+        return tmp_path_factory.mktemp("cache")
+
+    def test_load_dump_reload_compare(self, _cache_dir):
+        work_dir = self._setup_workdir_with_protobuf_from_original_and_reloaded_scenario(_cache_dir)
+        ref_text = _convert_protobuf_to_text(work_dir / self.protobuf_name)
+        copy_text = _convert_protobuf_to_text(work_dir / self.protobuf_copy_name)
+
+        # we can't convert the protobuf text directly because the order of the field can vary,
+        # so we do something simple here: sort the output text lines and check they are similar
+        ref_lines = ref_text.splitlines()
+        copy_lines = copy_text.splitlines()
+        ref_lines.sort()
+        copy_lines.sort()
+        # compare line by line to help spot the difference on a large output
+        for i, line_ref in enumerate(ref_lines):
+            assert i < len(copy_lines)
+            line_copy = copy_lines[i]
+            # the generated series id are likely to be different, so we ignore them
+            if "seriesId:" in line_ref:
+                assert "seriesId:" in line_copy
+            else:
+                assert line_ref == line_copy
+        # ensure the copy has no extra lines
+        assert len(ref_lines) == len(copy_lines)
+
+    def _setup_workdir_with_protobuf_from_original_and_reloaded_scenario(self, cache_dir) -> Path:
+        this_script_dir = os.path.dirname(os.path.realpath(__file__))
+        example_dir = os.path.join(this_script_dir, self.path_to_examples)
+        work_dir = shutil.copytree(example_dir, cache_dir / "examples/Germany2019")
+        path_resolver = CustomPathResolver(work_dir)
+
+        original_scenario = _load_and_validate_yaml_file(work_dir / self.scenario_name, path_resolver)
+        _write_protobuf_file(original_scenario, path_resolver, work_dir / self.protobuf_name)
+
+        with open(work_dir / self.scenario_copy_name, "w") as f:
+            yaml.dump(original_scenario.to_dict(), f)
+        copied_scenario = _load_and_validate_yaml_file(work_dir / self.scenario_copy_name, path_resolver)
+        _write_protobuf_file(copied_scenario, path_resolver, work_dir / self.protobuf_copy_name)
+        return work_dir

fameio-1.8.2/tests/test_loader.py

@@ -0,0 +1,59 @@
+# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+import pytest
+from fameio.source.loader import PathResolver, load_yaml, check_for_yaml_file_type
+
+
+class Test:
+    def test_load_yaml_plain(self):
+        expected = {"ToBe": "ThatIs", "OrNot": "TheQuestion"}
+        loaded = load_yaml(Path("tests/yaml/simple.yaml"))
+        assert expected == loaded
+
+    def test_load_yaml_with_simple_include(self):
+        expected = {"Is": {"ToBe": "ThatIs", "OrNot": "TheQuestion"}}
+        loaded = load_yaml(Path("tests/yaml/simple_include.yaml"))
+        assert expected == loaded
+
+    def test_load_yaml_with_nested_include(self):
+        expected = {
+            "ToBe": {"ThatIs": {"Or": "maybe"}, "TheQuestion": {"not": "?"}},
+            "OrNot": {"not": "?"},
+        }
+        loaded = load_yaml(Path("tests/yaml/a.yaml"))
+        assert expected == loaded
+
+    def test_with_custom_path_resolver(self):
+        class CustomPathResolver(PathResolver):
+            def __init__(self):
+                super().__init__()
+                self.last_file_pattern = ""
+
+            def resolve_yaml_imported_file_pattern(self, root_path: str, file_pattern: str):
+                self.last_file_pattern = file_pattern
+                return super().resolve_yaml_imported_file_pattern(root_path, file_pattern)
+
+        path_resolver = CustomPathResolver()
+        load_yaml(Path("tests/yaml/simple_include.yaml"), path_resolver)
+        assert path_resolver.last_file_pattern.endswith("simple.yaml")
+
+    def test_with_failed_path_resolver(self):
+        class BadPathResolver(PathResolver):
+            def resolve_yaml_imported_file_pattern(self, root_path: str, file_pattern: str):
+                return []
+
+        with pytest.raises(Exception):
+            load_yaml(Path("tests/yaml/simple_include.yaml"), BadPathResolver())
+
+    @pytest.mark.parametrize("file_name", ["my/non_yaml/file.csv", "my/non_yaml/file", "file.", "file.xml"])
+    def test_check_for_yaml_file_type_invalid(self, file_name):
+        with pytest.raises(Exception):
+            check_for_yaml_file_type(Path(file_name))
+
+    @pytest.mark.parametrize("file_name", ["my/file.yml", "file.Yml", "my/file.yaml", "file.YAML", "file.yAmL"])
+    def test_check_for_yaml_file_type_valid(self, file_name):
+        check_for_yaml_file_type(Path(file_name))

fameio-1.8.2/tests/test_series.py

@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from fameio.source.series import TimeSeriesManager
+
+
+class TestTimeSeriesManager:
+    def test_save_get_time_series_id_same_file_same_id(self):
+        manager = TimeSeriesManager()
+        id1 = manager.save_get_time_series_id("FILE_NAME")
+        id2 = manager.save_get_time_series_id("FILE_NAME")
+        assert id1 == id2
+
+    def test_save_get_time_series_id_different_files_different_id(self):
+        manager = TimeSeriesManager()
+        id1 = manager.save_get_time_series_id("FILE_NAME")
+        id2 = manager.save_get_time_series_id("OTHER_FILE")
+        assert id1 != id2
+
+    def test_get_ids_of_series_by_name(self):
+        manager = TimeSeriesManager()
+        id1 = manager.save_get_time_series_id("FILE_NAME")
+        id2 = manager.save_get_time_series_id("OTHER_FILE")
+        ids_by_name = manager.get_ids_of_series_by_name()
+        assert ids_by_name["FILE_NAME"] == id1
+        assert ids_by_name["OTHER_FILE"] == id2