strictyamlx 0.1.0__tar.gz

strictyamlx-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Muneeb ur Rahman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.

strictyamlx-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: strictyamlx
+Version: 0.1.0
+Summary: An extension of StrictYAML that adds more expressive schema tools for validation.
+License: MIT
+License-File: LICENSE
+Author: Muneeb ur Rahman
+Author-email: muneebdev1@gmail.com
+Requires-Python: >=3.12,<=3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: strictyaml (==1.7.3)
+Description-Content-Type: text/markdown
+
+# strictyamlx
+An extension of StrictYAML that adds more expressive schema tools for validation.
+

strictyamlx-0.1.0/README.md

@@ -0,0 +1,2 @@
+# strictyamlx
+An extension of StrictYAML that adds more expressive schema tools for validation.

strictyamlx-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "strictyamlx"
+version = "0.1.0"
+description = "An extension of StrictYAML that adds more expressive schema tools for validation."
+authors = [
+    {name = "Muneeb ur Rahman",email = "muneebdev1@gmail.com"}
+]
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.12,<=3.14"
+dependencies = [
+    "strictyaml==1.7.3"
+]
+
+[tool.poetry]
+packages = [{include = "strictyamlx", from = "src"}]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[dependency-groups]
+dev = [
+    "pytest (>=9.0.2,<10.0.0)"
+]

strictyamlx-0.1.0/src/strictyamlx/__init__.py

@@ -0,0 +1,7 @@
+from strictyaml import *
+
+
+from .forwardref import ForwardRef
+from .dmap import DMap
+from .control import Control
+from .blocks import Block, Case

strictyamlx-0.1.0/src/strictyamlx/blocks.py

@@ -0,0 +1,44 @@
+from strictyaml import Validator
+from collections.abc import Callable
+
+
+class Block:
+    def __init__(
+        self,
+        when: Callable[..., bool],
+        schema: Validator,
+        constraints: list[Callable[..., bool]] | None = None,
+    ):
+        assert isinstance(schema, Validator), "schema must be of type Validator"
+        self.when = when
+        self._validator = schema
+        self.constraints = constraints
+
+    def __repr__(self):
+        return "{0}(when={1}, schema={2}{3})".format(
+            self.__class__.__name__,
+            repr(self.when),
+            repr(self._validator),
+            ", constraints={0}".format(repr(self.constraints)) if self.constraints else "",
+        )
+
+
+class Case(Block):
+    def __init__(
+        self,
+        when: Callable[..., bool],
+        schema: Validator,
+        constraints: list[Callable[..., bool]] | None = None,
+    ):
+        super().__init__(when, schema, constraints)
+
+
+# TODO: implement in DMap
+class Overlay(Block):
+    def __init__(
+        self,
+        when: Callable[..., bool],
+        schema: Validator,
+        constraints: list[Callable[..., bool]] | None = None,
+    ):
+        super().__init__(when, schema, constraints)

strictyamlx-0.1.0/src/strictyamlx/builder.py

@@ -0,0 +1,78 @@
+from strictyaml import Validator
+from strictyaml.validators import MapValidator
+from strictyaml import Map, MapCombined
+import copy
+from .utils import unpack, ensure_validator_dict
+
+
+class ValidatorBuilder:
+    def __init__(
+        self,
+        control_validator: Validator,
+        case_validator: Validator,
+        control_source: tuple[str] | str | None = None,
+    ):
+        self.control_source = control_source
+        self.control_validator = control_validator
+        self.case_validator = case_validator
+        self.validator = self._build()
+
+    def merge_recursive(self, control_validator, case_validator):
+        control_validator = unpack(control_validator)
+        if not hasattr(control_validator, '_validator') or not isinstance(control_validator._validator, dict):
+            return
+        if not hasattr(case_validator, '_validator') or not isinstance(case_validator._validator, dict):
+            return
+
+        for key, val in control_validator._validator.items():
+            val_unpacked = unpack(val)
+            if isinstance(val_unpacked, MapValidator):
+                if key not in case_validator._validator:
+                    case_validator._validator[key] = Map({})
+                    
+                target = ensure_validator_dict(case_validator._validator[key])
+                case_validator._validator[key] = target
+                self.merge_recursive(val, target)
+            else:
+                if key not in case_validator._validator:
+                    case_validator._validator[key] = val
+
+    def rebuild_validator_recursive(self, validator):
+        validator = ensure_validator_dict(validator)
+        if not hasattr(validator, '_validator') or not isinstance(validator._validator, dict):
+            return validator
+
+        new_dict = {}
+        for key, val in validator._validator.items():
+            val_unpacked = ensure_validator_dict(val)
+            if hasattr(val_unpacked, '_validator') and isinstance(val_unpacked._validator, dict):
+                new_dict[key] = self.rebuild_validator_recursive(val_unpacked)
+            else:
+                new_dict[key] = val_unpacked
+
+        if isinstance(validator, MapCombined):
+            return MapCombined(new_dict, validator.key_validator, getattr(validator, '_value_validator', None))
+        return Map(new_dict)
+
+    def _build(self):
+        control_validator = copy.deepcopy(unpack(self.control_validator))
+        if self.control_source:
+            if isinstance(self.control_source, str):
+                self.control_source = [self.control_source]
+            for key in reversed(self.control_source):
+                map_layer = Map({})
+                map_layer._validator[key] = control_validator
+                control_validator = map_layer
+
+        case_validator = copy.deepcopy(ensure_validator_dict(self.case_validator))
+
+        if hasattr(case_validator, 'control') and hasattr(case_validator.control, '_validator'):
+            case_validator.control._validator = ValidatorBuilder(
+                control_validator, case_validator.control._validator
+            ).validator
+            return case_validator
+
+        self.merge_recursive(control_validator, case_validator)
+        final_validator = self.rebuild_validator_recursive(case_validator)
+
+        return final_validator

