datacontract-cli 1.1.2__tar.gz → 1.1.3__tar.gz

{datacontract_cli-1.1.2/datacontract_cli.egg-info → datacontract_cli-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacontract-cli
-Version: 1.1.2
+Version: 1.1.3
 Summary: The datacontract CLI is an open source command-line tool for working with Data Contracts. It uses data contract YAML files to lint the data contract, connect to data sources and execute schema and quality tests, detect breaking changes, and export to different formats. The tool is written in Python. It can be used as a standalone CLI tool, in a CI/CD pipeline, or directly as a Python library.
 Author-email: Jochen Christ <jochen.christ@entropy-data.com>, Stefan Negele <stefan.negele@innoq.com>, Simon Harrer <simon.harrer@entropy-data.com>
 License-Expression: MIT
@@ -46,7 +46,7 @@ Requires-Dist: boto3<2.0.0,>=1.34.41
 Requires-Dist: Jinja2<4.0.0,>=3.1.5
 Requires-Dist: jinja_partials<1.0.0,>=0.2.1
 Requires-Dist: datacontract-specification<2.0.0,>=1.2.3
-Requires-Dist: open-data-contract-standard<4.0.0,>=3.1.2
+Requires-Dist: open-data-contract-standard<3.2.0,>=3.1.2
 Requires-Dist: deepdiff<10.0.0,>=6.0.0
 Provides-Extra: avro
 Requires-Dist: avro==1.12.2; extra == "avro"
@@ -138,7 +138,7 @@ Requires-Dist: datacontract-cli[all]; extra == "dev"
 Requires-Dist: httpx==0.28.1; extra == "dev"
 Requires-Dist: kafka-python; extra == "dev"
 Requires-Dist: minio==7.2.20; extra == "dev"
-Requires-Dist: moto==5.2.2; extra == "dev"
+Requires-Dist: moto==5.2.3; extra == "dev"
 Requires-Dist: openapi-spec-validator<0.10,>=0.7; extra == "dev"
 Requires-Dist: pandas>=2.1.0; extra == "dev"
 Requires-Dist: pre-commit<4.7.0,>=3.7.1; extra == "dev"
@@ -148,7 +148,7 @@ Requires-Dist: pytest-xdist; extra == "dev"
 Requires-Dist: pymssql==2.3.13; extra == "dev"
 Requires-Dist: psycopg2-binary<3.0,>=2.9; extra == "dev"
 Requires-Dist: mysql-connector-python<26.8.0,>=8.0.30; extra == "dev"
-Requires-Dist: ruff==0.16.4; extra == "dev"
+Requires-Dist: ruff==0.16.5; extra == "dev"
 Requires-Dist: testcontainers[kafka,minio,mssql,mysql,postgres]==4.15.0; extra == "dev"
 Requires-Dist: trino==0.339.0; extra == "dev"
 Dynamic: license-file
@@ -296,6 +296,9 @@ $ datacontract lint odcs.yaml
 # show a changelog between two data contracts
 $ datacontract changelog v1.odcs.yaml v2.odcs.yaml
 
+# fail when a contract change is backward-incompatible
+$ datacontract breaking v1.odcs.yaml v2.odcs.yaml
+
 # execute schema and quality checks (define credentials as environment variables)
 $ datacontract test odcs.yaml
 

{datacontract_cli-1.1.2 → datacontract_cli-1.1.3}/README.md

@@ -141,6 +141,9 @@ $ datacontract lint odcs.yaml
 # show a changelog between two data contracts
 $ datacontract changelog v1.odcs.yaml v2.odcs.yaml
 
+# fail when a contract change is backward-incompatible
+$ datacontract breaking v1.odcs.yaml v2.odcs.yaml
+
 # execute schema and quality checks (define credentials as environment variables)
 $ datacontract test odcs.yaml
 

{datacontract_cli-1.1.2 → datacontract_cli-1.1.3}/datacontract/api.py

@@ -15,6 +15,7 @@ from pydantic import BaseModel, Field, ValidationError
 
 from datacontract.config import Config, known_env_names
 from datacontract.data_contract import DataContract, ExportFormat
+from datacontract.model.breaking import BreakingChangeEntry
 from datacontract.model.changelog import ChangelogEntry
 from datacontract.model.exceptions import DataContractException, DefinitionResolutionError
 from datacontract.model.run import Check, ResultEnum, Run
@@ -323,6 +324,14 @@ app = FastAPI(
                 "url": "https://docs.datacontract.com/commands/changelog",
             },
         },
