dqflow 0.1.0__py3-none-any.whl

dqflow/__init__.py

@@ -0,0 +1,8 @@
+"""dqflow - Lightweight, contract-first data quality engine."""
+
+from dqflow.column import Column
+from dqflow.contract import Contract
+from dqflow.result import ValidationResult
+
+__version__ = "0.1.0"
+__all__ = ["Contract", "Column", "ValidationResult"]

dqflow/cli.py

@@ -0,0 +1,130 @@
+"""Command-line interface for dqflow."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import click
+import pandas as pd
+
+from dqflow import __version__
+from dqflow.contract import Contract
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="dqflow")
+def main() -> None:
+    """dqflow - Contract-first data quality for modern pipelines."""
+    pass
+
+
+@main.command()
+@click.argument("contract", type=click.Path(exists=True, path_type=Path))
+@click.argument("data", type=click.Path(exists=True, path_type=Path))
+@click.option("--output", "-o", type=click.Choice(["text", "json"]), default="text")
+@click.option("--fail-fast", is_flag=True, help="Exit with error code on validation failure")
+def validate(contract: Path, data: Path, output: str, fail_fast: bool) -> None:
+    """Validate DATA against CONTRACT.
+
+    CONTRACT: Path to contract YAML file
+    DATA: Path to data file (parquet, csv, json)
+    """
+    # Load contract
+    c = Contract.from_yaml(contract)
+
+    # Load data based on extension
+    df = _load_dataframe(data)
+
+    # Validate
+    result = c.validate(df)
+
+    # Output results
+    if output == "json":
+        click.echo(json.dumps(result.to_dict(), indent=2))
+    else:
+        click.echo(result.summary())
+
+    if fail_fast and not result.ok:
+        sys.exit(1)
+
+
+@main.command()
+@click.argument("contract", type=click.Path(exists=True, path_type=Path))
+def show(contract: Path) -> None:
+    """Show details of a CONTRACT."""
+    c = Contract.from_yaml(contract)
+
+    click.echo(f"Contract: {c.name}")
+    if c.description:
+        click.echo(f"Description: {c.description}")
+    click.echo()
+
+    click.echo("Columns:")
+    for col_name, col_def in c.columns.items():
+        constraints = []
+        if col_def.not_null:
+            constraints.append("NOT NULL")
+        if col_def.min is not None:
+            constraints.append(f"min={col_def.min}")
+        if col_def.max is not None:
+            constraints.append(f"max={col_def.max}")
+        if col_def.allowed:
+            constraints.append(f"allowed={col_def.allowed}")
+        if col_def.freshness_minutes:
+            constraints.append(f"freshness={col_def.freshness_minutes}m")
+
+        constraint_str = f" ({', '.join(constraints)})" if constraints else ""
+        click.echo(f"  {col_name}: {col_def.dtype}{constraint_str}")
+
+    if c.rules:
+        click.echo()
+        click.echo("Rules:")
+        for rule in c.rules:
+            click.echo(f"  - {rule}")
+
+
+@main.command()
+@click.argument("data", type=click.Path(exists=True, path_type=Path))
+@click.argument("output", type=click.Path(path_type=Path))
+def infer(data: Path, output: Path) -> None:
+    """Infer a contract from DATA and write to OUTPUT."""
+    df = _load_dataframe(data)
+
+    from dqflow.column import Column
+
+    columns = {}
+    for col in df.columns:
+        dtype = df[col].dtype
+        if pd.api.types.is_integer_dtype(dtype):
+            columns[col] = Column(dtype=int)
+        elif pd.api.types.is_float_dtype(dtype):
+            columns[col] = Column(dtype=float)
+        elif pd.api.types.is_bool_dtype(dtype):
+            columns[col] = Column(dtype=bool)
+        elif pd.api.types.is_datetime64_any_dtype(dtype):
+            columns[col] = Column(dtype="timestamp")
+        else:
+            columns[col] = Column(dtype=str)
+
+    contract = Contract(name=output.stem, columns=columns)
+    contract.to_yaml(output)
+    click.echo(f"Contract written to {output}")
+
+
+def _load_dataframe(path: Path) -> pd.DataFrame:
+    """Load DataFrame from file based on extension."""
+    suffix = path.suffix.lower()
+    if suffix == ".parquet":
+        return pd.read_parquet(path)
+    elif suffix == ".csv":
+        return pd.read_csv(path)
+    elif suffix == ".json":
+        return pd.read_json(path)
+    else:
+        raise click.ClickException(f"Unsupported file format: {suffix}")
+
+
+if __name__ == "__main__":
+    main()

dqflow/column.py

@@ -0,0 +1,25 @@
+"""Column definition and validation logic."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Column:
+    """Define expectations for a single column."""
+
+    dtype: type | str
+    not_null: bool = False
+    min: float | None = None
+    max: float | None = None
+    allowed: Sequence[Any] | None = None
+    freshness_minutes: int | None = None
+    description: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.min is not None and self.max is not None and self.min > self.max:
+            raise ValueError(f"min ({self.min}) cannot be greater than max ({self.max})")

