cfn-check 0.1.1__py3-none-any.whl

cfn_check/__init__.py

@@ -0,0 +1,2 @@
+from .rules.rules import Rules as Rules
+from .rules.rule import Rule as Rule

cfn_check/cli/root.py

@@ -0,0 +1,72 @@
+import asyncio
+import sys
+
+from cocoa.cli import CLI, CLIStyle
+from cocoa.ui.config.mode import TerminalMode
+from cocoa.ui.components.terminal import Section, SectionConfig
+from cocoa.ui.components.header import Header, HeaderConfig
+from cocoa.ui.components.terminal import Terminal, EngineConfig
+
+from .validate import validate
+
+async def create_header(
+    terminal_mode: TerminalMode = "full", 
+):
+    
+    cfn_check_terminal_mode = "extended"
+    if terminal_mode == "ci":
+        cfn_check_terminal_mode = "compatability"
+
+    header = Section(
+        SectionConfig(height="xx-small", width="large"),
+        components=[
+            Header(
+                "header",
+                HeaderConfig(
+                    header_text="cfn-check",
+                    color="indian_red_3",
+                    attributes=["bold"],
+                    terminal_mode=cfn_check_terminal_mode,
+                    font='cyberpunk'
+                ),
+            ),
+        ],
+    )
+
+    terminal = Terminal(
+        [
+            header,
+        ],
+        config=EngineConfig(
+            max_height=40,
+            max_width=120
+        )
+    )
+
+    return await terminal.render_once()
+
+
+
+@CLI.root(  
+    validate,
+    global_styles=CLIStyle(
+        header=create_header,
+        flag_description_color="white",
+        error_color="indian_red_3",
+        error_attributes=["italic"],
+        flag_color="indian_red_3",
+        text_color="slate_blue_2",
+        subcommand_color="slate_blue_2",
+        indentation=5,
+        terminal_mode="extended",
+    ),
+)
+async def cfn_check():
+    '''
+    Check and test CloudFormation
+    '''
+
+
+
+def run():
+    asyncio.run(CLI.run(sys.argv[1:]))

cfn_check/cli/utils/attributes.py

@@ -0,0 +1,12 @@
+from cfn_check.rules.rules import Rules
+from cfn_check.validation.validator import Validator
+
+
+def bind(
+    rule_set: Rules,
+    validation: Validator
+):
+    validation.func = validation.func.__get__(rule_set, rule_set.__class__)
+    setattr(rule_set, validation.func.__name__, validation.func)
+
+    return validation

cfn_check/cli/utils/files.py

@@ -0,0 +1,68 @@
+
+import asyncio
+import os
+import yaml
+from cfn_check.loader.loader import (
+    Loader,
+    create_tag,
+    find_templates,
+)
+from cfn_check.shared.types import YamlObject, Data
+
+def open_template(path: str) -> YamlObject | Exception:
+    try:
+        with open(path, 'r') as f:
+            return yaml.load(f, Loader=Loader)
+    except (Exception, ) as e:
+        raise e
+    
+def is_file(path: str) -> bool:
+    return os.path.isdir(path) is False
+
+
+async def load_templates(
+    path: str,
+    tags: list[str],
+    file_pattern: str | None = None,
+):
+    loop = asyncio.get_event_loop()
+
+    if await loop.run_in_executor(
+        None,
+        is_file,
+        path,
+    ) or file_pattern is None:
+        template_filepaths = [
+            path,
+        ]
+
+    elif file_pattern:
+
+        template_filepaths = await loop.run_in_executor(
+            None,
+            find_templates,
+            path,
+            file_pattern,
+        )
+
+    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[Data]  = await asyncio.gather(*[
+        loop.run_in_executor(
+            None,
+            open_template,
+            template_path,
+        ) for template_path in template_filepaths
+    ])
+
+    return templates

cfn_check/cli/validate.py

