FourCIPP 1.2.0__tar.gz → 1.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FourCIPP
-Version: 1.2.0
+Version: 1.3.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.3.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.3.0/src/FourCIPP.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FourCIPP
-Version: 1.2.0
+Version: 1.3.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.3.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,20 @@ 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,
     ) -> 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.
         """
 
         if validate or validate_sections_only:
@@ -448,7 +520,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)
 
     def validate(
         self,

{fourcipp-1.2.0 → fourcipp-1.3.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.3.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.3.0}/src/fourcipp/utils/yaml_io.py

@@ -24,6 +24,7 @@
 import json
 import pathlib
 import re
+from typing import Callable
 
 import ryml
 
@@ -61,17 +62,21 @@ 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
+) -> str:
     """Dump dict as yaml.
 
     Args:
         data: Data to dump.
-        sort_keys: If true sort the sections by section name
+        sort_function: Function to sort the data.
+
+    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")))
@@ -88,14 +93,19 @@ 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,
+) -> 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.
     """
     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),
+        encoding="utf-8",
     )

{fourcipp-1.2.0 → fourcipp-1.3.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.3.0'
+__version_tuple__ = version_tuple = (1, 3, 0)
 
-__commit_id__ = commit_id = 'g979d1f40a'
+__commit_id__ = commit_id = 'gdf724552b'

{fourcipp-1.2.0 → fourcipp-1.3.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.3.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.2.0 → fourcipp-1.3.0}/tests/fourcipp/utils/test_yaml_io.py

@@ -21,6 +21,7 @@
 # THE SOFTWARE.
 """Test yaml io utils."""
 
+from fourcipp.utils.dict_utils import sort_alphabetically
 from fourcipp.utils.yaml_io import dump_yaml, load_yaml
 
 
@@ -33,10 +34,12 @@ def test_dump_not_sorted(tmp_path):
     assert reloaded_data == data
 
 
-def test_dump_sorted(tmp_path):
+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_keys=True)
+    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())