dqflow/contract.py

@@ -0,0 +1,102 @@
+"""Contract definition and validation orchestration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import yaml
+
+from dqflow.column import Column
+from dqflow.result import ValidationResult
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+@dataclass
+class Contract:
+    """Data quality contract defining expectations for a dataset."""
+
+    name: str
+    columns: dict[str, Column] = field(default_factory=dict)
+    rules: list[str] = field(default_factory=list)
+    description: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def validate(self, df: pd.DataFrame) -> ValidationResult:
+        """Validate a DataFrame against this contract."""
+        from dqflow.engines.pandas import PandasEngine
+
+        engine = PandasEngine()
+        return engine.validate(df, self)
+
+    @classmethod
+    def from_yaml(cls, path: str | Path) -> Contract:
+        """Load contract from YAML file."""
+        path = Path(path)
+        with path.open() as f:
+            data = yaml.safe_load(f)
+
+        columns = {}
+        for col_name, col_def in data.get("columns", {}).items():
+            if isinstance(col_def, dict):
+                dtype = col_def.pop("type", str)
+                columns[col_name] = Column(dtype=dtype, **col_def)
+            else:
+                columns[col_name] = Column(dtype=col_def)
+
+        return cls(
+            name=data.get("name", path.stem),
+            columns=columns,
+            rules=data.get("rules", []),
+            description=data.get("description", ""),
+            metadata=data.get("metadata", {}),
+        )
+
+    def to_yaml(self, path: str | Path) -> None:
+        """Save contract to YAML file."""
+        path = Path(path)
+
+        columns_data = {}
+        for col_name, col in self.columns.items():
+            col_dict: dict[str, Any] = {"type": _dtype_to_str(col.dtype)}
+            if col.not_null:
+                col_dict["not_null"] = True
+            if col.min is not None:
+                col_dict["min"] = col.min
+            if col.max is not None:
+                col_dict["max"] = col.max
+            if col.allowed is not None:
+                col_dict["allowed"] = list(col.allowed)
+            if col.freshness_minutes is not None:
+                col_dict["freshness_minutes"] = col.freshness_minutes
+            columns_data[col_name] = col_dict
+
+        data = {
+            "name": self.name,
+            "columns": columns_data,
+        }
+        if self.rules:
+            data["rules"] = self.rules
+        if self.description:
+            data["description"] = self.description
+
+        with path.open("w") as f:
+            yaml.safe_dump(data, f, default_flow_style=False, sort_keys=False)
+
+
+def _dtype_to_str(dtype: type | str) -> str:
+    """Convert dtype to string representation."""
+    if isinstance(dtype, str):
+        return dtype
+    if dtype is str:
+        return "string"
+    if dtype is int:
+        return "integer"
+    if dtype is float:
+        return "float"
+    if dtype is bool:
+        return "boolean"
+    return str(dtype)

dqflow/engines/__init__.py

@@ -0,0 +1,6 @@
+"""Validation engines."""
+
+from dqflow.engines.base import Engine
+from dqflow.engines.pandas import PandasEngine
+
+__all__ = ["Engine", "PandasEngine"]

dqflow/engines/base.py

@@ -0,0 +1,19 @@
+"""Abstract base engine."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from dqflow.contract import Contract
+    from dqflow.result import ValidationResult
+
+
+class Engine(ABC):
+    """Abstract base class for validation engines."""
+
+    @abstractmethod
+    def validate(self, data: Any, contract: Contract) -> ValidationResult:
+        """Validate data against a contract."""
+        ...

