Source code for geoh5py.ui_json.validation

#  Copyright (c) 2023 Mira Geoscience Ltd.
#  This file is part of geoh5py.
#  geoh5py is free software: you can redistribute it and/or modify
#  it under the terms of the GNU Lesser General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#  geoh5py is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  GNU Lesser General Public License for more details.
#  You should have received a copy of the GNU Lesser General Public License
#  along with geoh5py.  If not, see <>.

from __future__ import annotations

from copy import deepcopy
from typing import Any, cast
from uuid import UUID

from geoh5py.groups import PropertyGroup
from geoh5py.shared import Entity
from geoh5py.shared.exceptions import RequiredValidationError
from geoh5py.shared.validators import (
from geoh5py.ui_json.utils import requires_value

[docs] class InputValidation: """ Validations on dictionary of parameters. Attributes ---------- validations : Validations dictionary with matching set of input parameter keys. ignore_requirements (optional): Omit raising error on 'required' validator. Methods ------- validate_data(data) Validates data of params and contents/type/shape/keys/reqs of values. """ def __init__( self, validators: dict[str, BaseValidator] | None = None, validations: dict[str, Any] | None = None, ui_json: dict[str, Any] | None = None, validation_options: dict[str, Any] | None = None, ): self.validations = self.infer_validations(ui_json, validations=validations) self.validators: dict[str, BaseValidator] = validators if validation_options is None: validation_options = {} self.ignore_list: tuple = validation_options.get("ignore_list", ()) self.ignore_requirements: bool = validation_options.get( "ignore_requirements", False ) @property def validations(self): return self._validations @validations.setter def validations(self, val: dict[str, Any]): self._validations = val @property def validators(self): return self._validators @validators.setter def validators(self, val: dict[str, BaseValidator]): if val is None: val = {} elif not all(isinstance(v, BaseValidator) for v in val.values()): raise TypeError("Validators should be subclass of BaseValidator.") if self.validations is not None: required_validators = InputValidation._required_validators(self.validations) val = dict(required_validators, **val) self._validators = val @staticmethod def _unique_validators(validations: dict[str, Any]) -> list[str]: """Return names of validators required by a validations dictionary.""" return list({key for item in validations.values() for key in item}) @staticmethod def _required_validators(validations): """Returns dictionary of validators required by validations.""" unique_validators = InputValidation._unique_validators(validations) sub_classes: list[BaseValidator] = getattr(BaseValidator, "__subclasses__")() all_validators: dict[str, Any] = {k.validator_type: k() for k in sub_classes} val = {} for k in unique_validators: if k not in all_validators: raise ValueError(f"No validator implemented for argument '{k}'.") val[k] = all_validators[k] return val @staticmethod def _validations_from_uijson(ui_json: dict[str, Any]) -> dict[str, dict]: """Determine base set of validations from ui.json structure.""" validations: dict[str, dict] = {} for key, item in ui_json.items(): if not isinstance(item, dict): check_type = cast(Any, type(item)) validations[key] = { "types": [check_type], } continue if "isValue" in item: validations[key] = { "types": [str, UUID, int, float, Entity], } validations[key]["association"] = item["parent"] validations[key]["uuid"] = None elif "choiceList" in item: validations[key] = { "types": [str], "values": item["choiceList"], } elif "fileType" in item: validations[key] = { "types": [str], } elif "meshType" in item or "groupType" in item: validations[key] = { "types": [str, UUID, Entity], "association": "geoh5", "uuid": None, } elif "parent" in item: validations[key] = { "types": [str, UUID, Entity], "association": item["parent"], "uuid": None, } if "dataGroupType" in item: validations[key]["property_group_type"] = item["dataGroupType"] validations[key]["types"] = [str, UUID, PropertyGroup] elif "value" in item: check_type = str if item["value"] is not None: check_type = cast(Any, type(item["value"])) validations[key] = { "types": [check_type, Entity] if check_type is UUID else [check_type], } validations[key].update({"optional": not requires_value(ui_json, key)}) if "types" in validations[key]: if not requires_value(ui_json, key): validations[key]["types"] += [type(None)] if item.get("multiSelect", False): validations[key]["types"] += [list] return validations
[docs] @staticmethod def infer_validations( ui_json: dict[str, Any] | None, validations: dict[str, dict] | None = None ) -> dict: """Infer necessary validations from ui json structure.""" inferred_validations = ( {} if ui_json is None else InputValidation._validations_from_uijson(ui_json) ) if validations is not None: inferred_validations = InputValidation._merge_validations( inferred_validations, validations ) return inferred_validations
@staticmethod def _merge_validations( validations_a: dict[str, dict], validations_b: dict[str, dict] ): """Merge validations_b into validations_a.""" out = deepcopy(validations_a) if validations_b is not None: for key, val in validations_b.items(): if key not in out: out[key] = val else: out[key].update(val) return out
[docs] def validate( self, name: str, value: Any, validations: dict[str, Any] | None = None ): """ Run validations on a given key and value. :param name: Parameter identifier. :param value: Input parameter value. :param validations: [Optional] Validations provided on runtime """ if validations is None: if name not in self.validations: raise KeyError(f"{name} is missing from the known validations.") validations = self.validations[name] for validator in [ RequiredValidator, AtLeastOneValidator, OptionalValidator, TypeValidator, UUIDValidator, AssociationValidator, PropertyGroupValidator, ValueValidator, ShapeValidator, ]: val = str(validator.validator_type) if ( val not in validations or (val == "required" and self.ignore_requirements) or name in self.ignore_list ): continue self.validators[val](name, value, validations[val])
[docs] def validate_data(self, data: dict[str, Any]) -> None: """ Calls validate method on ui.json data structure for cross-dependencies. Individual key, value pairs are validated for expected type. :param data: Input data with known validations. """ one_of_validations: dict[str, Any] = {} local_validations = self.validations.copy() for param, validations in local_validations.items(): if param not in data.keys(): if "required" in validations and not self.ignore_requirements: raise RequiredValidationError(param) continue if "one_of" in validations: one_of_group = validations.pop("one_of") val = {param: data[param] is not None} if one_of_group in one_of_validations: one_of_validations[one_of_group].update(val) else: one_of_validations[one_of_group] = val if "association" in validations and validations["association"] in data: valid = validations.copy() valid["association"] = data[validations["association"]] self.validate(param, data[param], valid) else: self.validate(param, data.get(param, None), validations) for name, val in one_of_validations.items(): self.validate(name, val, {"one_of": None})
def __call__(self, data, *args): if isinstance(data, dict): self.validate_data(data) elif isinstance(data, str) and args is not None: self.validate(data, args) else: raise ValueError( "InputValidators can only be called with dictionary of data or " "(key, value) pair." )