cfn-check 0.4.0__tar.gz → 0.5.1__tar.gz

{cfn_check-0.4.0 → cfn_check-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cfn-check
-Version: 0.4.0
+Version: 0.5.1
 Summary: Validate Cloud Formation
 Author-email: Ada Lundhe <adalundhe@lundhe.audio>
 License: MIT License

{cfn_check-0.4.0 → cfn_check-0.5.1}/cfn_check/cli/render.py

@@ -11,7 +11,8 @@ from cfn_check.logging.models import InfoLog
 async def render(
     path: str,
     output_file: str  = 'rendered.yml',
-    mappings: list[str] | None = None,
+    parameters: list[str] | None = None,
+    references: list[str] | None = None,
     tags: list[str] = [
         'Ref',
         'Sub',
@@ -35,7 +36,8 @@ async def render(
     Render a Cloud Formation template
 
     @param output_file Path to output the rendered CloudFormation template to
-    @param mappings A list of <key>=<value> string pairs specifying Mappings
+    @param parameters A list of <key>=<value> input Parameters to use
+    @param references A list of <key>=<value> input !Ref values to use
     @param tags List of CloudFormation intrinsic function tags
     @param log_level The log level to use
     """
@@ -45,11 +47,16 @@ async def render(
         log_output='stderr',
     )
 
-    selected_mappings: dict[str, str] | None = None
+    parsed_parameters: dict[str, str] | None = None
+    if parameters:
+        parsed_parameters = dict([
+            parameter.split('=', maxsplit=1) for parameter in parameters if len(parameter.split('=', maxsplit=1)) > 0
+        ])
 
-    if mappings:
-        selected_mappings = dict([
-            mapping.split('=', maxsplit=1) for mapping in mappings if len(mapping.split('=', maxsplit=1)) > 0
+    parsed_references: dict[str, str] | None = None
+    if references:
+        parsed_references = dict([
+            reference.split('=', maxsplit=1) for reference in references if len(reference.split('=', maxsplit=1)) > 0
         ])
 
     logger = Logger()
@@ -63,7 +70,11 @@ async def render(
 
     _, template = templates[0]
     renderer = Renderer()
-    rendered = renderer.render(template, selected_mappings=selected_mappings)
+    rendered = renderer.render(
+        template,
+        parameters=parsed_parameters,
+        references=parsed_references,
+    )
 
     await write_to_file(output_file, rendered)
 

{cfn_check-0.4.0 → cfn_check-0.5.1}/cfn_check/cli/utils/files.py

@@ -2,22 +2,24 @@
 import asyncio
 import os
 import pathlib
-import yaml
-from cfn_check.loader.loader import (
-    Loader,
-    create_tag,
-    find_templates,
-)
+from ruamel.yaml import YAML
 from cfn_check.shared.types import YamlObject, Data
 
+
+def find_templates(path, file_pattern):
+    return list(pathlib.Path(path).rglob(file_pattern))
+
 def open_template(path: str) -> tuple[str, YamlObject] | None:
 
     if os.path.exists(path) is False:
         return None
 
     try:
-        with open(path, 'r') as f:
-            return (path, yaml.load(f, Loader=Loader))
+        with open(path, 'r') as yml:
+            loader = YAML(typ='rt')
+            loader.preserve_quotes = True
+            loader.indent(mapping=2, sequence=4, offset=2)
+            return (path, loader.load(yml))
     except Exception as e:
         raise e
     
@@ -99,16 +101,6 @@ async def load_templates(
 
     assert len(template_filepaths) > 0 , '❌ No matching files found'
     
-    for tag in tags:
-        new_tag = await loop.run_in_executor(
-            None,
-            create_tag,
-            tag,
-        )
-
-        Loader.add_constructor(f'!{tag}', new_tag)
-
-    
     templates: list[tuple[str, Data]]  = await asyncio.gather(*[
         loop.run_in_executor(
             None,
@@ -142,5 +134,9 @@ async def write_to_file(path: str, data: YamlObject):
     )
 
 def _write_to_file(path: str, data: YamlObject):
+    dumper = YAML(typ='rt')
+    dumper.preserve_quotes = True
+    dumper.width = 4096
+    dumper.indent(mapping=2, sequence=4, offset=2)
     with open(path, 'w') as yml:
-        yaml.safe_dump(data, yml, indent=2)
+        dumper.dump(data, yml)

{cfn_check-0.4.0 → cfn_check-0.5.1}/cfn_check/collection/collection.py

@@ -10,7 +10,6 @@ class Collection:
         self.documents: dict[str, Data] = {}
         self._evaluator = Evaluator()
 
-
     def query(
         self,
         query: str,

cfn_check-0.5.1/cfn_check/rendering/renderer.py

@@ -0,0 +1,740 @@
+from __future__ import annotations
+import base64
+import json
+import re
+from typing import Callable, Any
+from collections import deque
+from ruamel.yaml.tag import Tag
+from ruamel.yaml.comments import TaggedScalar, CommentedMap, CommentedSeq
+from .utils import assign
+
+from cfn_check.shared.types import (
+    Data,
+    Items,
+    YamlObject,
+)
+
+class Renderer:
+
+    def __init__(self):
+        self.items: Items = deque()
+        self._sub_pattern = re.compile(r'\$\{([\w+::]+)\}')
+        self._sub_inner_text_pattern = re.compile(r'[\$|\{|\}]+')
+        self._visited: list[str | int] = []
+        self._data: YamlObject = {}
+        self._parameters = CommentedMap()
+        self._mappings = CommentedMap()
+        self._parameters_with_defaults: dict[str, str | int | float | bool | None] = {}
+        self._selected_mappings = CommentedMap()
+        self._references: dict[str, str] = {}
+        self._resources: dict[str, YamlObject] = CommentedMap()
+        self._attributes: dict[str, str] = {}
+
+        self._resolvers: dict[str, Callable[[CommentedMap, str], YamlObject]] = {
+            '!Ref': self._resolve_ref,
+            '!FindInMap': self._resolve_by_subset_query,
+            '!GetAtt': self._resolve_getatt,
+            '!Join': self._resolve_join,
+            '!Sub': self._resolve_sub,
+            '!Base64': self._resolve_base64,
+            '!Split': self._resolve_split,
+            '!Select': self._resolve_select,
+            '!ToJsonString': self._resolve_tree_to_json,
+        }
+
+    def render(
+        self,
+        template: YamlObject,
+        attributes: dict[str, Any] | None = None,
+        parameters: dict[str, Any] | None = None,
+        references: dict[str, str] | None = None,
+        mappings: dict[str, str] | None = None,
+    ):
+
+        self._sources = list(template.keys())
+
+        self._assemble_parameters(template)
+
+        attributes = {
+            'LambdaExecutionRole.Arn': 'This is a test',
+            'AllSecurityGroups.Value': [
+                '123456',
+                '112211'
+            ]
+
+        }
+        if attributes:
+            self._attributes = self._process_attributes(attributes)
+
+        self._parameters = template.get('Parameters', CommentedMap())
+        if parameters:
+            self._parameters_with_defaults.update(parameters)
+
+        if references:
+            self._references.update(references)
+
+        self._mappings = template.get('Mappings', CommentedMap())
+        
+        if mappings:
+            self._selected_mappings = mappings
+
+        self._resources = template.get('Resources', CommentedMap())
+
+        return self._resolve_tree(template)
+
+    def _resolve_tree(self, root: YamlObject):
+        self.items.clear()
+        self.items.append((None, None, root))
+        self.items.append((None, None, root))
+
+        while self.items:
+            parent, accessor, node = self.items.pop()
+
+            if isinstance(node, TaggedScalar):
+                # Replace in parent
+                if parent is not None and (
+                    resolved := self._resolve_tagged(root, node)
+                ):
+                    parent[accessor] = resolved
+
+            elif isinstance(node, CommentedMap):
+                if isinstance(node.tag, Tag) and node.tag.value is not None and parent and (
+                    resolved_node := self._resolve_tagged(root, node)
+                ):
+                    parent[accessor] = resolved_node
+
+                elif isinstance(node.tag, Tag) and node.tag.value is not None:
+                    node = self._resolve_tagged(root, node)
+                    for k in reversed(list(node.keys())):
+                        self.items.append((node, k, node[k]))
+
+                    root = node
+                
+                else:
+                    # Process keys in reverse order for proper DFS
+                    for k in reversed(list(node.keys())):
+                        self.items.append((node, k, node[k]))
+
+            elif isinstance(node, CommentedSeq):
+                
+                if isinstance(node.tag, Tag) and node.tag.value is not None and parent and (
+                    resolved_node := self._resolve_tagged(root, node)
+                ):
+                    parent[accessor] = resolved_node
+
+                elif isinstance(node.tag, Tag) and node.tag.value is not None:
+                    node = self._resolve_tagged(root, node)
+                    for idx, val in enumerate(reversed(node)):
+                        self.items.append((node, idx, val))
+
+                    root = node
+
+                else:
+                    # Process indices in reverse order for proper DFS
+                    for idx, val in enumerate(reversed(node)):
+                        self.items.append((node, idx, val))
+
+        return root
+    
+    def _find_matching_key(
+        self,
+        root: CommentedMap, 
+        search_key: str,
+    ):
+        """Returns the first path (list of keys/indices) to a mapping with key == search_key, and the value at that path."""
+        stack = [(root, [])]
+        while stack:
+            node, path = stack.pop()
+            if isinstance(node, CommentedMap):
+                for k in node.keys():
+                    if k == search_key:
+                        return node[k]
+                    stack.append((node[k], path + [k]))
+            elif isinstance(node, CommentedSeq):
+                for idx, item in reversed(list(enumerate(node))):
+                    stack.append((item, path + [idx]))
+
+        return None  # No match found
+    
+    def _assemble_parameters(self, resources: YamlObject):
+        params: dict[str, Data] = resources.get("Parameters", {})
+        for param_name, param in params.items():
+            if default := param.get("Default"):
+                self._parameters_with_defaults[param_name] = default
+
+    def _resolve_tagged(self, root: CommentedMap, node: TaggedScalar | CommentedMap | CommentedSeq):
+        resolver: Callable[[CommentedMap, str], YamlObject] | None = None
+        
+        if isinstance(node.tag, Tag) and (
+            resolver := self._resolvers.get(node.tag.value)
+        ):    
+            return resolver(root, node)
+    
+    def _resolve_ref(self, root: YamlObject, scalar: TaggedScalar):
+        '''
+        Sometimes we can resolve a !Ref if it has an explicit correlation
+        to a Resources key or input Parameter. This helps reduce the amount
+        of work we have to do when resolving later.
+        '''
+        if val := self._parameters_with_defaults.get(scalar.value):
+            return val
+        
+        elif scalar.value in self._parameters:
+            return scalar
+
+        elif scalar.value in self._resources:
+            return scalar.value
+        
+        elif ref := self._references.get(scalar.value):
+            return ref
+
+        else:
+            return self._find_matching_key(root, scalar.value)
+        
+    def _resolve_by_subset_query(
+        self, 
+        root: CommentedMap, 
+        subset: CommentedMap | CommentedSeq,
+    ) -> YamlObject | None:
+        """
+        Traverse `subset` iteratively. For every leaf (scalar or TaggedScalar) encountered in `subset`,
+        use its value as the next key/index into `root`. Return (path, value) where:
+        - path: list of keys/indices used to reach into `root`
+        - value: the value at the end of traversal, or None if a step was missing (early return)
+        TaggedScalar is treated as a leaf and its .value is used as the key component.
+        """
+        current = self._mappings
+        path = []
+
+        stack = [(subset, [])]
+        while stack:
+            node, _ = stack.pop()
+
+            if isinstance(node, CommentedMap):
+
+                if isinstance(node.tag, Tag) and node.tag.value is not None and (
+                    node != subset
+                ):
+                    resolved_node = self._resolve_tagged(root, node)
+                    stack.append((resolved_node, []))
+                
+                else:
+                    for k in reversed(list(node.keys())):
+                        stack.append((node[k], []))
+
+            elif isinstance(node, CommentedSeq):
+
+                if isinstance(node.tag, Tag) and node.tag.value is not None and (
+                    node != subset
+                ):
+                    resolved_node = self._resolve_tagged(root, node)
+                    stack.append((resolved_node, []))
+
+                else:
+                    for val in reversed(node):
+                        stack.append((val, []))
+            else:
+                # Leaf: scalar or TaggedScalar
+                key = self._resolve_tagged(
+                    self._selected_mappings,
+                    node,
+                ) if isinstance(node, TaggedScalar) else node
+                path.append(key)
+
+                if isinstance(current, CommentedMap):
+                    if key in current:
+                        current = current[key]
+                    else:
+                        return None
+                elif isinstance(current, CommentedSeq) and isinstance(key, int) and 0 <= key < len(current):
+                    current = current[key]
+                else:
+                    return None
+                
+        if isinstance(current, TaggedScalar):
+            return path, self._resolve_tagged(
+                self._selected_mappings,
+                current,
+            )
+
+        return current
+    
+    def _resolve_getatt(
+        self,
+        root: CommentedMap, 
+        query: TaggedScalar | CommentedMap | CommentedSeq,
+    ) -> YamlObject | None:
+        steps: list[str] = []
+
+        if isinstance(query, TaggedScalar):
+            steps_string: str = query.value
+            steps = steps_string.split('.')
+
+        elif (
+            resolved := self._longest_path(root, query)
+        ) and isinstance(
+            resolved,
+            list,
+        ):
+            steps = resolved
+
+        if value := self._attributes.get(
+            '.'.join(steps)
+        ):
+            return value
+
+        current = self._resources
+        for step in steps:
+            if step == 'Value':
+                return current
+            # Mapping
+            if isinstance(current, (CommentedMap, dict)):
+                if step in current:
+                    current = current[step]
+                else:
+                    return None
+            # Sequence
+            elif isinstance(current, (CommentedSeq, list)):
+                try:
+                    idx = int(step)
+                except ValueError:
+                    return None
+                if 0 <= idx < len(current):
+                    current = current[idx]
+                else:
+                    return None
+            else:
+                # Hit a scalar (including TaggedScalar) before consuming all steps
+                return None
+        
+        return current
+    
+    def _resolve_join(
+        self,
+        root: CommentedMap,
+        source: CommentedSeq,
+    ) -> Any:
+        if len(source) < 2:
+            return ''
+        
+        delimiter = source[0]
+        if isinstance(delimiter, (TaggedScalar, CommentedMap, CommentedSeq)):
+            delimiter = str(self._resolve_tagged(root, delimiter))
+
+        else:
+            delimiter = str(delimiter)  
+        
+        subselction = source[1:]
+        resolved = self._resolve_subtree(root, subselction)
+
+        if not isinstance(resolved, CommentedSeq):
+            return resolved
+
+        return delimiter.join([
+            str(self._resolve_tagged(
+                root,
+                node,
+            ))
+            if isinstance(
+                node,
+                (TaggedScalar, CommentedMap, CommentedSeq)
+            ) else node 
+            for subset in resolved
+            for node in subset
+        ])
+    
+    def _resolve_sub(
+        self, 
+        root: CommentedMap,
+        source: CommentedSeq | TaggedScalar,
+    ):
+        if isinstance(source, TaggedScalar) and isinstance(
+            source.tag,
+            Tag,
+        ):
+            source_string = source.value
+            variables = self._resolve_template_string(source_string)
+            return self._resolve_sub_ref_queries(
+                variables,
+                source_string,
+            )
+
+        elif len(source) > 1:
+            source_string: str = source[0]
+            template_vars = self._resolve_template_string(source_string)
+            variables = source[1:]
+            resolved: list[dict[str, Any]] = self._resolve_subtree(root, variables)
+            
+            for resolve_var in resolved:
+                for template_var, accessor in template_vars:
+                    if val := resolve_var.get(accessor):
+                        source_string = source_string.replace(template_var, val)
+
+            return source_string
+
+        return source
+    
+    def _resolve_base64(
+        self,
+        root: CommentedMap,
+        source: CommentedMap | CommentedSeq | TaggedScalar,
+    ):
+        if isinstance(source, TaggedScalar) and isinstance(
+            source.tag, 
+            Tag,
+        ) and isinstance(
+            source.tag.value,
+            str,
+        ):
+            return base64.b64encode(source.tag.value.encode()).decode('ascii')
+        
+        elif (
+            resolved := self._resolve_subtree(root, source)
+        ) and isinstance(
+            resolved,
+            str
+        ):
+          return  base64.b64encode(resolved.encode()).decode('ascii')
+        
+        return source
+    
+    def _resolve_split(
+        self,
+        root: CommentedMap,
+        source: CommentedSeq | CommentedMap | TaggedScalar,
+    ):
+        if isinstance(
+            source,
+            (CommentedMap, TaggedScalar),
+        ) or len(source) != 2:
+            return source
+        
+        delimiter = source[0]
+        if not isinstance(
+            delimiter,
+            str,
+        ):
+            delimiter = self._resolve_subtree(root, delimiter)
+
+        target = source[1]
+        if not isinstance(
+            target,
+            str,
+        ):
+            target = self._resolve_subtree(root, target)
+
+        if isinstance(delimiter, str) and isinstance(target, str):
+            return CommentedSeq(target.split(delimiter))
+        
+        return target
+    
+    def _resolve_select(
+        self,
+        root: CommentedMap,
+        source: CommentedSeq | CommentedMap | TaggedScalar,
+    ):
+        if isinstance(
+            source,
+            (CommentedMap, TaggedScalar),
+        ) or len(source) != 2:
+            return source
+        
+        
+        index = source[0]
+        if not isinstance(
+            index,
+            int,
+        ):
+            index = self._resolve_subtree(root, index)
+
+        target = self._resolve_subtree(root, source[1])
+        if index > len(target):
+            return source
+        
+        return target[index]
+    
+    def _resolve_tree_to_json(
+        self,
+        root: CommentedMap,
+        source: CommentedSeq | CommentedMap | TaggedScalar,
+    ):
+        
+        stack: list[tuple[CommentedMap | CommentedSeq | None, Any | None, Any]] = [(None, None, source)]
+
+        while stack:
+            parent, accessor, node = stack.pop()
+            if isinstance(node, TaggedScalar):
+                # Replace in parent
+                if parent is not None and (
+                    resolved := self._resolve_tagged(root, node)
+                ):
+                    parent[accessor] = resolved
+
+            elif isinstance(node, CommentedMap):
+                if isinstance(node.tag, Tag) and node.tag.value is not None and parent and (
+                    resolved_node := self._resolve_tagged(root, node)
+                ) and node != source:
+                    parent[accessor] = resolved_node
+
+                elif isinstance(node.tag, Tag) and node.tag.value is not None and node != source:
+                    node = self._resolve_tagged(root, node)
+                    for k in reversed(list(node.keys())):
+                        stack.append((node, k, node[k]))
+
+                    source = node
+                
+                else:
+                    # Push children (keys) in reverse for DFS order
+                    for k in reversed(list(node.keys())):
+                        stack.append((node, k, node[k]))
+
+            elif isinstance(node, CommentedSeq):
+                if isinstance(node.tag, Tag) and node.tag.value is not None and parent and (
+                    resolved_node := self._resolve_tagged(root, node)
+                )  and node != source :
+                    parent[accessor] = resolved_node
+
+                elif isinstance(node.tag, Tag) and node.tag.value is not None and node != source:
+                    node = self._resolve_tagged(root, node)
+                    for idx, val in enumerate(reversed(node)):
+                        stack.append((node, idx, val))
+
+                    source = node
+                
+                else:
+                    # Process indices in reverse order for proper DFS
+                    for idx, val in enumerate(reversed(node)):
+                        stack.append((node, idx, val))
+        
+        return json.dumps(source)
+
+    def _resolve_subtree(
+        self,
+        root: CommentedMap,
+        source: CommentedSeq
+    ) -> Any:
+        """
+        Iterative DFS over a ruamel.yaml tree.
+        - CommentedMap/CommentedSeq are traversed.
+        """
+        stack: list[tuple[CommentedMap | CommentedSeq | None, Any | None, Any]] = [(None, None, source)]
+
+        while stack:
+            parent, accessor, node = stack.pop()
+            if isinstance(node, TaggedScalar):
+                # Replace in parent
+                if parent is not None and (
+                    resolved := self._resolve_tagged(root, node)
+                ):
+                    parent[accessor] = resolved
+
+            elif isinstance(node, CommentedMap):
+                if isinstance(node.tag, Tag) and node.tag.value is not None and parent and (
+                    resolved_node := self._resolve_tagged(root, node)
+                ):
+                    parent[accessor] = resolved_node
+
+                elif isinstance(node.tag, Tag) and node.tag.value is not None:
+                    node = self._resolve_tagged(root, node)
+                    for k in reversed(list(node.keys())):
+                        stack.append((node, k, node[k]))
+
+                    source = node
+                
+                else:
+                    # Push children (keys) in reverse for DFS order
+                    for k in reversed(list(node.keys())):
+                        stack.append((node, k, node[k]))
+
+            elif isinstance(node, CommentedSeq):
+                if isinstance(node.tag, Tag) and node.tag.value is not None and parent and (
+                    resolved_node := self._resolve_tagged(root, node)
+                ):
+                    parent[accessor] = resolved_node
+
+                elif isinstance(node.tag, Tag) and node.tag.value is not None:
+                    node = self._resolve_tagged(root, node)
+                    for idx, val in enumerate(reversed(node)):
+                        stack.append((node, idx, val))
+
+                    source = node
+                
+                else:
+                    # Process indices in reverse order for proper DFS
+                    for idx, val in enumerate(reversed(node)):
+                        stack.append((node, idx, val))
+        
+        return source
+    
+    def _longest_path(
+        self,
+        root: CommentedMap,
+        source: TaggedScalar | CommentedMap | CommentedSeq
+    ):
+        """
+        Return the longest path from `node` to any leaf as a list of strings.
+        - Map keys are appended as strings.
+        - Sequence indices are appended as strings.
+        - TaggedScalar and other scalars are leafs.
+        """
+        stack = [(source, [])]
+        longest: list[str] = []
+
+        while stack:
+            current, path = stack.pop()
+
+            if isinstance(current, CommentedMap):
+                if not current:
+                    if len(path) > len(longest):
+                        longest = path
+                else:
+
+                    if isinstance(current.tag, Tag) and current.tag.value is not None and (
+                        current != source
+                    ):
+                        resolved_node = self._resolve_tagged(root, current)
+                        stack.append((resolved_node, path))
+
+                    else:
+                        # Iterate in normal order; push in reverse to keep DFS intuitive
+                        keys = list(current.keys())
+                        for k in reversed(keys):
+                            stack.append((current[k], path + [str(k)]))
+
+            elif isinstance(current, CommentedSeq):
+                if not current:
+                    if len(path) > len(longest):
+                        longest = path
+                else:
+                    if isinstance(current.tag, Tag) and current.tag.value is not None and (
+                        current != source
+                    ):
+                        resolved_node = self._resolve_tagged(root, current)
+                        stack.append((resolved_node, path))
+
+                    else:
+                        for idx in reversed(range(len(current))):
+                            stack.append((current[idx], path + [str(idx)]))
+
+            else:
+                # Scalar (incl. TaggedScalar) -> leaf
+                if len(path) > len(longest):
+                    longest = path
+
+        return longest
+
+    def _assemble_mappings(self, mappings: dict[str, str]):
+        for mapping, value in mappings.items():
+            if (
+                map_data := self._mappings.get(mapping)
+            ) and (
+                selected := map_data.get(value)
+            ):
+                self._selected_mappings[mapping] = selected
+
+    def _process_attributes(
+        self,
+        attributes: dict[str, Any],
+    ):
+        return {
+            key: self._process_python_structure(value)
+            for key, value in attributes.items()
+        }
+
+    def _process_python_structure(
+        self,
+        obj: Any
+    ) -> Any:
+        """
+        Convert arbitrarily nested Python data (dict/list/scalars) into ruamel.yaml
+        CommentedMap/CommentedSeq equivalents using iterative DFS. Scalars are returned as-is.
+        """
+        # Fast path for scalars
+        if not isinstance(obj, (dict, list)):
+            return obj
+
+        # Create root container
+        if isinstance(obj, dict):
+            root_out: Any = CommentedMap()
+            work: list[tuple[Any, CommentedMap | CommentedSeq | None, Any | None]] = [(obj, None, None)]
+        else:
+            root_out = CommentedSeq()
+            work = [(obj, None, None)]
+
+       
+
+        # Map from input container id to output container to avoid recreating
+        created: dict[int, CommentedMap | CommentedSeq] = {id(obj): root_out}
+
+
+        while work:
+            in_node, out_parent, out_key = work.pop()
+
+            if isinstance(in_node, dict):
+                out_container = created.get(id(in_node))
+                if out_container is None:
+                    out_container = CommentedMap()
+                    created[id(in_node)] = out_container
+                    assign(out_parent, out_key, out_container)
+                else:
+                    # Root case: already created and assigned
+                    assign(out_parent, out_key, out_container)
+
+                # Push children in reverse to process first child next (DFS)
+                items = list(in_node.items())
+                for k, v in reversed(items):
+                    if isinstance(v, (dict, list)):
+                        # Create child container placeholder now for correct parent linkage
+                        child_container = CommentedMap() if isinstance(v, dict) else CommentedSeq()
+                        created[id(v)] = child_container
+                        work.append((v, out_container, k))
+                    else:
+                        # Scalar, assign directly
+                        out_container[k] = v
+
+            elif isinstance(in_node, list):
+                out_container = created.get(id(in_node))
+                if out_container is None:
+                    out_container = CommentedSeq()
+                    created[id(in_node)] = out_container
+                    assign(out_parent, out_key, out_container)
+                else:
+                    assign(out_parent, out_key, out_container)
+
+                # Push children in reverse order
+                for idx in reversed(range(len(in_node))):
+                    v = in_node[idx]
+                    if isinstance(v, (dict, list)):
+                        child_container = CommentedMap() if isinstance(v, dict) else CommentedSeq()
+                        created[id(v)] = child_container
+                        work.append((v, out_container, idx))
+                    else:
+                        out_container.append(v)
+
+            else:
+                # Scalar node
+                assign(out_parent, out_key, in_node)
+
+        return root_out
+
+    def _resolve_template_string(self, template: str):
+
+        variables: list[tuple[str, str]] = []
+        for match in self._sub_pattern.finditer(template):
+            variables.append((
+                match.group(0),
+                self._sub_inner_text_pattern.sub('', match.group(0)),
+            ))
+
+        return variables
+
+    def _resolve_sub_ref_queries(
+        self,
+        variables: list[tuple[str, str]],
+        source_string: str,
+    ):
+        for variable, accessor in variables:
+            if val := self._references.get(accessor):
+                source_string = source_string.replace(variable, val)
+
+        return source_string

cfn_check-0.5.1/cfn_check/rendering/utils.py

@@ -0,0 +1,13 @@
+from typing import Any
+from ruamel.yaml.comments import CommentedMap, CommentedSeq
+
+
+def assign(parent: CommentedMap | CommentedSeq | None, key_or_index: Any, value: Any):
+    if parent is None:
+        return  # root already set
+    if isinstance(parent, CommentedMap):
+        parent[key_or_index] = value
+    else:
+        # key_or_index is an int for sequences
+        # Ensure sequence large enough (iterative approach assigns in order, so append is fine)
+        parent.append(value)

{cfn_check-0.4.0 → cfn_check-0.5.1}/cfn_check.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cfn-check
-Version: 0.4.0
+Version: 0.5.1
 Summary: Validate Cloud Formation
 Author-email: Ada Lundhe <adalundhe@lundhe.audio>
 License: MIT License

{cfn_check-0.4.0 → cfn_check-0.5.1}/cfn_check.egg-info/SOURCES.txt

@@ -25,18 +25,18 @@ cfn_check/evaluation/parsing/__init__.py
 cfn_check/evaluation/parsing/query_parser.py
 cfn_check/evaluation/parsing/token.py
 cfn_check/evaluation/parsing/token_type.py
-cfn_check/loader/__init__.py
-cfn_check/loader/loader.py
 cfn_check/logging/__init__.py
 cfn_check/logging/models.py
 cfn_check/rendering/__init__.py
 cfn_check/rendering/renderer.py
+cfn_check/rendering/utils.py
 cfn_check/rules/__init__.py
 cfn_check/rules/rule.py
 cfn_check/shared/__init__.py
 cfn_check/shared/types.py
 cfn_check/validation/__init__.py
 cfn_check/validation/validator.py
+example/multitag.py
 example/pydantic_rules.py
 example/renderer_test.py
 example/rules.py

cfn_check-0.5.1/example/multitag.py

@@ -0,0 +1,21 @@
+import ruamel.yaml
+import sys
+
+class MultiTaggedObject:
+    def __init__(self, value, tags):
+        self.value = value
+        self.tags = tags
+
+def represent_multi_tagged_object(dumper, data):
+    return dumper.represent_mapping('!MultiTagged', {'value': data.value, 'tags': data.tags})
+
+def construct_multi_tagged_object(constructor, node):
+    mapping = constructor.construct_mapping(node)
+    return MultiTaggedObject(mapping['value'], mapping['tags'])
+
+yaml = ruamel.yaml.YAML()
+yaml.register_class(MultiTaggedObject)
+
+# Example usage:
+data = MultiTaggedObject("some_value", ["tag1", "tag2"])
+yaml.dump({'item': data}, sys.stdout)

{cfn_check-0.4.0 → cfn_check-0.5.1}/example/renderer_test.py

@@ -1,5 +1,5 @@
 import yaml
-from cfn_check.render import Renderer
+from cfn_check.rendering import Renderer
 from cfn_check.cli.utils.files import open_template, Loader, create_tag
 def test():
 

{cfn_check-0.4.0 → cfn_check-0.5.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cfn-check"
-version = "0.4.0"
+version = "0.5.1"
 requires-python = ">=3.12"
 description = "Validate Cloud Formation"
 readme = "README.md"

cfn_check-0.4.0/cfn_check/loader/loader.py

@@ -1,21 +0,0 @@
-import yaml
-import pathlib
-
-
-class Loader(yaml.SafeLoader):
-    pass
-
-def create_tag(tag):
-    def constructor(loader: Loader, node):
-        if isinstance(node, yaml.ScalarNode):
-            return node.value
-        elif isinstance(node, yaml.SequenceNode):
-            return loader.construct_sequence(node)
-        elif isinstance(node, yaml.MappingNode):
-            return loader.construct_mapping(node)
-    return constructor
-
-
-def find_templates(path, file_pattern):
-    return list(pathlib.Path(path).rglob(file_pattern))
-

cfn_check-0.4.0/cfn_check/rendering/renderer.py

@@ -1,124 +0,0 @@
-import re
-from collections import deque
-
-from cfn_check.shared.types import (
-    Data,
-    Items,
-    YamlObject,
-)
-
-
-class Renderer:
-
-    def __init__(self):
-        self.parameter_defaults: dict[str, str | int | float | bool | None] = {}
-        self.items: Items = deque()
-        self._ref_pattern = re.compile(r'^!Ref\s+')
-        self._visited: list[str | int] = []
-        self._data: YamlObject = {}
-        self._mappings: dict[str, dict[str, YamlObject]] = {}
-        self._selected_mappings: dict[str, YamlObject] = {}
-        self._inputs: dict[str, str] = {}
-
-    def render(
-        self,
-        resources: YamlObject,
-        selected_mappings: dict[str, str] | None = None,
-    ):
-        data = resources.get("Resources", {})
-        self.items.clear()
-        self.items.append(data)
-
-        self._assemble_parameters(resources)
-
-        self._mappings = resources.get('Mappings', {})
-
-        if selected_mappings:
-            self._assemble_mappings(selected_mappings)
-
-        while len(self.items) > 0:
-            item = self.items.pop()
-
-            if isinstance(item, list):
-                self._visited.append((None, item))
-                self.items.extend([
-                    (idx, val) for idx, val in enumerate(item)
-                ])
-
-            elif isinstance(item, dict):
-                self._visited.append((None, item))
-                self.items.extend(list(item.items()))
-
-            elif isinstance(item, tuple):
-                key, value = item
-                self._parse_kv_pair(key, value)
-
-        last_item = data
-        validator = dict(resources)
-        validator_data = validator.get("Resources", {})
-        for key, value in self._visited:
-
-            if isinstance(value, str) and (
-                _ := self._selected_mappings.get(value)
-            ):
-                pass
-            
-            if isinstance(key, str) and isinstance(last_item, dict) and key in validator_data:
-                last_item[key] = value
-
-            elif isinstance(key, int) and isinstance(last_item, list) and (
-                value in validator_data or self.parameter_defaults.get(validator_data[key]) is not None
-            ):
-                last_item[key] = value
-
-            if key and isinstance(value, (dict, list)):
-                last_item = value
-                validator_data = value
- 
-  
-        return resources
-
-    def _parse_kv_pair(self, key: str | int, value: Data):
-
-        if isinstance(value, list):
-            self.items.extend([
-                (idx, val) for idx, val in enumerate(value)
-            ])
-
-        elif isinstance(value, dict):
-            self.items.extend(list(value.items()))
-
-        else:
-            key, value = self._parse_value(key, value)
-
-        self._visited.append((key, value))
-
-
-    def _parse_value(self, key: str | int, value: str | int | float | bool):
-        
-        if val := self.parameter_defaults.get(key):
-            value = val
-
-        elif val := self.parameter_defaults.get(value):
-            value = val
-
-        return key, value
-    
-    def _assemble_parameters(self, resources: YamlObject):
-        params: dict[str, Data] = resources.get("Parameters", {})
-        for param_name, param in params.items():
-            if default := param.get("Default"):
-                self.parameter_defaults[param_name] = default
-
-
-    def _assemble_mappings(
-        self,
-        selected_keys: dict[str, str]
-    ):
-        for key, value in selected_keys.items():
-            if (
-                mapping := self._mappings.get(key)
-            ) and (
-                selected := mapping.get(value)
-            ):
-                self._selected_mappings[key] = selected