FourCIPP 1.14.0__py3-none-any.whl → 1.15.0__py3-none-any.whl

fourcipp/fourc_input.py

@@ -41,8 +41,8 @@ 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.not_set import NOT_SET, check_if_set
+from fourcipp.utils.type_hinting import Path
 from fourcipp.utils.validation import ValidationError, validate_using_json_schema
 from fourcipp.utils.yaml_io import dump_yaml, load_yaml
 
@@ -289,7 +289,7 @@ class FourCInput:
                 f"Section '{key}' not set. Did out mean '{difflib.get_close_matches(key.upper(), self.all_sections_names, n=1, cutoff=0.3)[0]}'? The set sections are:\n - {sections}"
             )
 
-    def pop(self, key: str, default_value: Any = NotSet) -> Any:
+    def pop(self, key: str, default_value: Any = NOT_SET) -> Any:
         """Pop entry.
 
         Args:

fourcipp/legacy_io/__init__.py

@@ -27,7 +27,7 @@ from fourcipp.legacy_io.element import read_element, write_element
 from fourcipp.legacy_io.node import read_node, write_node
 from fourcipp.legacy_io.node_topology import read_node_topology, write_node_topology
 from fourcipp.legacy_io.particle import read_particle, write_particle
-from fourcipp.utils.typing import T
+from fourcipp.utils.type_hinting import T
 
 
 def _iterate_and_evaluate(function: Callable[..., T], iterable: Sequence) -> list[T]:

fourcipp/legacy_io/element.py

@@ -30,7 +30,7 @@ from fourcipp.legacy_io.inline_dat import (
     nested_casting_factory,
     to_dat_string,
 )
-from fourcipp.utils.typing import LineCastingDict
+from fourcipp.utils.type_hinting import LineCastingDict
 
 ElementCastingDict: TypeAlias = dict[str, dict[str, LineCastingDict]]
 

fourcipp/legacy_io/inline_dat.py

@@ -24,8 +24,8 @@
 from functools import partial
 from typing import Any
 
-from fourcipp.utils.metadata import METADATA_TO_PYTHON
-from fourcipp.utils.typing import (
+from fourcipp.utils.metadata import Primitive
+from fourcipp.utils.type_hinting import (
     Extractor,
     LineCastingDict,
     LineListExtractor,
@@ -34,7 +34,7 @@ from fourcipp.utils.typing import (
 )
 
 # Metadata types currently supported
-SUPPORTED_METADATA_TYPES = list(METADATA_TO_PYTHON.keys()) + ["vector", "enum"]
+SUPPORTED_METADATA_TYPES = Primitive.PRIMITIVE_TYPES + ["enum", "vector"]
 
 
 def to_dat_string(object: Any) -> str:
@@ -121,10 +121,12 @@ def _entry_casting_factory(spec: dict) -> LineListExtractor:
     Returns:
         Casting function for the spec
     """
-    if spec["type"] in METADATA_TO_PYTHON:
-        return partial(_extract_entry, extractor=METADATA_TO_PYTHON[spec["type"]])
+    if spec["type"] in Primitive.PRIMITIVE_TYPES_TO_PYTHON:
+        return partial(
+            _extract_entry, extractor=Primitive.PRIMITIVE_TYPES_TO_PYTHON[spec["type"]]
+        )
     elif spec["type"] == "vector":
-        value_type = METADATA_TO_PYTHON[spec["value_type"]["type"]]
+        value_type = Primitive.PRIMITIVE_TYPES_TO_PYTHON[spec["value_type"]["type"]]
         return partial(_extract_vector, extractor=value_type, size=spec["size"])
     elif spec["type"] == "enum":
         choices = [s["name"] for s in spec["choices"]]

fourcipp/legacy_io/particle.py

@@ -31,7 +31,7 @@ from fourcipp.legacy_io.inline_dat import (
     inline_dat_read,
     to_dat_string,
 )
-from fourcipp.utils.typing import LineCastingDict
+from fourcipp.utils.type_hinting import LineCastingDict
 
 _particle_casting = casting_factory(CONFIG.fourc_metadata["legacy_particle_specs"])
 

fourcipp/utils/cli.py

@@ -33,7 +33,7 @@ from fourcipp.utils.configuration import (
     change_profile,
     show_config,
 )
-from fourcipp.utils.typing import Path
+from fourcipp.utils.type_hinting import Path
 from fourcipp.utils.yaml_io import dump_yaml, load_yaml
 
 

fourcipp/utils/configuration.py

@@ -28,7 +28,7 @@ from dataclasses import dataclass, field
 
 from loguru import logger
 
-from fourcipp.utils.typing import Path
+from fourcipp.utils.type_hinting import Path
 from fourcipp.utils.yaml_io import dump_yaml, load_yaml
 
 CONFIG_PACKAGE: pathlib.Path = pathlib.Path(__file__).parents[1] / "config"

fourcipp/utils/metadata.py

@@ -19,14 +19,999 @@
 # 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.
-"""Metadata utils."""
+"""Metadata objects from the 4C input metadata."""
 
-import pathlib
+from __future__ import annotations
 
