Create API for just taking a config (#4177)

* Create API for just taking a config

Author: kddejong

src/cfnlint/__init__.py

@@ -5,7 +5,7 @@
 
 import logging
 
-from cfnlint.api import lint, lint_all, lint_file
+from cfnlint.api import lint, lint_all, lint_by_config, lint_file
 from cfnlint.config import ConfigMixIn, ManualArgs
 from cfnlint.rules import Rules
 from cfnlint.template import Template

src/cfnlint/api.py

@@ -127,3 +127,37 @@ def lint_file(
 
     runner = Runner(config_mixin)
     return list(runner.run())
+
+
+def lint_by_config(config: ManualArgs) -> list[Match]:
+    """Validate a template using a Config
+
+    Parameters
+    ----------
+    config : ManualArgs
+        Configuration options for the linter
+
+    Returns
+    -------
+    list
+        a list of errors if any were found, else an empty list
+    """
+
+    config_mixin = ConfigMixIn(**config)
+
+    # Use the centralized validation logic
+    try:
+        config_mixin.validate()
+    except ValueError as e:
+        from cfnlint.rules.errors import ConfigError
+
+        return [
+            Match.create(
+                message=str(e),
+                filename="",
+                rule=ConfigError(),
+            )
+        ]
+
+    runner = Runner(config_mixin)
+    return list(runner.run())

src/cfnlint/config.py

@@ -731,7 +731,6 @@ def _merge_configs(
 
 # pylint: disable=too-many-public-methods
 class ConfigMixIn(TemplateArgs, CliArgs, ConfigFileArgs):
-
     def __init__(self, cli_args: list[str] | None = None, **kwargs: Unpack[ManualArgs]):
         self._manual_args = kwargs or ManualArgs()
         CliArgs.__init__(self, cli_args)
@@ -793,6 +792,68 @@ def __eq__(self, value):
 
         return True
 
+    def validate(self, allow_stdin: bool = False) -> None:
+        """
+        Validate the configuration for logical consistency.
+
+        This method validates configuration constraints that may not be enforced
+        by argparse when using the API directly (vs CLI usage). While the CLI
+        uses argparse mutually exclusive groups to prevent some conflicts, the
+        API bypasses argparse, so this method ensures all constraints are enforced
+        consistently across both usage patterns.
+
+        Args:
+            allow_stdin: If True, allows validation to pass when no templates/deployment
+                        files are specified (for CLI stdin handling)
+
+        Raises:
+            ValueError: When configuration is invalid with a descriptive message
+        """
+        # Get raw configuration values using the same logic as the templates property
+        # For templates, we need to check both templates and template_alt
+        raw_templates = []
+        if "templates" in self._manual_args:
+            raw_templates = self._manual_args["templates"]
+        else:
+            cli_alt_args = self._get_argument_value("template_alt", False, False)
+            cli_args = self._get_argument_value("templates", False, False)
+            if cli_alt_args:
+                raw_templates = cli_alt_args
+            elif cli_args:
+                raw_templates = cli_args
+
+        # Ensure it's a list
+        if isinstance(raw_templates, str):
+            raw_templates = [raw_templates]
+        raw_templates = raw_templates or []
+        raw_deployment_files = (
+            self._get_argument_value("deployment_files", False, False) or []
+        )
+        raw_parameters = self._get_argument_value("parameters", False, False) or {}
+        raw_parameter_files = (
+            self._get_argument_value("parameter_files", False, False) or []
+        )
+
+        # Check if no templates or deployment files are specified
+        if not raw_templates and not raw_deployment_files and not allow_stdin:
+            raise ValueError("No templates or deployment files specified")
+
+        # Check for conflicting deployment files with other options
+        if raw_deployment_files:
+            if raw_templates or raw_parameters or raw_parameter_files:
+                raise ValueError(
+                    "Deployment files cannot be used with templates, parameters, "
+                    "or parameter files"
+                )
+
+        # Check for conflicting parameter options
+        if raw_parameters and raw_parameter_files:
+            raise ValueError("Cannot specify both --parameters and --parameter-files")
+
+        # Check for multiple templates with parameters
+        if (raw_parameters or raw_parameter_files) and len(raw_templates) > 1:
+            raise ValueError("Parameters can only be used with a single template")
+
     def _get_argument_value(self, arg_name, is_template, is_config_file):
         cli_value = getattr(self.cli_args, arg_name)
         template_value = self.template_args.get(arg_name)
@@ -1032,7 +1093,6 @@ def force(self):
         return self._get_argument_value("force", False, False)
 
     def evolve(self, **kwargs: Unpack[ManualArgs]) -> "ConfigMixIn":
-
         config = deepcopy(self)
         config._manual_args.update(kwargs)
         return config

src/cfnlint/rules/jsonschema/Base.py

@@ -10,6 +10,7 @@
 
 from cfnlint.context import Context
 from cfnlint.jsonschema import V, ValidationError, Validator
+from cfnlint.jsonschema.exceptions import _unset
 from cfnlint.rules import CloudFormationLintRule, RuleMatch
 from cfnlint.schema.resolver import RefResolver
 
@@ -33,8 +34,13 @@ def _convert_validation_errors_to_matches(
     ):
         matches = []
         kwargs: dict[Any, Any] = {}
+
+        # Only add validator and instance if they are not unset
+        if e.validator is not _unset:
+            kwargs["validator"] = e.validator
+
         if e.extra_args:
-            kwargs = e.extra_args
+            kwargs.update(e.extra_args)
         e_path = list(path) + list(e.path)
         if len(e.path) > 0:
             e_path_override = e.path_override

src/cfnlint/runner/cli.py

@@ -285,26 +285,22 @@ def cli(self) -> None:
             print(self.rules)
             sys.exit(0)
 
-        if not self.config.templates and not self.config.deployment_files:
-            if sys.stdin.isatty():
-                self.config.parser.print_help()
-                sys.exit(1)
-
-        if self.config.deployment_files:
-            if (
-                self.config.templates
-                or self.config.parameters
-                or self.config.parameter_files
-            ):
-                self.config.parser.print_help()
-                sys.exit(1)
-
-        if self.config.parameters and self.config.parameter_files:
+        # Use centralized configuration validation
+        # For CLI, we allow stdin input when no templates/deployment files are specified
+        try:
+            self.config.validate(allow_stdin=True)
+        except ValueError as e:
+            print(f"Configuration error: {e}")
             self.config.parser.print_help()
             sys.exit(1)
 
-        if self.config.parameters or self.config.parameter_files:
-            if len(self.config.templates) > 1:
+        # Special case: if no templates/deployment files and stdin is a tty, show help
+        raw_templates = self.config._get_argument_value("templates", True, False) or []
+        raw_deployment_files = (
+            self.config._get_argument_value("deployment_files", False, False) or []
+        )
+        if not raw_templates and not raw_deployment_files:
+            if sys.stdin.isatty():
                 self.config.parser.print_help()
                 sys.exit(1)
 

src/cfnlint/runner/deployment_file/deployment_types/git_sync.py

@@ -15,7 +15,7 @@
 
 
 def create_deployment_from_git_sync(
-    data: dict[str, Any]
+    data: dict[str, Any],
 ) -> tuple[DeploymentFileData | None, RuleMatches | None]:
 
     schema = load_resource(cfnlint.data.schemas.other.deployment_files, "git_sync.json")