FourCIPP 1.2.0__tar.gz → 1.4.0__tar.gz

{fourcipp-1.2.0/src/FourCIPP.egg-info → fourcipp-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FourCIPP
-Version: 1.2.0
+Version: 1.4.0
 Summary: A streamlined Python Parser for 4C input files
 Author: FourCIPP Authors
 License: The MIT License (MIT)
@@ -168,7 +168,7 @@ input_4C["PROBLEM SIZE"]["NODES"] = 10_000_000
 removed_section = input_4C.pop("PROBLEM SIZE")
 
 # Dump to file
-input_4C.dump(input_file_path, sort_sections=True, validate=True)
+input_4C.dump(input_file_path, validate=True)
 ```
 <!--example, do not remove this comment-->
 

{fourcipp-1.2.0 → fourcipp-1.4.0}/README.md

@@ -124,7 +124,7 @@ input_4C["PROBLEM SIZE"]["NODES"] = 10_000_000
 removed_section = input_4C.pop("PROBLEM SIZE")
 
 # Dump to file
-input_4C.dump(input_file_path, sort_sections=True, validate=True)
+input_4C.dump(input_file_path, validate=True)
 ```
 <!--example, do not remove this comment-->
 

{fourcipp-1.2.0 → fourcipp-1.4.0/src/FourCIPP.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FourCIPP
-Version: 1.2.0
+Version: 1.4.0
 Summary: A streamlined Python Parser for 4C input files
 Author: FourCIPP Authors
 License: The MIT License (MIT)
@@ -168,7 +168,7 @@ input_4C["PROBLEM SIZE"]["NODES"] = 10_000_000
 removed_section = input_4C.pop("PROBLEM SIZE")
 
 # Dump to file
-input_4C.dump(input_file_path, sort_sections=True, validate=True)
+input_4C.dump(input_file_path, validate=True)
 ```
 <!--example, do not remove this comment-->
 

{fourcipp-1.2.0 → fourcipp-1.4.0}/src/fourcipp/fourc_input.py

@@ -27,7 +27,7 @@ import copy
 import difflib
 import pathlib
 from collections.abc import Sequence
-from typing import Any
+from typing import Any, Callable
 
 from loguru import logger
 
@@ -37,7 +37,10 @@ from fourcipp.legacy_io import (
     interpret_legacy_section,
 )
 from fourcipp.utils.converter import Converter
-from fourcipp.utils.dict_utils import compare_nested_dicts_or_lists
+from fourcipp.utils.dict_utils import (
+    compare_nested_dicts_or_lists,
+    sort_by_key_order,
+)
 from fourcipp.utils.not_set import NotSet, check_if_set
 from fourcipp.utils.typing import Path
 from fourcipp.utils.validation import ValidationError, validate_using_json_schema
@@ -66,6 +69,75 @@ def is_section_known(section_name: str, known_section_names: list[str]) -> bool:
     return section_name in known_section_names or section_name.startswith("FUNCT")
 
 
+def _sort_by_section_names(data: dict) -> dict:
+    """Sort a dictionary by its 4C sections.
+
+    This sorts the dictionary in the following style:
+
+        1. "TITLE" section
+        2. Alphabetically sorted sections
+        3. Alphabetically sorted legacy sections
+
+    Args:
+        data: Dictionary to sort.
+        section_names: List of all section names in the 4C style order.
+
+    Returns:
+        Dict sorted in 4C fashion
+    """
+
+    required_sections = CONFIG.fourc_json_schema["required"]
+    n_sections_splitter = len(CONFIG.sections.all_sections) * 1000
+
+    # collect typed sections + numeric FUNCT sections
+    typed_and_funct = sorted(
+        sorted(CONFIG.sections.typed_sections, key=str.lower)
+        + [s for s in data.keys() if s.startswith("FUNCT") and s[5:].isdigit()],
+        key=lambda s: (
+            s.lower() if not s.startswith("FUNCT") else f"funct{s[5:].zfill(10)}"
+        ),
+    )
+
+    def ordering_score(section: str) -> int:
+        """Get ordering score, small score comes first, larger comes later.
+
+        We offset the score by the number of sections multiplied by 1000. This way a score is guaranteed to never appear twice.
+
+        Args:
+            section: Section name to score
+
+        Returns:
+            ordering score
+        """
+        # Title sections
+        if section == CONFIG.fourc_metadata["metadata"]["description_section_name"]:
+            return 0
+        # Required sections
+        elif section in required_sections:
+            return 1 * n_sections_splitter + required_sections.index(section)
+        # Typed + FUNCT sections (alphabetical + case insensitive)
+        elif section in typed_and_funct:
+            return 2 * n_sections_splitter + typed_and_funct.index(section)
+        # Legacy sections
+        elif section in CONFIG.sections.legacy_sections:
+            return 3 * n_sections_splitter + CONFIG.sections.legacy_sections.index(
+                section
+            )
+        # Unknown section
+        else:
+            raise KeyError(f"Unknown section {section}")
+
+    unknown_sections = set(data.keys()) - set(CONFIG.sections.all_sections)
+
+    # Remove functions, these are a special case
+    if [section for section in unknown_sections if not section.startswith("FUNCT")]:
+        raise ValueError(
+            f"Sections {list(unknown_sections)} are not known in 'section_names'"
+        )
+
+    return sort_by_key_order(data, sorted(data.keys(), key=ordering_score))
+
+
 class FourCInput:
     """4C inout file object."""
 
@@ -420,20 +492,22 @@ class FourCInput:
     def dump(
         self,
         input_file_path: Path,
-        sort_sections: bool = False,
         validate: bool = False,
         validate_sections_only: bool = False,
         convert_to_native_types: bool = True,
+        sort_function: Callable[[dict], dict] | None = _sort_by_section_names,
+        use_fourcipp_yaml_style: bool = True,
     ) -> None:
         """Dump object to yaml.
 
         Args:
             input_file_path: Path to dump the data to
-            sort_sections: Sort the sections alphabetically
             validate: Validate input data before dumping
             validate_sections_only: Validate each section independently.
                 Requiredness of the sections themselves is ignored.
             convert_to_native_types: Convert all sections to native Python types
+            sort_function: Function to sort the sections.
+            use_fourcipp_yaml_style: If FourCIPP yaml style is to be used
         """
 
         if validate or validate_sections_only:
@@ -448,7 +522,7 @@ class FourCInput:
         if convert_to_native_types:
             self.convert_to_native_types()
 
-        dump_yaml(self.inlined, input_file_path, sort_sections)
+        dump_yaml(self.inlined, input_file_path, sort_function, use_fourcipp_yaml_style)
 
     def validate(
         self,

{fourcipp-1.2.0 → fourcipp-1.4.0}/src/fourcipp/utils/cli.py

@@ -34,9 +34,12 @@ from fourcipp.utils.configuration import (
     show_config,
 )
 from fourcipp.utils.typing import Path
+from fourcipp.utils.yaml_io import dump_yaml, load_yaml
 
 
-def modify_input_with_defaults(input_path: Path, overwrite: bool) -> None:
+def modify_input_with_defaults(
+    input_path: Path, overwrite: bool
+) -> None:  # pragma: no cover
     """Apply user defaults to an input file located at input_path.
 
     Args:
@@ -62,6 +65,24 @@ def modify_input_with_defaults(input_path: Path, overwrite: bool) -> None:
     logger.info(f"Input file incl. user defaults is now '{output_filename}'.")
 
 
+def format_file(
+    input_file: str, sort_sections: bool = False
+) -> None:  # pragma: no cover
+    """Formatting file.
+
+    Args:
+        input_file: File to format
+        sort_sections: Sort sections
+    """
+    if sort_sections:
+        # Requires reading the config
+        fourc_input = FourCInput.from_4C_yaml(input_file)
+        fourc_input.dump(input_file, use_fourcipp_yaml_style=True)
+    else:
+        # No config required, is purely a style question
+        dump_yaml(load_yaml(input_file), input_file, use_fourcipp_yaml_style=True)
+
+
 def main() -> None:
     """Main CLI interface."""
     # Set up the logger
@@ -110,6 +131,23 @@ def main() -> None:
         type=str,
     )
 
+    # Format parser
+    format_parser = subparsers.add_parser(
+        "format",
+        help="Format the file in fourcipp style. This sorts the sections and uses the flow styles from FourCIPP",
+    )
+
+    format_parser.add_argument(
+        "input-file",
+        help=f"4C input file.",
+        type=str,
+    )
+
+    format_parser.add_argument(
+        "--sort-sections",
+        action="store_true",
+        help=f"Overwrite existing input file.",
+    )
     # Replace "-" with "_" for variable names
     kwargs: dict = {}
     for key, value in vars(main_parser.parse_args(sys.argv[1:])).items():
@@ -126,3 +164,5 @@ def main() -> None:
             input_path = pathlib.Path(kwargs.pop("input_file"))
             overwrite = kwargs.pop("overwrite")
             modify_input_with_defaults(input_path, overwrite)
+        case "format":
+            format_file(**kwargs)

{fourcipp-1.2.0 → fourcipp-1.4.0}/src/fourcipp/utils/configuration.py

@@ -45,7 +45,7 @@ class Sections:
         """
         self.legacy_sections: list[str] = legacy_sections
         self.typed_sections: list[str] = typed_sections
-        self.all_sections: list[str] = legacy_sections + typed_sections
+        self.all_sections: list[str] = typed_sections + legacy_sections
 
     @classmethod
     def from_metadata(cls, fourc_metadata: dict) -> Sections:
@@ -58,9 +58,10 @@ class Sections:
             Sections: sections object
         """
         description_section = fourc_metadata["metadata"]["description_section_name"]
-        sections = [
+        sections = [description_section] + [
             section["name"] for section in fourc_metadata["sections"]["specs"]
-        ] + [description_section]
+        ]
+
         legacy_sections = list(fourc_metadata["legacy_string_sections"])
 
         return cls(legacy_sections, sections)

{fourcipp-1.2.0 → fourcipp-1.4.0}/src/fourcipp/utils/dict_utils.py

@@ -373,3 +373,35 @@ def rename_parameter(
 
     for entry, last_key in _split_off_last_key(nested_dict, keys):
         entry[new_name] = entry.pop(last_key)
+
+
+def sort_by_key_order(data: dict, key_order: list[str]) -> dict:
+    """Sort a dictionary by a specific key order.
+
+    Args:
+        data: Dictionary to sort.
+        key_order: List of keys in the desired order.
+
+    Returns:
+        Sorted dictionary.
+    """
+    if set(key_order) != set(data.keys()):
+        raise ValueError("'key_order' must include all keys in the dictionary!")
+
+    return {key: data[key] for key in key_order if key in data}
+
+
+def sort_alphabetically(
+    data: dict,
+) -> dict:
+    """Sort a dictionary alphabetically.
+
+    Args:
+        data: Dictionary to sort.
+
+    Returns:
+        Sorted dictionary.
+    """
+    return sort_by_key_order(
+        data, sorted(data.keys(), key=lambda s: (s.lower(), 0 if s.islower() else 1))
+    )

{fourcipp-1.2.0 → fourcipp-1.4.0}/src/fourcipp/utils/yaml_io.py

@@ -24,6 +24,7 @@
 import json
 import pathlib
 import re
+from typing import Callable
 
 import ryml
 
@@ -61,26 +62,83 @@ def load_yaml(path_to_yaml_file: Path) -> dict:
     return data
 
 
-def dict_to_yaml_string(data: dict, sort_keys: bool = False) -> str:
+def dict_to_yaml_string(
+    data: dict,
+    sort_function: Callable[[dict], dict] | None = None,
+    use_fourcipp_yaml_style: bool = True,
+) -> str:
     """Dump dict as yaml.
 
+    The FourCIPP yaml style sets flow
     Args:
         data: Data to dump.
-        sort_keys: If true sort the sections by section name
+        sort_function: Function to sort the data.
+        use_fourcipp_yaml_style: If FourCIPP yaml style is to be used
+
+    Returns:
+        YAML string representation of the data
     """
 
-    # Sort keys
-    if sort_keys:
-        data = {key: data[key] for key in sorted(data.keys())}
+    if sort_function is not None:
+        data = sort_function(data)
 
     # Convert dictionary into a ryml tree
     tree = ryml.parse_in_arena(bytearray(json.dumps(data).encode("utf8")))
 
-    # remove all style bits to enable a YAML style output
+    def check_is_vector(tree: ryml.Tree, node_id: int) -> bool:
+        """Check if sequence is of ints, floats or sequence there of.
+
+        In 4C metadata terms, list of strings, bools, etc. could also be vectors.
+        For the sake of simplicity these are omitted.
+
+        Args:
+            tree (ryml.Tree): Tree to check
+            node_id (int): Node id
+
+        Returns:
+            returns if entry is a vector
+        """
+
+        for sub_node, _ in ryml.walk(tree, node_id):
+            # Ignore the root node
+            if sub_node == node_id:
+                continue
+
+            # If sequence contains a dict
+            if tree.is_map(sub_node):
+                return False
+
+            # If sequence contains a sequence
+            elif tree.is_seq(sub_node):
+                if not check_is_vector(tree, sub_node):
+                    return False
+
+            # Else it's a value
+            else:
+                val = tree.val(sub_node).tobytes().decode("ascii")
+                is_not_numeric = (
+                    tree.is_val_quoted(sub_node)  # string
+                    or tree.val_is_null(sub_node)  # null
+                    or val == "true"  # bool
+                    or val == "false"  # bool
+                )
+                if is_not_numeric:
+                    return False
+
+        return True
+
+    # Change style bits to avoid JSON output and format vectors correctly
     # see https://github.com/biojppm/rapidyaml/issues/520
-    for node_id, _ in ryml.walk(tree):
-        if tree.is_map(node_id) or tree.is_seq(node_id):
+    for node_id, depth in ryml.walk(tree):
+        if tree.is_map(node_id):
             tree.set_container_style(node_id, ryml.NOTYPE)
+        elif tree.is_seq(node_id):
+            if (
+                not use_fourcipp_yaml_style  # do not do special formatting
+                or depth == 1  # is a section
+                or not check_is_vector(tree, node_id)  # is not a vector
+            ):
+                tree.set_container_style(node_id, ryml.NOTYPE)
 
         if tree.has_key(node_id):
             tree.set_key_style(node_id, ryml.NOTYPE)
@@ -88,14 +146,21 @@ def dict_to_yaml_string(data: dict, sort_keys: bool = False) -> str:
     return ryml.emit_yaml(tree)
 
 
-def dump_yaml(data: dict, path_to_yaml_file: Path, sort_keys: bool = False) -> None:
+def dump_yaml(
+    data: dict,
+    path_to_yaml_file: Path,
+    sort_function: Callable[[dict], dict] | None = None,
+    use_fourcipp_yaml_style: bool = True,
+) -> None:
     """Dump yaml to file.
 
     Args:
         data: Data to dump.
         path_to_yaml_file: Yaml file path
-        sort_keys: If true sort the sections by section name
+        sort_function: Function to sort the data
+        use_fourcipp_yaml_style: If FourCIPP yaml style is to be used
     """
     pathlib.Path(path_to_yaml_file).write_text(
-        dict_to_yaml_string(data, sort_keys), encoding="utf-8"
+        dict_to_yaml_string(data, sort_function, use_fourcipp_yaml_style),
+        encoding="utf-8",
     )

{fourcipp-1.2.0 → fourcipp-1.4.0}/src/fourcipp/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.2.0'
-__version_tuple__ = version_tuple = (1, 2, 0)
+__version__ = version = '1.4.0'
+__version_tuple__ = version_tuple = (1, 4, 0)
 
-__commit_id__ = commit_id = 'g979d1f40a'
+__commit_id__ = commit_id = 'g861e0a123'

{fourcipp-1.2.0 → fourcipp-1.4.0}/tests/fourcipp/test_fourc_input.py

@@ -23,6 +23,7 @@
 
 import contextlib
 import pathlib
+import random
 import subprocess
 import time
 from collections.abc import Callable
@@ -33,6 +34,7 @@ from fourcipp import CONFIG
 from fourcipp.fourc_input import (
     FourCInput,
     UnknownSectionException,
+    _sort_by_section_names,
 )
 from fourcipp.utils.cli import modify_input_with_defaults
 from fourcipp.utils.validation import ValidationError
@@ -552,6 +554,53 @@ def test_validation(fourc_input, error_context, sections_only):
         fourc_input.validate(sections_only=sections_only)
 
 
+def test_sort_by_section_names():
+    """Test sorting by section names."""
+
+    # create list of typed sections without title and required sections
+    typed_sections = [
+        sec
+        for sec in CONFIG.sections.typed_sections
+        if sec != CONFIG.fourc_metadata["metadata"]["description_section_name"]
+        and sec not in set(CONFIG.fourc_json_schema["required"])
+    ]
+
+    # also use end subset to also add some lowercase sections
+    typed_and_functions = (
+        typed_sections[:15]
+        + typed_sections[-15:]
+        + [f"FUNCT{i}" for i in [1, 2, 9, 10, 33]]
+    )
+
+    # sort with proper key: alphabetically for typed, numerically for FUNCT
+    typed_and_functions = sorted(
+        typed_and_functions,
+        key=lambda s: (
+            s.lower() if not s.startswith("FUNCT") else f"funct{s[5:].zfill(10)}"
+        ),
+    )
+
+    correct_section_order = (
+        [CONFIG.fourc_metadata["metadata"]["description_section_name"]]
+        + CONFIG.fourc_json_schema["required"]
+        + typed_and_functions
+        + CONFIG.sections.legacy_sections
+    )
+
+    shuffled_section_order = correct_section_order.copy()
+    random.seed(42)
+    random.shuffle(shuffled_section_order)
+
+    shuffled_data = {k: 1 for k in shuffled_section_order}
+
+    sorted_data = _sort_by_section_names(shuffled_data)
+
+    assert list(sorted_data.keys()) == correct_section_order
+
+
+## performance tests
+
+
 def create_dummy_elements() -> dict:
     """Create dummy elements for the performance test.
 

{fourcipp-1.2.0 → fourcipp-1.4.0}/tests/fourcipp/utils/test_dict_utils.py

@@ -34,6 +34,8 @@ from fourcipp.utils.dict_utils import (
     remove,
     rename_parameter,
     replace_value,
+    sort_alphabetically,
+    sort_by_key_order,
 )
 
 
@@ -664,3 +666,30 @@ def test_get_dict_optional(nested_input_dict):
         result = entry
     # assert if nothing changed
     assert result == "some value"
+
+
+def test_sort_by_key_order_basic():
+    """Test sorting by key order."""
+
+    data = {"b": 2, "a": 1, "c": 3}
+
+    assert sort_by_key_order(data, ["a", "b", "c"]) == {"a": 1, "b": 2, "c": 3}
+
+
+def test_sort_by_key_order_error_mismatched_keys():
+    """Test sorting by key order with mismatched keys."""
+
+    data = {"b": 2, "a": 1, "c": 3}
+
+    with pytest.raises(
+        ValueError, match="'key_order' must include all keys in the dictionary!"
+    ):
+        sort_by_key_order(data, ["a", "b"])
+
+
+def test_sort_alphabetically():
+    """Test alphabetical sorting."""
+
+    data = {"A": 1, "b": 2, "a": 0, "B": 3, "c": 4, "C": 5}
+
+    assert sort_alphabetically(data) == {"a": 0, "A": 1, "b": 2, "B": 3, "c": 4, "C": 5}

fourcipp-1.4.0/tests/fourcipp/utils/test_yaml_io.py

@@ -0,0 +1,126 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2025 FourCIPP Authors
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+"""Test yaml io utils."""
+
+import pytest
+
+from fourcipp.utils.dict_utils import sort_alphabetically
+from fourcipp.utils.yaml_io import dict_to_yaml_string, dump_yaml, load_yaml
+
+
+def test_dump_not_sorted(tmp_path):
+    """Test if key order is preserved."""
+    data = {"c": 1, "b": 2, "a": 3}
+    sorted_file_path = tmp_path / "sorted.yaml"
+    dump_yaml(data, path_to_yaml_file=sorted_file_path)
+    reloaded_data = load_yaml(sorted_file_path)
+    assert reloaded_data == data
+
+
+def test_dump_sorted_alphabetically(tmp_path):
+    """Test if key order is sorted."""
+    data = {"c": 1, "b": 2, "a": 3}
+    sorted_file_path = tmp_path / "sorted.yaml"
+    dump_yaml(
+        data, path_to_yaml_file=sorted_file_path, sort_function=sort_alphabetically
+    )
+    reloaded_data = load_yaml(sorted_file_path)
+    assert list(reloaded_data.keys()) == sorted(data.keys())
+
+
+@pytest.mark.parametrize(
+    "use_fourcipp_yaml_style, expected",
+    [
+        (
+            False,
+            """SECTION:
+  - vector:
+      - 1.23
+      - 2
+      - 3
+    nested_vector:
+      - - 1
+        - 2.0
+        - 3
+      - - 4.5
+        - 5
+        - 2.333
+  - list_with_bool:
+      - 1
+      - true
+      - 3
+    list_with_null:
+      - 1
+      - null
+      - 4
+  - list_with_string:
+      - 1
+      - "abc"
+      - 5
+    nested_list_with_string:
+      - - 1
+        - 2.1
+      - - 2
+        - "def"
+""",
+        ),
+        (
+            True,
+            """SECTION:
+  - vector: [1.23,2,3]
+    nested_vector: [[1,2.0,3],[4.5,5,2.333]]
+  - list_with_bool:
+      - 1
+      - true
+      - 3
+    list_with_null:
+      - 1
+      - null
+      - 4
+  - list_with_string:
+      - 1
+      - "abc"
+      - 5
+    nested_list_with_string:
+      - [1,2.1]
+      - - 2
+        - "def"
+""",
+        ),
+    ],
+)
+def test_yaml_style(use_fourcipp_yaml_style, expected):
+    """Test yaml output style."""
+    data = {
+        "SECTION": [
+            {"vector": [1.23, 2, 3], "nested_vector": [[1, 2.0, 3], [4.5, 5, 2.333]]},
+            {"list_with_bool": [1, True, 3], "list_with_null": [1, None, 4]},
+            {
+                "list_with_string": [1, "abc", 5],
+                "nested_list_with_string": [[1, 2.1], [2, "def"]],
+            },
+        ]
+    }
+    assert (
+        dict_to_yaml_string(data, use_fourcipp_yaml_style=use_fourcipp_yaml_style)
+        == expected
+    )

fourcipp-1.2.0/tests/fourcipp/utils/test_yaml_io.py

@@ -1,42 +0,0 @@
-# The MIT License (MIT)
-#
-# Copyright (c) 2025 FourCIPP Authors
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-"""Test yaml io utils."""
-
-from fourcipp.utils.yaml_io import dump_yaml, load_yaml
-
-
-def test_dump_not_sorted(tmp_path):
-    """Test if key order is preserved."""
-    data = {"c": 1, "b": 2, "a": 3}
-    sorted_file_path = tmp_path / "sorted.yaml"
-    dump_yaml(data, path_to_yaml_file=sorted_file_path)
-    reloaded_data = load_yaml(sorted_file_path)
-    assert reloaded_data == data
-
-
-def test_dump_sorted(tmp_path):
-    """Test if key order is sorted."""
-    data = {"c": 1, "b": 2, "a": 3}
-    sorted_file_path = tmp_path / "sorted.yaml"
-    dump_yaml(data, path_to_yaml_file=sorted_file_path, sort_keys=True)
-    reloaded_data = load_yaml(sorted_file_path)
-    assert list(reloaded_data.keys()) == sorted(data.keys())