datadile 0.1.0__py3-none-any.whl

datadile/__init__.py

@@ -0,0 +1,3 @@
+from .core import main
+
+__all__ = ["main"]

datadile/config.py

@@ -0,0 +1,125 @@
+import os
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+CONFIG_FILENAME = "datadile.yaml"
+USER_CONFIG_PATH = Path.home() / ".datadile" / CONFIG_FILENAME
+DEFAULT_API_KEY_ENV = "DATADILE_API_KEY"
+DEFAULT_DATA_SOURCE_PASSWORD_ENV = "DATADILE_DATA_SOURCE_PASSWORD"
+
+CONFIG_TEMPLATE = """\
+# Optional. Only required for premium server-backed features.
+api_key_env: DATADILE_API_KEY
+
+# Optional. Used by tests that do not set data_source.
+default_data_source: main
+
+data_sources:
+  main:
+    type: postgresql
+    host: localhost
+    port: 5432
+    user: myuser
+    database: mydb
+    password_env: DATADILE_DATA_SOURCE_PASSWORD
+
+# Premium server-backed data source example:
+# data_sources:
+#   main:
+#     id: ds_abc123
+"""
+
+
+def _find_config_file() -> Path | None:
+    local = Path(CONFIG_FILENAME)
+    if local.exists():
+        return local
+    if USER_CONFIG_PATH.exists():
+        return USER_CONFIG_PATH
+    return None
+
+
+def load_config(required: bool = True) -> dict[str, Any]:
+    config_path = _find_config_file()
+    if config_path is None:
+        if not required:
+            return {}
+        raise FileNotFoundError(
+            f"No config file found. Create one at:\n"
+            f"  ./{CONFIG_FILENAME}\n"
+            f"  {USER_CONFIG_PATH}\n\n"
+            f"Template:\n{CONFIG_TEMPLATE}"
+        )
+
+    with config_path.open() as f:
+        config = yaml.safe_load(f) or {}
+
+    if not isinstance(config, dict):
+        raise ValueError(f"Config file {config_path} must contain a YAML mapping.")
+    return config
+
+
+def get_api_key() -> str | None:
+    config = load_config(required=False)
+    if config.get("api_key"):
+        raise ValueError("Do not put API keys in datadile.yaml. Use api_key_env instead.")
+
+    api_key_env = str(config.get("api_key_env", DEFAULT_API_KEY_ENV))
+    return os.environ.get(api_key_env)
+
+
+def get_api_host() -> str:
+    config = load_config(required=False)
+    return str(config.get("api_host", "datadile.io"))
+
+
+def _resolve_data_source_config(data_source: Any, label: str) -> dict[str, Any]:
+    if not isinstance(data_source, dict):
+        raise KeyError(f"Missing {label} mapping in config file.")
+
+    if data_source.get("id"):
+        api_key = get_api_key()
+        if not api_key:
+            api_key_env = str(load_config(required=False).get("api_key_env", DEFAULT_API_KEY_ENV))
+            raise ValueError(
+                f"{label}.id requires an API key for server-backed data source access. "
+                f"Set the {api_key_env} environment variable."
+            )
+        return {"id": str(data_source["id"]), "api_key": api_key, "api_host": get_api_host()}
+
+    if data_source.get("password"):
+        raise ValueError(f"Do not put data source passwords in datadile.yaml. Use password_env instead.")
+
+    password_env = str(data_source.get("password_env", DEFAULT_DATA_SOURCE_PASSWORD_ENV))
+    password = os.environ.get(password_env)
+    if not password:
+        raise ValueError(f"Missing data source password. Set the {password_env} environment variable.")
+
+    return {
+        "type": data_source.get("type", "postgresql"),
+        "host": data_source.get("host", "localhost"),
+        "port": int(data_source.get("port", 5432)),
+        "user": data_source.get("user"),
+        "password": password,
+        "database": data_source.get("database"),
+    }
+
+
+def get_data_source_config(name: str | None = None) -> dict[str, Any]:
+    config = load_config()
+
+    data_sources = config.get("data_sources")
+    if not isinstance(data_sources, dict):
+        raise KeyError("Missing data_sources mapping in config file.")
+
+    data_source_name = name or config.get("default_data_source")
+    if not data_source_name:
+        raise ValueError("Missing data source. Add default_data_source to datadile.yaml or data_source to the test.")
+
+    data_source_name = str(data_source_name)
+    if data_source_name not in data_sources:
+        raise KeyError(f"Unknown data source '{data_source_name}' in config file.")
+
+    return _resolve_data_source_config(data_sources[data_source_name], f"data_sources.{data_source_name}")

