datacheck-cli 2.0.0__tar.gz → 2.0.2__tar.gz

{datacheck_cli-2.0.0 → datacheck_cli-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datacheck-cli
-Version: 2.0.0
+Version: 2.0.2
 Summary: CLI-first data validation tool for data engineers. Catch bad data before it breaks pipelines.
 License: Apache-2.0
 License-File: LICENSE

{datacheck_cli-2.0.0 → datacheck_cli-2.0.2}/datacheck/__init__.py

@@ -37,7 +37,7 @@ from datacheck.profiling.formatters import (
     TerminalFormatter,
 )
 
-__version__ = "2.0.0"
+__version__ = "2.0.2"
 __author__ = "Squrtech"
 __email__ = "contact@squrtech.com"
 

{datacheck_cli-2.0.0 → datacheck_cli-2.0.2}/datacheck/cli/schema.py

@@ -1,5 +1,6 @@
 """Schema commands for DataCheck CLI."""
 
+import sys
 from pathlib import Path
 
 import typer
@@ -8,6 +9,15 @@ from rich.table import Table
 import pandas as pd
 
 from datacheck.cli import console
+
+
+def _safe_encoding() -> bool:
+    """Check if stdout can handle Unicode symbols."""
+    encoding = getattr(sys.stdout, "encoding", None) or ""
+    return encoding.lower().replace("-", "") in ("utf8", "utf16", "utf32", "utf16le", "utf16be")
+
+
+_TICK = "✓" if _safe_encoding() else "v"
 from datacheck.exceptions import DataLoadError
 
 # Schema sub-app for schema evolution commands
@@ -301,12 +311,12 @@ def schema_capture(
         # Save baseline
         manager = BaselineManager(baseline_dir=baseline_dir)
         filepath = manager.save_baseline(schema, name=name)
-        console.print(f"[green]✓[/green] Schema saved to: {filepath}")
+        console.print(f"[green]{_TICK}[/green] Schema saved to: {filepath}")
 
         # Save to history if requested
         if save_history:
             history_path = manager.save_to_history(schema)
-            console.print(f"[green]✓[/green] Schema added to history: {history_path}")
+            console.print(f"[green]{_TICK}[/green] Schema added to history: {history_path}")
 
         # Display summary
         console.print("\n[bold]Schema Summary:[/bold]")
@@ -493,7 +503,7 @@ def schema_compare(
         else:
             # Terminal output
             if not comparison.changes:
-                console.print("[green]✓ No schema changes detected[/green]")
+                console.print(f"[green]{_TICK} No schema changes detected[/green]")
             else:
                 # Compatibility summary
                 compat_style = {

{datacheck_cli-2.0.0 → datacheck_cli-2.0.2}/datacheck/cli/validate.py

@@ -428,17 +428,7 @@ def validate(
     )
 
     try:
-        # Initialize Slack notifier if webhook provided
-        notifier = None
-        if slack_webhook:
-            from datacheck.notifications import SlackNotifier
-            try:
-                notifier = SlackNotifier(slack_webhook)
-            except Exception as e:
-                console.print(f"[red]Slack Configuration Error:[/red] {e}", style="red")
-                raise typer.Exit(code=2) from e
-
-        # Initialize validation engine
+        # Initialize validation engine first (to access config)
         try:
             if config:
                 config_path = Path(config)
@@ -448,7 +438,6 @@ def validate(
                     workers=workers,
                     chunk_size=chunk_size,
                     show_progress=show_progress,
-                    notifier=notifier,
                     sources_file=sources_file,
                 )
             else:
@@ -457,13 +446,31 @@ def validate(
                     workers=workers,
                     chunk_size=chunk_size,
                     show_progress=show_progress,
-                    notifier=notifier,
                     sources_file=sources_file,
                 )
         except ConfigurationError as e:
             console.print(f"[red]Configuration Error:[/red] {e}", style="red")
             raise typer.Exit(code=2) from e
 
+        # Initialize Slack notifier: CLI flag overrides config
+        notifier = None
+        effective_webhook = slack_webhook
+        mention_on_failure = False
+        if not effective_webhook and engine.config.notifications:
+            effective_webhook = engine.config.notifications.slack_webhook
+            mention_on_failure = engine.config.notifications.mention_on_failure
+
+        if effective_webhook:
+            from datacheck.notifications import SlackNotifier
+            try:
+                notifier = SlackNotifier(effective_webhook, mention_on_failure=mention_on_failure)
+            except Exception as e:
+                console.print(f"[red]Slack Configuration Error:[/red] {e}", style="red")
+                raise typer.Exit(code=2) from e
+
+        # Attach notifier to engine
+        engine.notifier = notifier
+
         # Progress spinner — gives user feedback during load + validation
         num_checks = len(engine.config.checks)
         _status = (
@@ -524,7 +531,7 @@ def validate(
                     "loading_inline_data_source",
                     extra={"type": inline_source.type, "path": str(source_path)},
                 )
-                summary = engine.validate_file(str(source_path))
+                summary = engine.validate_file(str(source_path), **inline_source.options)
                 logger.info(
                     "data_loaded",
                     extra={"source_type": "inline", "path": str(source_path)},

{datacheck_cli-2.0.0 → datacheck_cli-2.0.2}/datacheck/config/__init__.py

@@ -6,6 +6,7 @@ Provides config validation, parsing, generation, and CLI tools.
 # Original config module classes (for backward compatibility)
 from datacheck.config.loader import (
     ConfigLoader,
+    NotificationsConfig,
     RuleConfig,
     SamplingConfig,
     ValidationConfig,
@@ -27,6 +28,7 @@ from datacheck.config.templates import (
 __all__ = [
     # Original exports (backward compatibility)
     "ConfigLoader",
+    "NotificationsConfig",
     "RuleConfig",
     "SamplingConfig",
     "ValidationConfig",

{datacheck_cli-2.0.0 → datacheck_cli-2.0.2}/datacheck/config/generator.py

@@ -105,7 +105,7 @@ class ConfigGenerator:
                 col_names = cc_rule["columns"]
                 cc_check: dict[str, Any] = {
                     "name": f"cross_{'_'.join(col_names[:2])}_{cc_rule['rule']}",
-                    "columns": col_names,
+                    "column": col_names[0],
                     "rules": {cc_rule["rule"]: cc_rule["params"]},
                     "description": cc_rule.get("reason", "Cross-column rule"),
                 }
@@ -130,6 +130,7 @@ class ConfigGenerator:
         config["checks"] = checks
 
         config["reporting"] = {
+            "output_path": "./output",
             "export_failures": True,
         }
 
@@ -237,8 +238,20 @@ class ConfigGenerator:
         """
         from datacheck.loader import LoaderFactory
 
+        data_path = Path(data_path)
         df = LoaderFactory.load(str(data_path), **load_kwargs)
-        name = Path(data_path).stem
+        name = data_path.stem
+
+        # Determine source type from file extension
+        ext = data_path.suffix.lower().lstrip(".")
+        source_type_map = {
+            "csv": "csv",
+            "parquet": "parquet",
+            "pq": "parquet",
+            "json": "json",
+            "avro": "avro",
+        }
+        source_type = source_type_map.get(ext, "csv")
 
         if return_profile:
             if confidence_threshold not in self.CONFIDENCE_LEVELS:
@@ -250,11 +263,20 @@ class ConfigGenerator:
             config = self.generate_from_profile(
                 profile, confidence_threshold=confidence_threshold
             )
+            config["data_source"] = {
+                "type": source_type,
+                "path": f"./{data_path.name}",
+            }
             return config, profile
 
-        return self.generate_from_dataframe(
+        config = self.generate_from_dataframe(
             df, name=name, confidence_threshold=confidence_threshold
         )
+        config["data_source"] = {
+            "type": source_type,
+            "path": f"./{data_path.name}",
+        }
+        return config
 
     def save_config(
         self,
@@ -301,7 +323,7 @@ class ConfigGenerator:
 
         # Version
         if "version" in config:
-            lines.append(f"version: \"{config['version']}\"")
+            lines.append(f"version: '{config['version']}'")
             lines.append("")
 
         # Metadata
@@ -310,11 +332,27 @@ class ConfigGenerator:
             lines.append("metadata:")
             for key, value in config["metadata"].items():
                 if isinstance(value, str):
-                    lines.append(f"  {key}: \"{value}\"")
+                    lines.append(f"  {key}: '{value}'")
                 else:
                     lines.append(f"  {key}: {value}")
             lines.append("")
 
+        # Data source
+        if "data_source" in config:
+            ds = config["data_source"]
+            lines.append("# Data source configuration")
+            lines.append("data_source:")
+            lines.append(f"  type: {ds['type']}")
+            lines.append(f"  path: '{ds['path']}'")
+            if "options" in ds and ds["options"]:
+                lines.append("  options:")
+                for key, value in ds["options"].items():
+                    if isinstance(value, str):
+                        lines.append(f"    {key}: '{value}'")
+                    else:
+                        lines.append(f"    {key}: {value}")
+            lines.append("")
+
         # Checks
         lines.append("# Validation checks")
         lines.append("# Each check validates a single column with one or more rules")
@@ -333,7 +371,7 @@ class ConfigGenerator:
                 lines.append(f"    column: {check['column']}")
 
             if "description" in check:
-                lines.append(f"    description: \"{check['description']}\"")
+                lines.append(f"    description: '{check['description']}'")
 
             lines.append("    rules:")
             rule_reasons = check.get("_rule_reasons", {})
@@ -401,13 +439,13 @@ class ConfigGenerator:
                 lines.append(f"{prefix}{rule_name}:")
             for k, v in rule_value.items():
                 if isinstance(v, str):
-                    lines.append(f"{sub_prefix}{k}: \"{v}\"")
+                    lines.append(f"{sub_prefix}{k}: '{v}'")
                 elif isinstance(v, list):
                     lines.append(f"{sub_prefix}{k}:")
                     item_prefix = "          # " if commented else "          "
                     for item in v:
                         if isinstance(item, str):
-                            lines.append(f"{item_prefix}- \"{item}\"")
+                            lines.append(f"{item_prefix}- '{item}'")
                         else:
                             lines.append(f"{item_prefix}- {item}")
                 else:
@@ -419,11 +457,11 @@ class ConfigGenerator:
                 lines.append(f"{prefix}{rule_name}:")
             for item in rule_value:
                 if isinstance(item, str):
-                    lines.append(f"{sub_prefix}- \"{item}\"")
+                    lines.append(f"{sub_prefix}- '{item}'")
                 else:
                     lines.append(f"{sub_prefix}- {item}")
         elif isinstance(rule_value, str):
-            lines.append(f"{prefix}{rule_name}: \"{rule_value}\"{comment}")
+            lines.append(f"{prefix}{rule_name}: '{rule_value}'{comment}")
         else:
             lines.append(f"{prefix}{rule_name}: {rule_value}{comment}")
 

{datacheck_cli-2.0.0 → datacheck_cli-2.0.2}/datacheck/config/loader.py

@@ -1,6 +1,6 @@
 """Configuration parsing and validation (original config module)."""
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
@@ -81,10 +81,12 @@ class DataSourceConfig:
     Attributes:
         type: Source type (csv, parquet, json, excel, delta)
         path: Path to the data file (relative to config file or absolute)
+        options: Loader-specific options (e.g. encoding, delimiter for CSV)
     """
 
     type: str
     path: str
+    options: dict[str, Any] = field(default_factory=dict)
 
     def __post_init__(self) -> None:
         """Validate data source configuration."""
@@ -211,6 +213,34 @@ class SamplingConfig:
                 )
 
 
+@dataclass
+class NotificationsConfig:
+    """Configuration for validation notifications.
+
+    Attributes:
+        slack_webhook: Slack webhook URL for sending results
+        mention_on_failure: Whether to mention @channel on failures
+    """
+
+    slack_webhook: str | None = None
+    mention_on_failure: bool = False
+
+    def __post_init__(self) -> None:
+        """Validate notifications configuration."""
+        if self.slack_webhook is not None:
+            from urllib.parse import urlparse
+
+            url = self.slack_webhook.strip()
+            if not url:
+                raise ConfigurationError("Slack webhook URL cannot be empty")
+            parsed = urlparse(url)
+            if parsed.scheme != "https":
+                raise ConfigurationError(
+                    "Slack webhook URL must use HTTPS scheme"
+                )
+            self.slack_webhook = url
+
+
 @dataclass
 class ValidationConfig:
     """Complete validation configuration.
@@ -224,6 +254,7 @@ class ValidationConfig:
         table: Default table name for all checks
         data_source: Inline data source configuration (for single-source validation)
         reporting: Output and reporting configuration
+        notifications: Optional notifications configuration
     """
 
     checks: list[RuleConfig]
@@ -234,6 +265,7 @@ class ValidationConfig:
     table: str | None = None
     data_source: DataSourceConfig | None = None
     reporting: ReportingConfig | None = None
+    notifications: NotificationsConfig | None = None
 
     def __post_init__(self) -> None:
         """Validate configuration after initialization."""
@@ -278,10 +310,14 @@ class ConfigLoader:
         if not path.is_file():
             raise ConfigurationError(f"Configuration path is not a file: {config_path}")
 
-        # Read and parse YAML
+        # Read and parse YAML (with env-var substitution and extends resolution)
         try:
-            with open(path, encoding="utf-8") as f:
-                data = yaml.safe_load(f)
+            from datacheck.config.parser import ConfigParser
+
+            parser = ConfigParser()
+            data = parser.load(path, resolve_env=True, resolve_extends=True)
+        except ConfigurationError:
+            raise
         except yaml.YAMLError as e:
             raise ConfigurationError(f"Invalid YAML in {config_path}: {e}") from e
         except Exception as e:
@@ -304,26 +340,33 @@ class ConfigLoader:
                 f"'checks' must be a list, got {type(data['checks']).__name__}"
             )
 
-        # Parse checks
+        # Parse checks — collect all errors before raising
         checks = []
+        check_errors: list[str] = []
         for idx, check_data in enumerate(data["checks"]):
             if not isinstance(check_data, dict):
-                raise ConfigurationError(
+                check_errors.append(
                     f"Check at index {idx} must be a dictionary, "
                     f"got {type(check_data).__name__}"
                 )
+                continue
 
             # Validate required fields
+            missing = False
             if "name" not in check_data:
-                raise ConfigurationError(f"Check at index {idx} missing 'name' field")
+                check_errors.append(f"Check at index {idx} missing 'name' field")
+                missing = True
             if "column" not in check_data:
-                raise ConfigurationError(
-                    f"Check '{check_data.get('name', idx)}' missing 'column' field"
-                )
+                name = check_data.get("name", f"index {idx}")
+                check_errors.append(f"Check '{name}' missing 'column' field")
+                missing = True
             if "rules" not in check_data:
-                raise ConfigurationError(
-                    f"Check '{check_data['name']}' missing 'rules' field"
-                )
+                name = check_data.get("name", f"index {idx}")
+                check_errors.append(f"Check '{name}' missing 'rules' field")
+                missing = True
+
+            if missing:
+                continue
 
             try:
                 rule_config = RuleConfig(
@@ -338,12 +381,17 @@ class ConfigLoader:
                 # Only add enabled checks
                 if rule_config.enabled:
                     checks.append(rule_config)
-            except ConfigurationError:
-                raise
+            except ConfigurationError as e:
+                check_errors.append(str(e))
             except Exception as e:
-                raise ConfigurationError(
+                check_errors.append(
                     f"Error parsing check '{check_data.get('name', idx)}': {e}"
-                ) from e
+                )
+
+        if check_errors:
+            raise ConfigurationError(
+                "Configuration has errors:\n  - " + "\n  - ".join(check_errors)
+            )
 
         # Parse plugins (optional)
         plugins = data.get("plugins", [])
@@ -400,9 +448,13 @@ class ConfigLoader:
                 raise ConfigurationError("'data_source' missing 'path' field")
 
             try:
+                options = ds_data.get("options", {})
+                if not isinstance(options, dict):
+                    raise ConfigurationError("'data_source.options' must be a dictionary")
                 data_source = DataSourceConfig(
                     type=ds_data["type"],
                     path=ds_data["path"],
+                    options=options,
                 )
             except ConfigurationError:
                 raise
@@ -427,6 +479,23 @@ class ConfigLoader:
             except Exception as e:
                 raise ConfigurationError(f"Error parsing reporting config: {e}") from e
 
+        # Parse notifications (optional)
+        notifications = None
+        if "notifications" in data:
+            notif_data = data["notifications"]
+            if not isinstance(notif_data, dict):
+                raise ConfigurationError("'notifications' must be a dictionary")
+
+            try:
+                notifications = NotificationsConfig(
+                    slack_webhook=notif_data.get("slack_webhook"),
+                    mention_on_failure=notif_data.get("mention_on_failure", False),
+                )
+            except ConfigurationError:
+                raise
+            except Exception as e:
+                raise ConfigurationError(f"Error parsing notifications config: {e}") from e
+
         return ValidationConfig(
             checks=checks,
             plugins=plugins,
@@ -436,6 +505,7 @@ class ConfigLoader:
             table=default_table,
             data_source=data_source,
             reporting=reporting,
+            notifications=notifications,
         )
 
     @staticmethod
@@ -468,6 +538,7 @@ class ConfigLoader:
 
 __all__ = [
     "DataSourceConfig",
+    "NotificationsConfig",
     "ReportingConfig",
     "RuleConfig",
     "SamplingConfig",

{datacheck_cli-2.0.0 → datacheck_cli-2.0.2}/datacheck/config/templates/basic.yaml

@@ -62,6 +62,11 @@ checks:
         - inactive
         - pending
 
+# Notifications (optional)
+# notifications:
+#   slack_webhook: "${SLACK_WEBHOOK}"
+#   mention_on_failure: false
+
 # Output configuration
 reporting:
   export_failures: true