FourCIPP 1.50.0__py3-none-any.whl

fourcipp/legacy_io/node_topology.py

@@ -0,0 +1,194 @@
+# 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.
+"""Node topology io.
+
+Once this section is implemented in 4C using InputSpec, this file can be
+simplified.
+"""
+
+from fourcipp.legacy_io.inline_dat import (
+    _extract_entry,
+    _extract_enum,
+    to_dat_string,
+)
+
+
+def _read_corner(line_list: list) -> dict:
+    """Read corner line.
+
+    Args:
+        line_list: List to extract the entry
+
+    Returns:
+        corner as dict
+    """
+    corner = {
+        "type": "CORNER",
+        "discretization_type": line_list.pop(0),
+        "corner_description": [
+            _extract_enum(line_list, choices=["x-", "x+", "y-", "y+", "z-", "z+"]),
+            _extract_enum(line_list, choices=["x-", "x+", "y-", "y+", "z-", "z+"]),
+            _extract_enum(line_list, choices=["x-", "x+", "y-", "y+", "z-", "z+"]),
+        ],
+        "d_type": line_list.pop(0),
+        "d_id": _extract_entry(line_list, extractor=int),
+    }
+    return corner
+
+
+def _read_edge(line_list: list[str]) -> dict:
+    """Read edge line.
+
+    Args:
+        line_list: List to extract the entry
+
+    Returns:
+        edge as dict
+    """
+    edge = {
+        "type": "EDGE",
+        "discretization_type": line_list.pop(0),
+        "edge_description": [
+            _extract_enum(line_list, choices=["x-", "x+", "y-", "y+", "z-", "z+"]),
+            _extract_enum(line_list, choices=["x-", "x+", "y-", "y+", "z-", "z+"]),
+        ],
+        "d_type": line_list.pop(0),
+        "d_id": _extract_entry(line_list, extractor=int),
+    }
+    return edge
+
+
+def _read_side(line_list: list[str]) -> dict:
+    """Read side line.
+
+    Args:
+        line_list: List to extract the entry
+
+    Returns:
+        Side as dict
+    """
+    side = {
+        "type": "SIDE",
+        "discretization_type": line_list.pop(0),
+        "side_description": [
+            _extract_enum(line_list, choices=["x-", "x+", "y-", "y+", "z-", "z+"]),
+        ],
+        "d_type": line_list.pop(0),
+        "d_id": _extract_entry(line_list, extractor=int),
+    }
+    return side
+
+
+def _read_volume(line_list: list[str]) -> dict:
+    """Read volume line.
+
+    Args:
+        line_list: List to extract the entry
+
+    Returns:
+        Volume as dict
+    """
+    volume = {
+        "type": "VOLUME",
+        "discretization_type": line_list.pop(0),
+        "d_type": line_list.pop(0),
+        "d_id": _extract_entry(line_list, extractor=int),
+    }
+    return volume
+
+
+def _read_domain_topology(line_list: list[str], extractor: str) -> dict:
+    """Read domain topology.
+
+    Args:
+        line_list: List to extract the entry
+        extractor: Type of domain node topology
+
+    Returns:
+        Topology entry as a dict
+    """
+    if extractor == "CORNER":
+        return _read_corner(line_list)
+    elif extractor == "EDGE":
+        return _read_edge(line_list)
+    elif extractor == "SIDE":
+        return _read_side(line_list)
+    elif extractor == "VOLUME":
+        return _read_volume(line_list)
+    else:
+        raise TypeError(f"Unknown entry type {extractor}")
+
+
+def _read_d_topology(line_list: list[str]) -> dict:
+    """Read d topology.
+    Args:
+        line_list: List to extract the entries
+
+    Returns:
+        Topology entry as a dict
+    """
+    node_id = _extract_entry(line_list, extractor=int)
+    d_type = _extract_enum(
+        line_list, choices=["DNODE", "DLINE", "DSURFACE", "DSURF", "DVOLUME", "DVOL"]
+    )
+    d_id = _extract_entry(line_list, extractor=int)
+
+    d_topology = {
+        "type": "NODE",
+        "node_id": node_id,
+        "d_type": d_type,
+        "d_id": d_id,
+    }
+    return d_topology
+
+
+def read_node_topology(line: str) -> dict:
+    """Read topology entry as line.
+
+    Args:
+        line: Inline dat description of the topology entry
+
+    Returns:
+        Topology entry as a dict
+    """
+    line_list = line.split()
+    extractor = line_list.pop(0)
+
+    if extractor == "NODE":
+        return _read_d_topology(line_list)
+
+    if extractor in ["CORNER", "EDGE", "SIDE", "VOLUME"]:
+        return _read_domain_topology(line_list, extractor)
+
+    raise ValueError(f"Unknown type {extractor}")
+
+
+def write_node_topology(topology: dict) -> str:
+    """Write topology line.
+
+    Args:
+        topology: Topology dict
+
+    Returns:
+        Topology entry as line
+    """
+    return " ".join([to_dat_string(e) for e in topology.values()])

