duckguard 2.0.0__py3-none-any.whl

duckguard/semantic/validators.py

@@ -0,0 +1,354 @@
+"""Semantic type validators for DuckGuard.
+
+Provides validation functions specific to each semantic type.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from duckguard.semantic.detector import SemanticType
+
+
+@dataclass
+class Validator:
+    """A validation function for a semantic type.
+
+    Attributes:
+        name: Validator name
+        description: Human-readable description
+        validate: Validation function (value -> bool)
+        pattern: Optional regex pattern
+        error_message: Message template for failures
+    """
+
+    name: str
+    description: str
+    validate: Callable[[Any], bool]
+    pattern: str | None = None
+    error_message: str = "Value failed validation"
+
+
+def _make_pattern_validator(pattern: str, flags: int = 0) -> Callable[[Any], bool]:
+    """Create a validator from a regex pattern."""
+    compiled = re.compile(pattern, flags)
+    return lambda v: bool(compiled.match(str(v))) if v is not None else True
+
+
+def _luhn_check(card_number: str) -> bool:
+    """Validate credit card number using Luhn algorithm."""
+    digits = [int(d) for d in re.sub(r"\D", "", str(card_number))]
+    if len(digits) < 13:
+        return False
+
+    # Luhn algorithm
+    checksum = 0
+    for i, digit in enumerate(reversed(digits)):
+        if i % 2 == 1:
+            digit *= 2
+            if digit > 9:
+                digit -= 9
+        checksum += digit
+
+    return checksum % 10 == 0
+
+
+# Validators by semantic type
+VALIDATORS: dict[SemanticType, list[Validator]] = {
+    SemanticType.EMAIL: [
+        Validator(
+            name="email_format",
+            description="Valid email format",
+            validate=_make_pattern_validator(
+                r"^[\w\.\-\+]+@[\w\.\-]+\.[a-zA-Z]{2,}$"
+            ),
+            pattern=r"^[\w\.\-\+]+@[\w\.\-]+\.[a-zA-Z]{2,}$",
+            error_message="Invalid email format",
+        ),
+    ],
+    SemanticType.PHONE: [
+        Validator(
+            name="phone_format",
+            description="Valid phone number format",
+            validate=_make_pattern_validator(r"^\+?[\d\s\-\(\)\.]{10,}$"),
+            pattern=r"^\+?[\d\s\-\(\)\.]{10,}$",
+            error_message="Invalid phone number format",
+        ),
+    ],
+    SemanticType.URL: [
+        Validator(
+            name="url_format",
+            description="Valid URL format",
+            validate=_make_pattern_validator(
+                r"^https?://[\w\.\-]+(/[\w\.\-\?=&%/]*)?$"
+            ),
+            pattern=r"^https?://[\w\.\-]+(/[\w\.\-\?=&%/]*)?$",
+            error_message="Invalid URL format",
+        ),
+    ],
+    SemanticType.UUID: [
+        Validator(
+            name="uuid_format",
+            description="Valid UUID format",
+            validate=_make_pattern_validator(
+                r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+            ),
+            pattern=r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$",
+            error_message="Invalid UUID format",
+        ),
+    ],
+    SemanticType.SSN: [
+        Validator(
+            name="ssn_format",
+            description="Valid SSN format (XXX-XX-XXXX)",
+            validate=_make_pattern_validator(r"^\d{3}-\d{2}-\d{4}$"),
+            pattern=r"^\d{3}-\d{2}-\d{4}$",
+            error_message="Invalid SSN format",
+        ),
+    ],
+    SemanticType.CREDIT_CARD: [
+        Validator(
+            name="credit_card_format",
+            description="Valid credit card format",
+            validate=_make_pattern_validator(
+                r"^\d{4}[\s\-]?\d{4}[\s\-]?\d{4}[\s\-]?\d{4}$"
+            ),
+            pattern=r"^\d{4}[\s\-]?\d{4}[\s\-]?\d{4}[\s\-]?\d{4}$",
+            error_message="Invalid credit card format",
+        ),
+        Validator(
+            name="credit_card_luhn",
+            description="Valid credit card number (Luhn check)",
+            validate=_luhn_check,
+            error_message="Credit card number fails Luhn check",
+        ),
+    ],
+    SemanticType.IP_ADDRESS: [
+        Validator(
+            name="ipv4_format",
+            description="Valid IPv4 address",
+            validate=lambda v: _validate_ipv4(v),
+            pattern=r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$",
+            error_message="Invalid IPv4 address",
+        ),
+    ],
+    SemanticType.ZIPCODE: [
+        Validator(
+            name="us_zipcode",
+            description="Valid US ZIP code",
+            validate=_make_pattern_validator(r"^\d{5}(-\d{4})?$"),
+            pattern=r"^\d{5}(-\d{4})?$",
+            error_message="Invalid US ZIP code format",
+        ),
+    ],
+    SemanticType.DATE: [
+        Validator(
+            name="iso_date",
+            description="Valid ISO date (YYYY-MM-DD)",
+            validate=lambda v: _validate_date(v),
+            pattern=r"^\d{4}-\d{2}-\d{2}$",
+            error_message="Invalid date format (expected YYYY-MM-DD)",
+        ),
+    ],
+    SemanticType.DATETIME: [
+        Validator(
+            name="iso_datetime",
+            description="Valid ISO datetime",
+            validate=_make_pattern_validator(
+                r"^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}"
+            ),
+            pattern=r"^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}",
+            error_message="Invalid datetime format",
+        ),
+    ],
+    SemanticType.TIME: [
+        Validator(
+            name="time_format",
+            description="Valid time format (HH:MM:SS)",
+            validate=_make_pattern_validator(r"^\d{2}:\d{2}(:\d{2})?$"),
+            pattern=r"^\d{2}:\d{2}(:\d{2})?$",
+            error_message="Invalid time format",
+        ),
+    ],
+    SemanticType.COUNTRY_CODE: [
+        Validator(
+            name="iso_country_code",
+            description="Valid ISO country code",
+            validate=_make_pattern_validator(r"^[A-Z]{2,3}$"),
+            pattern=r"^[A-Z]{2,3}$",
+            error_message="Invalid country code (expected 2-3 letter ISO code)",
+        ),
+    ],
+    SemanticType.LATITUDE: [
+        Validator(
+            name="latitude_range",
+            description="Valid latitude (-90 to 90)",
+            validate=lambda v: _validate_range(v, -90, 90),
+            error_message="Latitude must be between -90 and 90",
+        ),
+    ],
+    SemanticType.LONGITUDE: [
+        Validator(
+            name="longitude_range",
+            description="Valid longitude (-180 to 180)",
+            validate=lambda v: _validate_range(v, -180, 180),
+            error_message="Longitude must be between -180 and 180",
+        ),
+    ],
+    SemanticType.PERCENTAGE: [
+        Validator(
+            name="percentage_range",
+            description="Valid percentage (0-100)",
+            validate=lambda v: _validate_range(v, 0, 100),
+            error_message="Percentage must be between 0 and 100",
+        ),
+    ],
+    SemanticType.AGE: [
+        Validator(
+            name="age_range",
+            description="Valid age (0-150)",
+            validate=lambda v: _validate_range(v, 0, 150),
+            error_message="Age must be between 0 and 150",
+        ),
+    ],
+    SemanticType.CURRENCY: [
+        Validator(
+            name="non_negative",
+            description="Non-negative currency amount",
+            validate=lambda v: v is None or float(v) >= 0,
+            error_message="Currency amount cannot be negative",
+        ),
+    ],
+    SemanticType.SLUG: [
+        Validator(
+            name="slug_format",
+            description="Valid URL slug",
+            validate=_make_pattern_validator(r"^[a-z0-9]+(?:-[a-z0-9]+)*$"),
+            pattern=r"^[a-z0-9]+(?:-[a-z0-9]+)*$",
+            error_message="Invalid slug format",
+        ),
+    ],
+}
+
+
+def _validate_ipv4(value: Any) -> bool:
+    """Validate IPv4 address."""
+    if value is None:
+        return True
+    try:
+        parts = str(value).split(".")
+        if len(parts) != 4:
+            return False
+        return all(0 <= int(part) <= 255 for part in parts)
+    except (ValueError, AttributeError):
+        return False
+
+
+def _validate_date(value: Any) -> bool:
+    """Validate ISO date format and values."""
+    if value is None:
+        return True
+    try:
+        from datetime import datetime
+        datetime.strptime(str(value), "%Y-%m-%d")
+        return True
+    except (ValueError, AttributeError):
+        return False
+
+
+def _validate_range(value: Any, min_val: float, max_val: float) -> bool:
+    """Validate numeric range."""
+    if value is None:
+        return True
+    try:
+        num = float(value)
+        return min_val <= num <= max_val
+    except (ValueError, TypeError):
+        return False
+
+
+def get_validator_for_type(semantic_type: SemanticType) -> list[Validator]:
+    """Get validators for a semantic type.
+
+    Args:
+        semantic_type: The semantic type
+
+    Returns:
+        List of validators for that type
+    """
+    return VALIDATORS.get(semantic_type, [])
+
+
+def validate_value(value: Any, semantic_type: SemanticType) -> tuple[bool, list[str]]:
+    """Validate a value against its semantic type.
+
+    Args:
+        value: Value to validate
+        semantic_type: Expected semantic type
+
+    Returns:
+        Tuple of (is_valid, list of error messages)
+    """
+    validators = get_validator_for_type(semantic_type)
+    errors = []
+
+    for validator in validators:
+        try:
+            if not validator.validate(value):
+                errors.append(validator.error_message)
+        except Exception as e:
+            errors.append(f"Validation error: {e}")
+
+    return len(errors) == 0, errors
+
+
+def validate_column_values(
+    values: list[Any],
+    semantic_type: SemanticType
+) -> tuple[int, int, list[tuple[Any, str]]]:
+    """Validate a list of values against a semantic type.
+
+    Args:
+        values: Values to validate
+        semantic_type: Expected semantic type
+
+    Returns:
+        Tuple of (valid_count, invalid_count, list of (invalid_value, error) tuples)
+    """
+    validators = get_validator_for_type(semantic_type)
+    if not validators:
+        return len(values), 0, []
+
+    valid_count = 0
+    invalid_count = 0
+    invalid_samples: list[tuple[Any, str]] = []
+
+    for value in values:
+        if value is None:
+            valid_count += 1
+            continue
+
+        is_valid = True
+        error_msg = ""
+
+        for validator in validators:
+            try:
+                if not validator.validate(value):
+                    is_valid = False
+                    error_msg = validator.error_message
+                    break
+            except Exception as e:
+                is_valid = False
+                error_msg = str(e)
+                break
+
+        if is_valid:
+            valid_count += 1
+        else:
+            invalid_count += 1
+            if len(invalid_samples) < 10:  # Keep first 10 samples
+                invalid_samples.append((value, error_msg))
+
+    return valid_count, invalid_count, invalid_samples

duckguard/validators/__init__.py

@@ -0,0 +1,7 @@
+"""Validators module - validation logic is built into Column class."""
+
+# Note: The validation methods are implemented directly in the Column class
+# for a cleaner API. This module exists for potential future expansion
+# and for backwards compatibility.
+
+__all__ = []

duckguard-2.0.0.dist-info/METADATA

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: duckguard
+Version: 2.0.0
+Summary: A Python-native data quality tool with AI superpowers, built on DuckDB for speed
+Project-URL: Homepage, https://github.com/duckguard/duckguard
+Project-URL: Documentation, https://duckguard.dev
+Project-URL: Repository, https://github.com/duckguard/duckguard
+Author: DuckGuard Team
+License-Expression: Elastic-2.0
+License-File: LICENSE
+Keywords: data-engineering,data-quality,data-validation,duckdb,testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: duckdb>=1.0.0
+Requires-Dist: packaging>=21.0
+Requires-Dist: pyarrow>=14.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: all
+Requires-Dist: anthropic>=0.18.0; extra == 'all'
+Requires-Dist: databricks-sql-connector>=2.0.0; extra == 'all'
+Requires-Dist: google-cloud-bigquery>=3.0.0; extra == 'all'
+Requires-Dist: kafka-python>=2.0.0; extra == 'all'
+Requires-Dist: openai>=1.0.0; extra == 'all'
+Requires-Dist: oracledb>=1.0.0; extra == 'all'
+Requires-Dist: psycopg2-binary>=2.9.0; extra == 'all'
+Requires-Dist: pymongo>=4.0.0; extra == 'all'
+Requires-Dist: pymysql>=1.0.0; extra == 'all'
+Requires-Dist: pyodbc>=4.0.0; extra == 'all'
+Requires-Dist: redshift-connector>=2.0.0; extra == 'all'
+Requires-Dist: snowflake-connector-python>=3.0.0; extra == 'all'
+Provides-Extra: bigquery
+Requires-Dist: google-cloud-bigquery>=3.0.0; extra == 'bigquery'
+Provides-Extra: databases
+Requires-Dist: databricks-sql-connector>=2.0.0; extra == 'databases'
+Requires-Dist: google-cloud-bigquery>=3.0.0; extra == 'databases'
+Requires-Dist: kafka-python>=2.0.0; extra == 'databases'
+Requires-Dist: oracledb>=1.0.0; extra == 'databases'
+Requires-Dist: psycopg2-binary>=2.9.0; extra == 'databases'
+Requires-Dist: pymongo>=4.0.0; extra == 'databases'
+Requires-Dist: pymysql>=1.0.0; extra == 'databases'
+Requires-Dist: pyodbc>=4.0.0; extra == 'databases'
+Requires-Dist: redshift-connector>=2.0.0; extra == 'databases'
+Requires-Dist: snowflake-connector-python>=3.0.0; extra == 'databases'
+Provides-Extra: databricks
+Requires-Dist: databricks-sql-connector>=2.0.0; extra == 'databricks'
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: kafka
+Requires-Dist: kafka-python>=2.0.0; extra == 'kafka'
+Provides-Extra: llm
+Requires-Dist: anthropic>=0.18.0; extra == 'llm'
+Requires-Dist: openai>=1.0.0; extra == 'llm'
+Provides-Extra: mongodb
+Requires-Dist: pymongo>=4.0.0; extra == 'mongodb'
+Provides-Extra: mysql
+Requires-Dist: pymysql>=1.0.0; extra == 'mysql'
+Provides-Extra: oracle
+Requires-Dist: oracledb>=1.0.0; extra == 'oracle'
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary>=2.9.0; extra == 'postgres'
+Provides-Extra: redshift
+Requires-Dist: redshift-connector>=2.0.0; extra == 'redshift'
+Provides-Extra: snowflake
+Requires-Dist: snowflake-connector-python>=3.0.0; extra == 'snowflake'
+Provides-Extra: sqlserver
+Requires-Dist: pyodbc>=4.0.0; extra == 'sqlserver'
+Description-Content-Type: text/markdown
+
+# DuckGuard
+
+Data quality that just works. Python-native, DuckDB-powered, 10x faster.
+
+[![PyPI version](https://badge.fury.io/py/duckguard.svg)](https://badge.fury.io/py/duckguard)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: Elastic-2.0](https://img.shields.io/badge/License-Elastic--2.0-blue.svg)](https://www.elastic.co/licensing/elastic-license)
+
+```bash
+pip install duckguard
+```
+
+## 60-Second Demo
+
+```bash
+# CLI - instant data quality check
+duckguard check data.csv
+
+# Auto-generate validation rules
+duckguard discover data.csv --output duckguard.yaml
+```
+
+```python
+# Python - feels like pytest
+from duckguard import connect
+
+orders = connect("data/orders.csv")
+
+assert orders.row_count > 0
+assert orders.customer_id.null_percent < 5
+assert orders.amount.between(0, 10000)
+assert orders.status.isin(['pending', 'shipped', 'delivered'])
+```
+
+## Key Features
+
+| Feature | Description |
+|---------|-------------|
+| **Quality Scoring** | Get A-F grades for your data |
+| **YAML Rules** | Define checks in simple YAML files |
+| **Semantic Detection** | Auto-detect emails, phones, SSNs, PII |
+| **Data Contracts** | Schema + SLAs with breaking change detection |
+| **Anomaly Detection** | Z-score, IQR, and percent change methods |
+| **pytest Integration** | Data tests alongside unit tests |
+
+## Quick Examples
+
+### Quality Score
+```python
+quality = orders.score()
+print(f"Grade: {quality.grade}")  # A, B, C, D, or F
+```
+
+### YAML Rules
+```yaml
+# duckguard.yaml
+dataset: orders
+rules:
+  - order_id is not null
+  - order_id is unique
+  - amount >= 0
+  - status in ['pending', 'shipped', 'delivered']
+```
+
+```python
+from duckguard import load_rules, execute_rules
+result = execute_rules(load_rules("duckguard.yaml"), dataset=orders)
+```
+
+### PII Detection
+```python
+from duckguard.semantic import SemanticAnalyzer
+analysis = SemanticAnalyzer().analyze(orders)
+print(f"PII found: {analysis.pii_columns}")
+```
+
+### Anomaly Detection
+```python
+from duckguard import detect_anomalies
+report = detect_anomalies(orders, method="zscore")
+```
+
+### Data Contracts
+```python
+from duckguard import generate_contract, validate_contract
+contract = generate_contract(orders)
+result = validate_contract(contract, new_orders)
+```
+
+## Supported Sources
+
+**Files:** CSV, Parquet, JSON, Excel
+**Cloud:** S3, GCS, Azure Blob
+**Databases:** PostgreSQL, MySQL, SQLite, Snowflake, BigQuery, Redshift, Databricks, SQL Server, Oracle, MongoDB
+**Formats:** Delta Lake, Apache Iceberg
+
+```python
+# Connect to anything
+orders = connect("s3://bucket/orders.parquet")
+orders = connect("postgres://localhost/db", table="orders")
+orders = connect("snowflake://account/db", table="orders")
+```
+
+## CLI Commands
+
+```bash
+duckguard check <file>       # Run quality checks
+duckguard discover <file>    # Auto-generate rules
+duckguard contract generate  # Create data contract
+duckguard contract validate  # Validate against contract
+duckguard anomaly <file>     # Detect anomalies
+```
+
+## Column Methods
+
+```python
+# Statistics
+col.null_percent, col.unique_percent
+col.min, col.max, col.mean, col.stddev
+
+# Validations
+col.between(0, 100)
+col.matches(r'^\d{5}$')
+col.isin(['a', 'b', 'c'])
+col.has_no_duplicates()
+```
+
+## Performance
+
+Built on DuckDB for speed:
+
+| | Pandas/GX | DuckGuard |
+|---|---|---|
+| 1GB CSV | 45s, 4GB RAM | 4s, 200MB RAM |
+
+## License
+
+Elastic License 2.0 - see [LICENSE](LICENSE)

duckguard-2.0.0.dist-info/RECORD

@@ -0,0 +1,55 @@
+duckguard/__init__.py,sha256=wxGbL0z4mLna0KajP_Mjlo5ldneGmSZnu1kPlzeRtNo,2339
+duckguard/anomaly/__init__.py,sha256=PB7fvywbLVzsA_M1jv-JWIGnCL3uyW6fvdZWO3Xrl1A,741
+duckguard/anomaly/detector.py,sha256=6F4BU-Xn97XhS5PzXGS4Ku3Cp_fSUC4s6hLn2YzFgEk,12520
+duckguard/anomaly/methods.py,sha256=woLJ3MQsvroawlN1pqFQxA8xqdZEpUlFP4zVSUJo_p4,12774
+duckguard/cli/__init__.py,sha256=s5MNXEu_MbRqyV-jeUgCIDlHRQA97a9knM_anJooTl0,87
+duckguard/cli/main.py,sha256=zGwT9AiqHBmUFuCNL2qOYjOlHjEadiFbo70iu3CxVhM,24486
+duckguard/connectors/__init__.py,sha256=nAZA214EKTQqVJZ0PSgF0hei4NzOKyfdSb994wbToT4,2232
+duckguard/connectors/base.py,sha256=XzGY6_pUwDJIVNhTfgNMkcGNOBs3xxjbnQ_NeMoz4eM,1864
+duckguard/connectors/bigquery.py,sha256=Zy6sT0z1ve91imLVBHR7f7GlSRv8A6TLKh0VYMa39bc,5327
+duckguard/connectors/databricks.py,sha256=yBs2v51WL7jWSoI86log9uAdQ1GZS4iLKVZJis-A-28,6550
+duckguard/connectors/factory.py,sha256=dScZqRAQ3BJgpEVmB44VhL6jrLHX8oxhjBgZ_aL5X5A,9157
+duckguard/connectors/files.py,sha256=ulDvFhODv9cMqgFgIBKCF68fWrC4bxL13PNZasEBIH0,3841
+duckguard/connectors/kafka.py,sha256=xO0Zq-Krj0TDN-svVZEnqR8wYhVunZMF3PbyR26lMd8,10711
+duckguard/connectors/mongodb.py,sha256=QtNBMdbc_ZSj00-4MFx7MvmD6GslwxlDWv-h0Gc5MPg,7271
+duckguard/connectors/mysql.py,sha256=vYHPhSXByLXcwwj_f67b2NCcu9PAtsbtBQ3xJAbxuI8,3875
+duckguard/connectors/oracle.py,sha256=sYERxtanasZaQxD-cXqzA2LeOfWhxY2bm-vPV-xd9DI,6178
+duckguard/connectors/postgres.py,sha256=fOb6LFl9NvDsqZAVCyKMSu7oZ6EycmPERs8VdnArfWQ,3071
+duckguard/connectors/redshift.py,sha256=-m_eiEo-yTVjUu0RtWYBwM4PZS5QiFcjdrYXZDipBpg,4951
+duckguard/connectors/snowflake.py,sha256=a-jO6g7NuFnvR3KXpmYVmilgsJfQe0ZQXF4gjIpBHF8,7118
+duckguard/connectors/sqlite.py,sha256=kuS7ZeblORJ1noruwfjIUGuzLIculi2WqX4BldWSlyI,3346
+duckguard/connectors/sqlserver.py,sha256=p17F7hguRbDx93nYsjrZ3DXOrfevnPAoGNYIL0p3TG8,7582
+duckguard/contracts/__init__.py,sha256=ryEK_amxt0m_sCy7dywYL07MSZA8WNKcVYVcQhe-e9M,1313
+duckguard/contracts/diff.py,sha256=Ztcd0mbvMGw9Md8HvGJK4rPwfwhZPXd5fb8upiFIxPM,15085
+duckguard/contracts/generator.py,sha256=dZhxbSx0B_-oC2zimL7Jg6W7_l3lTaKsOXJ51fBBcX8,10992
+duckguard/contracts/loader.py,sha256=ydUL6_xf-028ug224u7vZiSSpOvtUt408I4l-ONmmIA,10883
+duckguard/contracts/schema.py,sha256=pLoR4QIXs68Q93DOZqqTmPnPecCeZ4iy9lDXZMNuVmI,7032
+duckguard/contracts/validator.py,sha256=rDUKQZHxcptHmBWI5z4YJxoM871_MG1K13gfW74OGPk,16464
+duckguard/core/__init__.py,sha256=E9lCV2G7OqsQt-usfFPjWi4Bn5qgkEM8GZwgohVzyMY,356
+duckguard/core/column.py,sha256=3I6e36cZPI29m4T4OiYk6sXkswrvL8KVdmOOqwhyBME,13489
+duckguard/core/dataset.py,sha256=OOrKJ-rPl1xCgr-jHH-rpdoADBWSK6j7uw3XVwHMJVM,8287
+duckguard/core/engine.py,sha256=ld_NHsWyBkVynmWyvbyQcHdXHhpIoSaRDyqAAtVx8J0,7897
+duckguard/core/result.py,sha256=wzggv0ra0EbgjcjhuK0wIS8_mO133XKKc1Hs_JLnzoY,3052
+duckguard/core/scoring.py,sha256=W37qJio035M2zOqRV1CDm6IUTzljdGEAZe5Vh610jpg,16876
+duckguard/profiler/__init__.py,sha256=a16GYeeFDZzwCemTsTuzO3Ih4M7_hOPb9hS8yt-nHzU,169
+duckguard/profiler/auto_profile.py,sha256=hS9Ef1aAbwrqYMAxrsNsFJRV8wNuMlNKR19lqkOxwSE,12275
+duckguard/pytest_plugin/__init__.py,sha256=YTu7eG2Kb_d_g4wzsakb5jwJtxleKTVB_MDgHvhSEJ0,168
+duckguard/pytest_plugin/plugin.py,sha256=9kVuUoa18DWdzHspMmvkLfJaoXOwpPbTN8cRLZHZ7LE,4949
+duckguard/reporting/__init__.py,sha256=R7Fm--yEiuOb_II-Qo7MGXYyCNhsGnVsMVuAzZT6rIM,199
+duckguard/reporting/console.py,sha256=NKTnUaiQO9trMCiYyNSym3MZCA_F8C8nd8Ai2HnEh4Y,3026
+duckguard/reporting/json_report.py,sha256=dqUry9akuPRwNz4ysUM6ZP6ZCXl77nA_Z7mXG-1VGKA,3509
+duckguard/rules/__init__.py,sha256=QvMDHQRKMDzwp2YEPHeW7Nlk4FHeqfwPXjR7BoK2UVA,813
+duckguard/rules/executor.py,sha256=353t9sKzQrmNNAhBpoR04X1tGhdcbP2UCIUBN0WIlQ4,20771
+duckguard/rules/generator.py,sha256=OMpaHbEsl_wxBDB7gb7DyRmkI1nkJD6BhN6955O4qwE,10989
+duckguard/rules/loader.py,sha256=XRFvFEXEFVMqUW3XM1fhFgzzjj992lgaFhpXSMbqeHI,14627
+duckguard/rules/schema.py,sha256=KkUAUjQBNbDLRX_XfiXc6DH8EdK4Zbd3NqupKjkoZjc,9326
+duckguard/semantic/__init__.py,sha256=Z_nxl5bwSyJZnyHTU2pkiSePX7chreejR6qaDlgzZc0,847
+duckguard/semantic/analyzer.py,sha256=nw1kUj_56sHBl6luYMgdRdFgaN3-GGMxh40-sxGYRM8,8336
+duckguard/semantic/detector.py,sha256=YUAPj-CEiKQCQn2BjnL5gzETH4N4ffV1EIdGcD4r3ms,14872
+duckguard/semantic/validators.py,sha256=iZv0_983fPeX6GLv030qWBIAHq3fRK9gfZIYeZymBUE,10918
+duckguard/validators/__init__.py,sha256=g717IM5xlVLCTg1nLRRccLAFHCsbRO-IgjzG4H6K32A,268
+duckguard-2.0.0.dist-info/METADATA,sha256=gSkdAUaMl-j6G2OisrQwoaa8WRl5Yh7GIJGra9zqbd4,7054
+duckguard-2.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+duckguard-2.0.0.dist-info/entry_points.txt,sha256=teP6JdXUvY20E9P44TW_Z24xuQtXMgnCyOuWtd_KIYU,108
+duckguard-2.0.0.dist-info/licenses/LICENSE,sha256=1Li9P3fainL-epQ9kEHZWKDScWtp4inPd6AkhUTJStk,3841
+duckguard-2.0.0.dist-info/RECORD,,

duckguard-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

duckguard-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+duckguard = duckguard.cli.main:app
+
+[pytest11]
+duckguard = duckguard.pytest_plugin.plugin