duckguard 3.0.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

duckguard/anomaly/methods.py

@@ -29,6 +29,53 @@ class AnomalyScore:
     threshold: float
     details: dict[str, Any] = field(default_factory=dict)
 
+    def __lt__(self, other: AnomalyScore | float) -> bool:
+        """Less than comparison based on score."""
+        if isinstance(other, AnomalyScore):
+            return self.score < other.score
+        return self.score < other
+
+    def __le__(self, other: AnomalyScore | float) -> bool:
+        """Less than or equal comparison based on score."""
+        if isinstance(other, AnomalyScore):
+            return self.score <= other.score
+        return self.score <= other
+
+    def __gt__(self, other: AnomalyScore | float) -> bool:
+        """Greater than comparison based on score."""
+        if isinstance(other, AnomalyScore):
+            return self.score > other.score
+        return self.score > other
+
+    def __ge__(self, other: AnomalyScore | float) -> bool:
+        """Greater than or equal comparison based on score."""
+        if isinstance(other, AnomalyScore):
+            return self.score >= other.score
+        return self.score >= other
+
+    def __eq__(self, other: object) -> bool:
+        """Equality comparison based on score."""
+        if isinstance(other, AnomalyScore):
+            return self.score == other.score
+        if isinstance(other, (int, float)):
+            return self.score == other
+        return NotImplemented
+
+    def __ne__(self, other: object) -> bool:
+        """Inequality comparison based on score."""
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return result
+        return not result
+
+    def __float__(self) -> float:
+        """Convert to float (returns the score)."""
+        return self.score
+
+    def __format__(self, format_spec: str) -> str:
+        """Format the score using the given format specification."""
+        return format(self.score, format_spec)
+
 
 class AnomalyMethod(ABC):
     """Base class for anomaly detection methods."""

duckguard/anomaly/ml_methods.py

@@ -60,6 +60,18 @@ class DistributionComparison:
     method: str
     details: dict[str, Any] = field(default_factory=dict)
 
+    @property
+    def is_drift(self) -> bool:
+        """Alias for is_drifted (backward compatibility)."""
+        return self.is_drifted
+
+    @property
+    def message(self) -> str:
+        """Generate a human-readable message about the comparison."""
+        if self.is_drifted:
+            return f"Distribution drift detected (p-value: {self.p_value:.4f} < threshold)"
+        return f"No significant drift detected (p-value: {self.p_value:.4f})"
+
 
 class BaselineMethod(AnomalyMethod):
     """Detect anomalies by comparing to learned baseline.
@@ -111,12 +123,32 @@ class BaselineMethod(AnomalyMethod):
     def name(self) -> str:
         return "baseline"
 
-    def fit(self, values: list[float]) -> None:
+    @property
+    def baseline_mean(self) -> float:
+        """Get the baseline mean value."""
+        return self._mean
+
+    @property
+    def baseline_std(self) -> float:
+        """Get the baseline standard deviation."""
+        return self._stddev
+
+    @property
+    def is_fitted(self) -> bool:
+        """Check if the model has been fitted."""
+        return self._fitted
+
+    def fit(self, values: list[float] | Any) -> None:
         """Learn baseline from values.
 
         Args:
-            values: List of numeric values to learn from
+            values: List of numeric values or Column object to learn from
         """
+        # Handle Column objects
+        from duckguard.core.column import Column
+        if isinstance(values, Column):
+            values = self._get_column_values(values)
+
         clean = [v for v in values if v is not None and not math.isnan(v)]
         if not clean:
             return
@@ -135,15 +167,37 @@ class BaselineMethod(AnomalyMethod):
         self._sample_count = n
         self._fitted = True
 
-    def score(self, value: float) -> AnomalyScore:
-        """Score a value against the baseline.
+    def _get_column_values(self, column) -> list[float]:
+        """Extract numeric values from a Column object."""
+        dataset = column._dataset
+        column_name = column._name
+        engine = dataset._engine
+        table_name = dataset._source.replace('\\', '/')
+
+        query = f"""
+            SELECT "{column_name}"
+            FROM '{table_name}'
+            WHERE "{column_name}" IS NOT NULL
+        """
+
+        result = engine.fetch_all(query)
+        return [float(row[0]) for row in result]
+
+    def score(self, value: float | Any) -> AnomalyScore | list[AnomalyScore]:
+        """Score a value or column against the baseline.
 
         Args:
-            value: Value to score
+            value: Single numeric value or Column object to score
 
         Returns:
-            AnomalyScore indicating how anomalous the value is
+            AnomalyScore for single value, or list of AnomalyScores for Column
         """