@@ -0,0 +1,81 @@
+import inspect
+
+from async_logging import LogLevelName, Logger, LoggingConfig
+from cocoa.cli import CLI, ImportType
+
+from cfn_check.cli.utils.attributes import bind
+from cfn_check.cli.utils.files import load_templates
+from cfn_check.evaluation.validate import run_validations
+from cfn_check.logging.models import InfoLog
+from cfn_check.rules.rules import Rules
+from cfn_check.validation.validator import Validator
+
+
+@CLI.command()
+async def validate(
+    path: str,
+    file_pattern: str | None = None,
+    rules: ImportType[Rules] = None,
+    tags: list[str] = [
+        'Ref',
+        'Sub',
+        'Join',
+        'Select',
+        'Split',
+        'GetAtt',
+        'GetAZs',
+        'ImportValue',
+        'Equals',
+        'If',
+        'Not',
+        'And',
+        'Or',
+        'Condition',
+        'FindInMap',
+    ],
+    log_level: LogLevelName = 'info',
+):
+    '''
+    Validate Cloud Foundation
+    
+    @param rules Path to a file containing Rules
+    @param file_pattern A string pattern used to find template files
+    @param tags List of CloudFormation intrinsic function tags
+    @param log_level The log level to use
+    '''
+
+    logging_config = LoggingConfig()
+    logging_config.update(
+        log_level=log_level,
+        log_output='stderr',
+    )
+
+    logger = Logger()
+
+    templates = await load_templates(
+        path,
+        tags,
+        file_pattern=file_pattern,
+    )
+
+    validations: list[Validator] = [ 
+        bind(
+            rule,
+            validation,
+        )
+        for rule in rules.data.values()
+        for _, validation in inspect.getmembers(rule)
+        if isinstance(validation, Validator)
+    ]
+    
+    if validation_error := run_validations(
+        templates,
+        validations,
+    ):
+        raise validation_error
+    
+    checks_passed = len(validations)
+    templates_evaluated = len(templates)
+    
+    await logger.log(InfoLog(message=f'✅ {checks_passed} validations met for {templates_evaluated} templates'))
+    

cfn_check/evaluation/check.py

@@ -0,0 +1,20 @@
+from typing import TypeVar
+
+from pydantic import ValidationError
+
+from cfn_check.validation.validator import Validator
+from cfn_check.shared.types import (
+    YamlList,
+    YamlObject,
+    YamlValueBase,
+)
+
+T = TypeVar("T")
+
+
+def check(
+    matched: YamlList | YamlObject | YamlValueBase,
+    assertion: Validator[T],
+) ->  Exception | ValidationError | None:
+    if err := assertion(matched):
+        return err

cfn_check/evaluation/errors.py

@@ -0,0 +1,33 @@
+import textwrap
+from pydantic import ValidationError
+from cfn_check.rules.rule import Validator
+
+
+def assemble_validation_error(
+    errors: list[
+        tuple[
+            Validator,
+            Exception | ValidationError,
+        ],
+    ],
+) -> Exception:
+    validation_error: Exception | None = None
+    if len(errors) > 0:
+
+        error_message = textwrap.indent(
+            '\n'.join([
+                (
+                    f'Rule: {validator.name} failed\n'
+                    f'Query: {validator.query}\n'
+                    f'{str(err)}\n'
+                )
+                for validator, err in errors
+            ]),
+            '\t',
+        )
+
+        validation_error = Exception(
+            f'\n{error_message}',
+        )
+
+    return validation_error

cfn_check/evaluation/search.py

@@ -0,0 +1,137 @@
+import re
+from collections import deque
+from typing import Deque
+from cfn_check.shared.types import (
+    Data,
+    Items,
+    YamlList,
+    YamlObject,
+    YamlValueBase,
+)
+
+
+numbers_pattern = re.compile(r'\d+')
+
+def search(
+    resources: YamlObject,
+    path: str,
+):
+    items: Items = deque()
+    items.append(resources)
+
+    segments = path.split("::")[::-1]
+    # Queries can be multi-segment,
+    # so we effectively perform per-segment
+    # repeated DFS searches, returning the matches
+    # for each segment
+
+    composite_keys: list[str] = []
+
+    while len(segments):
+        query = segments.pop()
+        items, keys = search_with_query(items, query)
+
+        if len(composite_keys) == 0:
+            composite_keys.extend(keys)
+
+        else:
+            updated_keys: list[str] = []
+            for composite_key in composite_keys:
+                while len(keys):
+                    key = keys.pop()
+
+                    updated_keys.append(f'{composite_key}.{key}')
+
+            composite_keys = updated_keys
+
+    results: list[tuple[str, Data]] = []
+    for idx, item in enumerate(list(items)):
+        results.append((
+            composite_keys[idx],
+            item,
+        ))
+
+    return results
+
+
+def parse_list_query(query: str):
+    
+    queries = query.strip('[]').split(',')
+
+    if len(queries) < 1:
+        return None
+    
+    indexes = []
+    for query in queries:
+
+        if match := numbers_pattern.match(query):
+            indexes.append(
+                int(match.group(0))
+            )
+    
+    return indexes
+
+
+def parse_list_matches(
+    query: str,
+    node: YamlList,
+):
+    if indexes := parse_list_query(query):
+        return [
+            item
+            for idx, item in enumerate(node)
+            if idx in indexes
+        ]
+
+    return [
+        str(idx) for idx in indexes
+    ], node
+
+
+def search_with_query(
+    items: Items,
+    query: str,
+) -> tuple[Items, Deque[str]]:
+    
+    found: Items = deque()
+
+    keys: Deque[str] = deque()
+    
+    while len(items):
+        node = items.pop()
+
+        key: (
+            str | None
+        ) = None
+        value: (
+            YamlValueBase | YamlList | YamlObject | None
+        ) = None
+
+        if isinstance(node, dict):
+            items.extend(node.items())
+
+        elif query.startswith('[') and query.startswith(']'):
+            indexes, matched = parse_list_matches(query, node)
+            keys.extend(indexes)
+            found.extend(matched)
+ 
+        elif isinstance(node, list):
+            items.extend(node)
+
+        elif isinstance(node, tuple): 
+            key, value = node
+
+        else:
+            # If we encounter just
+            # a raw YAML int/bool/etc
+            # then we should just
+            # skip to the next iteration
+            continue
+
+        if (
+            key == query or query == "*"
+        ) and value:
+            keys.append(key)
+            found.append(value)
+        
+    return found, keys