+        {
+            "name": "breaking",
+            "description": "Compare two versions of a data contract and grade each change by compatibility impact.",
+            "externalDocs": {
+                "description": "Documentation",
+                "url": "https://docs.datacontract.com/commands/breaking",
+            },
+        },
     ],
 )
 
@@ -881,6 +890,21 @@ class ChangelogResponse(BaseModel):
     )
 
 
+class BreakingChangesResponse(BaseModel):
+    """Every change between two versions of a data contract, each graded `info`, `warning` or `error`."""
+
+    summary: list[BreakingChangeEntry] = Field(
+        description="One entry per changed element, graded by the most severe change. A property whose type and requiredness "
+        "both changed appears once.",
+    )
+    entries: list[BreakingChangeEntry] = Field(
+        description="Every single change with its grade and the old and new value.",
+    )
+    is_breaking: bool = Field(
+        description="Whether any detected change is classified as an error-level breaking change.",
+    )
+
+
 @app.post(
     "/changelog",
     tags=["changelog"],
@@ -935,6 +959,54 @@ async def changelog_endpoint(
         os.unlink(v2_path)
 
 
+@app.post(
+    "/breaking",
+    tags=["breaking"],
+    operation_id="breakingChangesDataContracts",
+    summary="Show compatibility impact between two data contracts.",
+    description="""
+Compare two versions of an ODCS data contract and detect backward-incompatible changes.
+
+`POST` a JSON body with `v1` (before) and `v2` (after) as YAML strings. A contract that cannot be
+parsed is answered with `422`.
+    """,
+    response_description="The breaking changes detected between the two data contracts.",
+    responses={
+        **AUTHENTICATION_RESPONSES,
+        422: {
+            "description": "One of the two data contracts is not valid YAML or not a valid data contract.",
+            "model": UnprocessableEntityResponse,
+            "content": {"application/json": {"example": {"detail": "Invalid YAML: while parsing a block mapping"}}},
+        },
+    },
+)
+def breaking_endpoint(
+    body: ChangelogRequest,
+    api_key: Annotated[str | None, Depends(api_key_header)] = None,
+) -> BreakingChangesResponse:
+    check_api_key(api_key)
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f1:
+        f1.write(body.v1)
+        v1_path = f1.name
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f2:
+        f2.write(body.v2)
+        v2_path = f2.name
+
+    try:
+        result = DataContract(data_contract_file=v1_path).breaking(DataContract(data_contract_file=v2_path))
+        return BreakingChangesResponse(summary=result.summary, entries=result.entries, is_breaking=result.is_breaking)
+    except yaml.YAMLError as e:
+        raise HTTPException(status_code=422, detail=f"Invalid YAML: {e}")
+    except pydantic.ValidationError as e:
+        raise HTTPException(status_code=422, detail=f"Invalid data contract: {e}")
+    except DataContractException as e:
+        raise HTTPException(status_code=422, detail=f"Data Contract Validation Failure: {e}")
+    finally:
+        os.unlink(v1_path)
+        os.unlink(v2_path)
+
+
 @app.post(
     "/export",
     tags=["export"],

datacontract_cli-1.1.3/datacontract/breaking/detector.py

@@ -0,0 +1,74 @@
+from collections import defaultdict
+from collections.abc import Iterable
+
+from datacontract.breaking.rules import DEFAULT_RULES, BreakingChangeRule
+from datacontract.model.breaking import BreakingChangeEntry, BreakingChangeLevel, BreakingChangeResult
+from datacontract.model.changelog import ChangelogEntry, ChangelogResult, ChangelogType
+
+_LEVEL_ORDER = {
+    BreakingChangeLevel.INFO: 0,
+    BreakingChangeLevel.WARNING: 1,
+    BreakingChangeLevel.ERROR: 2,
+}
+
+
+class BreakingChangeDetector:
+    """Classify detailed changelog entries using an ordered rule set."""
+
+    def __init__(self, rules: Iterable[BreakingChangeRule] = DEFAULT_RULES):
+        self._rules = tuple(rules)
+        if not self._rules:
+            raise ValueError("At least one breaking-change rule is required")
+
+    def detect(self, changelog: ChangelogResult) -> BreakingChangeResult:
+        entries = [self._classify(entry) for entry in changelog.entries]
+        # Nothing inside a newly added element can break a consumer: it did not exist before.
+        added = {entry.path for entry in entries if entry.change_type == ChangelogType.added}
+        for entry in entries:
+            segments = entry.path.split(".")
+            if any(".".join(segments[:i]) in added for i in range(1, len(segments))):
+                entry.level = BreakingChangeLevel.INFO
+        entries_by_prefix = defaultdict(list)
+        for entry in entries:
+            prefix = ""
+            for segment in entry.path.split("."):
+                prefix = f"{prefix}.{segment}" if prefix else segment
+                entries_by_prefix[prefix].append(entry)
+        summary = [self._summarize(entry, entries_by_prefix.get(entry.path, [])) for entry in changelog.summary]
+        return BreakingChangeResult(v1=changelog.v1, v2=changelog.v2, summary=summary, entries=entries)
+
+    def _classify(self, entry: ChangelogEntry) -> BreakingChangeEntry:
+        for rule in self._rules:
+            evaluation = rule.evaluate(entry)
+            if evaluation is not None:
+                return BreakingChangeEntry(
+                    path=entry.path,
+                    change_type=entry.type,
+                    level=evaluation.level,
+                    message=evaluation.message,
+                    rule_id=evaluation.rule_id,
+                    old_value=entry.old_value,
+                    new_value=entry.new_value,
+                )
+        raise ValueError(f"No breaking-change rule classified {entry.path}")
+
+    @staticmethod
+    def _summarize(summary_entry: ChangelogEntry, entries: list[BreakingChangeEntry]) -> BreakingChangeEntry:
+        if not entries:
+            return BreakingChangeEntry(
+                path=summary_entry.path,
+                change_type=summary_entry.type,
+                level=BreakingChangeLevel.INFO,
+                message=f"Changed contract at {summary_entry.path}",
+                rule_id="summary-fallback",
+            )
+        highest = max(entries, key=lambda entry: _LEVEL_ORDER[entry.level])
+        return BreakingChangeEntry(
+            path=summary_entry.path,
+            change_type=summary_entry.type,
+            level=highest.level,
+            message=f"{highest.level.value.capitalize()} impact at {summary_entry.path}",
+            rule_id=f"summary:{highest.rule_id}",
+            old_value=highest.old_value,
+            new_value=highest.new_value,
+        )

datacontract_cli-1.1.3/datacontract/breaking/rules.py

@@ -0,0 +1,196 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import date
+
+from datacontract.model.breaking import BreakingChangeLevel
+from datacontract.model.changelog import ChangelogEntry, ChangelogType
+
+
+@dataclass(frozen=True)
+class RuleEvaluation:
+    rule_id: str
+    level: BreakingChangeLevel
+    message: str
+
+
+class BreakingChangeRule(ABC):
+    rule_id: str
+
+    @abstractmethod
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation | None:
+        """Return a classification when this rule applies to ``entry``."""
+
+
+class SchemaRemovedRule(BreakingChangeRule):
+    rule_id = "schema-removed"
+
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation | None:
+        segments = entry.path.split(".")
+        if entry.type == ChangelogType.removed and len(segments) == 2 and segments[0] == "schema":
+            return RuleEvaluation(self.rule_id, BreakingChangeLevel.ERROR, f"Removed schema {segments[1]}")
+        return None
+
+
+class FieldRemovedRule(BreakingChangeRule):
+    rule_id = "field-removed"
+
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation | None:
+        segments = entry.path.split(".")
+        if entry.type != ChangelogType.removed or not _is_schema_property_path(segments):
+            return None
+        property_name = segments[-1]
+        return RuleEvaluation(self.rule_id, BreakingChangeLevel.ERROR, f"Removed property {property_name}")
+
+
+class RequiredChangedRule(BreakingChangeRule):
+    rule_id = "required-changed"
+
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation | None:
+        if not entry.path.endswith(".required"):
+            return None
+        old = _parse_bool(entry.old_value)
+        new = _parse_bool(entry.new_value)
+        if entry.type == ChangelogType.added and new is True:
+            level = BreakingChangeLevel.ERROR
+        elif entry.type == ChangelogType.removed or new is False:
+            # Dropping the requirement, or writing out the optional default, only loosens the contract.
+            level = BreakingChangeLevel.INFO
+        elif entry.type == ChangelogType.updated and old is False and new is True:
+            level = BreakingChangeLevel.ERROR
+        elif entry.type in (ChangelogType.added, ChangelogType.updated):
+            level = BreakingChangeLevel.WARNING
+        else:
+            return None
+        return RuleEvaluation(self.rule_id, level, _change_message("requiredness", entry))
+
+
+class TypeChangedRule(BreakingChangeRule):
+    rule_id = "type-changed"
+
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation | None:
+        if not entry.path.endswith((".logicalType", ".physicalType")):
+            return None
+        if entry.type == ChangelogType.updated:
+            level = BreakingChangeLevel.ERROR
+        elif entry.type == ChangelogType.added:
+            level = BreakingChangeLevel.INFO
+        elif entry.type == ChangelogType.removed:
+            level = BreakingChangeLevel.WARNING
+        else:
+            return None
+        return RuleEvaluation(self.rule_id, level, _change_message("type", entry))
+
+
+class UniqueConstraintRule(BreakingChangeRule):
+    rule_id = "unique-constraint-changed"
+
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation | None:
+        if not entry.path.endswith(".unique"):
+            return None
+        old = _parse_bool(entry.old_value)
+        new = _parse_bool(entry.new_value)
+        if new is True and old is not True:
+            level = BreakingChangeLevel.ERROR
+        elif old is True and new is not True:
+            level = BreakingChangeLevel.INFO
+        else:
+            level = BreakingChangeLevel.WARNING
+        return RuleEvaluation(self.rule_id, level, _change_message("uniqueness", entry))
+
+
+class KeyConstraintRule(BreakingChangeRule):
+    rule_id = "key-constraint-changed"
+
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation | None:
+        if not entry.path.endswith((".primaryKey", ".primary_key")):
+            return None
+        return RuleEvaluation(self.rule_id, BreakingChangeLevel.WARNING, _change_message("key constraint", entry))
+
+
+class ValidationConstraintRule(BreakingChangeRule):
+    rule_id = "validation-constraint-changed"
+    _suffixes = (
+        ".pattern",
+        ".minLength",
+        ".maxLength",
+        ".minimum",
+        ".maximum",
+        ".exclusiveMinimum",
+        ".exclusiveMaximum",
+    )
+
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation | None:
+        if not entry.path.endswith(self._suffixes):
+            return None
+        old = _parse_number(entry.old_value)
+        new = _parse_number(entry.new_value)
+        if old is None or new is None:
+            level = BreakingChangeLevel.WARNING
+        elif _is_tightening(entry.path, old, new):
+            level = BreakingChangeLevel.ERROR
+        else:
+            level = BreakingChangeLevel.INFO
+        return RuleEvaluation(self.rule_id, level, _change_message("validation constraint", entry))
+
+
+class MetadataFallbackRule(BreakingChangeRule):
+    rule_id = "metadata-or-unknown-change"
+
+    def evaluate(self, entry: ChangelogEntry) -> RuleEvaluation:
+        return RuleEvaluation(self.rule_id, BreakingChangeLevel.INFO, _change_message("contract", entry))
+
+
+def _is_schema_property_path(segments: list[str]) -> bool:
+    return len(segments) >= 3 and segments[0] == "schema" and segments[-2] == "properties"
+
+
+def _parse_bool(value: str | None) -> bool | None:
+    if value is None:
+        return None
+    normalized = value.strip().lower()
+    if normalized in {"true", "1"}:
+        return True
+    if normalized in {"false", "0"}:
+        return False
+    return None
+
+
+def _parse_number(value: str | None) -> float | None:
+    if value is None:
+        return None
+    normalized = value.strip()
+    try:
+        return float(normalized)
+    except ValueError:
+        try:
+            return float(date.fromisoformat(normalized).toordinal())
+        except ValueError:
+            return None
+
+
+def _is_tightening(path: str, old: float, new: float) -> bool:
+    if path.endswith((".minLength", ".minimum", ".exclusiveMinimum")):
+        return new > old
+    if path.endswith((".maxLength", ".maximum", ".exclusiveMaximum")):
+        return new < old
+    return True
+
+
+def _change_message(subject: str, entry: ChangelogEntry) -> str:
+    if entry.type == ChangelogType.added:
+        return f"Added {subject} at {entry.path}"
+    if entry.type == ChangelogType.removed:
+        return f"Removed {subject} at {entry.path}"
+    return f"Changed {subject} at {entry.path} from {entry.old_value!r} to {entry.new_value!r}"
+
+
+DEFAULT_RULES: tuple[BreakingChangeRule, ...] = (
+    RequiredChangedRule(),
+    SchemaRemovedRule(),
+    FieldRemovedRule(),
+    TypeChangedRule(),
+    UniqueConstraintRule(),
+    KeyConstraintRule(),
+    ValidationConstraintRule(),
+    MetadataFallbackRule(),
+)

{datacontract_cli-1.1.2 → datacontract_cli-1.1.3}/datacontract/cli.py

@@ -28,6 +28,7 @@ COMMAND_ORDER = [
     "edit",
     "lint",
     "changelog",
+    "breaking",
     "sync",  # `dbt sync` subcommand; no top-level `sync`, so this only orders the dbt group
     "test",
     "ci",
@@ -217,11 +218,19 @@ def enable_debug_logging(debug: bool, otherwise_disable_stderr: bool = False):
             logging.getLogger(noisy_logger).setLevel(logging.ERROR)
 
 
-def validate_publish_url(publish: str | None) -> None:
-    """Reject `--publish` values that aren't http/https before any real work runs."""
-    if publish is not None and not (publish.startswith("http://") or publish.startswith("https://")):
+def validate_publish_url(publish: str | None) -> str | None:
+    """Normalize `--publish` and reject values that aren't http/https before any real work runs.
+
+    An empty value means "don't publish". CI templates that render the URL from an unset variable
+    pass `--publish ''` rather than omitting the option, e.g. GitHub Actions container actions,
+    where an argument list cannot drop an entry conditionally.
+    """
+    if not publish:
+        return None
+    if not (publish.startswith("http://") or publish.startswith("https://")):
         console.print(f"[red]--publish URL must start with http:// or https:// (got: {publish!r}).[/red]")
         raise typer.Exit(code=1)
+    return publish
 
 
 def resolve_output_format(output_format: Optional[OutputFormat], output: Optional[Path]) -> Optional[OutputFormat]:
@@ -263,6 +272,7 @@ def _print_publish_failure(run, out=None):
 # Display order for `--help` is controlled by COMMAND_ORDER above, not by import order.
 from datacontract import (  # noqa: E402, F401
     command_api,
+    command_breaking,
     command_catalog,
     command_changelog,
     command_ci,

datacontract_cli-1.1.3/datacontract/command_breaking.py

@@ -0,0 +1,39 @@
+import typer
+from typing_extensions import Annotated
+
+from datacontract.cli import app, console, debug_option, enable_debug_logging
+from datacontract.config import cli_config
+from datacontract.data_contract import DataContract
+from datacontract.output.text_breaking_results import write_text_breaking_results
+
+
+@app.command(
+    name="breaking",
+    epilog="Example: datacontract breaking datacontract-v1.yaml datacontract-v2.yaml",
+)
+def breaking(
+    v1: Annotated[
+        str,
+        typer.Argument(help="The location (url, s3 url, or local path) of the source (before) data contract YAML."),
+    ],
+    v2: Annotated[
+        str,
+        typer.Argument(help="The location (url, s3 url, or local path) of the target (after) data contract YAML."),
+    ],
+    inline_references: Annotated[
+        bool,
+        typer.Option(
+            help="Resolve external references (currently: authoritativeDefinitions\\[type in {definition, semantics}]) "
+            "in the contract and inline the fetched content from the configured entropy-data host."
+        ),
+    ] = True,
+    debug: debug_option = None,
+):
+    """Show compatibility impact between two data contracts."""
+    enable_debug_logging(debug)
+    result = DataContract(config=cli_config(), data_contract_file=v1, inline_references=inline_references).breaking(
+        DataContract(config=cli_config(), data_contract_file=v2, inline_references=inline_references)
+    )
+    write_text_breaking_results(result, console)
+    if result.is_breaking:
+        raise typer.Exit(code=1)

{datacontract_cli-1.1.2 → datacontract_cli-1.1.3}/datacontract/command_ci.py

@@ -92,7 +92,7 @@ def ci(
     Run tests for CI/CD pipelines. Emits GitHub Actions annotations and step summary.
     """
     enable_debug_logging(debug, otherwise_disable_stderr=True)
-    validate_publish_url(publish)
+    publish = validate_publish_url(publish)
 
     if not locations:
         locations = ["datacontract.yaml"]

{datacontract_cli-1.1.2 → datacontract_cli-1.1.3}/datacontract/command_dbt.py

@@ -347,7 +347,7 @@ def sync_command(
     the generated tests.
     """
     enable_debug_logging(debug)
-    validate_publish_url(publish)
+    publish = validate_publish_url(publish)
 
     if publish is not None and not run_tests_flag:
         console.print("[red]--publish requires --run-tests.[/red]")
@@ -476,7 +476,7 @@ def test_command(
     them. Use `datacontract dbt sync` to create and update the tests first.
     """
     enable_debug_logging(debug)
-    validate_publish_url(publish)
+    publish = validate_publish_url(publish)
     check_dbt_on_path()
 
     explicit_project_dir = project_dir is not None

{datacontract_cli-1.1.2 → datacontract_cli-1.1.3}/datacontract/command_export.py

@@ -66,6 +66,7 @@ def _export(
     inline_references: bool = True,
     clickhouse_engine: Optional[str] = None,
     clickhouse_order_by: Optional[str] = None,
+    suite_name: Optional[str] = None,
 ):
     result = DataContract(
         config=cli_config(),
@@ -83,6 +84,7 @@ def _export(
         template=template,
         clickhouse_engine=clickhouse_engine,
         clickhouse_order_by=clickhouse_order_by,
+        suite_name=suite_name,
     )
     if output is None:
         console.print(result, markup=False, soft_wrap=True)
@@ -587,6 +589,10 @@ def export_great_expectations(
     schema: schema_option = None,
     inline_references: inline_references_option = True,
     debug: debug_option = None,
+    suite_name: Annotated[
+        Optional[str],
+        typer.Option(help="The suite name for the Great Expectations run."),
+    ] = None,
 ):
     """Export a data contract to Great Expectations suite."""
     enable_debug_logging(debug)
@@ -600,6 +606,7 @@ def export_great_expectations(
         engine=engine.value if engine is not None else None,
         sql_server_type=dialect.value,
         inline_references=inline_references,
+        suite_name=suite_name,
     )
 
 

{datacontract_cli-1.1.2 → datacontract_cli-1.1.3}/datacontract/command_test.py

@@ -218,6 +218,13 @@ def test(
             "Checks that read row values are skipped."
         ),
     ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            help="Report the checks that would run, without connecting to the server or reading any data. "
+            "Reported checks have the result 'skipped', or 'warning' where a check could not be planned."
+        ),
+    ] = False,
     include_failed_samples: Annotated[
         bool,
         typer.Option(
@@ -243,7 +250,7 @@ def test(
     Run schema and quality tests on configured servers.
     """
     enable_debug_logging(debug, otherwise_disable_stderr=True)
-    validate_publish_url(publish)
+    publish = validate_publish_url(publish)
 
     check_categories = _parse_enum_csv(
         checks,
@@ -284,6 +291,7 @@ def test(
         filter=filter,
         filters=parsed_filters,
         metadata_only=metadata_only,
+        dry_run=dry_run,
     ).test()
     if logs:
         _print_logs(run)

{datacontract_cli-1.1.2 → datacontract_cli-1.1.3}/datacontract/config/settings.py

@@ -162,6 +162,7 @@ class Config(BaseSettings):
     kafka_schema_registry_password: SecretStr | None = None
     kafka_max_messages: int | None = None
     kafka_timeout: int | None = None
+    kafka_group_prefix: str | None = None
 
     # mysql
     mysql_username: str | None = None
@@ -588,6 +589,9 @@ class Config(BaseSettings):
     def get_kafka_timeout(self) -> int | None:
         return self._int_option("kafka_timeout")
 
+    def get_kafka_group_prefix(self, required: bool = False) -> str | None:
+        return self._str_option("kafka_group_prefix", required)
+
     # --- mysql ---
     def get_mysql_username(self, required: bool = False) -> str | None:
         return self._str_option("mysql_username", required)