strictyamlx-0.1.0/src/strictyamlx/control.py

@@ -0,0 +1,65 @@
+from strictyaml import Validator
+from strictyaml.validators import MapValidator
+from strictyaml.yamllocation import YAMLChunk
+from functools import reduce
+from strictyaml.ruamel.comments import CommentedMap
+from strictyaml.exceptions import YAMLSerializationError
+
+
+class Control:
+    def __init__(self, validator: Validator, source: tuple[str] | str | None = None):
+        self._validator = validator
+        self.source = source
+        self.validated = None
+
+        assert isinstance(
+            self._validator, Validator
+        ), "validator must be of type Validator"
+
+    def __repr__(self):
+        return "Control({0}{1})".format(
+            repr(self._validator),
+            ", source={0}".format(repr(self.source)) if self.source else "",
+        )
+
+    def projection(self, chunk, validator):
+        from .utils import unpack
+        validator = unpack(validator)
+        projected_chunk = {}
+        
+        if hasattr(validator, '_validator_dict'):
+            keys = validator._validator_dict.items()
+        elif hasattr(validator, '_validator') and isinstance(validator._validator, dict):
+            # for when _validator_dict isn't explicitly built but _validator is a dict
+            keys = [
+                (k.key if hasattr(k, 'key') else k, v)
+                for k, v in validator._validator.items()
+            ]
+        else:
+            from strictyaml.exceptions import InvalidValidatorError
+            raise InvalidValidatorError("Control validator must be a Map with specific keys")
+
+        for key, val in keys:
+            val = unpack(val)
+            if key in chunk:
+                if isinstance(val, MapValidator):
+                    projected_chunk[key] = self.projection(
+                        chunk[key], val
+                    )
+                else:
+                    projected_chunk[key] = chunk[key]
+                    
+        return CommentedMap(projected_chunk)
+
+    def validate(self, chunk):
+        if self.source and self.source != "":
+            if isinstance(self.source, str):
+                chunk_pointer = chunk.contents[self.source]
+            elif isinstance(self.source, tuple):
+                chunk_pointer = reduce(
+                    lambda d, key: d[key], self.source, chunk.contents
+                )
+        else:
+            chunk_pointer = chunk.contents
+        source_chunk = YAMLChunk(self.projection(chunk_pointer, self._validator))
+        self.validated = self._validator(source_chunk)

strictyamlx-0.1.0/src/strictyamlx/dmap.py