fourcipp/legacy_io/particle.py

@@ -0,0 +1,71 @@
+# 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.
+"""Particle io.
+
+Once this section is implemented in 4C using InputSpec, this file can be
+simplified.
+"""
+
+from fourcipp import CONFIG
+from fourcipp.legacy_io.inline_dat import (
+    casting_factory,
+    inline_dat_read,
+    to_dat_string,
+)
+from fourcipp.utils.type_hinting import LineCastingDict
+
+_particle_casting = casting_factory(CONFIG.fourc_metadata["legacy_particle_specs"])
+
+
+def read_particle(
+    line: str, particle_casting: LineCastingDict = _particle_casting
+) -> dict:
+    """Read particle.
+
+    Args:
+        line: Inline dat description of the particle
+        particle_casting: Particle casting dict.
+
+    Returns:
+        Particle section as dict
+    """
+    return inline_dat_read(line.split(), particle_casting)
+
+
+def write_particle(particle: dict) -> str:
+    """Write particles section.
+
+    Args:
+        particle: Particle as dict
+
+    Returns:
+        Particle line
+    """
+    line = ""
+
+    for k, v in particle.items():
+        if line:
+            line += " "
+
+        line += k + " " + to_dat_string(v)
+
+    return line

fourcipp/utils/__init__.py

@@ -0,0 +1,22 @@
+# 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.
+"""FourCIPP utils modules."""

fourcipp/utils/cli.py