datadile/core.py

@@ -0,0 +1,270 @@
+import argparse
+import ast
+import operator
+import shutil
+import sys
+from dataclasses import dataclass
+from decimal import Decimal
+from importlib import resources
+from pathlib import Path
+from typing import Any, Callable
+
+import yaml
+from rich.console import Console
+from rich.table import Table
+from sqlalchemy import create_engine, text
+
+from .config import get_data_source_config
+
+console = Console()
+
+DATA_TEST_FILE_PATTERN = "*.dile.yaml"
+DEFAULT_SKILL_INSTALL_PATH = Path(".opencode") / "skills" / "datadile" / "SKILL.md"
+SEVERITIES = {"LOW", "MEDIUM", "HIGH"}
+EXPECT_OPERATORS = {
+    ">=": operator.ge,
+    "<=": operator.le,
+    "!=": operator.ne,
+    "=": operator.eq,
+    ">": operator.gt,
+    "<": operator.lt,
+}
+
+
+@dataclass(frozen=True)
+class DataTest:
+    name: str
+    description: str
+    query: str
+    expect: str
+    severity: str = "MEDIUM"
+    data_source: str | None = None
+
+
+@dataclass(frozen=True)
+class DataTestResult:
+    test: DataTest
+    actual: Any = None
+    passed: bool = False
+    error: str | None = None
+
+
+def _build_postgres_connection_url(data_source_config: dict) -> str:
+    return (
+        f"postgresql+psycopg2://{data_source_config['user']}:{data_source_config['password']}"
+        f"@{data_source_config['host']}:{data_source_config['port']}/{data_source_config['database']}"
+    )
+
+
+def load_data_tests(path: str | Path) -> list[DataTest]:
+    test_path = Path(path)
+    with test_path.open() as f:
+        raw = yaml.safe_load(f)
+
+    if isinstance(raw, dict) and "tests" in raw:
+        raw_tests = raw["tests"]
+    else:
+        raw_tests = raw
+
+    if not isinstance(raw_tests, list):
+        raise ValueError("Data test file must contain a list of tests or a top-level 'tests' list.")
+
+    return [_parse_data_test(item, index) for index, item in enumerate(raw_tests, start=1)]
+
+
+def discover_data_test_files(root: str | Path = ".") -> list[Path]:
+    return sorted(Path(root).rglob(DATA_TEST_FILE_PATTERN))
+
+
+def _parse_data_test(raw: Any, index: int) -> DataTest:
+    if not isinstance(raw, dict):
+        raise ValueError(f"Test #{index} must be a mapping.")
+
+    missing = [field for field in ("name", "description", "query", "expect") if field not in raw]
+    if missing:
+        raise ValueError(f"Test #{index} is missing required field(s): {', '.join(missing)}.")
+
+    severity = str(raw.get("severity", "MEDIUM")).upper()
+    if severity not in SEVERITIES:
+        raise ValueError(f"Test #{index} has invalid severity '{severity}'. Use LOW, MEDIUM, or HIGH.")
+
+    return DataTest(
+        name=str(raw["name"]),
+        description=str(raw["description"]),
+        query=str(raw["query"]),
+        expect=str(raw["expect"]),
+        severity=severity,
+        data_source=str(raw["data_source"]) if raw.get("data_source") else None,
+    )
+
+
+def evaluate_expectation(actual: Any, expectation: str) -> bool:
+    op_symbol, expected = _parse_expectation(expectation)
+    return EXPECT_OPERATORS[op_symbol](actual, expected)
+
+
+def _parse_expectation(expectation: str) -> tuple[str, Any]:
+    expression = expectation.strip()
+    for op_symbol in sorted(EXPECT_OPERATORS, key=len, reverse=True):
+        if expression.startswith(op_symbol):
+            rhs = expression[len(op_symbol) :].strip()
+            if not rhs:
+                raise ValueError(f"Expectation '{expectation}' is missing a comparison value.")
+            return op_symbol, _parse_expected_value(rhs)
+    raise ValueError(
+        f"Expectation '{expectation}' must start with one of: "
+        f"{', '.join(sorted(EXPECT_OPERATORS, key=len, reverse=True))}."
+    )
+
+
+def _parse_expected_value(value: str) -> Any:
+    try:
+        return ast.literal_eval(value)
+    except (SyntaxError, ValueError):
+        return yaml.safe_load(value)
+
+
+def run_data_tests(tests: list[DataTest], data_source_config: dict | Callable[[str | None], dict]) -> list[DataTestResult]:
+    query_runners: dict[str | None, Callable[[str], list[dict[str, Any]]]] = {}
+    default_run_query = None if callable(data_source_config) else _build_query_runner(data_source_config)
+    results = []
+
+    for test in tests:
+        try:
+            if callable(data_source_config):
+                if test.data_source not in query_runners:
+                    query_runners[test.data_source] = _build_query_runner(data_source_config(test.data_source))
+                run_query = query_runners[test.data_source]
+            else:
+                run_query = default_run_query
+
+            rows = run_query(test.query)
+            actual = _normalize_query_result(rows)
+            passed = evaluate_expectation(actual, test.expect)
+            results.append(DataTestResult(test=test, actual=actual, passed=passed))
+        except Exception as exc:
+            results.append(DataTestResult(test=test, passed=False, error=str(exc)))
+
+    return results
+
+
+def _build_query_runner(data_source_config: dict) -> Callable[[str], list[dict[str, Any]]]:
+    if data_source_config.get("id"):
+        data_source_id = data_source_config["id"]
+        raise ValueError(
+            f"Server-backed data source '{data_source_id}' is configured, but remote test execution "
+            "is not implemented in this package yet."
+        )
+
+    data_source_type = str(data_source_config.get("type", "postgresql")).lower()
+    if data_source_type in {"postgres", "postgresql"}:
+        engine = create_engine(_build_postgres_connection_url(data_source_config))
+
+        def run_postgres_query(query: str) -> list[dict[str, Any]]:
+            with engine.connect() as conn:
+                return [dict(row._mapping) for row in conn.execute(text(query))]
+
+        return run_postgres_query
+
+    raise ValueError(f"Unsupported data source type '{data_source_type}'.")
+
+
+def _normalize_query_result(rows: list[dict[str, Any]]) -> Any:
+    normalized_rows = [_normalize_value(row) for row in rows]
+    if not normalized_rows:
+        return None
+
+    if len(normalized_rows) == 1:
+        row = normalized_rows[0]
+        values = list(row.values())
+        return values[0] if len(values) == 1 else row
+
+    if all(len(row) == 1 for row in normalized_rows):
+        return [next(iter(row.values())) for row in normalized_rows]
+    return normalized_rows
+
+
+def _normalize_value(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {key: _normalize_value(inner) for key, inner in value.items()}
+    if isinstance(value, list):
+        return [_normalize_value(inner) for inner in value]
+    if isinstance(value, Decimal):
+        if value == value.to_integral_value():
+            return int(value)
+        return float(value)
+    return value
+
+
+def print_results(results: list[DataTestResult]) -> None:
+    table = Table(title="Datadile Data Tests")
+    table.add_column("Status")
+    table.add_column("Severity")
+    table.add_column("Name")
+    table.add_column("Expect")
+    table.add_column("Actual")
+
+    for result in results:
+        status = "PASS" if result.passed else "FAIL"
+        style = "green" if result.passed else "red"
+        actual = result.error if result.error else repr(result.actual)
+        table.add_row(
+            f"[{style}]{status}[/{style}]",
+            result.test.severity,
+            result.test.name,
+            result.test.expect,
+            actual,
+        )
+
+    console.print(table)
+
+    failures = [result for result in results if not result.passed]
+    console.print(f"{len(results) - len(failures)} passed, {len(failures)} failed")
+
+
+def test_command(args: argparse.Namespace) -> None:
+    test_paths = [Path(args.filepath)] if args.filepath else discover_data_test_files()
+    if not test_paths:
+        console.print(f"No data test files found matching {DATA_TEST_FILE_PATTERN}")
+        sys.exit(1)
+
+    tests = []
+    for test_path in test_paths:
+        tests.extend(load_data_tests(test_path))
+
+    results = run_data_tests(tests, get_data_source_config)
+    print_results(results)
+
+    if any(not result.passed for result in results):
+        sys.exit(1)
+
+
+def install_skill_command(args: argparse.Namespace) -> None:
+    destination = Path(args.destination)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+
+    with resources.path("datadile.skill", "SKILL.md") as source:
+        shutil.copyfile(source, destination)
+
+    console.print(f"Installed Datadile skill to {destination}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Datadile data quality CLI")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    test_parser = subparsers.add_parser("test", help="Run YAML data tests")
+    test_parser.add_argument("filepath", nargs="?", help="Path to a YAML data test file")
+    test_parser.set_defaults(func=test_command)
+
+    skill_parser = subparsers.add_parser("install-skill", help="Install the bundled coding-agent skill")
+    skill_parser.add_argument(
+        "destination",
+        nargs="?",
+        default=DEFAULT_SKILL_INSTALL_PATH,
+        help=f"Where to write SKILL.md (default: {DEFAULT_SKILL_INSTALL_PATH})",
+    )
+    skill_parser.set_defaults(func=install_skill_command)
+
+    args = parser.parse_args()
+    args.func(args)

datadile/script_context.py

@@ -0,0 +1,167 @@
+import ast
+import re
+from pathlib import Path
+
+
+DEFAULT_CONTEXT_CHAR_LIMIT = 50_000
+_SQL_START_RE = re.compile(r"^\s*(select|with|insert|update|delete|create|alter|drop)\b", re.I)
+
+
+def detect_script_language(script: str, script_path: str | Path | None = None) -> str:
+    if script_path is not None:
+        suffix = Path(script_path).suffix.lower()
+        if suffix == ".py":
+            return "python"
+        if suffix == ".sql":
+            return "sql"
+
+    try:
+        ast.parse(script)
+    except SyntaxError:
+        if _SQL_START_RE.search(script):
+            return "sql"
+        return "unknown"
+
+    return "python"
+
+
+def expand_python_internal_dependencies(
+    script: str,
+    script_path: str | Path,
+    char_limit: int = DEFAULT_CONTEXT_CHAR_LIMIT,
+) -> str:
+    """Append local Python dependencies imported by script, recursively, within char_limit."""
+    root_path = Path(script_path).resolve()
+    dependency_blocks = []
+    remaining = max(0, char_limit - len(script))
+
+    for dependency_path in _iter_internal_dependencies(script, root_path):
+        if remaining <= 0:
+            break
+
+        try:
+            dependency_code = dependency_path.read_text()
+        except OSError:
+            continue
+
+        block = f"\n\n# Internal dependency: {dependency_path}\n{dependency_code}"
+        if len(block) > remaining:
+            block = block[:remaining]
+        dependency_blocks.append(block)
+        remaining -= len(block)
+
+    return script + "".join(dependency_blocks)
+
+
+def build_api_code(
+    script: str,
+    script_path: str | Path,
+    char_limit: int = DEFAULT_CONTEXT_CHAR_LIMIT,
+) -> str:
+    if detect_script_language(script, script_path) != "python":
+        return script
+    return expand_python_internal_dependencies(script, script_path, char_limit)
+
+
+def _iter_internal_dependencies(script: str, script_path: Path):
+    seen = {script_path}
+    queued = list(_resolve_imports(script, script_path))
+
+    while queued:
+        dependency_path = queued.pop(0)
+        if dependency_path in seen:
+            continue
+        seen.add(dependency_path)
+        yield dependency_path
+
+        try:
+            dependency_code = dependency_path.read_text()
+        except OSError:
+            continue
+        queued.extend(_resolve_imports(dependency_code, dependency_path))
+
+
+def _resolve_imports(script: str, source_path: Path) -> list[Path]:
+    try:
+        tree = ast.parse(script)
+    except SyntaxError:
+        return []
+
+    dependencies = []
+    seen = set()
+    for import_node in ast.walk(tree):
+        candidates = []
+        if isinstance(import_node, ast.Import):
+            for alias in import_node.names:
+                candidates.extend(_resolve_absolute_module(alias.name, source_path))
+        elif isinstance(import_node, ast.ImportFrom):
+            candidates.extend(_resolve_import_from(import_node, source_path))
+
+        for candidate in candidates:
+            if candidate == source_path or candidate in seen:
+                continue
+            seen.add(candidate)
+            dependencies.append(candidate)
+
+    return dependencies
+
+
+def _resolve_import_from(import_node: ast.ImportFrom, source_path: Path) -> list[Path]:
+    module_parts = import_node.module.split(".") if import_node.module else []
+    if import_node.level:
+        base_dir = _relative_import_base(source_path, import_node.level)
+        paths = _module_candidates(base_dir, module_parts)
+        for alias in import_node.names:
+            if alias.name != "*":
+                paths.extend(_module_candidates(base_dir, [*module_parts, alias.name]))
+        return _existing_python_files(paths)
+
+    paths = []
+    if import_node.module:
+        paths.extend(_resolve_absolute_module(import_node.module, source_path))
+        for alias in import_node.names:
+            if alias.name != "*":
+                paths.extend(_resolve_absolute_module(f"{import_node.module}.{alias.name}", source_path))
+    return paths
+
+
+def _resolve_absolute_module(module_name: str, source_path: Path) -> list[Path]:
+    module_parts = module_name.split(".")
+    candidates = []
+    for root in _candidate_roots(source_path):
+        candidates.extend(_module_candidates(root, module_parts))
+    return _existing_python_files(candidates)
+
+
+def _candidate_roots(source_path: Path) -> list[Path]:
+    roots = [source_path.parent, Path.cwd().resolve()]
+    return list(dict.fromkeys(roots))
+
+
+def _relative_import_base(source_path: Path, level: int) -> Path:
+    base = source_path.parent
+    for _ in range(max(0, level - 1)):
+        base = base.parent
+    return base
+
+
+def _module_candidates(root: Path, module_parts: list[str]) -> list[Path]:
+    if not module_parts:
+        return [root / "__init__.py"]
+
+    module_path = root.joinpath(*module_parts)
+    return [module_path.with_suffix(".py"), module_path / "__init__.py"]
+
+
+def _existing_python_files(paths: list[Path]) -> list[Path]:
+    existing = []
+    seen = set()
+    for path in paths:
+        resolved = path.resolve()
+        if resolved in seen or not resolved.is_file():
+            continue
+        if any(part in {"site-packages", "dist-packages", ".venv", "venv"} for part in resolved.parts):
+            continue
+        seen.add(resolved)
+        existing.append(resolved)
+    return existing

datadile/search.py

@@ -0,0 +1,61 @@
+import os
+import re
+from pathlib import Path
+
+from rank_bm25 import BM25Plus
+
+
+def _is_text_file(path: Path) -> bool:
+    try:
+        with open(path, "rb") as f:
+            chunk = f.read(8192)
+        return b"\x00" not in chunk
+    except OSError:
+        return False
+
+
+def search_codebase(search_dirs: list[str], column_names: list[str]) -> list[dict]:
+    """Search directories recursively for files mentioning column names, ranked by BM25."""
+    if not column_names:
+        return []
+
+    file_paths = []
+    file_contents = []
+
+    for search_dir in search_dirs:
+        for root, dirs, files in os.walk(search_dir):
+            dirs[:] = [d for d in dirs if not d.startswith(".")]
+            for fname in sorted(files):
+                fpath = Path(root) / fname
+                if not _is_text_file(fpath):
+                    continue
+                try:
+                    content = fpath.read_text(errors="ignore")
+                except OSError:
+                    continue
+                file_paths.append(str(fpath))
+                file_contents.append(content)
+
+    if not file_contents:
+        return []
+
+    def tokenize(text: str) -> list[str]:
+        return re.findall(r"\w+", text.lower())
+
+    tokenized_corpus = [tokenize(c) for c in file_contents]
+    bm25 = BM25Plus(tokenized_corpus)
+
+    query_tokens = [col.lower() for col in column_names]
+    scores = bm25.get_scores(query_tokens)
+
+    ranked = sorted(
+        [
+            {"path": file_paths[i], "content": file_contents[i], "score": float(scores[i])}
+            for i in range(len(file_paths))
+            if scores[i] > 0
+        ],
+        key=lambda x: x["score"],
+        reverse=True,
+    )
+
+    return ranked

datadile/skill/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: datadile
+description: Use when creating, editing, reviewing, or debugging Datadile data tests, datadile.yaml config, *.dile.yaml files, SQL expectations, or the datadile CLI/package code. Load this skill before changing data test YAML, connection configuration, test discovery, expectation parsing, result normalization, or CLI behavior.
+---
+
+# Datadile
+
+Datadile runs YAML-defined data tests against query results. Use this skill when work involves Datadile test files, configuration, CLI behavior, or package internals.
+
+## Use Cases
+
+- Add or update `*.dile.yaml` files near application code.
+- Review data tests for safe SQL, clear expectations, and valid severities.
+- Create or edit `datadile.yaml` without storing secrets in the file.
+- Debug `datadile test` failures, test discovery, config lookup, or data source selection.
+- Modify Datadile internals such as parsing, expectation evaluation, result normalization, or CLI commands.
+
+## Core Rules
+
+- Datadile discovers only files named `*.dile.yaml` when `datadile test` is run without a path.
+- Each test needs `name`, `description`, `query`, and `expect`.
+- `severity` is optional and must be `LOW`, `MEDIUM`, or `HIGH`; it defaults to `MEDIUM`.
+- `data_source` is optional; without it, Datadile uses `default_data_source` from `datadile.yaml`.
+- Keep passwords and API keys in environment variables. Use `password_env` and `api_key_env`; do not put secret values directly in YAML.
+- PostgreSQL is the local execution target today. Keep test YAML generic enough that other query engines can be added later.
+
+## Data Test Examples
+
+Use this shape for count checks:
+
+```yaml
+tests:
+  - name: no_failed_orders_today
+    description: Orders should not fail during the current day.
+    severity: HIGH
+    data_source: app_db
+    query: |
+      select count(*) as failed_orders
+      from orders
+      where status = 'failed'
+        and created_at >= current_date
+    expect: "= 0"
+```
+
+Use list expectations for one-column multi-row checks:
+
+```yaml
+tests:
+  - name: active_plan_ids_are_known
+    description: Active subscriptions should only use known plan IDs.
+    query: |
+      select distinct plan_id
+      from subscriptions
+      where status = 'active'
+      order by plan_id
+    expect: "= [1, 2, 3]"
+```
+
+## Config Examples
+
+Local config lives at `./datadile.yaml`; user config lives at `~/.datadile/datadile.yaml`. Local config takes precedence.
+
+```yaml
+api_key_env: DATADILE_API_KEY
+default_data_source: main
+
+data_sources:
+  main:
+    type: postgresql
+    host: localhost
+    port: 5432
+    user: myuser
+    database: mydb
+    password_env: DATADILE_DATA_SOURCE_PASSWORD
+```
+
+Server-backed data sources can reference an ID, but remote execution is not implemented in the local package yet:
+
+```yaml
+api_key_env: DATADILE_API_KEY
+default_data_source: warehouse
+
+data_sources:
+  warehouse:
+    id: ds_abc123
+```
+
+## Expectation Semantics
+
+- Supported operators are `=`, `!=`, `>`, `>=`, `<`, and `<=`.
+- One-row, one-column results compare as a scalar, such as `= 0`.
+- Multi-row, one-column results compare as a list, such as `= [1, 2, 3]`.
+- Wider rows compare as dictionaries or lists of dictionaries.
+- Empty result sets normalize to `None`, so use `= null` when that is intentional.
+
+## Coding Guidance
+
+- Preserve the `*.dile.yaml` discovery rule unless the user explicitly asks to broaden it.
+- Do not add support for inline passwords or API keys.
+- Keep YAML examples quoted around expectation strings, especially values beginning with comparison operators.
+- When changing CLI behavior, keep `datadile test [filepath]` working.
+- When changing config behavior, keep local `datadile.yaml` precedence over `~/.datadile/datadile.yaml`.

datadile-0.1.0.dist-info/METADATA

@@ -0,0 +1,340 @@
+Metadata-Version: 2.4
+Name: datadile
+Version: 0.1.0
+Summary: YAML-defined data tests for SQL query results
+Project-URL: Homepage, https://github.com/Sand1929/datadile
+Project-URL: Repository, https://github.com/Sand1929/datadile
+Author-email: Sandy Suh <sandy@parsagon.io>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright 2026 Sandy Suh
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+License-File: LICENSE
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: httpx
+Requires-Dist: prompt-toolkit
+Requires-Dist: psycopg2-binary
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rank-bm25>=0.2
+Requires-Dist: rich
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: sqlparse>=0.4
+Description-Content-Type: text/markdown
+
+# datadile
+
+Datadile runs YAML-defined data tests against query results.
+
+## Installation
+
+```bash
+pip install datadile
+```
+
+## Configuration
+
+datadile looks for a YAML config file in two locations (local takes precedence):
+
+1. `./datadile.yaml` (current directory)
+2. `~/.datadile/datadile.yaml` (user-level)
+
+Copy the example and fill in your values:
+
+```bash
+cp datadile.yaml.example datadile.yaml
+```
+
+```yaml
+# Optional. Only required for premium server-backed features.
+api_key_env: DATADILE_API_KEY
+
+# Optional. Used by tests that do not set data_source.
+default_data_source: main
+
+data_sources:
+  main:
+    type: postgresql
+    host: localhost
+    port: 5432
+    user: myuser
+    database: mydb
+    password_env: DATADILE_DATA_SOURCE_PASSWORD
+```
+
+Put data source passwords and API keys in environment variables, not in `datadile.yaml`:
+
+```bash
+export DATADILE_DATA_SOURCE_PASSWORD='your_password_here'
+export DATADILE_API_KEY='your_api_key_here'
+```
+
+Use `password_env` or `api_key_env` if you want Datadile to read a different environment variable name.
+
+Add more named entries under `data_sources` when tests need to run against multiple databases. `default_data_source` is optional, but tests that do not set `data_source` need a default.
+
+`api_key_env` is optional. You only need it for premium features that access Datadile servers.
+
+Data source entries can be defined inline, or referenced by ID if the connection details are stored on your Datadile account:
+
+```yaml
+api_key_env: DATADILE_API_KEY
+
+default_data_source: warehouse
+
+data_sources:
+  warehouse:
+    id: ds_abc123
+```
+
+`postgresql` is currently supported for local execution. Data tests keep `query` generic so query engines such as MongoDB can be added without changing the test format.
+
+## Usage
+
+```bash
+datadile test
+datadile test <path/to/file.dile.yaml>
+```
+
+With no path, Datadile recursively discovers only files matching `*.dile.yaml` from the current directory. Other YAML files, such as `docker-compose.yaml`, GitHub Actions workflows, Helm values, and OpenAPI specs, are ignored.
+
+## Data Tests
+
+Tests are defined in YAML. Each test has `name`, `description`, `query`, and `expect`. `severity` is optional and defaults to `MEDIUM`; valid values are `LOW`, `MEDIUM`, and `HIGH`. `data_source` is optional and references a named source from `data_sources`; otherwise Datadile uses `default_data_source` if one is configured.
+
+For example, a test can set `data_source: app_db` after `app_db` is added under `data_sources`.
+
+Use the `*.dile.yaml` naming convention and colocate data tests near the application code they protect:
+
+```text
+app/orders/orders.py
+app/orders/orders.dile.yaml
+app/billing/invoices.ts
+app/billing/invoices.dile.yaml
+```
+
+```yaml
+tests:
+  - name: no_failed_orders
+    description: There should be no failed orders today.
+    severity: HIGH
+    data_source: app_db
+    query: |
+      select count(*) as failed_orders
+      from orders
+      where status = 'failed'
+        and created_at >= current_date
+    expect: "= 0"
+
+  - name: active_plan_ids
+    description: Active subscriptions should only use known plan IDs.
+    query: |
+      select distinct plan_id
+      from subscriptions
+      where status = 'active'
+      order by plan_id
+    expect: "= [1, 2, 3]"
+```
+
+`expect` is a comparison string. Supported operators are `=`, `!=`, `>`, `>=`, `<`, and `<=`.
+
+For one-row, one-column query results, Datadile compares the scalar value. For multi-row, one-column results, it compares a list of values. For wider results, it compares dictionaries or lists of dictionaries.

datadile-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+datadile/__init__.py,sha256=1V_F6lvCy82PQHLkHFzpaTtasq5D5RnaKNYNY6AfcOU,43
+datadile/config.py,sha256=VpfsBRgAH6K5jKKNW2PEggDQor87grnsynb8_XQ_q_Y,4105
+datadile/core.py,sha256=ywG2tj_7PgG6-BiY_nBdRxMeTwazRFHVQ-VeDwh5VWc,9144
+datadile/script_context.py,sha256=yRlbBsArMcerzClruN1YbhnHHTAyVoQfpHzOGudQ5G0,5303
+datadile/search.py,sha256=XTghjq-pqA4hc_JvzzxOlHR8wfgzZJWFtLIT44D1d80,1712
+datadile/skill/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datadile/skill/SKILL.md,sha256=1WkW29v_4i8sj82a_jvSM5J1vEKMoxGiPHaCm_qihpU,3721
+datadile-0.1.0.dist-info/METADATA,sha256=QfKcJ3odgq9y9kBtLgeokBWruqz5fc9ddqcStPz8L9w,17271
+datadile-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+datadile-0.1.0.dist-info/entry_points.txt,sha256=d68v93ozKg6FYneQutCIdepR6gntJduPRbHF-CvEmks,43
+datadile-0.1.0.dist-info/licenses/LICENSE,sha256=f3t_-KHmcTzmw5cQW5ynF4U-qQZvojU0VuHWGiUcLoE,11339
+datadile-0.1.0.dist-info/RECORD,,

datadile-0.1.0.dist-info/WHEEL

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

datadile-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+datadile = datadile:main

datadile-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Sandy Suh
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.