nadap 1.0.0__py3-none-any.whl

nadap/__init__.py

@@ -0,0 +1,14 @@
+"""
+Central import for types
+"""
+
+from nadap.nadap import Nadap
+from nadap.errors import SchemaDefinitionError, DataValidationError
+from nadap.schema import Schema
+from nadap.references import ReferenceFinding
+from nadap.results import ValidationFinding
+from nadap.base import SET_DEFAULTS, CONVERT_DATA, NOFLAG
+
+
+__version__ = "1.0.0"
+version_info = (1, 0, 0)

nadap/base.py

@@ -0,0 +1,222 @@
+"""
+Basic constants and functions
+"""
+
+# pylint: disable=too-few-public-methods
+
+import enum
+import copy
+import re
+
+if hasattr(re, "NOFLAG"):
+    NOFLAG = re.NOFLAG
+else:
+    NOFLAG = 0
+
+
+class OPT(enum.IntFlag):  # pylint: disable=no-member
+    """
+    Flags used to define a reference
+    """
+
+    NONE = 1
+    UNIQUE = 2
+    UNIQUE_GLOBAL = 4
+    PRODUCER = 8
+    PRODUCER_GLOBAL = 16
+    CONSUMER = 32
+    CONSUMER_GLOBAL = 64
+    ALLOW_ORPHAN_PRODUCER = 128
+
+
+INIT_OPTIONS = OPT.UNIQUE | OPT.UNIQUE_GLOBAL | OPT.PRODUCER | OPT.PRODUCER_GLOBAL
+
+
+class RegexObject:
+    """
+    Represents a regex allowed or not allowed value
+    """
+
+    def __init__(self, pattern: str, multiline: bool, fullmatch: bool):
+        self.multiline = multiline
+        self.fullmatch = fullmatch
+        self.pattern = re.compile(pattern, self.flags)
+
+    @property
+    def flags(self) -> list:
+        """
+        Create a list of re args to pass to match
+        """
+        if self.multiline:
+            return re.MULTILINE
+        return NOFLAG
+
+    def match(self, data: any) -> re.Match:
+        """
+        Test data if it matches
+        Returns:
+            re.Match object or None
+        """
+        if self.fullmatch:
+            return self.pattern.fullmatch(data)
+        return self.pattern.search(data)
+
+    def __hash__(self):
+        return self.pattern.pattern.__hash__()
+
+
+class PreProcessingFlag(enum.IntFlag):  # pylint: disable=no-member
+    """
+    Flags used as pre-processing options
+    """
+
+    NOFLAG = 0
+    SET_DEFAULTS = 1
+    CONVERT_DATA = 2
+
+
+class ValEnv:
+    """
+    Contains information and references required during
+    validation and pre-processing
+    """
+
+    def __init__(
+        self,
+        references,
+        findings,
+        flags: PreProcessingFlag = PreProcessingFlag.NOFLAG,
+    ):
+        self.references = references
+        self.findings = findings
+        self.flags = flags
+
+
+NOFLAG = PreProcessingFlag.NOFLAG
+SET_DEFAULTS = PreProcessingFlag.SET_DEFAULTS
+CONVERT_DATA = PreProcessingFlag.CONVERT_DATA
+UNDEFINED = object()
+
+
+def number_to_str_number(x: any) -> any:
+    """
+    Test if x is a str and represents an integer.
+    If yes return a string 'x', else return x
+    """
+    if isinstance(x, str):
+        try:
+            int(x)
+            x = f"'{x}'"
+        except ValueError:
+            try:
+                float(x)
+                x = f"'{x}'"
+            except ValueError:
+                pass
+    return x
+
+
+def merge_lists(left: list, right: list, list_merge: str = "append_rp") -> list:
+    """
+    Merge elements of list 'right' into list 'left'
+    """
+    if not isinstance(left, list):
+        raise ValueError("'left' is not a list")
+    if not isinstance(right, list):
+        raise ValueError("'right' is not a list")
+    _left = copy.deepcopy(left)
+    if list_merge == "replace":
+        return copy.deepcopy(right)
+    if list_merge == "append":
+        return _left + copy.deepcopy(right)
+    if list_merge == "prepend":
+        return copy.deepcopy(right) + _left
+    if list_merge in ["append_rp", "prepend_rp"]:
+        append = list_merge == "append_rp"
+        for element in right:
+            if element not in _left:
+                if append:
+                    _left.append(copy.deepcopy(element))
+                else:
+                    _left.insert(0, copy.deepcopy(element))
+        return _left
+    raise ValueError(f"'list_merge' option {list_merge} is not known")
+
+
+def merge_dictionaries(
+    left: dict, right: dict, recursive: bool = True, list_merge: str = "append_rp"
+) -> dict:
+    """
+    Merge keys (recursively) from dictionary 'right' into dictionary 'left'.
+    """
+    if not isinstance(left, dict):
+        raise ValueError("'left' is not a dictionary")
+    if not isinstance(right, dict):
+        raise ValueError("'right' is not a dictionary")
+    _left = copy.deepcopy(left)
+    for key, r_value in right.items():
+        if key not in _left or not isinstance(r_value, type(_left[key])):
+            # right element not in left or mismatching types => Just copy right to left
+            _left[key] = copy.deepcopy(r_value)
+        else:
+            # left value is same type as right value
+            if isinstance(r_value, list):
+                # Merge left list with right list
+                _left[key] = merge_lists(
+                    left=_left[key], right=right[key], list_merge=list_merge
+                )
+            elif isinstance(r_value, dict):
+                if recursive:
+                    # Merge left dict with right dict
+                    _left[key] = merge_dictionaries(
+                        left=_left[key],
+                        right=right[key],
+                        recursive=recursive,
+                        list_merge=list_merge,
+                    )
+                else:
+                    # Overwrite left with right value
+                    _left[key] = copy.deepcopy(r_value)
+            else:
+                # Something like integer or string and just copy right to left
+                _left[key] = copy.deepcopy(r_value)
+    return _left
+
+
+def merge_template_data(
+    template_data: dict,
+    additional_data: dict,
+    recursive: bool = True,
+    list_merge: str = "append_rp",
+) -> dict:
+    """
+    Merge definition from 'additional' template into template.
+    """
+    template_data = template_data.copy()
+    template_data_keys = set(list(template_data.keys()))
+    additional_data_keys = set(list(additional_data.keys()))
+    return_dict = template_data
+    for key in template_data_keys.intersection(additional_data_keys):
+        if isinstance(additional_data[key], list):
+            if isinstance(template_data[key], list):
+                return_dict[key] = merge_lists(
+                    left=template_data[key],
+                    right=additional_data[key],
+                    list_merge=list_merge,
+                )
+            else:
+                return_dict[key] = additional_data[key]
+        elif not isinstance(additional_data[key], dict) or not isinstance(
+            template_data[key], dict
+        ):
+            return_dict[key] = additional_data[key]
+        else:
+            return_dict[key] = merge_dictionaries(
+                left=template_data[key],
+                right=additional_data[key],
+                recursive=recursive,
+                list_merge=list_merge,
+            )
+    for key in additional_data_keys - template_data_keys:
+        return_dict[key] = additional_data[key]
+    return return_dict