cfn_check/evaluation/validate.py

@@ -0,0 +1,51 @@
+from pydantic import ValidationError
+
+from cfn_check.validation.validator import Validator
+from .check import check
+from .errors import assemble_validation_error
+from .search import search
+
+def run_validations(
+    templates: list[str],
+    validators: list[Validator],
+):
+    errors: list[Exception | ValidationError] = []
+
+    for template in templates:
+        for validator in validators:
+            if errs := run_validation(
+                validator,
+                template,
+            ):
+                errors.extend([
+                    (
+                        validator,
+                        err
+                    ) for err in errs
+                ])
+
+    if validation_error := assemble_validation_error(errors):
+        return validation_error 
+
+
+def run_validation(
+    validator: Validator,
+    template: str,
+):
+    found = search(template, validator.query)
+
+    assert len(found) > 0, "❌ No results matching rule"
+
+    errors: list[Exception | ValidationError] = []
+
+
+    for matched in found:
+        if err := check(
+            matched,
+            validator,
+        ):
+            errors.append(err)
+
+    if len(errors) > 0:
+        return errors
+    

cfn_check/loader/loader.py

@@ -0,0 +1,21 @@
+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/logging/models.py

@@ -0,0 +1,20 @@
+from async_logging import Entry, LogLevel
+
+
+class DebugLog(Entry, kw_only=True):
+    level: LogLevel = LogLevel.DEBUG
+
+class InfoLog(Entry, kw_only=True):
+    level: LogLevel = LogLevel.INFO
+
+class ErrorLog(Entry, kw_only=True):
+    error: str | bytes
+    level: LogLevel = LogLevel.ERROR
+
+class FatalLog(Entry, kw_only=True):
+    error: str | bytes
+    level: LogLevel = LogLevel.FATAL
+
+class CriticalLog(Entry, kw_only=True):
+    error: str | bytes
+    level: LogLevel = LogLevel.CRITICAL

cfn_check/rules/rule.py

@@ -0,0 +1,25 @@
+from typing import TypeVar
+from pydantic import BaseModel, JsonValue
+from typing import Callable
+from cfn_check.validation.validator import Validator
+
+
+T = TypeVar("T", bound= JsonValue | BaseModel)
+
+
+class Rule:
+
+    def __init__(
+        self,
+        query: str,
+        name: str,
+    ):
+        self.query = query
+        self.name = name
+
+    def __call__(self, func: Callable[[T], None]):
+        return Validator[T](
+            func,
+            self.query,
+            self.name,
+        )

cfn_check/rules/rules.py

@@ -0,0 +1,2 @@
+class Rules:
+    pass

cfn_check/shared/types.py

@@ -0,0 +1,17 @@
+from typing import Deque
+
+
+YamlValueBase = str | bool | int | float | None
+YamlObjectBase = dict[str, YamlValueBase]
+YamlListBase = dict[YamlValueBase]
+YamlObject = dict[str, YamlValueBase | YamlListBase | YamlObjectBase]
+YamlList = list[YamlValueBase | YamlObjectBase | YamlObject]
+
+Data = YamlList | YamlObject | YamlValueBase
+
+Items = Deque[
+    YamlObject | YamlList | tuple[
+        str,
+        Data
+    ]
+]