dqflow/engines/pandas.py

@@ -0,0 +1,179 @@
+"""Pandas validation engine."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+import pandas as pd
+
+from dqflow.column import Column
+from dqflow.contract import Contract
+from dqflow.engines.base import Engine
+from dqflow.result import CheckResult, ValidationResult
+
+
+class PandasEngine(Engine):
+    """Validation engine for pandas DataFrames."""
+
+    def validate(self, df: pd.DataFrame, contract: Contract) -> ValidationResult:
+        """Validate a DataFrame against a contract."""
+        result = ValidationResult(contract_name=contract.name)
+
+        # Column existence checks
+        for col_name in contract.columns:
+            if col_name not in df.columns:
+                result.checks.append(
+                    CheckResult(
+                        name=f"column_exists:{col_name}",
+                        passed=False,
+                        message=f"Column '{col_name}' not found in DataFrame",
+                    )
+                )
+            else:
+                result.checks.append(
+                    CheckResult(name=f"column_exists:{col_name}", passed=True)
+                )
+
+        # Column-level checks
+        for col_name, col_def in contract.columns.items():
+            if col_name not in df.columns:
+                continue
+            result.checks.extend(self._validate_column(df[col_name], col_name, col_def))
+
+        # Table-level rules
+        for rule in contract.rules:
+            result.checks.append(self._evaluate_rule(df, rule))
+
+        return result
+
+    def _validate_column(
+        self, series: pd.Series, col_name: str, col_def: Column
+    ) -> list[CheckResult]:
+        """Validate a single column."""
+        checks = []
+
+        # Not null check
+        if col_def.not_null:
+            null_count = series.isna().sum()
+            checks.append(
+                CheckResult(
+                    name=f"not_null:{col_name}",
+                    passed=null_count == 0,
+                    message=f"Found {null_count} null values" if null_count > 0 else "",
+                    details={"null_count": int(null_count)},
+                )
+            )
+
+        # Min check
+        if col_def.min is not None:
+            min_val = series.min()
+            passed = pd.isna(min_val) or min_val >= col_def.min
+            checks.append(
+                CheckResult(
+                    name=f"min:{col_name}",
+                    passed=bool(passed),
+                    message=f"Minimum value {min_val} is below {col_def.min}" if not passed else "",
+                    details={"actual_min": float(min_val) if pd.notna(min_val) else None},
+                )
+            )
+
+        # Max check
+        if col_def.max is not None:
+            max_val = series.max()
+            passed = pd.isna(max_val) or max_val <= col_def.max
+            checks.append(
+                CheckResult(
+                    name=f"max:{col_name}",
+                    passed=bool(passed),
+                    message=f"Maximum value {max_val} exceeds {col_def.max}" if not passed else "",
+                    details={"actual_max": float(max_val) if pd.notna(max_val) else None},
+                )
+            )
+
+        # Allowed values check
+        if col_def.allowed is not None:
+            allowed_set = set(col_def.allowed)
+            unique_vals = set(series.dropna().unique())
+            invalid = unique_vals - allowed_set
+            checks.append(
+                CheckResult(
+                    name=f"allowed:{col_name}",
+                    passed=len(invalid) == 0,
+                    message=f"Found invalid values: {invalid}" if invalid else "",
+                    details={"invalid_values": list(invalid)},
+                )
+            )
+
+        # Freshness check
+        if col_def.freshness_minutes is not None:
+            checks.append(self._check_freshness(series, col_name, col_def.freshness_minutes))
+
+        return checks
+
+    def _check_freshness(
+        self, series: pd.Series, col_name: str, freshness_minutes: int
+    ) -> CheckResult:
+        """Check if timestamp column has recent data."""
+        try:
+            ts_series = pd.to_datetime(series)
+            max_ts = ts_series.max()
+            if pd.isna(max_ts):
+                return CheckResult(
+                    name=f"freshness:{col_name}",
+                    passed=False,
+                    message="No valid timestamps found",
+                )
+
+            now = datetime.now(timezone.utc)
+            if max_ts.tzinfo is None:
+                max_ts = max_ts.replace(tzinfo=timezone.utc)
+
+            age = now - max_ts
+            threshold = timedelta(minutes=freshness_minutes)
+            passed = age <= threshold
+
+            return CheckResult(
+                name=f"freshness:{col_name}",
+                passed=passed,
+                message=f"Data is {age} old, threshold is {threshold}" if not passed else "",
+                details={
+                    "max_timestamp": max_ts.isoformat(),
+                    "age_minutes": age.total_seconds() / 60,
+                },
+            )
+        except Exception as e:
+            return CheckResult(
+                name=f"freshness:{col_name}",
+                passed=False,
+                message=f"Failed to check freshness: {e}",
+            )
+
+    def _evaluate_rule(self, df: pd.DataFrame, rule: str) -> CheckResult:
+        """Evaluate a table-level rule."""
+        try:
+            result = self._parse_and_evaluate(df, rule)
+            return CheckResult(
+                name=f"rule:{rule}",
+                passed=bool(result),
+                message="" if result else f"Rule '{rule}' failed",
+            )
+        except Exception as e:
+            return CheckResult(
+                name=f"rule:{rule}",
+                passed=False,
+                message=f"Failed to evaluate rule: {e}",
+            )
+
+    def _parse_and_evaluate(self, df: pd.DataFrame, rule: str) -> Any:
+        """Parse and evaluate a rule expression."""
+        # Simple rule parser - extend as needed
+        context = {
+            "row_count": len(df),
+            "null_rate": lambda col: df[col].isna().mean() if col in df.columns else 1.0,
+            "unique_count": lambda col: df[col].nunique() if col in df.columns else 0,
+            "duplicate_rate": lambda col: (
+                1 - (df[col].nunique() / len(df)) if col in df.columns and len(df) > 0 else 0
+            ),
+        }
+        return eval(rule, {"__builtins__": {}}, context)

dqflow/result.py

@@ -0,0 +1,68 @@
+"""Validation result structures."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class CheckResult:
+    """Result of a single validation check."""
+
+    name: str
+    passed: bool
+    message: str = ""
+    details: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ValidationResult:
+    """Aggregated result of contract validation."""
+
+    contract_name: str
+    checks: list[CheckResult] = field(default_factory=list)
+
+    @property
+    def ok(self) -> bool:
+        """Return True if all checks passed."""
+        return all(check.passed for check in self.checks)
+
+    @property
+    def failed_checks(self) -> list[CheckResult]:
+        """Return list of failed checks."""
+        return [check for check in self.checks if not check.passed]
+
+    def summary(self) -> str:
+        """Return human-readable summary."""
+        total = len(self.checks)
+        passed = sum(1 for c in self.checks if c.passed)
+        failed = total - passed
+
+        lines = [f"Contract '{self.contract_name}': {passed}/{total} checks passed"]
+
+        if failed > 0:
+            lines.append("Failed checks:")
+            for check in self.failed_checks:
+                lines.append(f"  - {check.name}: {check.message}")
+
+        return "\n".join(lines)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return JSON-serializable dict."""
+        return {
+            "contract_name": self.contract_name,
+            "ok": self.ok,
+            "total_checks": len(self.checks),
+            "passed": sum(1 for c in self.checks if c.passed),
+            "failed": sum(1 for c in self.checks if not c.passed),
+            "checks": [
+                {
+                    "name": c.name,
+                    "passed": c.passed,
+                    "message": c.message,
+                    "details": c.details,
+                }
+                for c in self.checks
+            ],
+        }

dqflow-0.1.0.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: dqflow
+Version: 0.1.0
+Summary: Lightweight, contract-first data quality engine for modern data pipelines
+Project-URL: Homepage, https://github.com/quang/dqflow
+Project-URL: Repository, https://github.com/quang/dqflow
+Project-URL: Issues, https://github.com/quang/dqflow/issues
+Author-email: Quang <nguyenvanquang247@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: data-contracts,data-quality,data-validation,etl,pandas
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Requires-Dist: pandas>=1.5.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dqflow
+
+**dqflow** is a lightweight, contract-first data quality engine for modern data pipelines.
+
+Define explicit expectations for your data (schema, validity, freshness) and **fail fast** when data breaks — before bad data reaches downstream systems.
+
+---
+
+## Why dqflow?
+
+Data quality issues are inevitable — silent failures are not.
+
+Most teams rely on ad-hoc checks, fragile assertions, or heavyweight frameworks that are hard to maintain. dqflow takes a different approach:
+
+* **Contracts over checks** — expectations are explicit and versionable
+* **Pipeline-first** — designed for ETL, ELT, and streaming workflows
+* **Lightweight & Pythonic** — minimal API, easy to embed
+* **Fail fast** — break pipelines intentionally, not silently
+
+---
+
+## Quick example
+
+```python
+from dqflow import Contract, Column
+
+orders = Contract(
+    name="orders",
+    columns={
+        "order_id": Column(str, not_null=True),
+        "amount": Column(float, min=0),
+        "currency": Column(str, allowed=["USD", "EUR"]),
+        "created_at": Column("timestamp", freshness_minutes=60),
+    },
+    rules=[
+        "row_count > 1000",
+        "null_rate(amount) < 0.01",
+    ],
+)
+
+result = orders.validate(df)
+
+if not result.ok:
+    raise Exception(result.summary())
+```
+
+---
+
+## Features (v0.1 scope)
+
+* Contract-as-code (Python & YAML)
+* Column-level checks
+
+  * type validation
+  * not null
+  * min / max
+  * allowed values
+* Table-level checks
+
+  * row count
+  * freshness
+* Structured validation results (JSON-friendly)
+* Pandas engine
+* CLI support
+
+---
+
+## CLI usage
+
+```bash
+dq validate contracts/orders.yaml data/orders.parquet
+```
+
+---
+
+## Supported engines
+
+* ✅ Pandas
+* 🚧 PySpark (planned)
+* 🚧 SQL tables (planned)
+
+---
+
+## Philosophy
+
+* **Explicit is better than implicit**
+* **Bad data should break pipelines early**
+* **Quality rules are part of your system design**
+
+> dqflow is not a full data observability platform.
+> It is a small, opinionated library meant to be embedded directly into pipelines.
+
+---
+
+## Roadmap
+
+* PySpark engine
+* dbt / dlt integrations
+* Incremental & backfill-aware validation
+* Metrics export (Prometheus-compatible)
+
+---
+
+## License
+
+MIT
+
+---
+
+## Status
+
+🚧 Early development (v0.1.0)
+
+APIs may change. Feedback and contributions are welcome.

dqflow-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+dqflow/__init__.py,sha256=zHtLJbdDnm8eSEHnhzLqMD28dfOpINX4DGQkoNWWsWg,254
+dqflow/cli.py,sha256=Nl8HYmPt-BV8r4BJo8zTJIwGZkJH_v3cNbqGDozVn8E,3945
+dqflow/column.py,sha256=WkX7UwirIr7SPhBrcz7Ed0e0RPCQOsxIq7bOPtR8Scg,747
+dqflow/contract.py,sha256=hXQpwt44SCKyAFO7dwITFzZo6NuGPOesWZOKMvCffIQ,3137
+dqflow/result.py,sha256=kuXMgK8nPn52v6bbHfiqlpPdWKzoziwVQcXweEh3hto,1959
+dqflow/engines/__init__.py,sha256=b-TtUG7wQc-Z1O42E5lhOvHU-XpTrxNiaRx2hnGv-74,151
+dqflow/engines/base.py,sha256=5RnXf3CqQ73ScuvMRul7PqlFfRdqDljwUpg4VqZiYbo,477
+dqflow/engines/pandas.py,sha256=8JT9OcssVCNdGBcaYPxB9bJyRwlEwjaHbzvrBR16jcI,6534
+dqflow-0.1.0.dist-info/METADATA,sha256=nE1zRlHJ_9uaBHqNx_Uely4lcXWcPhNbeoeZZmtlFwk,3617
+dqflow-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dqflow-0.1.0.dist-info/entry_points.txt,sha256=sS9ovPRPoTFro_Pi-5cAhj7HJoilZTYQYGoBstFiXIU,39
+dqflow-0.1.0.dist-info/licenses/LICENSE,sha256=csldIGJQ7mpAJegge6WFFzOIvLVGUO8CWz0xf57Mj9g,1062
+dqflow-0.1.0.dist-info/RECORD,,

dqflow-0.1.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

dqflow-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dq = dqflow.cli:main

dqflow-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Quang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.