@@ -0,0 +1,97 @@
+from strictyaml import Validator
+from strictyaml.validators import MapValidator
+from strictyaml.exceptions import YAMLSerializationError, InvalidValidatorError
+from .control import Control
+from .blocks import Block
+from collections.abc import Callable
+from .builder import ValidatorBuilder
+from strictyaml.representation import YAML
+
+
+class DMap(MapValidator):
+    def __init__(
+        self,
+        control: Control,
+        blocks: list[Block],
+        constraints: list[Callable[..., bool]] | None = None,
+    ):
+        assert isinstance(control, Control), "control must be of type Control"
+        assert isinstance(blocks, list), "blocks must be a list of Block"
+        for block in blocks:
+            assert isinstance(block, Block), "all blocks must be of type Block"
+            
+        if constraints is not None:
+            assert isinstance(constraints, list), "constraints must be a list of Callable"
+            for constraint in constraints:
+                assert callable(constraint), "every constraint must be callable"
+
+        self.control = control
+        self.blocks = blocks
+        self.constraints = constraints
+
+    @staticmethod
+    def compile_when(when):
+        if callable(when):
+            return when
+        return lambda raw, ctrl: bool(when)
+
+    @staticmethod
+    def compile_constraint(when):
+        if callable(when):
+            return when
+        return lambda raw, ctrl, val: bool(when)
+
+    def validate(self, chunk):
+        chunk.expect_mapping()
+        self.control.validate(chunk)
+        ctrl = self.control.validated.data
+        raw = chunk.whole_document
+        control_validator = self.control._validator
+        true_case_block = None
+        # TODO: what if the user doesn't really want a control validator and only selects based on raw
+        for block in self.blocks:
+            if DMap.compile_when(block.when)(raw, ctrl):
+                if true_case_block is None:
+                    true_case_block = block
+                else:
+                    chunk.expecting_but_found("when evaluating DMap blocks", "multiple cases were true")
+
+        if true_case_block is None:
+            chunk.expecting_but_found("when evaluating DMap blocks", "none of the cases were true")
+
+        final_validator = ValidatorBuilder(
+            control_validator, true_case_block._validator, self.control.source
+        ).validator
+
+        self.validated = final_validator(chunk)
+        val = self.validated.data
+
+        if self.constraints:
+            for constraint in self.constraints:
+                if not DMap.compile_constraint(constraint)(raw, ctrl, val):
+                    chunk.expecting_but_found("when evaluating DMap constraints", "constraints not fulfilled")
+        if true_case_block.constraints:
+            for constraint in true_case_block.constraints:
+                if not DMap.compile_constraint(constraint)(raw, ctrl, val):
+                    chunk.expecting_but_found("when evaluating DMap case constraints", "constraints not fulfilled")
+
+    def to_yaml(self, data):
+        self._should_be_mapping(data)
+
+        for block in self.blocks:
+            try:
+                final_validator = ValidatorBuilder(
+                    self.control._validator, block._validator, self.control.source
+                ).validator
+                return final_validator.to_yaml(data)
+            except (YAMLSerializationError, KeyError):
+                continue
+                
+        raise YAMLSerializationError("None of the DMap cases successfully serialized the data")
+
+    def __repr__(self):
+        return "DMap({0}, {1}{2})".format(
+            repr(self.control),
+            repr(self.blocks),
+            ", constraints={0}".format(repr(self.constraints)) if self.constraints else "",
+        )

strictyamlx-0.1.0/src/strictyamlx/forwardref.py

@@ -0,0 +1,37 @@
+from strictyaml import Validator
+from strictyaml.exceptions import YAMLSerializationError
+
+
+class ForwardRefValidator(Validator):
+    def _should_be_validator(self, validator):
+        if not isinstance(validator, Validator):
+            raise YAMLSerializationError(
+                "Expected a Validator, found '{}'".format(validator)
+            )
+
+
+class ForwardRef(ForwardRefValidator):
+    def __init__(self):
+        self._validator = None
+        self.has_expanded = False
+
+    def set(self, validator: Validator):
+        self._should_be_validator(validator)
+        self._validator = validator
+
+    def __call__(self, chunk):
+        if self._validator is None:
+            raise YAMLSerializationError("ForwardRef was used before it was set")
+        return self._validator(chunk)
+
+    def __repr__(self):
+        if self._validator is None:
+            return "{0}()".format(self.__class__.__name__)
+        if not self.has_expanded:
+            self.has_expanded = True
+            return "{0}".format(repr(self._validator))
+        else:
+            return "{0}()".format(self.__class__.__name__)
+
+    def to_yaml(self, data):
+        return self._validator.to_yaml(data)

strictyamlx-0.1.0/src/strictyamlx/utils.py

@@ -0,0 +1,17 @@
+from .forwardref import ForwardRef
+from strictyaml import Map, MapCombined, MapPattern
+from strictyaml.validators import Validator
+from strictyaml.exceptions import YAMLSerializationError
+
+def unpack(validator):
+    while isinstance(validator, ForwardRef):
+        if validator._validator is None:
+            raise YAMLSerializationError("ForwardRef was used before it was set")
+        validator = validator._validator
+    return validator
+
+def ensure_validator_dict(validator):
+    validator = unpack(validator)
+    if isinstance(validator, MapPattern):
+        return MapCombined({}, validator._key_validator, validator._value_validator)
+    return validator