nadap/errors.py

@@ -0,0 +1,28 @@
+"""
+Execption classes
+"""
+
+# pylint: disable=too-few-public-methods
+
+
+class SchemaDefinitionError(Exception):
+    """
+    Error while parsing schema definition.
+    """
+
+    def __init__(self, msg: str, path: str = None):
+        if path is not None:
+            msg = f"{path}: {msg}"
+        super().__init__(msg)
+
+
+class DataValidationError(Exception):
+    """
+    Exception indicating that data validation failed.
+    """
+
+
+class NadapReferenceError(Exception):
+    """
+    Class to identify an error during reference processing
+    """

nadap/mixin/accuracy.py

@@ -0,0 +1,88 @@
+"""
+Accuracy Mixin
+"""
+
+# pylint: disable=too-few-public-methods
+
+import nadap.schema
+from nadap.base import ValEnv
+from nadap.errors import SchemaDefinitionError, DataValidationError
+
+
+class AccuracyMixin:
+    """
+    Add options for maximum_decimals
+    """
+
+    def __init__(self, **kwargs):
+        self._maximum_decimals = None
+        self._round_to = None
+        super().__init__(**kwargs)
+
+    def _pop_options(self, definition: dict, schema_path: str):
+        self._maximum_decimals = definition.pop("maximum_decimals", None)
+        self._round_to = definition.pop("round_to_decimals", None)
+        super()._pop_options(definition=definition, schema_path=schema_path)
+
+    def _validate_options(self, schema_path: str):
+        super()._validate_options(schema_path=schema_path)
+        if self._maximum_decimals is not None:
+            _path = f"{schema_path}.maximum_decimals"
+            nadap.schema.is_int(self._maximum_decimals, _path)
+            if not 0 <= self._maximum_decimals <= 17:
+                raise SchemaDefinitionError("Must be >= 0 and <= 17", _path)
+        if self._round_to is not None:
+            _path = f"{schema_path}.round_to_decimals"
+            nadap.schema.is_int(self._round_to, _path)
+            if not 0 <= self._round_to <= 17:
+                raise SchemaDefinitionError("Must be >= 0 and <= 17", _path)
+
+    def _validate_data(
+        self,
+        data: any,
+        path: str,
+        env: "ValEnv" = None,
+    ) -> "any":
+        data = super()._validate_data(data=data, path=path, env=env)
+        if self._maximum_decimals is not None and data != round(
+            data, self._maximum_decimals
+        ):
+            env.findings.append(
+                nadap.results.ValidationFinding(
+                    "Float value has too many decimals",
+                    path,
+                )
+            )
+            raise DataValidationError()
+        return data
+
+    def _convert_data(self, data: any) -> any:
+        if self._round_to is not None:
+            data = round(data, self._round_to)
+        return super()._convert_data(data)
+
+    @property
+    def restrictions(self) -> "list[str]":
+        """
+        Get all restrictions for valid data
+        """
+        ret_list = super().restrictions
+        if self._maximum_decimals is not None:
+            ret_list.append(f"max allowed decimals: {self._maximum_decimals}")
+        return ret_list
+
+    @classmethod
+    def _doc_options_md_upper_part(cls) -> list[str]:
+        return super()._doc_options_md_upper_part() + [
+            "| **maximum_decimals** | `int` | | Must be >= 0 and <= 17 | "
+            + "Value's accuracy must be lower or equal |",
+            "| **round_to_decimals** | `int` | | Must be >= 0 and <= 17 | "
+            + "Convert value to this accuracy |",
+        ]
+
+    @classmethod
+    def _doc_options_yaml_upper_part(cls) -> list[str]:
+        return super()._doc_options_yaml_upper_part() + [
+            "maximum_decimals: <int>",
+            "round_to_decimals: <int>",
+        ]