cfn_check/validation/validator.py

@@ -0,0 +1,47 @@
+from typing import TypeVar, Generic
+from pydantic import BaseModel, ValidationError, JsonValue
+from typing import Callable, get_type_hints
+
+from cfn_check.shared.types import Data
+
+
+T = TypeVar("T", bound= JsonValue | BaseModel)
+
+
+class Validator(Generic[T]):
+    def __init__(
+        self,
+        func: Callable[[T], None],
+        query: str,
+        name: str,
+    ):
+        self.func = func
+        self.query = query
+        self.name = name
+
+        self.model: BaseModel | None = None
+
+        for _, param in get_type_hints(
+            self.func,
+        ).items():
+            if param in BaseModel.__subclasses__():
+                self.model = param
+
+    def __call__(self, arg: tuple[str, Data]):
+
+        try:
+            path, item = arg
+            if self.model and isinstance(item, dict):
+                arg = self.model(**item)
+
+            return self.func(item)
+        
+        except ValidationError as err:
+            return Exception(
+                f'Path: {path}\n❌ Validation Error: {str(err)}'
+            )
+        
+        except Exception as err:
+            return Exception(
+                f'Path: {path}\nError: {str(err)}'
+            )

cfn_check-0.1.1.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.4
+Name: cfn-check
+Version: 0.1.1
+Summary: Validate Cloud Formation
+Author-email: Ada Lundhe <adalundhe@lundhe.audio>
+License: MIT License
+        
+        Copyright (c) 2025 Ada Lündhé
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/adalundhe/cfn-check
+Keywords: cloud-formation,testing,aws,cli
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic
+Requires-Dist: pyyaml
+Requires-Dist: hyperlight-cocoa
+Requires-Dist: async-logging
+Dynamic: license-file
+
+# <b>CFN Check</b>
+<b>A tool for checking CloudFormation</b>
+
+[![PyPI version](https://img.shields.io/pypi/v/cfn-check?color=blue)](https://pypi.org/project/cfn-check/)
+[![License](https://img.shields.io/github/license/adalundhe/cfn-check)](https://github.com/adalundhe/cfn-check/blob/main/LICENSE)
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](https://github.com/adalundhe/cfn-check/blob/main/CODE_OF_CONDUCT.md)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cfn-check?color=red)](https://pypi.org/project/cfn-check/)
+
+
+| Package     | Cocoa                                                           |
+| ----------- | -----------                                                     |
+| Version     | 0.1.0                                                           |
+| Download    | https://pypi.org/project/cfn-check/                             | 
+| Source      | https://github.com/adalundhe/cfn-check                          |
+| Keywords    | cloud-formation, testing, aws, cli                              |
+
+
+CFN-Check is a small, fast, friendly tool for validating AWS CloudFormation YAML templates. It is code-driven, with 
+rules written as simple, `Rule` decorator wrapped python class methods for `Rules`-inheriting classes.
+
+<br/>
+
+# Why CFN-Check?
+
+AWS has its own tools for validating Cloud Formation - `cfn-lint` and `cfn-guard`. `cfn-check` aims to solve
+problems inherint to `cfn-lint` more than `cfn-guard`, primarily:
+
+- Confusing, unclear syntax around rules configuration
+- Inability to parse non-resource wildcards
+- Inability to validate non-resource template data
+- Inabillity to use structured models to validate input
+
+In comparison to `cfn-guard`, `cfn-check` is pure Python, thus
+avoiding YADSL (Yet Another DSL) headaches. It also proves
+significantly more configurable/modular/hackable as a result.
+
+CFN-Check uses a combination of simple depth-first-search tree
+parsing, friendly `cfn-lint` like query syntax, `Pydantic` models,
+and `pytest`-like assert-driven checks to make validating your
+Cloud Formation easy while offering both CLI and Python API interfaces.
+
+<br/>
+
+# Getting Started
+
+`cfn-check` requires:
+
+- `Python 3.12`
+- Any number of valid CloudFormation templates or a path to said templates.
+- A `.py` file containing at least one `Rules` class with at least one valid `@Rule()` decorated method
+
+To get started (we recommend using `uv`), run:
+
+```bash
+uv venv
+source .venv/bin/activate
+
+uv pip install cfn-check
+
+touch rules.py
+touch template.yaml
+```
+
+Next open the `rules.py` file and create a basic Python class
+as below.
+
+```python
+from cfn_check import Rules, Rule
+
+
+class ValidateResourceType(Rules):
+
+    @Rule(
+        "Resources::*::Type",
+        "It checks Resource::Type is correctly definined",
+    )
+    def validate_test(self, value: str): 
+        assert value is not None, '❌ Resource Type not defined'
+        assert isinstance(value, str), '❌ Resource Type not a string'
+```
+
+This provides us a basic rule set that validates that the `Type` field of our CloudFormation template(s) exists and is the correct data type.
+
+> [!NOTE]
+> Don't worry about adding an `__init__()` method to this class!
+
+Next open the `template.yaml` file and paste the following CloudFormation:
+
+```yaml
+AWSTemplateFormatVersion: '2010-09-09'
+Parameters:
+  ExistingSecurityGroups:
+    Type: List<AWS::EC2::SecurityGroup::Id>
+  ExistingVPC:
+    Type: AWS::EC2::VPC::Id
+    Description: The VPC ID that includes the security groups in the ExistingSecurityGroups parameter.
+  InstanceType:
+    Type: String
+    Default: t2.micro
+    AllowedValues:
+      - t2.micro
+      - m1.small
+Mappings:
+  AWSInstanceType2Arch:
+    t2.micro:
+      Arch: HVM64
+    m1.small:
+      Arch: HVM64
+  AWSRegionArch2AMI:
+    us-east-1:
+      HVM64: ami-0ff8a91507f77f867
+      HVMG2: ami-0a584ac55a7631c0c
+Resources:
+  SecurityGroup:
+    Type: AWS::EC2::SecurityGroup
+    Properties:
+      GroupDescription: Allow HTTP traffic to the host
+      VpcId: !Ref ExistingVPC
+      SecurityGroupIngress:
+        - IpProtocol: tcp
+          FromPort: 80
+          ToPort: 80
+          CidrIp: 0.0.0.0/0
+      SecurityGroupEgress:
+        - IpProtocol: tcp
+          FromPort: 80
+          ToPort: 80
+          CidrIp: 0.0.0.0/0
+  AllSecurityGroups:
+    Type: Custom::Split
+    Properties:
+      ServiceToken: !GetAtt AppendItemToListFunction.Arn
+      List: !Ref ExistingSecurityGroups
+      AppendedItem: !Ref SecurityGroup
+  AppendItemToListFunction:
+    Type: AWS::Lambda::Function
+    Properties:
+      Handler: index.handler
+      Role: !GetAtt LambdaExecutionRole.Arn
+      Code:
+        ZipFile: !Join
+          - ''
+          - - var response = require('cfn-response');
+            - exports.handler = function(event, context) {
+            - '   var responseData = {Value: event.ResourceProperties.List};'
+            - '   responseData.Value.push(event.ResourceProperties.AppendedItem);'
+            - '   response.send(event, context, response.SUCCESS, responseData);'
+            - '};'
+      Runtime: nodejs20.x
+  MyEC2Instance:
+    Type: AWS::EC2::Instance
+    Properties:
+      ImageId: !FindInMap
+        - AWSRegionArch2AMI
+        - !Ref AWS::Region
+        - !FindInMap
+          - AWSInstanceType2Arch
+          - !Ref InstanceType
+          - Arch
+      SecurityGroupIds: !GetAtt AllSecurityGroups.Value
+      InstanceType: !Ref InstanceType
+  LambdaExecutionRole:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Version: '2012-10-17'
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service:
+                - lambda.amazonaws.com
+            Action:
+              - sts:AssumeRole
+      Path: /
+      Policies:
+        - PolicyName: root
+          PolicyDocument:
+            Version: '2012-10-17'
+            Statement:
+              - Effect: Allow
+                Action:
+                  - logs:*
+                Resource: arn:aws:logs:*:*:*
+Outputs:
+  AllSecurityGroups:
+    Description: Security Groups that are associated with the EC2 instance
+    Value: !Join
+      - ', '
+      - !GetAtt AllSecurityGroups.Value
+```
+
+This represents a basic configuration for an AWS Lambda function.
+
+Finally, run:
+
+```bash
+cfn-lint validate -r rules.py template.yaml
+```
+
+which outputs:
+
+```
+2025-09-17T01:46:41.542078+00:00 - INFO - 19783474 - /Users/adalundhe/Documents/Duckbill/cfn-check/cfn_check/cli/validate.py:validate.80 - ✅ 1 validations met for 1 templates
+```
+
+Congrats! You've just made the cloud a bit better place!

cfn_check-0.1.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+cfn_check/__init__.py,sha256=k1-xUfaN07znTID-I4uJcP3l1cWG3Fr-hPFoB5NVKHk,76
+cfn_check/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfn_check/cli/root.py,sha256=dHq9zzXyj-Wrj-fzirtFjptShzWbBGsO3n9tspm-pec,1688
+cfn_check/cli/validate.py,sha256=qUQ-4BFZAfqCh2lc12dkR6EwimXmRJCfw_0cLvOzkK8,1987
+cfn_check/cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfn_check/cli/utils/attributes.py,sha256=zKOZhyWYsU1qcBUqQg8ppbHqrnwPNEcj2FI0eP29gzY,319
+cfn_check/cli/utils/files.py,sha256=W2lf42qAlTOJ-YJeBWsK99FjnsxZtmit241cLyURg2A,1448
+cfn_check/evaluation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfn_check/evaluation/check.py,sha256=5GgoZY0YfyOeOP92VJVH4Y3AYB7jUGjxwsr0qsbVGeo,414
+cfn_check/evaluation/errors.py,sha256=yPJdtRYo67le4yMC9sYqcboCnkqKsJ3KPbSPFY2-Pi8,773
+cfn_check/evaluation/search.py,sha256=WCi4mvvrRQyI3k05ohsFiIM8lKe5K6f3y-YsItu7rK0,2959
+cfn_check/evaluation/validate.py,sha256=sLqtwVqdybCoE9zXfg_u6To22yJSvczxXAu1EKnTNs4,1187
+cfn_check/loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfn_check/loader/loader.py,sha256=7yiDLLW_vNp_8O47erLXjQQtAB47fU3nimb91N5N_R8,532
+cfn_check/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfn_check/logging/models.py,sha256=-tBaK6p8mJ0cO8h2keEJ-VmtFX_VW4XzwAw2PtqbkF0,490
+cfn_check/rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfn_check/rules/rule.py,sha256=r6-eKCUdPaNIena2NDv3J_QlcWes1KLObI9ukRZZz1o,500
+cfn_check/rules/rules.py,sha256=d7VvF6nlXER1puY9lEbQjFQv7RJMmD-wF4RoDCm8mQ0,22
+cfn_check/shared/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfn_check/shared/types.py,sha256=-om3DyZsjK_tJd-I8SITkoE55W0nB2WA3LOc87Cs7xI,414
+cfn_check/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cfn_check/validation/validator.py,sha256=FGPeb8Uc8lvX3Y5rs-fxeJKIOqzUXwXh_gCFcy6d3b0,1182
+cfn_check-0.1.1.dist-info/licenses/LICENSE,sha256=EbCpGNzOkyQ53ig7J2Iwgmy4Og0dgHe8COo3WylhIKk,1069
+example/rules.py,sha256=gEAX52iK76XBdfiilqfqnxh6j8rACp7v7dwbb_EQ-1o,359
+cfn_check-0.1.1.dist-info/METADATA,sha256=26wu7hNXHtzg6hAZer8_lNcNFRM9mJ_R2Ji1JkW-jd4,8447
+cfn_check-0.1.1.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+cfn_check-0.1.1.dist-info/entry_points.txt,sha256=B4lCHoDHmwisABxKgRLShwqqFv7QwwDAFXoAChOnkwg,53
+cfn_check-0.1.1.dist-info/top_level.txt,sha256=hUn9Ya50yY1fpgWxEhG5iMgfMDDVX7qWQnM1xrgZnhM,18
+cfn_check-0.1.1.dist-info/RECORD,,

cfn_check-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cfn_check-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cfn-check = cfn_check.cli.root:run

cfn_check-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ada Lündhé
+
+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.

cfn_check-0.1.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+cfn_check
+example

example/rules.py

@@ -0,0 +1,12 @@
+from cfn_check import Rules, Rule
+
+
+class ValidateResourceTypes(Rules):
+
+    @Rule(
+        "Resources::*::Type",
+        "It checks Resource::Type is correctly definined",
+    )
+    def validate_test(self, value: str): 
+        assert value is not None, '❌ Resource Type not defined'
+        assert isinstance(value, str), '❌ Resource Type not a string'