two version of R2R are here HEAD master

1 files changed, 118 insertions, 0 deletions

diff --git a/.venv/lib/python3.12/site-packages/strictyaml/validators.py b/.venv/lib/python3.12/site-packages/strictyaml/validators.py
new file mode 100644
index 00000000..b63643b8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/strictyaml/validators.py
@@ -0,0 +1,118 @@
+from strictyaml.exceptions import YAMLValidationError, YAMLSerializationError
+from strictyaml.exceptions import InvalidValidatorError
+from strictyaml.representation import YAML
+from strictyaml import utils
+import sys
+
+
+if sys.version_info[0] == 3:
+    unicode = str
+
+
+class Validator(object):
+    def __or__(self, other):
+        return OrValidator(self, other)
+
+    def __call__(self, chunk):
+        self.validate(chunk)
+        return YAML(chunk, validator=self)
+
+    def __repr__(self):
+        return "{0}()".format(self.__class__.__name__)
+
+
+class MapValidator(Validator):
+    def _should_be_mapping(self, data):
+        if not isinstance(data, dict):
+            raise YAMLSerializationError("Expected a dict, found '{}'".format(data))
+        if len(data) == 0:
+            raise YAMLSerializationError(
+                (
+                    "Expected a non-empty dict, found an empty dict.\n"
+                    "Use EmptyDict validator to serialize empty dicts."
+                )
+            )
+
+
+class SeqValidator(Validator):
+    def _should_be_list(self, data):
+        if not isinstance(data, list):
+            raise YAMLSerializationError("Expected a list, found '{}'".format(data))
+        if len(data) == 0:
+            raise YAMLSerializationError(
+                (
+                    "Expected a non-empty list, found an empty list.\n"
+                    "Use EmptyList validator to serialize empty lists."
+                )
+            )
+
+
+class OrValidator(Validator):
+    def __init__(self, validator_a, validator_b):
+        assert isinstance(validator_a, Validator), "validator_a must be a Validator"
+        assert isinstance(validator_b, Validator), "validator_b must be a Validator"
+
+        self._validator_a = validator_a
+        self._validator_b = validator_b
+
+        def unpacked(validator):
+            if isinstance(validator, OrValidator):
+                return [
+                    unpacked(validator._validator_a),
+                    unpacked(validator._validator_b),
+                ]
+            else:
+                return [validator]
+
+        map_validator_count = len(
+            [
+                validator
+                for validator in list(utils.flatten(unpacked(self)))
+                if isinstance(validator, MapValidator)
+            ]
+        )
+
+        if map_validator_count > 1:
+            raise InvalidValidatorError(
+                (
+                    "You tried to Or ('|') together {} Map validators. "
+                    "Try using revalidation instead."
+                ).format(map_validator_count)
+            )
+
+        seq_validator_count = len(
+            [
+                validator
+                for validator in list(utils.flatten(unpacked(self)))
+                if isinstance(validator, SeqValidator)
+            ]
+        )
+
+        if seq_validator_count > 1:
+            raise InvalidValidatorError(
+                (
+                    "You tried to Or ('|') together {} Seq validators. "
+                    "Try using revalidation instead."
+                ).format(seq_validator_count)
+            )
+
+    def to_yaml(self, value):
+        try:
+            return self._validator_a.to_yaml(value)
+        except YAMLSerializationError:
+            return self._validator_b.to_yaml(value)
+
+    def __call__(self, chunk):
+        try:
+            result = self._validator_a(chunk)
+            result._selected_validator = result._validator
+            result._validator = self
+            return result
+        except YAMLValidationError:
+            result = self._validator_b(chunk)
+            result._selected_validator = result._validator
+            result._validator = self
+            return result
+
+    def __repr__(self):
+        return "{0} | {1}".format(repr(self._validator_a), repr(self._validator_b))