nadap/mixin/allowed_value.py

@@ -0,0 +1,79 @@
+"""
+AllowedValueMixin
+"""
+
+# pylint: disable=too-few-public-methods
+
+import nadap.schema
+from nadap.base import ValEnv, number_to_str_number
+
+
+class AllowedValueMixin:
+    """
+    Add allowed value tests for data
+    """
+
+    def __init__(self, **kwargs):
+        self.allowed_values = None
+        super().__init__(**kwargs)
+
+    def _validate_data(
+        self,
+        data: any,
+        path: str,
+        env: "ValEnv" = None,
+    ) -> "any":
+        """
+        Check if data matches allowed values
+        """
+        data = super()._validate_data(data=data, path=path, env=env)
+        if self.allowed_values and data not in self.allowed_values:
+            self._create_finding_with_error(
+                msg="Data not within allowed values",
+                path=path,
+                env=env,
+            )
+        return data
+
+    def _validate_options(self, schema_path: str):
+        super()._validate_options(schema_path=schema_path)
+        if self.allowed_values is not None:
+            nadap.schema.is_non_empty_list(
+                self.allowed_values, f"{schema_path}.allowed_values"
+            )
+            for index, v in enumerate(self.allowed_values):
+                self._test_data_type(
+                    data=v, path=f"{schema_path}.allowed_values[{index}]"
+                )
+
+    def _pop_options(self, definition: dict, schema_path: str):
+        self.allowed_values = definition.pop("allowed_values", None)
+        super()._pop_options(definition=definition, schema_path=schema_path)
+
+    @property
+    def restrictions(self) -> "list[str]":
+        """
+        Get all restrictions for valid data
+        """
+        ret_list = super().restrictions
+        if self.allowed_values:
+            ret_list.append("allowed values:")
+            ret_list.extend(
+                [f" - {str(number_to_str_number(x))}" for x in self.allowed_values]
+            )
+        return ret_list
+
+    @classmethod
+    def _doc_options_md_upper_part(cls) -> list[str]:
+        return super()._doc_options_md_upper_part() + [
+            "| **allowed_values** | `list` | | | "
+            + " Data must match one of these values |",
+            "| &nbsp;&nbsp;- <value> | `any` | | Must match data type's type(s) | |",
+        ]
+
+    @classmethod
+    def _doc_options_yaml_upper_part(cls) -> list[str]:
+        return super()._doc_options_yaml_upper_part() + [
+            "allowed_values:",
+            "  - <any>",
+        ]