+        # Handle Column objects
+        from duckguard.core.column import Column
+        if isinstance(value, Column):
+            values = self._get_column_values(value)
+            return [self.score(v) for v in values]
+
         if value is None or math.isnan(value):
             return AnomalyScore(
                 value=value,
@@ -343,12 +397,17 @@ class KSTestMethod(AnomalyMethod):
     def name(self) -> str:
         return "ks_test"
 
-    def fit(self, values: list[float]) -> None:
+    def fit(self, values: list[float] | Any) -> None:
         """Learn baseline distribution.
 
         Args:
-            values: List of numeric values for baseline
+            values: List of numeric values or Column object for baseline
         """
+        # Handle Column objects
+        from duckguard.core.column import Column
+        if isinstance(values, Column):
+            values = self._get_column_values(values)
+
         clean = sorted(v for v in values if v is not None and not math.isnan(v))
         if not clean:
             return
@@ -357,17 +416,39 @@ class KSTestMethod(AnomalyMethod):
         self._baseline_ecdf = self._compute_ecdf(clean)
         self._fitted = True
 
-    def score(self, value: float) -> AnomalyScore:
-        """Score a single value (uses empirical CDF).
+    def _get_column_values(self, column) -> list[float]:
+        """Extract numeric values from a Column object."""
+        dataset = column._dataset
+        column_name = column._name
+        engine = dataset._engine
+        table_name = dataset._source.replace('\\', '/')
+
+        query = f"""
+            SELECT "{column_name}"
+            FROM '{table_name}'
+            WHERE "{column_name}" IS NOT NULL
+        """
+
+        result = engine.fetch_all(query)
+        return [float(row[0]) for row in result]
+
+    def score(self, value: float | Any) -> AnomalyScore | list[AnomalyScore]:
+        """Score a value or column (uses empirical CDF).
 
         For distribution testing, use compare_distributions() instead.
 
         Args:
-            value: Value to score
+            value: Single numeric value or Column object to score
 
         Returns:
-            AnomalyScore based on position in baseline distribution
+            AnomalyScore for single value, or list of AnomalyScores for Column
         """
+        # Handle Column objects
+        from duckguard.core.column import Column
+        if isinstance(value, Column):
+            values = self._get_column_values(value)
+            return [self.score(v) for v in values]
+
         if value is None or math.isnan(value):
             return AnomalyScore(
                 value=value,
@@ -405,18 +486,35 @@ class KSTestMethod(AnomalyMethod):
 
     def compare_distributions(
         self,
-        current_values: list[float],
+        current_values: list[float] | Any,
+        baseline_values: list[float] | Any | None = None,
     ) -> DistributionComparison:
         """Compare current distribution to baseline using KS test.
 
         Args:
-            current_values: Current values to compare
+            current_values: List of values or Column object to compare
+            baseline_values: Optional baseline data. If not provided and not fitted,
+                           will use current_values as baseline (self-comparison)
 
         Returns:
             DistributionComparison with test results
         """
+        # Handle Column objects for current_values
+        from duckguard.core.column import Column
+        if isinstance(current_values, Column):
+            current_values = self._get_column_values(current_values)
+
+        # Handle Column objects for baseline_values
+        if baseline_values is not None and isinstance(baseline_values, Column):
+            baseline_values = self._get_column_values(baseline_values)
+
+        # Auto-fit if not fitted and baseline provided
         if not self._fitted:
-            raise ValueError("Method not fitted - call fit() first")
+            if baseline_values is not None:
+                self.fit(baseline_values)
+            else:
+                # Use current_values as baseline (self-comparison for normality test)
+                self.fit(current_values)
 
         clean_current = sorted(v for v in current_values if v is not None and not math.isnan(v))
         if not clean_current:
@@ -548,14 +646,19 @@ class SeasonalMethod(AnomalyMethod):
     def name(self) -> str:
         return f"seasonal_{self.period}"
 
-    def fit(self, values: list[float]) -> None:
+    def fit(self, values: list[float] | Any) -> None:
         """Fit without timestamps (falls back to global statistics).
 
         For proper seasonal detection, use fit_with_timestamps().
 
         Args:
-            values: List of numeric values
+            values: List of numeric values or Column object
         """
+        # Handle Column objects
+        from duckguard.core.column import Column
+        if isinstance(values, Column):
+            values = self._get_column_values(values)
+
         clean = [v for v in values if v is not None and not math.isnan(v)]
         if not clean:
             return
@@ -569,6 +672,22 @@ class SeasonalMethod(AnomalyMethod):
 
         self._fitted = True
 
+    def _get_column_values(self, column) -> list[float]:
+        """Extract numeric values from a Column object."""
+        dataset = column._dataset
+        column_name = column._name
+        engine = dataset._engine
+        table_name = dataset._source.replace('\\', '/')
+
+        query = f"""
+            SELECT "{column_name}"
+            FROM '{table_name}'
+            WHERE "{column_name}" IS NOT NULL
+        """
+
+        result = engine.fetch_all(query)
+        return [float(row[0]) for row in result]
+
     def fit_with_timestamps(
         self,
         data: list[tuple[Any, float]],
@@ -618,17 +737,23 @@ class SeasonalMethod(AnomalyMethod):
 
         self._fitted = True
 
-    def score(self, value: float) -> AnomalyScore:
-        """Score a value without timestamp (uses global stats).
+    def score(self, value: float | Any) -> AnomalyScore | list[AnomalyScore]:
+        """Score a value or column without timestamp (uses global stats).
 
         For proper seasonal scoring, use score_with_timestamp().
 
         Args:
-            value: Value to score
+            value: Single numeric value or Column object to score
 
         Returns:
-            AnomalyScore using global statistics
+            AnomalyScore for single value, or list of AnomalyScores for Column
         """
+        # Handle Column objects
+        from duckguard.core.column import Column
+        if isinstance(value, Column):
+            values = self._get_column_values(value)
+            return [self.score(v) for v in values]
+
         if value is None or math.isnan(value):
             return AnomalyScore(
                 value=value,

duckguard/core/result.py

@@ -37,6 +37,11 @@ class FailedRow:
     reason: str = ""
     context: dict[str, Any] = field(default_factory=dict)
 
+    @property
+    def row_number(self) -> int:
+        """Alias for row_index (backward compatibility)."""
+        return self.row_index
+
     def __repr__(self) -> str:
         return f"FailedRow(row={self.row_index}, column='{self.column}', value={self.value!r})"
 

duckguard/notifications/email.py

@@ -138,6 +138,15 @@ class EmailNotifier(BaseNotifier):
         if not self.email_config.to_addresses:
             raise ValueError("At least one recipient address (to_addresses) is required")
 
+        # Populate NotificationConfig with email settings for easy access
+        self.config.smtp_host = self.email_config.smtp_host
+        self.config.smtp_port = self.email_config.smtp_port
+        self.config.from_address = self.email_config.from_address
+        self.config.to_addresses = self.email_config.to_addresses
+        self.config.use_tls = self.email_config.use_tls
+        self.config.use_ssl = self.email_config.use_ssl
+        self.config.subject_prefix = self.email_config.subject_prefix
+
         # Set webhook_url to a placeholder (not used for email)
         self.webhook_url = "email://smtp"
 

duckguard/notifications/notifiers.py

@@ -40,6 +40,16 @@ class NotificationConfig:
     max_failures_shown: int = 10
     mention_users: list[str] = field(default_factory=list)
     channel: str | None = None
+    username: str | None = None  # Slack bot username
+
+    # Email-specific attributes (set by EmailNotifier)
+    smtp_host: str | None = None
+    smtp_port: int | None = None
+    from_address: str | None = None
+    to_addresses: list[str] | None = None
+    use_tls: bool | None = None
+    use_ssl: bool | None = None
+    subject_prefix: str | None = None
 
 
 class BaseNotifier(ABC):
@@ -143,13 +153,39 @@ class SlackNotifier(BaseNotifier):
     """Slack webhook notifier.
 
     Usage:
-        notifier = SlackNotifier(webhook_url="https://hooks.slack.com/...")
+        notifier = SlackNotifier(
+            webhook_url="https://hooks.slack.com/...",
+            channel="#data-quality",
+            username="DuckGuard Bot"
+        )
         # or set DUCKGUARD_SLACK_WEBHOOK environment variable
 
         result = execute_rules(rules, "data.csv")
         notifier.send_results(result)
     """
 
+    def __init__(
+        self,
+        webhook_url: str | None = None,
+        channel: str | None = None,
+        username: str | None = None,
+        config: NotificationConfig | None = None,
+    ):
+        """Initialize Slack notifier.
+
+        Args:
+            webhook_url: Slack webhook URL
+            channel: Override default channel (e.g., "#data-quality")
+            username: Bot username to display
+            config: Notification configuration
+        """
+        super().__init__(webhook_url=webhook_url, config=config)
+        # Only override if explicitly provided (don't overwrite config values with None)
+        if channel is not None:
+            self.config.channel = channel
+        if username is not None:
+            self.config.username = username
+
     @property
     def _env_var_name(self) -> str:
         return "DUCKGUARD_SLACK_WEBHOOK"
@@ -211,6 +247,8 @@ class SlackNotifier(BaseNotifier):
 
         if self.config.channel:
             message["channel"] = self.config.channel
+        if self.config.username:
+            message["username"] = self.config.username
 
         return message
 

{duckguard-3.0.0.dist-info → duckguard-3.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckguard
-Version: 3.0.0
+Version: 3.0.1
 Summary: A Python-native data quality tool with AI superpowers, built on DuckDB for speed
 Project-URL: Homepage, https://github.com/XDataHubAI/duckguard
 Project-URL: Documentation, https://github.com/XDataHubAI/duckguard

{duckguard-3.0.0.dist-info → duckguard-3.0.1.dist-info}/RECORD

@@ -3,8 +3,8 @@ duckguard/errors.py,sha256=xhQPxCCeB3dCQspTbQf58h_DvwHP1vAb6vKI9fHYAJ0,11493
 duckguard/anomaly/__init__.py,sha256=mrTyL70cOR5S7_RNc9QLADdnBimIsbAoFTbKlWiIsbw,1353
 duckguard/anomaly/baselines.py,sha256=k28CjjqBa8IaZxnIgof-wjw_Xdb7NJZImC2OJJkGXQ8,8776
 duckguard/anomaly/detector.py,sha256=voA7WS2x2p5h5cnwH3C_2ly7HdYpXLwC4jDiPL2Xleo,12443
-duckguard/anomaly/methods.py,sha256=CtV2G-kowXGgz0HYvNoi2Ge7eyHUg2GwGa3oZvunS38,13475
-duckguard/anomaly/ml_methods.py,sha256=UyEr8q4K_wNq7pWgTsV23IoBI13aqm0hHIwIFjIxeas,23449
+duckguard/anomaly/methods.py,sha256=IRt7_1YWGaQHz2syfEd89lL6kAjOjheSk6ayLRUi58M,15237
+duckguard/anomaly/ml_methods.py,sha256=Ne8BOULj-bcPmf1_YAqJqnlXDlljfhsxvFbBIjWkJB8,28221
 duckguard/checks/__init__.py,sha256=aSxO02ZILHnfrGhfomQ5EN69t7NZ4yr61Etwtcv_zIw,847
 duckguard/checks/conditional.py,sha256=gYFZD_6M-IUs1MGMZeDYH-qC99dyMJ-u63r1SgcBVs8,26646
 duckguard/checks/distributional.py,sha256=Cy3YlWnSPA5QZdNT_lYuTMRLrwvU1yJGk--RGzOQ5N4,18302
@@ -37,7 +37,7 @@ duckguard/core/__init__.py,sha256=pHndzrdehB0GFtlSQ46uvw8XgUQj55dVZQP1ZK-aDso,35
 duckguard/core/column.py,sha256=88m3WipKNdNslXNWAk4ofTf0kmNlDDAyhjDUa-Q6UGg,48326
 duckguard/core/dataset.py,sha256=kQY2ALTsid5x1NWOM5Wse60mOrLdUj8lKUs1cLK7cCo,44364
 duckguard/core/engine.py,sha256=ld_NHsWyBkVynmWyvbyQcHdXHhpIoSaRDyqAAtVx8J0,7897
-duckguard/core/result.py,sha256=BwmP0gNPAKVYHdyque1rDkbAhEvwFaA3PwhxaI7cY14,15178
+duckguard/core/result.py,sha256=kQ_tzDkxjJTGK_k1P6crprrrYIszokhSxQMGlP1laAw,15316
 duckguard/core/scoring.py,sha256=42CVgxmmfo3Yb3m3Xl8qWnDgR7ndSZd8vXRwy9XSThI,16826
 duckguard/freshness/__init__.py,sha256=8XR7JxH9tz61En5DTMSDHrjhroPzvwCTVzBbBiRFexs,854
 duckguard/freshness/monitor.py,sha256=O_b4fh6unyZ2DXioX6O7KP9VpenGdLTpb9OdNb79dX8,14695
@@ -49,9 +49,9 @@ duckguard/integrations/__init__.py,sha256=SuqOzfdaejlMCti372FHD_R6bVaPaUmfEPG9IM
 duckguard/integrations/airflow.py,sha256=pxC14Kgwou_2xWPvTfx8YWO-xg_vgFeAlGDhgGfXRyM,13195
 duckguard/integrations/dbt.py,sha256=Dw1meY-UhylDFhUZ2s47FnJGMp_gszHvadGn_hqYkSM,14101
 duckguard/notifications/__init__.py,sha256=qEfUvt7d_WXlbsGlLB-FaNF4ksLtAyO8JXi1JCdo89w,1541
-duckguard/notifications/email.py,sha256=jwgxec8r6NUNqrxz3v5B4A3UL0-ZdxnJZhXQXWgMWH4,17168
+duckguard/notifications/email.py,sha256=6qmHXufExnczyXEpa1dt6A6dli0kgRHZV_DhEkfMsj4,17677
 duckguard/notifications/formatter.py,sha256=Z2vGMpLdqPWYaYTaVtVjYnIbNU8Haer-7efohZ5IZxM,3991
-duckguard/notifications/notifiers.py,sha256=e-UBvoskFSzIwlCFTxIFdkI-z54zZeEeSQkvOvgV6JI,11703
+duckguard/notifications/notifiers.py,sha256=nViWe2rms8C9t05WMbc2mwJrryS7V8N2OBSJ3u0PQGE,13023
 duckguard/profiler/__init__.py,sha256=a16GYeeFDZzwCemTsTuzO3Ih4M7_hOPb9hS8yt-nHzU,169
 duckguard/profiler/auto_profile.py,sha256=KbAkty-HrpNbTribi2uD17Fcsb-UiV5eG4zZsbyBOL4,12267
 duckguard/profiler/distribution_analyzer.py,sha256=I_jnDUtEG260yu7zEBU-2vHRIeYpAzuF-HKX99i8MGU,12644
@@ -79,8 +79,8 @@ duckguard/semantic/analyzer.py,sha256=2be1oofe-owBhTg-Dy88-wihaoTQ7DPxf1NuA1sgfR
 duckguard/semantic/detector.py,sha256=MPdb2Rv9VGQBko7nmPk4-Kjga_XVjPZdHCr29gdET0M,15665
 duckguard/semantic/validators.py,sha256=8Zu3vwPwh79U09zGf4_PpcwV85_hbNCwRHcxTIQ7G_I,10945
 duckguard/validators/__init__.py,sha256=g717IM5xlVLCTg1nLRRccLAFHCsbRO-IgjzG4H6K32A,268
-duckguard-3.0.0.dist-info/METADATA,sha256=bkRQeGGM5c3BcvOZpJeHx4byCHWctL1jgCDHa7VR5kc,31770
-duckguard-3.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-duckguard-3.0.0.dist-info/entry_points.txt,sha256=teP6JdXUvY20E9P44TW_Z24xuQtXMgnCyOuWtd_KIYU,108
-duckguard-3.0.0.dist-info/licenses/LICENSE,sha256=1Li9P3fainL-epQ9kEHZWKDScWtp4inPd6AkhUTJStk,3841
-duckguard-3.0.0.dist-info/RECORD,,
+duckguard-3.0.1.dist-info/METADATA,sha256=9jLfixYYUu4coNP0hadedJL2pacYkyjqD6vBtwQj6Og,31770
+duckguard-3.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+duckguard-3.0.1.dist-info/entry_points.txt,sha256=teP6JdXUvY20E9P44TW_Z24xuQtXMgnCyOuWtd_KIYU,108
+duckguard-3.0.1.dist-info/licenses/LICENSE,sha256=1Li9P3fainL-epQ9kEHZWKDScWtp4inPd6AkhUTJStk,3841
+duckguard-3.0.1.dist-info/RECORD,,