Merge branch 'main' into #17-validate-json

Author: SarahJohnsonONS

.vscode/settings.json

@@ -1,6 +1,7 @@
 {
     "python.testing.pytestArgs": [
-        "tests"
+        "tests",
+        "dpytools"
     ],
     "python.testing.unittestEnabled": false,
     "python.testing.pytestEnabled": true,

dpytools/config/config.py

@@ -1,35 +1,89 @@
-from typing import Dict
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, List
 
 from .properties.base import BaseProperty
+from .properties.intproperty import IntegerProperty
+from .properties.string import StringProperty
 
 
 class Config:
+
+    def __init__(self):
+        self._properties_to_validate: List[BaseProperty] = []
+
     @staticmethod
-    def from_env(config_dict: Dict[str, BaseProperty]):
-        # TODO = read in and populate property classes as
-        # per the example in the main readme.
-        # You need to populate with dot notation in mind so:
-        #
-        # StringProperty("fieldname", "fieldvalue")
-        #
-        # should be accessed on Config/self, so:
-        #
-        # value = config.fieldvalue.value
-        # i.e
-        # config.fieldvalue = StringProperty("fieldname", "fieldvalue")
-        #
-        # Worth looking at the __setattr_ dunder method and a loop
-        # for how to do this.
-        #
-        # Do track the BaseProperty's that you add ready for
-        # assert_valid_config call.
-        ...
+    def from_env(config_dict: Dict[str, Dict[str, Any]]) -> Config:
+
+        config = Config()
+
+        for env_var_name, value in config_dict.items():
+
+            value_for_property = os.environ.get(env_var_name, None)
+            assert (
+                value_for_property is not None
+            ), f'Required envionrment value "{env_var_name}" could not be found.'
+
+            if value["class"] == StringProperty:
+                if value["kwargs"]:
+                    regex = value["kwargs"].get("regex")
+                    min_len = value["kwargs"].get("min_len")
+                    max_len = value["kwargs"].get("max_len")
+                else:
+                    regex = None
+                    min_len = None
+                    max_len = None
+
+                stringprop = StringProperty(
+                    _name=value["property"],
+                    _value=value_for_property,
+                    regex=regex,
+                    min_len=min_len,
+                    max_len=max_len,
+                )
+
+                prop_name = value["property"]
+                setattr(config, prop_name, stringprop)
+                config._properties_to_validate.append(stringprop)
+
+            elif value["class"] == IntegerProperty:
+                if value["kwargs"]:
+                    min_val = value["kwargs"].get("min_val")
+                    max_val = value["kwargs"].get("max_val")
+                else:
+                    min_val = None
+                    max_val = None
+
+                intprop = IntegerProperty(
+                    _name=value["property"],
+                    _value=value_for_property,
+                    min_val=min_val,
+                    max_val=max_val,
+                )
+
+                prop_name = value["property"]
+                setattr(config, prop_name, intprop)
+                config._properties_to_validate.append(intprop)
+
+            else:
+                prop_type = value["class"]
+                raise TypeError(
+                    f"Unsupported property type specified via 'property' field, got {prop_type}. Should be of type StringProperty or IntegerProperty"
+                )
+
+        return config
 
     def assert_valid_config(self):
         """
         Assert that then Config class has the properties that
         provided properties.
         """
+        for property in self._properties_to_validate:
+            property.type_is_valid()
+            property.secondary_validation()
+
+        self._properties_to_validate = []
 
         # For each of the properties you imbided above, run
         # self.type_is_valid()

dpytools/config/properties/__init__.py

@@ -1 +1,2 @@
 from .string import StringProperty
+from .intproperty import IntegerProperty

dpytools/config/properties/base.py

@@ -5,17 +5,24 @@
 
 @dataclass
 class BaseProperty(metaclass=ABCMeta):
-    name: str
-    value: Any
+    _name: str
+    _value: Any
 
-    # TODO: getter
-    # allow someone to get the property
+    @property
+    def name(self):
+        return self._name
 
-    # TODO: setter
-    # categorically disallow anyone from
-    # changing a property after the class
-    # has been instantiated.
-    # Refuse to do it, and log an error.
+    @name.setter
+    def name(self, value):
+         raise ValueError(f"Trying to change name property to value {value} but you cannot change a property name after instantiation.")
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        raise ValueError(f"Trying to change value to {value} but you cannot change a property value after instantiation.")
 
     @abstractmethod
     def type_is_valid(self):

dpytools/config/properties/intproperty.py

@@ -0,0 +1,32 @@
+from typing import Optional
+from dataclasses import dataclass
+from .base import BaseProperty
+
+@dataclass
+class IntegerProperty(BaseProperty):
+    min_val: Optional[int]
+    max_val: Optional[int]
+
+    def type_is_valid(self):
+        """
+        Validate that the property looks like
+        its of the correct type 
+        """
+        try:
+            int(self._value)
+        except Exception as err:
+            raise Exception(f"Cannot cast {self._name} value {self._value} to integer.") from err
+
+    def secondary_validation(self):
+        """
+        Non type based validation you might want to
+        run against a configuration value of this kind.
+        """
+        if not self._value:
+            raise ValueError(f"Integer value for {self._name} does not exist.")
+
+        if self.min_val and self._value < self.min_val:
+            raise ValueError(f"Integer value for {self._name} is lower than allowed minimum.")
+
+        if self.max_val and self._value > self.max_val:
+            raise ValueError(f"Integer value for {self._name} is higher than allowed maximum.")

dpytools/config/properties/string.py

@@ -1,8 +1,11 @@
 from typing import Optional
-
+from dataclasses import dataclass
 from .base import BaseProperty
 
+import re
+
 
+@dataclass
 class StringProperty(BaseProperty):
     regex: Optional[str]
     min_len: Optional[int]
@@ -14,28 +17,37 @@ def type_is_valid(self):
         its of the correct type
         """
         try:
-            str(self.value)
+            str(self._value)
         except Exception as err:
             raise Exception(
-                f"Cannot cast {self.name} value {self.value} to string."
+                f"Cannot cast {self.name} value {self._value} to string."
             ) from err
 
-    def secondary_validation_passed(self):
+    def secondary_validation(self):
         """
         Non type based validation you might want to
         run against a configuration value of this kind.
         """
-        if len(self.value) == 0:
+
+        if len(self._value) == 0:
             raise ValueError(f"Str value for {self.name} is an empty string")
 
         if self.regex:
             # TODO - confirm the value matches the regex
-            ...
+            regex_search = re.search(self.regex, self._value)
+            if not regex_search:
+                raise ValueError(
+                    f"Str value for {self.name} does not match the given regex."
+                )
 
         if self.min_len:
-            # TODO - confirm the string matches of exceeds the minimum length
-            ...
+            if len(self._value) < self.min_len:
+                raise ValueError(
+                    f"Str value for {self.name} is shorter than minimum length {self.min_len}"
+                )
 
         if self.max_len:
-            # TODO - confirm the value matches or is less than the max length
-            ...
+            if len(self._value) > self.max_len:
+                raise ValueError(
+                    f"Str value for {self.name} is longer than maximum length {self.max_len}"
+                )

dpytools/validation/json/validation.py

@@ -19,7 +19,7 @@ def validate_json_schema(
 
     Either `data_dict` or `data_path` must be provided.
 
-    `msg` and `indent` are used to format the error message if validation fails.
+    `error_msg` and `indent` are used to format the error message if validation fails.
     """
     # Confirm that *either* `data_dict` *or* `data_path` has been provided, otherwise raise ValueError
     if data_dict and data_path:
@@ -37,23 +37,27 @@ def validate_json_schema(
         if parsed_schema_path.scheme == "http":
             # TODO Load schema from URL
             raise NotImplementedError("Validation from remote schema not yet supported")
+        # Convert `schema_path` to pathlib.Path
         schema_path = Path(schema_path).absolute()
+    # Check `schema_path` exists
     if not schema_path.exists():
         raise ValueError(f"Schema path '{schema_path}' does not exist")
     with open(schema_path, "r") as f:
         schema_from_path = json.load(f)
 
-    # Load data to be validated as dict
+    # Load data to be validated
     if data_dict:
         if not isinstance(data_dict, Dict):
             raise ValueError("Invalid data format")
         data_to_validate = data_dict
 
     if data_path:
+        # Convert `data_path` to pathlib.Path
         if isinstance(data_path, str):
             data_path = Path(data_path).absolute()
         if not isinstance(data_path, Path):
             raise ValueError("Invalid data format")
+        # Check `data_path` exists
         if not data_path.exists():
             raise ValueError(f"Data path '{data_path}' does not exist")
         with open(data_path, "r") as f:
@@ -62,8 +66,8 @@ def validate_json_schema(
     # Validate data against schema
     try:
         jsonschema.validate(data_to_validate, schema_from_path)
+    # TODO Handle jsonschema.SchemaError?
     except jsonschema.ValidationError as err:
-        # TODO Handle jsonschema.SchemaError?
         # If error is in a specific field, get the JSON path of the error location
         if err.json_path != "$":
             error_location = err.json_path
@@ -73,8 +77,8 @@ def validate_json_schema(
         if error_msg or indent:
             formatted_msg = f"""
 Exception: {error_msg}
-Error details: {err.message}
-Error location: {error_location}
+Exception details: {err.message}
+Exception location: {error_location}
 JSON data:
 {json.dumps(data_to_validate, indent=indent)}
 """