nadap/mixin/ip.py

@@ -0,0 +1,177 @@
+"""
+Mixin for IP data types
+"""
+
+# pylint: disable=too-few-public-methods
+
+import ipaddress
+
+from nadap.base import ValEnv
+from nadap.errors import SchemaDefinitionError
+import nadap.mixin.allowed_value
+import nadap.mixin.not_allowed_value
+
+
+class IpMixin(
+    nadap.mixin.not_allowed_value.NotAllowedValueMixin,
+    nadap.mixin.allowed_value.AllowedValueMixin,
+):
+    """
+    Add handling of strings representing IPv4 or IPv6 string
+    """
+
+    _cls_python_classes = [str]
+    _doc_data_type = "str"
+    _ip_data_type_name = "IP"
+
+    def __init__(self, **kwargs):
+        self._test_loopback = None
+        self._test_link_local = None
+        self._test_multicast = None
+        self._test_private = None
+        self._test_public = None
+        super().__init__(**kwargs)
+
+    def _get_ip_obj(self, data):
+        return ipaddress.ip_address(data)
+
+    def _test_data_type(self, data: any, path: str, env: "ValEnv" = None) -> "any":
+        # pylint: disable=raise-missing-from
+        data = super()._test_data_type(data=data, path=path, env=env)
+        try:
+            self._get_ip_obj(data)
+        except ValueError:
+            msg = f"String does not represent an {self._ip_data_type_name}"
+            if env is None:
+                raise SchemaDefinitionError(
+                    msg=msg,
+                    path=path,
+                )
+            self._create_finding_with_error(msg=msg, path=path, env=env)
+        return data
+
+    def _pop_options(self, definition: dict, schema_path: str):
+        self._test_loopback = definition.pop("loopback", None)
+        self._test_link_local = definition.pop("link_local", None)
+        self._test_private = definition.pop("private", None)
+        self._test_public = definition.pop("public", None)
+        self._test_multicast = definition.pop("multicast", None)
+        super()._pop_options(definition=definition, schema_path=schema_path)
+
+    def _validate_options(self, schema_path: str):
+        super()._validate_options(schema_path=schema_path)
+        if (
+            self._test_link_local is not None
+            and self._test_loopback is not None
+            and self._test_link_local == self._test_loopback
+        ):
+            raise SchemaDefinitionError(
+                "Mismatching test for link_local and loopback", schema_path
+            )
+        if (
+            self._test_link_local is not None
+            and self._test_multicast is not None
+            and self._test_link_local == self._test_multicast
+        ):
+            raise SchemaDefinitionError(
+                "Mismatching test for link_local and multicast", schema_path
+            )
+        if (
+            self._test_loopback is not None
+            and self._test_multicast is not None
+            and self._test_loopback == self._test_multicast
+        ):
+            raise SchemaDefinitionError(
+                "Mismatching test for loopback and multicast", schema_path
+            )
+        if (
+            self._test_private is not None
+            and self._test_public is not None
+            and self._test_private == self._test_public
+        ):
+            raise SchemaDefinitionError(
+                "Mismatching test for private and public", schema_path
+            )
+
+    def _validate_data(
+        self,
+        data: any,
+        path: str,
+        env: "ValEnv" = None,
+    ) -> "any":
+        """
+        Check if data matches IP options
+        """
+        data = super()._validate_data(data=data, path=path, env=env)
+        ip_obj = self._get_ip_obj(data)
+        msg = None
+        if (
+            self._test_link_local is not None
+            and self._test_link_local != ip_obj.is_link_local
+        ):
+            msg = "Is link-local" if ip_obj.is_link_local else "Is not link-local"
+        elif (
+            self._test_loopback is not None
+            and self._test_loopback != ip_obj.is_loopback
+        ):
+            msg = "Is loopback" if ip_obj.is_loopback else "Is not loopback"
+        elif (
+            self._test_multicast is not None
+            and self._test_multicast != ip_obj.is_multicast
+        ):
+            msg = "Is multicast" if ip_obj.is_multicast else "Is not multicast"
+        elif self._test_private is not None and self._test_private != ip_obj.is_private:
+            msg = "Is private" if ip_obj.is_private else "Is not private"
+        elif self._test_public is not None and self._test_public != ip_obj.is_global:
+            msg = "Is public" if ip_obj.is_global else "Is not public"
+        if msg:
+            self._create_finding_with_error(msg=msg, path=path, env=env)
+
+        return data
+
+    @property
+    def restrictions(self) -> "list[str]":
+        """
+        Get all restrictions for valid data
+        """
+        ret_list = super().restrictions
+        opt_list = []
+        if self._test_link_local is not None:
+            opt_list.append(
+                f"{self._markdown_indent}- link-local: {self._test_link_local}"
+            )
+        if self._test_loopback is not None:
+            opt_list.append(f"{self._markdown_indent}- loopback: {self._test_loopback}")
+        if self._test_multicast is not None:
+            opt_list.append(
+                f"{self._markdown_indent}- multicast: {self._test_multicast}"
+            )
+        if self._test_private is not None:
+            opt_list.append(f"{self._markdown_indent}- private: {self._test_private}")
+        if self._test_public is not None:
+            opt_list.append(f"{self._markdown_indent}- public: {self._test_public}")
+        if opt_list:
+            ret_list.append("IP restrictions:")
+            ret_list.extend(opt_list)
+        return ret_list
+
+    @classmethod
+    def _doc_options_md_upper_part(cls) -> list[str]:
+        return super()._doc_options_md_upper_part() + [
+            "| **link_local** | `bool` | | | IP must be link-local |",
+            "| **loopback** | `bool` | | | IP must be loopback |",
+            "| **multicast** | `bool` | | | IP must be multicast |",
+            "| **private** | `bool` | | | IP must be private |",
+            "| **public** | `bool` | | | IP must be public/global |",
+        ]
+
+    @classmethod
+    def _doc_options_yaml_upper_part(cls) -> list[str]:
+        return super()._doc_options_yaml_upper_part() + [
+            "",
+            "link_local: <true|false",
+            "loopback: <true|false",
+            "multicast: <true|false",
+            "private: <true|false",
+            "public: <true|false",
+        ]