-METADATA_TO_PYTHON: dict = {
-    "int": int,
-    "double": float,
-    "string": str,
-    "bool": bool,
-    "path": pathlib.Path,
-}
+import abc
+import re
+from collections.abc import Generator, Sequence
+from typing import Callable, Literal, Protocol, TypeAlias, TypeVar
+
+from fourcipp.utils.not_set import NotSet, check_if_set
+from fourcipp.utils.type_hinting import NotSetAlias
+
+PRIMITIVES_PYTHON_TYPES = float | bool | int | str
+
+ValidatorAlias: TypeAlias = Callable[[object], bool] | None
+
+NotSetString: NotSetAlias[str] = NotSet(str)
+
+T = TypeVar("T", int, float)
+G = TypeVar("G", contravariant=True)
+
+
+class InputSpec:
+    """Input spec base class."""
+
+    def __init__(
+        self,
+        spec_type: str,
+        name: NotSetAlias[str] = NotSetString,
+        description: NotSetAlias[str] = NotSetString,
+        required: bool = False,
+        noneable: bool = False,
+        validator: ValidatorAlias = None,
+    ) -> None:
+        """Initialise InputSpec.
+
+        Args:
+            spec_type (str): Type of input spec
+            name: Name
+            description: Description
+            required: True if parameter is required
+            noneable: True if parameter can be None
+            validator: Validator callable
+        """
+        self.spec_type = spec_type
+        self.name = name
+        self.description = description
+        self.required = required
+        self.noneable = noneable
+        self.validator = validator
+
+    @classmethod
+    @abc.abstractmethod
+    def from_4C_metadata(cls, data_dict: dict) -> InputSpec:
+        """Create InputSpec from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            InputSpec
+        """
+
+
+class All_Of:
+    def __init__(
+        self,
+        specs: Sequence[Spec],
+        description: NotSetAlias[str] = NotSetString,
+    ) -> None:
+        """Initialise All_Of.
+
+        Args:
+            specs: Specs of the All_Of
+            description: Description
+        """
+        self.specs: list[InputSpec | One_Of] = All_Of.condense(specs)
+        self.description = description
+
+    @staticmethod
+    def condense(specs: Sequence[Spec]) -> list[InputSpec | One_Of]:
+        """Condense All_Of.
+
+        All_Ofs of All_Ofs are joined, aka flattened or condensed.
+
+        Args:
+            specs: Specs to condense
+
+        Returns:
+            Condensed specs
+        """
+        new_specs: list[InputSpec | One_Of] = []
+        one_ofs: list[One_Of] = []
+
+        for spec in specs:
+            match spec:
+                case InputSpec():
+                    new_specs.append(spec)
+                case All_Of():
+                    # Check if it is an One_Of
+                    if spec.is_one_of():
+                        one_ofs.append(spec.specs[0])  # type: ignore
+                    else:
+                        new_specs.extend(All_Of.condense(spec.specs))
+                case One_Of():
+                    one_ofs.append(spec)
+                case _:
+                    raise TypeError(f"Invalid spec {spec}")
+
+        if len(one_ofs) > 1:
+            oo = "\n".join([str(oo) for oo in one_ofs])
+            raise ValueError(f"More than one_of is not allowed {oo}")
+
+        if one_ofs:
+            new_specs = [one_ofs[0].add_specs(new_specs)]
+
+        return new_specs
+
+    def add_specs(self, input_specs: Sequence[Spec]) -> All_Of:
+        """Add specs to the All_Of.
+
+        Returns:
+            All_Of object.
+        """
+        self.specs = All_Of.condense(self.specs + list(input_specs))
+        return self
+
+    def is_one_of(self) -> bool:
+        """Check if All_Of only hold a One_Of.
+
+        In essence this means that the All_Of is simply a One_Of.
+
+        Returns:
+            True if is a One_Of in disguise
+        """
+        return len(self.specs) == 1 and isinstance(self.specs[0], One_Of)
+
+    @classmethod
+    def from_4C_metadata(cls, data_dict: dict) -> All_Of:
+        """Create All_Of from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            All_Of
+        """
+        data_dict.pop("type", None)
+        specs = data_dict.pop("specs", [])
+        specs = [metadata_from_dict(spec) for spec in specs]
+        return cls(specs=specs, **data_dict)
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String method."""
+        return "All_of(" + ", ".join([str(spec) for spec in self.specs]) + ")"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation method."""
+        return "All_of(" + ", ".join([str(spec) for spec in self.specs]) + ")"
+
+    def __len__(self) -> int:
+        """Len of the All_Of.
+
+        Returns:
+            number of specs
+        """
+        return len(self.specs)
+
+    def __iter__(self) -> Generator[One_Of | InputSpec]:
+        """Iterate All_Of.
+
+        Yields:
+            All_Of specs
+        """
+        yield from self.specs
+
+
+class One_Of:
+    def __init__(
+        self,
+        specs: Sequence[Spec],
+        description: NotSetAlias[str] = NotSetString,
+    ) -> None:
+        """Initialise One_Of.
+
+        Args:
+            specs: Specs of the One_Of, i.e., each distinct branch
+            description: Description
+        """
+        self.specs: list[All_Of] = One_Of.condense(specs)
+        self.description = description
+
+    @staticmethod
+    def condense(specs: Sequence[Spec]) -> list[All_Of]:
+        """Condense One_Of.
+
+        One_Ofs of One_Ofs are combined to a single One_Of.
+
+        Args:
+            specs: Specs of the One_Of
+
+        Returns:
+            condesed specs
+        """
+        new_specs: list[All_Of] = []
+
+        for spec in specs:
+            match spec:
+                case InputSpec():
+                    new_specs.append(All_Of([spec]))
+                case All_Of():
+                    if spec.is_one_of():
+                        # One_of in One_of
+                        new_specs.extend(One_Of.condense(spec.specs[0].specs))  # type: ignore
+                    else:
+                        new_specs.append(spec)
+                case One_Of():
+                    # One_of in one_of
+                    new_specs.extend(One_Of.condense(spec.specs))
+                case _:
+                    raise TypeError(f"Not supported type {type(spec)} for {spec}")
+
+        return new_specs
+
+    def add_specs(self, input_specs: Sequence[Spec]) -> One_Of:
+        """Add specs to the One_Of.
+
+        Returns:
+            One_Of object.
+        """
+        for i in range(len(self.specs)):
+            self.specs[i].add_specs(input_specs)
+        self.specs = One_Of.condense(self.specs)
+        return self
+
+    @classmethod
+    def from_4C_metadata(cls, data_dict: dict) -> One_Of:
+        """Create One_Of from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            One_Of
+        """
+        data_dict.pop("type", None)
+        specs = [metadata_from_dict(spec) for spec in data_dict.pop("specs")]
+        return cls(specs=specs, **data_dict)
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String method."""
+        return "One_of(" + ", ".join([str(spec) for spec in self.specs]) + ")"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation method."""
+        return "One_of(" + ", ".join([str(spec) for spec in self.specs]) + ")"
+
+    def __len__(self) -> int:
+        """Len of the One_Of.
+
+        Returns:
+            number of One_Of branches
+        """
+        return len(self.specs)
+
+    def __iter__(self) -> Generator[All_Of]:
+        """Iterate One_of.
+
+        Yields:
+            One_Of branches
+        """
+        yield from self.specs
+
+
+class Primitive(InputSpec):
+    PRIMITIVE_TYPES: list[str] = ["double", "bool", "int", "string", "path"]
+    PRIMITIVE_TYPES_TO_PYTHON: dict[str, type] = {
+        "double": float,
+        "bool": bool,
+        "int": int,
+        "string": str,
+        "path": str,
+    }
+
+    def __init__(
+        self,
+        spec_type: Literal["double", "int", "bool", "string", "path"],
+        name: NotSetAlias[
+            str
+        ] = NotSetString,  # Name is only optional with vectors, maps, tuple
+        description: NotSetAlias[str] = NotSetString,
+        required: bool = True,
+        noneable: bool = False,
+        validator: ValidatorAlias = None,
+        default: NotSetAlias[PRIMITIVES_PYTHON_TYPES] = NotSet("default"),
+    ) -> None:
+        """Initialise primitive.
+
+        Args:
+            spec_type: Type of primitive
+            name: Name
+            description: Description
+            required: True if parameter is required
+            noneable: True if parameter can be None
+            validator: Validator callable
+            default: Default value of the spec
+        """
+        if spec_type not in Primitive.PRIMITIVE_TYPES:
+            raise TypeError(
+                f"Spec type {spec_type} is not supported. Supported ones are: {Primitive.PRIMITIVE_TYPES}"
+            )
+        super().__init__(spec_type, name, description, required, noneable, validator)
+        if check_if_set(default) and default is not None and False:
+            if not isinstance(default, Primitive.PRIMITIVE_TYPES_TO_PYTHON[spec_type]):
+                raise TypeError(
+                    f"Default {default} for the parameter of type '{spec_type}' is not Python type {Primitive.PRIMITIVE_TYPES_TO_PYTHON[spec_type]}"
+                )
+        self.default = default
+
+    @classmethod
+    def from_4C_metadata(cls, data_dict: dict) -> Primitive:
+        """Create primitive from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            primitive
+        """
+        spec_type = data_dict.pop("type")
+        if "validator" in data_dict:
+            data_dict["validator"] = validator_from_dict(data_dict["validator"])
+        return cls(spec_type=spec_type, **data_dict)
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String method."""
+        return f"{self.name}"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation method."""
+        return f"{self.name}"
+
+
+class Enum(InputSpec):
+    def __init__(
+        self,
+        choices: Sequence[str],
+        name: NotSetAlias[str] = NotSetString,
+        description: NotSetAlias[str] = NotSetString,
+        required: bool = True,
+        noneable: bool = False,
+        validator: ValidatorAlias = None,
+        default: NotSetAlias[str] = NotSet("default"),
+    ) -> None:
+        """Initialise enum.
+
+        Args:
+            choices: Enum choices
+            name: Name
+            description: Description
+            required: True if parameter is required
+            noneable: True if parameter can be None
+            validator: Validator callable
+            default: Default value
+        """
+        super().__init__("enum", name, description, required, noneable, validator)
+        if check_if_set(default):
+            if default not in choices:
+                raise ValueError(
+                    f"Default choice {default} is not in the valid enum choices {choices}"
+                )
+        self.choices = choices
+        self.default = default
+
+    @classmethod
+    def from_4C_metadata(cls, data_dict: dict) -> Enum:
+        """Create enum from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            enum
+        """
+        data_dict.pop("type", None)
+        choices = [c["name"] for c in data_dict.pop("choices")]
+        # TODO add description from choices
+        if "validator" in data_dict:
+            data_dict["validator"] = validator_from_dict(data_dict["validator"])
+        return cls(choices=choices, **data_dict)
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String method."""
+        return f"{self.name}"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation method."""
+        return f"{self.name}"
+
+
+class Vector(InputSpec):
+    def __init__(
+        self,
+        value_type: NATIVE_CPP_ALIAS,
+        size: int | None = None,
+        name: NotSetAlias[str] = NotSetString,
+        description: NotSetAlias[str] = NotSetString,
+        required: bool = True,
+        noneable: bool = False,
+        validator: ValidatorAlias = None,
+        default: NotSetAlias[Sequence[NATIVE_CPP_ALIAS]] = NotSet("default"),
+    ) -> None:
+        """Initialise vector.
+
+        Args:
+            value_type: Type of vector elements
+            size: Vector dimension
+            name: Name
+            description: Description
+            required: True if parameter is required
+            noneable: True if parameter can be None
+            validator: Validator callable
+            default: Default value
+        """
+        super().__init__("vector", name, description, required, noneable, validator)
+        if not isinstance(value_type, NATIVE_CPP_TYPES):
+            raise TypeError(
+                f"Value type {value_type} has to be of type: {NATIVE_CPP_TYPES}"
+            )
+        self.value_type = value_type
+        self.size = size
+        self.default = default
+
+    @classmethod
+    def from_4C_metadata(cls, data_dict: dict) -> Vector:
+        """Create vector from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            vector
+        """
+        data_dict.pop("type", None)
+        value_type: NATIVE_CPP_ALIAS = metadata_from_dict(data_dict.pop("value_type"))  # type: ignore
+        if "validator" in data_dict:
+            data_dict["validator"] = validator_from_dict(data_dict["validator"])
+        return cls(value_type=value_type, **data_dict)
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String method."""
+        return f"{self.name}"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation method."""
+        return f"{self.name}"
+
+    def __iter__(self) -> Generator[NATIVE_CPP_ALIAS]:
+        """Iterate vector.
+
+        Yields:
+            value type of the vector
+        """
+        yield self.value_type
+
+
+class Map(InputSpec):
+    def __init__(
+        self,
+        value_type: NATIVE_CPP_ALIAS,
+        size: int | None = None,
+        name: NotSetAlias[str] = NotSetString,
+        description: NotSetAlias[str] = NotSetString,
+        required: bool = True,
+        noneable: bool = False,
+        validator: ValidatorAlias = None,
+        default: NotSetAlias[dict[str, NATIVE_CPP_ALIAS]] = NotSet("default"),
+    ) -> None:
+        """Initialise map.
+
+        Args:
+            value_type: Type of map elements
+            size: Number of entries in the map
+            name: Name
+            description: Description
+            required: True if parameter is required
+            noneable: True if parameter can be None
+            validator: Validator callable
+            default: Default value
+        """
+        if not isinstance(value_type, NATIVE_CPP_TYPES):
+            raise TypeError(
+                f"Value type {value_type} has to be of type: {NATIVE_CPP_TYPES}"
+            )
+        super().__init__("map", name, description, required, noneable, validator)
+        self.value_type: NATIVE_CPP_ALIAS = value_type
+        self.size = size
+        self.default = default
+
+    @classmethod
+    def from_4C_metadata(cls, data_dict: dict) -> Map:
+        """Create map from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            map
+        """
+        data_dict.pop("type", None)
+        value_type: NATIVE_CPP_ALIAS = metadata_from_dict(data_dict.pop("value_type"))  # type: ignore
+        if "validator" in data_dict:
+            data_dict["validator"] = validator_from_dict(data_dict["validator"])
+        return cls(value_type=value_type, **data_dict)
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String method."""
+        return f"{self.name}"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation method."""
+        return f"{self.name}"
+
+    def __iter__(self) -> Generator[NATIVE_CPP_ALIAS]:
+        """Iterate map.
+
+        Yields:
+            value type of the map
+        """
+        yield self.value_type
+
+
+class Tuple(InputSpec):
+    def __init__(
+        self,
+        value_types: Sequence[NATIVE_CPP_ALIAS],
+        size: int,
+        name: NotSetAlias[str] = NotSetString,
+        description: NotSetAlias[str] = NotSetString,
+        required: bool = True,
+        noneable: bool = False,
+        validator: ValidatorAlias = None,
+        default: NotSetAlias[Sequence[NATIVE_CPP_ALIAS]] = NotSet("default"),
+    ) -> None:
+        """Initialise tuple.
+
+        Args:
+            value_types: Types of the tuple element
+            size: Number of tuple entries
+            name: Name
+            description: Description
+            required: True if parameter is required
+            noneable: True if parameter can be None
+            validator: Validator callable
+            default: Default value
+        """
+        super().__init__("tuple", name, description, required, noneable, validator)
+        for i, value_type in enumerate(value_types):
+            if not isinstance(value_type, NATIVE_CPP_TYPES):
+                raise TypeError(
+                    f"Value type {value_type} (parameter number {i + 1} in {value_types}) has to be of type: {NATIVE_CPP_TYPES}"
+                )
+        self.value_types = value_types
+        self.size = size
+        if self.size != len(self.value_types):
+            raise ValueError(
+                f"Tuple size {self.size} does not match the number of value types "
+                f"{len(self.value_types)}"
+            )
+        self.default = default
+
+    @classmethod
+    def from_4C_metadata(cls, data_dict: dict) -> Tuple:
+        """Create tuple from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            tuple
+        """
+        data_dict.pop("type", None)
+        value_types = [
+            metadata_from_dict(value_type)
+            for value_type in data_dict.pop("value_types")
+        ]
+        if "validator" in data_dict:
+            data_dict["validator"] = validator_from_dict(data_dict["validator"])
+        return cls(value_types=value_types, **data_dict)  # type: ignore
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String method."""
+        return f"{self.name}"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation method."""
+        return f"{self.name}"
+
+    def __iter__(self) -> Generator[NATIVE_CPP_ALIAS]:
+        """Iterate tuple.
+
+        Yields:
+            value types of the tuple
+        """
+        yield from self.value_types
+
+
+class Selection(InputSpec):
+    def __init__(
+        self,
+        name: NotSetAlias[str],
+        choices: dict[str, Spec],
+        description: NotSetAlias[str] = NotSetString,
+        required: bool = True,
+        noneable: bool = False,
+        defaultable: bool = False,
+        validator: ValidatorAlias = None,
+    ) -> None:
+        """Initialise selection.
+
+        Args:
+            name: Name
+            choices: Choices of the selection
+            description: Description
+            required: True if parameter is required
+            noneable: True if parameter can be None
+            defaultable: Can have a default
+            validator: Validator callable
+        """
+        super().__init__("selection", name, description, required, noneable, validator)
+        self.choices: dict[str, All_Of] = {k: All_Of([v]) for k, v in choices.items()}
+        self.defautable = defaultable
+
+    @classmethod
+    def from_4C_metadata(cls, data_dict: dict) -> Selection:
+        """Create selection from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            selection
+        """
+        data_dict.pop("type", None)
+
+        choices = {}
+        for choice in data_dict.pop("choices"):
+            spec = choice.pop("spec")
+            choices[choice.pop("name")] = metadata_from_dict(spec)
+        if "validator" in data_dict:
+            data_dict["validator"] = validator_from_dict(data_dict["validator"])
+        return cls(choices=choices, **data_dict)
+
+    def __iter__(self) -> Generator[Spec]:
+        """Iterate selection.
+
+        Yields:
+            choices of the selection
+        """
+        yield from self.choices.values()
+
+    def __len__(self) -> int:
+        """Len of the selection.
+
+        Returns:
+            number of choices
+        """
+        return len(self.choices)
+
+
+class Group(InputSpec):
+    def __init__(
+        self,
+        name: NotSetAlias[str],
+        spec: Spec,
+        description: NotSetAlias[str] = NotSetString,
+        required: bool = True,
+        noneable: bool = False,
+        defaultable: bool = False,
+        validator: ValidatorAlias = None,
+    ) -> None:
+        """Initialise group.
+
+        Args:
+            name: Name
+            spec: Spec of the group
+            description: Description
+            required: True if parameter is required
+            noneable: True if parameter can be None
+            defaultable: Can have a default
+            validator: Validator callable
+        """
+        super().__init__("group", name, description, required, noneable, validator)
+        self.spec: All_Of = All_Of([spec])
+        self.defautable = defaultable
+
+    @classmethod
+    def from_4C_metadata(cls, data_dict: dict) -> Group:
+        """Create group from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            group
+        """
+        data_dict.pop("type", None)
+        specs = [metadata_from_dict(spec) for spec in data_dict.pop("specs", [])]
+        if "validator" in data_dict:
+            data_dict["validator"] = validator_from_dict(data_dict["validator"])
+        return cls(spec=All_Of(specs), **data_dict)
+
+    def __iter__(self) -> Generator[All_Of]:
+        """Iterate group.
+
+        Yields:
+            group spec
+        """
+        yield self.spec
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String method."""
+        return f"{self.name} Group({self.spec})"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation method."""
+        return f"{self.name} Group({self.spec})"
+
+
+class List(InputSpec):
+    def __init__(
+        self,
+        name: NotSetAlias[str],
+        spec: Spec,
+        size: int | None = None,
+        description: NotSetAlias[str] = NotSetString,
+        required: bool = True,
+        noneable: bool = False,
+        defaultable: bool = False,
+        validator: ValidatorAlias = None,
+    ) -> None:
+        """Initialise list.
+
+        Args:
+            name: Name
+            spec: Spec of the list entries
+            size: Number of list entries
+            description: Description
+            required: True if parameter is required
+            noneable: True if parameter can be None
+            defaultable: Can have a default
+            validator: Validator callable
+        """
+        super().__init__("list", name, description, required, noneable, validator)
+        self.spec: All_Of = All_Of([spec])
+        self.size = size
+        self.defautable = defaultable
+
+    @classmethod
+    def from_4C_metadata(cls, data_dict: dict) -> List:
+        """Create list from 4C metadata file.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            list
+        """
+        data_dict.pop("type", None)
+        spec = metadata_from_dict(data_dict.pop("spec"))
+        if "validator" in data_dict:
+            data_dict["validator"] = validator_from_dict(data_dict["validator"])
+        return cls(spec=All_Of([spec]), **data_dict)
+
+    def __iter__(self) -> Generator[All_Of]:
+        """Iterate list.
+
+        Yields:
+            spec
+        """
+        yield self.spec
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String method."""
+        return f"{self.name} List({self.spec})"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation method."""
+        return f"{self.name} List({self.spec})"
+
+
+Spec: TypeAlias = InputSpec | All_Of | One_Of
+NATIVE_CPP_ALIAS: TypeAlias = Primitive | Enum | Vector | Map | Tuple
+NATIVE_CPP_TYPES = (Primitive, Enum, Vector, Map, Tuple)
+
+_METADATA_TYPE_TO_CLASS: dict[str, type[Spec]] = {
+    i.__name__.lower(): i
+    for i in [Enum, Vector, Map, Tuple, Selection, Group, List, All_Of, One_Of]
+} | {i: Primitive for i in Primitive.PRIMITIVE_TYPES}
+
+
+def metadata_from_dict(data_dict: dict) -> Spec:
+    """Create metadata object from 4C metadata dict.
+
+    Args:
+        data_dict: Data from 4C metadata file
+
+    Returns:
+        metadata object
+    """
+    entry_type: str = data_dict.get("type")  # type: ignore
+
+    metadata_class: type[Spec] | None = _METADATA_TYPE_TO_CLASS.get(entry_type, None)
+
+    if metadata_class is not None:
+        return metadata_class.from_4C_metadata(data_dict)
+
+    raise TypeError(
+        f"Unknown type {entry_type} for {data_dict}, known ones are {list(_METADATA_TYPE_TO_CLASS.keys())}"
+    )
+
+
+class Validator(Protocol[G]):
+    """Validator protocol."""
+
+    def _validate(self, entry: G) -> bool:
+        """Validate object.
+
+        Args:
+            entry: Object to validate
+
+        Returns:
+            True if valid
+        """
+        pass
+
+    def __call__(self, entry: G) -> bool:
+        """Call method."""
+        return self._validate(entry)
+
+
+class RangeValidator(Validator[T]):
+    def __init__(
+        self,
+        minimum: T,
+        maximum: T,
+        minimum_exclusive: bool = False,
+        maximum_exclusive: bool = False,
+    ) -> None:
+        """Range validator.
+
+        Args:
+            entry: Entry value
+            minimum: Minimum value
+            maximum: Maximum value
+            minimum_exclusive: Minimum is exclusive
+            maximum_exclusive: Maximum is exclusive
+        """
+        self.minimum: T = minimum
+        self.maximum: T = maximum
+        self.minimum_exclusive = minimum_exclusive
+        self.maximum_exclusive = maximum_exclusive
+
+    def _validate(self, entry: T) -> bool:
+        """Validate if float or in is in range.
+
+        Args:
+            entry: Entry value
+            minimum: Minimum value
+            maximum: Maximum value
+            minimum_exclusive: Minimum is exclusive
+            maximum_exclusive: Maximum is exclusive
+
+        Returns:
+            True if in range
+        """
+        if self.minimum_exclusive:
+            if entry <= self.minimum:
+                return False
+        else:
+            if entry < self.minimum:
+                return False
+
+        if self.maximum_exclusive:
+            if entry >= self.maximum:
+                return False
+        else:
+            if entry > self.maximum:
+                return False
+
+        return True
+
+    @classmethod
+    def from_4C_metadata_dict(cls, data_dict: dict) -> RangeValidator:
+        """Create validator from 4C metadata dict.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            range validator
+        """
+        return cls(**data_dict)
+
+
+class AllEmementsValidator(Validator[Sequence]):
+    def __init__(self, element_validator: Callable[[Sequence], bool]) -> None:
+        """All elements validator.
+
+        Validates each entry of a sequence with the `element_validator`.
+
+        Args:
+            element_validator: Validator for each entry
+        """
+        self.element_validator = element_validator
+
+    def _validate(self, entry: Sequence) -> bool:
+        """Validate sequence.
+
+        Args:
+            entry: Sequence to validate
+
+        Returns:
+            True if all entries are valid
+        """
+        return all([self.element_validator(e) for e in entry])
+
+    @classmethod
+    def from_4C_metadata_dict(cls, data_dict: dict) -> AllEmementsValidator:
+        """Create validator from 4C metadata dict.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            all elements validator
+        """
+        element_validator = validator_from_dict(data_dict)
+        return cls(element_validator)
+
+
+class PatternValidator(Validator):
+    def __init__(self, pattern: str):
+        """Regex pattern validator.
+
+        Args:
+            pattern: Pattern to match
+        """
+        self.pattern = re.compile(pattern)
+
+    def _validate(self, entry: str) -> bool:
+        """Validate pattern.
+
+        Args:
+            entry: Entry to validate
+
+        Returns:
+            True if pattern matches
+        """
+        return bool(self.pattern.match(entry))
+
+    @classmethod
+    def from_4C_metadata_dict(cls, data_dict: dict) -> PatternValidator:
+        """Create validator from 4C metadata dict.
+
+        Args:
+            data_dict: Data from 4C metadata file
+
+        Returns:
+            validator
+        """
+        return cls(**data_dict)
+
+
+def validator_from_dict(data_dict: dict) -> Validator:
+    """Create validator from dict.
+
+    Args:
+        data_dict: Data from 4C metadata file
+
+    Returns:
+        validator
+    """
+    if len(data_dict) == 0:
+        raise ValueError(f"Can not construct value error from {data_dict}.")
+    validator_name = list(data_dict.keys())[0]
+    validator_data = data_dict[validator_name]
+    match validator_name:
+        case "range":
+            return RangeValidator.from_4C_metadata_dict(validator_data)
+        case "all_elements":
+            return AllEmementsValidator.from_4C_metadata_dict(validator_data)
+        case "pattern":
+            return PatternValidator.from_4C_metadata_dict(validator_data)
+        case _:
+            raise KeyError(f"Unknown validator {data_dict}")

