FourCIPP 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

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/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/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/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/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/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 = None

{fourcipp-1.2.0.dist-info → fourcipp-1.4.0.dist-info}/METADATA

@@ -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.dist-info → fourcipp-1.4.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 fourcipp/__init__.py,sha256=4pz7DVXErSbUcLqPTaHnQfdJzKkpfZDivBqbHbTgpRE,1388
-fourcipp/fourc_input.py,sha256=4ZcaD5NQVqPqsUaUCap0UFLn80QboXSbrvWk1qd7yTU,21260
-fourcipp/version.py,sha256=-uLONazCO1SzFfcY-K6A1keL--LIVfTYccGX6ciADac,704
+fourcipp/fourc_input.py,sha256=TXVP-N_FTadt4L8MPH3VZXeT7i5uy7Btz3H-N0pxMr0,23948
+fourcipp/version.py,sha256=qX8_mGjWClM0QeMyVAByaVXEA4Pk87fxkFSMEQx9-KM,704
 fourcipp/config/4C_metadata.yaml,sha256=3n3Uj24iblvsfqUI-8H2LYMHOROjeHl68Nok0F22Unc,11868927
 fourcipp/config/4C_schema.json,sha256=67giZGZSKXkjO_NCbZzx-blVdGB6BFXRbHrXkmqB_T4,16412275
 fourcipp/config/config.yaml,sha256=n2c2a6E4HKfAdNWOQz1kLUuf5p4NLxIddaAi2t5eM38,460
@@ -11,18 +11,18 @@ fourcipp/legacy_io/node.py,sha256=e7m0W7dai_b1XgaqD37k3QS44ySCas3HetmyTLS9_78,35
 fourcipp/legacy_io/node_topology.py,sha256=hqGGzhyNhFX-BMW8SzztfzM8zoZLLltVScMv-p4hDH0,5394
 fourcipp/legacy_io/particle.py,sha256=0rxwdiMnHI1QUGZPqWgsxqyslrxB7aq7qxgNMb_y_rk,2166
 fourcipp/utils/__init__.py,sha256=ccdlf4taJ0mKLg_ru8ilXEa72PoO9N2UIxHNHDEtQmY,1151
-fourcipp/utils/cli.py,sha256=43Nmy9tnoQzwWMZwpktWVv3T3a3y4qDzfuDB1bHogbA,4658
-fourcipp/utils/configuration.py,sha256=mDrizczVvMQ1r5EancScbWzYn3g9bmQAdDACLbPLfq0,6460
+fourcipp/utils/cli.py,sha256=I0N6mcJQGX7seLtXpfrPJA5EWrmhgOph_gHrrxEs6JE,5801
+fourcipp/utils/configuration.py,sha256=HDrvHrH4K5mdienzVsAt_sh9j2Pv81bxWBqqbeNb1KE,6461
 fourcipp/utils/converter.py,sha256=D40YQ96WqPEEpB7fwAB5XC2v-jRki4v1sIJ-ngO08nU,5194
-fourcipp/utils/dict_utils.py,sha256=Ha9eHHcItLZFQgkqC_Ew_2h_2tmLNmzdJmpECcJ3LFQ,12126
+fourcipp/utils/dict_utils.py,sha256=uC0uaBNP3Wh2v3kFy9JHnAYARMukAN4cl40pmiBT13Y,12891
 fourcipp/utils/metadata.py,sha256=98jz9Gm8qdvZ-b1jwYObNJTaiMQWwbknvS70Nv6Gwhk,1291
 fourcipp/utils/not_set.py,sha256=04C_3axe2cupBYgfpgDAcGs1zHVzG3I58UGO58TH05A,2017
 fourcipp/utils/typing.py,sha256=8iX9PuKe8B1WJ3vEjiM5ZfefvgYnaZDiSdB7Nx9SrVw,1625
 fourcipp/utils/validation.py,sha256=FejHOj1MddaU7gEpMN-f8Mz3rYjflakd1qcsKnctHqA,5292
-fourcipp/utils/yaml_io.py,sha256=fPJiIMVzVoHX97LFynGxmQ2PKQsUAb3GIBDWvkPfftI,3477
-fourcipp-1.2.0.dist-info/licenses/LICENSE,sha256=lkSOHdH9IZ8c3Vnz0fFjqls1cRlmLADBP8QEIwUlH3o,1082
-fourcipp-1.2.0.dist-info/METADATA,sha256=hTqbCDM3DU1mK3f_pGeYSvT0xTR3gBe4TbBSr2wZxVI,7967
-fourcipp-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fourcipp-1.2.0.dist-info/entry_points.txt,sha256=44XBG4bwhuq1EwOZ0U055HYP8_qN6_d30ecVsa5Igng,53
-fourcipp-1.2.0.dist-info/top_level.txt,sha256=oZ6jgFFmvi157VwGUEFuKT3D8oS5mOkpOVx8zZURZrQ,9
-fourcipp-1.2.0.dist-info/RECORD,,
+fourcipp/utils/yaml_io.py,sha256=bs78Mc3fIz0kK5wgwwu89OhaDpLzECTRBQtIpnifTqk,5559
+fourcipp-1.4.0.dist-info/licenses/LICENSE,sha256=lkSOHdH9IZ8c3Vnz0fFjqls1cRlmLADBP8QEIwUlH3o,1082
+fourcipp-1.4.0.dist-info/METADATA,sha256=ldyK7yc2khoquz4mNXn5ibAG8EATRDaUlYiPxNnsGW4,7947
+fourcipp-1.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fourcipp-1.4.0.dist-info/entry_points.txt,sha256=44XBG4bwhuq1EwOZ0U055HYP8_qN6_d30ecVsa5Igng,53
+fourcipp-1.4.0.dist-info/top_level.txt,sha256=oZ6jgFFmvi157VwGUEFuKT3D8oS5mOkpOVx8zZURZrQ,9
+fourcipp-1.4.0.dist-info/RECORD,,