@@ -0,0 +1,168 @@
+# 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.
+"""CLI utils."""
+
+import argparse
+import pathlib
+import sys
+
+from loguru import logger
+
+from fourcipp import CONFIG
+from fourcipp.fourc_input import FourCInput
+from fourcipp.utils.configuration import (
+    change_profile,
+    show_config,
+)
+from fourcipp.utils.type_hinting import Path
+from fourcipp.utils.yaml_io import dump_yaml, load_yaml
+
+
+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:
+         input_path: Input filename to apply user defaults to.
+         overwrite: Whether to overwrite the existing input file.
+                         By default, a new file with suffix '_mod.4C.yaml' is created.
+    """
+    output_appendix = "_mod"
+
+    input_path = pathlib.Path(input_path)
+    if not input_path.is_file():
+        raise FileNotFoundError(f"Input file '{input_path}' does not exist.")
+    input_data = FourCInput.from_4C_yaml(input_path)
+    user_defaults_string = CONFIG.user_defaults_path
+    input_data.apply_user_defaults(user_defaults_string)
+    if overwrite:
+        output_filename = input_path
+    else:
+        names = input_path.name.split(".")
+        names[0] += output_appendix
+        output_filename = input_path.parent / ".".join(names)
+    input_data.dump(output_filename)
+    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
+    logger.enable("fourcipp")
+    logger.remove()
+    logger.add(sys.stdout, format="{message}")
+
+    # The FourCIPP CLI is build upon argparse and subparsers. The latter ones are use to interface
+    # mutual exclusive commands. If you add a new command add a new subparser and add the CLI
+    # parameters as you would normally with argparse. Finally add the new command to the pattern
+    # matching. More details can be found here:
+    # https://docs.python.org/3/library/argparse/html#sub-commands
+
+    main_parser = argparse.ArgumentParser(prog="FourCIPP")
+    subparsers = main_parser.add_subparsers(dest="command")
+
+    # Config parser
+    subparsers.add_parser("show-config", help="Show the FourCIPP config.")
+
+    # Switch config parser
+    switch_config_profile_parser = subparsers.add_parser(
+        "switch-config-profile", help="Switch user config profile."
+    )
+    switch_config_profile_parser.add_argument(
+        "profile",
+        help=f"FourCIPP config profile name.",
+        type=str,
+    )
+
+    # Apply user defaults parser
+    apply_user_defaults_parser = subparsers.add_parser(
+        "apply-user-defaults",
+        help="Apply user defaults from the file given in the user defaults path.",
+    )
+
+    apply_user_defaults_parser.add_argument(
+        "-o",
+        "--overwrite",
+        action="store_true",
+        help=f"Overwrite existing input file.",
+    )
+
+    apply_user_defaults_parser.add_argument(
+        "input-file",
+        help=f"4C input file.",
+        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():
+        kwargs[key.replace("-", "_")] = value
+    command = kwargs.pop("command")
+
+    # Select the desired command
+    match command:
+        case "show-config":
+            show_config()
+        case "switch-config-profile":
+            change_profile(**kwargs)
+        case "apply-user-defaults":
+            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

@@ -0,0 +1,222 @@
+# 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.
+"""Configuration utils."""
+
+from __future__ import annotations
+
+import copy
+import pathlib
+from dataclasses import dataclass, field
+
+from loguru import logger
+
+from fourcipp.utils.type_hinting import Path, T
+from fourcipp.utils.yaml_io import dump_yaml, load_yaml
+
+CONFIG_PACKAGE: pathlib.Path = pathlib.Path(__file__).parents[1] / "config"
+CONFIG_FILE: pathlib.Path = CONFIG_PACKAGE / "config.yaml"
+
+
+class Sections:
+    def __init__(self, legacy_sections: list[str], typed_sections: list[str]):
+        """Sections data container.
+
+        Args:
+            legacy_sections: Legacy sections, i.e., their information is not provided in the schema file
+            typed_sections: Typed sections, non-legacy sections natively supported by the schema
+        """
+        self.legacy_sections: list[str] = legacy_sections
+        self.typed_sections: list[str] = typed_sections
+        self.all_sections: list[str] = typed_sections + legacy_sections
+
+    @classmethod
+    def from_metadata(cls, fourc_metadata: dict) -> Sections:
+        """Get section names from metadata.
+
+        Args:
+            fourc_metadata (dict): 4C metadata
+
+        Returns:
+            Sections: sections object
+        """
+        description_section = fourc_metadata["metadata"]["description_section_name"]
+        sections = [description_section] + [
+            section["name"] for section in fourc_metadata["sections"]["specs"]
+        ]
+
+        legacy_sections = list(fourc_metadata["legacy_string_sections"])
+
+        return cls(legacy_sections, sections)
+
+
+@dataclass
+class ConfigProfile:
+    """Fourcipp configuration profile.
+
+    Attributes:
+        name: Name of the configuration profile
+        description: Description of the profile
+        fourc_metadata_path: Path to metadata yaml file
+        json_schema_path: Path to json schema path
+        user_defaults_path: Path to user specific defaults
+    """
+
+    name: str
+    description: str
+    fourc_metadata_path: Path
+    fourc_json_schema_path: Path
+    user_defaults_path: Path | None = None
+    fourc_metadata: dict = field(init=False)
+    fourc_json_schema: dict = field(init=False)
+    sections: Sections = field(init=False)
+
+    def __post_init__(self) -> None:
+        """Update stuff."""
+        self.fourc_metadata_path = pathlib.Path(self.fourc_metadata_path)
+        self.fourc_metadata = ConfigProfile._resolve_references(
+            ConfigProfile._load_data_from_path(self.fourc_metadata_path)
+        )
+        self.sections = Sections.from_metadata(self.fourc_metadata)
+
+        self.fourc_json_schema_path = pathlib.Path(self.fourc_json_schema_path)
+        self.fourc_json_schema = ConfigProfile._load_data_from_path(
+            self.fourc_json_schema_path
+        )
+
+        if self.user_defaults_path is not None:
+            self.user_defaults_path = pathlib.Path(self.user_defaults_path)
+            if not self.user_defaults_path.is_file():
+                raise FileNotFoundError(
+                    f"User defaults file '{self.user_defaults_path}' does not exist."
+                )
+
+    @staticmethod
+    def _load_data_from_path(path: Path) -> dict:
+        """Load data from path."""
+        if not pathlib.Path(path).is_absolute():
+            # Assumption: Path is relative to FourCIPP config package
+            logger.debug(
+                f"Path {path} is a relative path. The absolute path is set to {CONFIG_PACKAGE / path}"
+            )
+            path = CONFIG_PACKAGE / path
+        return load_yaml(path)
+
+    @staticmethod
+    def _resolve_references(metadata_dict: dict) -> dict:
+        """Resolve references in the 4C metadata file.
+
+        Args:
+            metadata_dict: 4C metadata
+
+        Returns:
+            metadata_dict without references
+        """
+
+        references = metadata_dict.pop("$references")
+
+        def insert_references(metadata: T, references: dict) -> T:
+            """Iterate nested dict and insert references.
+
+            Args:
+                metadata: Metadata to check for references
+                references: Dict with all the references
+
+            Returns:
+                metadata with resolved references
+            """
+            if isinstance(metadata, dict):
+                if "$ref" in metadata:
+                    # Add an actual copy of the data
+                    metadata = copy.deepcopy(references[metadata.pop("$ref")])
+                else:
+                    for k in metadata:
+                        metadata[k] = insert_references(metadata[k], references)
+            elif isinstance(metadata, list):
+                for i, e in enumerate(metadata):
+                    metadata[i] = insert_references(e, references)
+
+            return metadata
+
+        metadata_dict = insert_references(metadata_dict, references)
+
+        return metadata_dict
+
+    def __str__(self) -> str:
+        """String method for the config."""
+
+        def add_keyword(name: str, data: object) -> str:
+            """Create keyword description line."""
+            return f"\n - {name}: {data}"
+
+        s = f"FourCIPP configuration '{self.name}'"
+        s += add_keyword("Configuration file", CONFIG_FILE)
+        s += add_keyword("Description", self.description)
+        s += add_keyword("4C metadata path", self.fourc_json_schema_path)
+        s += add_keyword("4C JSON schema path", self.fourc_json_schema_path)
+        s += add_keyword("User default path", self.user_defaults_path)
+
+        return s
+
+
+def load_config() -> ConfigProfile:
+    """Set config profile.
+
+    Args:
+        profile: Config profile to be set.
+
+    Returns:
+        user config.
+    """
+    config_data: dict = load_yaml(CONFIG_FILE)
+    profile_name = config_data["profile"]
+    profile = config_data["profiles"][profile_name]
+    logger.debug(f"Reading config profile {profile}")
+
+    config = ConfigProfile(name=profile_name, **profile)
+    logger.debug(config)
+    return config
+
+
+def change_profile(profile: str) -> None:
+    """Change config profile.
+
+    Args:
+        profile: Profil name to set
+    """
+    config_data: dict = load_yaml(CONFIG_FILE)
+
+    if profile not in config_data["profiles"]:
+        known_profiles = ", ".join(config_data["profiles"])
+        raise KeyError(
+            f"Profile {profile} unknown. Known profiles are: {known_profiles}"
+        )
+    config_data["profile"] = profile
+    logger.info(f"Changing to config profile '{profile}'")
+    dump_yaml(config_data, CONFIG_FILE)
+
+
+def show_config() -> None:
+    """Show FourCIPP config."""
+    logger.info("Fourcipp configuration")
+    logger.info(f"  Config file: {CONFIG_FILE.resolve()}")
+    logger.info("  Contents:")
+    logger.info("    " + "\n    ".join(CONFIG_FILE.read_text().split("\n")))