fourcipp/utils/not_set.py

@@ -21,18 +21,31 @@
 # THE SOFTWARE.
 """Not set utils."""
 
-from typing import Any
 
-
-class _NotSet:
+class NotSet:
     """Not set object."""
 
+    def __init__(self, expected: object = object) -> None:
+        """Not set object.
+
+        Args:
+            expected: Expected object to to display
+        """
+        self.expected = expected
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String method."""
+        return f"NotSet({self.expected})"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation method."""
+        return f"NotSet({self.expected})"
+
 
-# Not set object
-NotSet = _NotSet()
+NOT_SET = NotSet()
 
 
-def check_if_set(obj: Any) -> bool:
+def check_if_set(obj: object) -> bool:
     """Check if object or is NotSet.
 
     Args:
@@ -42,10 +55,10 @@ def check_if_set(obj: Any) -> bool:
         True if object is set
     """
     # Check if object is not of type _NotSet, i.e. it has a value
-    return not isinstance(obj, _NotSet)
+    return not isinstance(obj, NotSet)
 
 
-def pop_arguments(key: str, default: Any = NotSet) -> tuple:
+def pop_arguments(key: str, default: object = NOT_SET) -> tuple:
     """Create arguments for the pop method.
 
     We need this utility since pop is not implemented using kwargs, instead the default is checked

fourcipp/utils/{typing.py → type_hinting.py}

@@ -25,6 +25,8 @@ import pathlib
 from collections.abc import Callable
 from typing import TypeAlias, TypeVar
 
+from fourcipp.utils.not_set import NotSet
+
 # Generic type variable
 T = TypeVar("T")
 
@@ -37,3 +39,6 @@ Extractor: TypeAlias = Callable[[str], T]
 LineListExtractor: TypeAlias = Callable[[list[str]], T]
 LineCastingDict: TypeAlias = dict[str, LineListExtractor]
 NestedCastingDict: TypeAlias = dict[str, LineCastingDict | LineListExtractor]
+
+# NotSet
+NotSetAlias: TypeAlias = NotSet | T

fourcipp/utils/yaml_io.py

@@ -28,7 +28,7 @@ from typing import Callable
 import regex
 import ryml
 
-from fourcipp.utils.typing import Path
+from fourcipp.utils.type_hinting import Path
 
 
 def load_yaml(path_to_yaml_file: Path) -> dict:

fourcipp/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.14.0'
-__version_tuple__ = version_tuple = (1, 14, 0)
+__version__ = version = '1.15.0'
+__version_tuple__ = version_tuple = (1, 15, 0)
 
 __commit_id__ = commit_id = None

{fourcipp-1.14.0.dist-info → fourcipp-1.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FourCIPP
-Version: 1.14.0
+Version: 1.15.0
 Summary: A streamlined Python Parser for 4C input files
 Author: FourCIPP Authors
 License: The MIT License (MIT)

fourcipp-1.15.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+fourcipp/__init__.py,sha256=4pz7DVXErSbUcLqPTaHnQfdJzKkpfZDivBqbHbTgpRE,1388
+fourcipp/fourc_input.py,sha256=1-EMbwc5tWbWtbZqzRF4_ytrvkcQVgtC5ZX1uz6NFuQ,23954
+fourcipp/version.py,sha256=gvymR90UfRuuIQ_1PRcQFHGu4ixvgau9sZalU_-52us,706
+fourcipp/config/4C_metadata.yaml,sha256=j3DmYTTuKewugGAG6joSzdcuEpefF4B32Ipkk_9TigY,11887345
+fourcipp/config/4C_schema.json,sha256=Ndrzh5G5tdpIpbq4ExSyh4clBQwELEaQt5Ze77ElKsk,16417772
+fourcipp/config/config.yaml,sha256=n2c2a6E4HKfAdNWOQz1kLUuf5p4NLxIddaAi2t5eM38,460
+fourcipp/legacy_io/__init__.py,sha256=L3MWW-WjPbPAJVX8Z0Uheftn0dRPnqNnSBic3uloFhI,5750
+fourcipp/legacy_io/element.py,sha256=rP8F-m-8ZCwCxtV_OASvvLeNYr01zsmgZsDZSJ_G1gY,3977
+fourcipp/legacy_io/inline_dat.py,sha256=t8eMmJ_mAK7kKYAhNNlsES9JbZ760DHR0101Mj9vkSQ,6723
+fourcipp/legacy_io/node.py,sha256=e7m0W7dai_b1XgaqD37k3QS44ySCas3HetmyTLS9_78,3522
+fourcipp/legacy_io/node_topology.py,sha256=hqGGzhyNhFX-BMW8SzztfzM8zoZLLltVScMv-p4hDH0,5394
+fourcipp/legacy_io/particle.py,sha256=8LoRsyKVfhl5Qf_EoO8vLmbH0QSpB_Nho464ifkHAZc,2172
+fourcipp/utils/__init__.py,sha256=ccdlf4taJ0mKLg_ru8ilXEa72PoO9N2UIxHNHDEtQmY,1151
+fourcipp/utils/cli.py,sha256=Tn9jx0KhC421zv-DMpqNU2hpb6fyi4-r4qV17f-ts4Y,5807
+fourcipp/utils/configuration.py,sha256=_9Yo_2Rxw1QDhib9OV_MjLXBhVPfIBA2qmdOG3EuIKU,6467
+fourcipp/utils/converter.py,sha256=D40YQ96WqPEEpB7fwAB5XC2v-jRki4v1sIJ-ngO08nU,5194
+fourcipp/utils/dict_utils.py,sha256=uC0uaBNP3Wh2v3kFy9JHnAYARMukAN4cl40pmiBT13Y,12891
+fourcipp/utils/metadata.py,sha256=wYu07eCrOTNHSnhDxHyQzF6OU8D_2ZuJfytiIpn3sxY,30895
+fourcipp/utils/not_set.py,sha256=NHf0UXDmTuZfvfnIIgkkx4EohxRsN4MVUHUpt7VOnaQ,2433
+fourcipp/utils/type_hinting.py,sha256=izPEhbMdmhrIBamCLqqF_6iDZW-w7a8kplUugbQILyw,1714
+fourcipp/utils/validation.py,sha256=FejHOj1MddaU7gEpMN-f8Mz3rYjflakd1qcsKnctHqA,5292
+fourcipp/utils/yaml_io.py,sha256=jPgVnxE858XTpDC6BVhfbbljQegL58zc3u2VPYCTvGE,5771
+fourcipp-1.15.0.dist-info/licenses/LICENSE,sha256=lkSOHdH9IZ8c3Vnz0fFjqls1cRlmLADBP8QEIwUlH3o,1082
+fourcipp-1.15.0.dist-info/METADATA,sha256=sG1SQJhzC-K7904TyarihRHwJvsdstz3DoD8m1EnWZ0,7916
+fourcipp-1.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fourcipp-1.15.0.dist-info/entry_points.txt,sha256=44XBG4bwhuq1EwOZ0U055HYP8_qN6_d30ecVsa5Igng,53
+fourcipp-1.15.0.dist-info/top_level.txt,sha256=oZ6jgFFmvi157VwGUEFuKT3D8oS5mOkpOVx8zZURZrQ,9
+fourcipp-1.15.0.dist-info/RECORD,,

fourcipp-1.14.0.dist-info/RECORD

@@ -1,28 +0,0 @@
-fourcipp/__init__.py,sha256=4pz7DVXErSbUcLqPTaHnQfdJzKkpfZDivBqbHbTgpRE,1388
-fourcipp/fourc_input.py,sha256=ocyxXdu8NFIRM94dc4EG_r8XsBkJajvw1YWHmZh-G6Y,23946
-fourcipp/version.py,sha256=B_zXbaY_VjR5QzFDQUWID71ivmfxjMpJLAttgWbEkMU,706
-fourcipp/config/4C_metadata.yaml,sha256=j3DmYTTuKewugGAG6joSzdcuEpefF4B32Ipkk_9TigY,11887345
-fourcipp/config/4C_schema.json,sha256=Ndrzh5G5tdpIpbq4ExSyh4clBQwELEaQt5Ze77ElKsk,16417772
-fourcipp/config/config.yaml,sha256=n2c2a6E4HKfAdNWOQz1kLUuf5p4NLxIddaAi2t5eM38,460
-fourcipp/legacy_io/__init__.py,sha256=y6aTjgUe61OQSl1NMiZ-fQAGTab_xNT1eJTnaTnsIkc,5744
-fourcipp/legacy_io/element.py,sha256=b8--f3IR9nB68R25mk4DHHOBdDLqASewtAdPZAkA2t4,3971
-fourcipp/legacy_io/inline_dat.py,sha256=n9qWrIX33Atv0JruuLWAxy6lrCaeuCZRIvtl3Jr1a1U,6659
-fourcipp/legacy_io/node.py,sha256=e7m0W7dai_b1XgaqD37k3QS44ySCas3HetmyTLS9_78,3522
-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=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=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=GZtgBn-5OB7xAJmgjo66eG3JwkHnfQFp4VIA2-rVVSg,5765
-fourcipp-1.14.0.dist-info/licenses/LICENSE,sha256=lkSOHdH9IZ8c3Vnz0fFjqls1cRlmLADBP8QEIwUlH3o,1082
-fourcipp-1.14.0.dist-info/METADATA,sha256=ABNia81ZL2ubbhDiRoNsm7_Aj_qTgFFDfDlso_XNxLU,7916
-fourcipp-1.14.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fourcipp-1.14.0.dist-info/entry_points.txt,sha256=44XBG4bwhuq1EwOZ0U055HYP8_qN6_d30ecVsa5Igng,53
-fourcipp-1.14.0.dist-info/top_level.txt,sha256=oZ6jgFFmvi157VwGUEFuKT3D8oS5mOkpOVx8zZURZrQ,9
-fourcipp-1.14.0.dist-info/RECORD,,