aqualisys 0.1.0__py3-none-any.whl

aqualisys/__init__.py

@@ -0,0 +1,19 @@
+"""
+Aqualisys: a Polars-first data quality toolkit.
+
+Expose the key classes so downstream users can import from `aqualisys`.
+"""
+
+from .checker import DataQualityChecker, RuleBundle
+from .checks.rules import AcceptedValuesRule, NotNullRule, RelationshipRule, UniqueRule
+from .logging.sqlite import SQLiteRunLogger
+
+__all__ = [
+    "AcceptedValuesRule",
+    "DataQualityChecker",
+    "NotNullRule",
+    "RelationshipRule",
+    "RuleBundle",
+    "SQLiteRunLogger",
+    "UniqueRule",
+]

aqualisys/checker.py

@@ -0,0 +1,98 @@
+from collections.abc import Callable, Iterable, Sequence
+from dataclasses import dataclass
+from uuid import uuid4
+
+try:
+    import polars as pl
+except ModuleNotFoundError:
+    # pragma: no cover - optional dependency in some environments
+    pl = None  # type: ignore
+
+from .checks.base import BaseRule, RuleContext, RuleResult, RuleSeverity
+from .logging.base import RunLogger
+
+
+@dataclass(slots=True)
+class RuleBundle:
+    name: str
+    description: str
+    rule_factory: Callable[[], Sequence[BaseRule]]
+
+    def rules(self) -> list[BaseRule]:
+        return list(self.rule_factory())
+
+
+@dataclass(slots=True)
+class ValidationReport:
+    run_id: str
+    dataset_name: str
+    results: list[RuleResult]
+
+    @property
+    def passed(self) -> bool:
+        return all(result.passed for result in self.results)
+
+    @property
+    def failed_rules(self) -> list[RuleResult]:
+        return [result for result in self.results if not result.passed]
+
+
+class DataQualityChecker:
+    """Coordinates rule execution and logging."""
+
+    def __init__(
+        self,
+        rules: Iterable[BaseRule] | None = None,
+        bundles: Iterable[RuleBundle] | None = None,
+        logger: RunLogger | None = None,
+        fail_fast: bool = False,
+    ) -> None:
+        self._rules: list[BaseRule] = list(rules or [])
+        for bundle in bundles or []:
+            self._rules.extend(bundle.rules())
+        self._logger = logger
+        self._fail_fast = fail_fast
+
+    @property
+    def rules(self) -> list[BaseRule]:
+        return list(self._rules)
+
+    def add_rules(self, *rules: BaseRule) -> None:
+        self._rules.extend(rules)
+
+    def run(
+        self,
+        dataframe: "pl.DataFrame",
+        dataset_name: str,
+        run_id: str | None = None,
+    ) -> ValidationReport:
+        if pl is None:  # pragma: no cover - guard for environments without polars
+            raise RuntimeError("polars is required to run validations")
+
+        run_id = run_id or str(uuid4())
+        context = RuleContext(dataset_name=dataset_name, run_id=run_id)
+        results: list[RuleResult] = []
+
+        if self._logger:
+            self._logger.log_run_started(context)
+
+        for rule in self._rules:
+            result = rule.evaluate(dataframe)
+            results.append(result)
+            if self._logger:
+                self._logger.log_rule_result(context, result)
+            if (
+                self._fail_fast
+                and not result.passed
+                and rule.severity is RuleSeverity.ERROR
+            ):
+                break
+
+        if self._logger:
+            self._logger.log_run_completed(context, results)
+
+        return ValidationReport(
+            run_id=run_id,
+            dataset_name=dataset_name,
+            results=results,
+        )

aqualisys/checks/__init__.py

@@ -0,0 +1,3 @@
+from .rules import AcceptedValuesRule, NotNullRule, RelationshipRule, UniqueRule
+
+__all__ = ["AcceptedValuesRule", "NotNullRule", "RelationshipRule", "UniqueRule"]

aqualisys/checks/base.py

@@ -0,0 +1,55 @@
+from collections.abc import Mapping
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from enum import StrEnum
+from typing import Any, Protocol, runtime_checkable
+
+try:
+    import polars as pl
+except ModuleNotFoundError:
+    # pragma: no cover - polars is an optional runtime dependency in tests
+    pl = None  # type: ignore
+
+
+class RuleSeverity(StrEnum):
+    ERROR = "error"
+    WARN = "warn"
+
+
+class RuleStatus(StrEnum):
+    PASSED = "passed"
+    FAILED = "failed"
+
+
+@dataclass(slots=True)
+class RuleResult:
+    """Represents the outcome of a single rule."""
+
+    rule_name: str
+    status: RuleStatus
+    message: str
+    severity: RuleSeverity
+    metrics: Mapping[str, Any] | None = None
+
+    @property
+    def passed(self) -> bool:
+        return self.status is RuleStatus.PASSED
+
+
+@dataclass(slots=True)
+class RuleContext:
+    dataset_name: str
+    run_id: str
+    executed_at: datetime = datetime.now(tz=UTC)
+
+
+@runtime_checkable
+class BaseRule(Protocol):
+    """All validation rules must follow this shape."""
+
+    name: str
+    description: str
+    severity: RuleSeverity
+
+    def evaluate(self, df: "pl.DataFrame") -> RuleResult:  # pragma: no cover - protocol
+        ...

aqualisys/checks/rules.py

@@ -0,0 +1,130 @@
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+import polars as pl
+
+from .base import BaseRule, RuleResult, RuleSeverity, RuleStatus
+
+
+@dataclass(slots=True)
+class ColumnRule(BaseRule):
+    column: str
+    severity: RuleSeverity = RuleSeverity.ERROR
+    description: str | None = None
+
+    def __post_init__(self) -> None:
+        self.description = (
+            self.description or f"{self.__class__.__name__} on {self.column}"
+        )
+
+    @property
+    def name(self) -> str:
+        return f"{self.__class__.__name__}::{self.column}"
+
+
+class NotNullRule(ColumnRule):
+    def evaluate(self, df: pl.DataFrame) -> RuleResult:
+        nulls = df.select(pl.col(self.column).is_null().sum().alias("nulls")).item()
+        status = RuleStatus.PASSED if nulls == 0 else RuleStatus.FAILED
+        message = (
+            "column has no nulls"
+            if status is RuleStatus.PASSED
+            else f"{nulls} null values found"
+        )
+        return RuleResult(
+            rule_name=self.name,
+            status=status,
+            message=message,
+            severity=self.severity,
+            metrics={"null_count": nulls},
+        )
+
+
+class UniqueRule(ColumnRule):
+    def evaluate(self, df: pl.DataFrame) -> RuleResult:
+        total_rows = df.height
+        unique_rows = df.select(pl.col(self.column).n_unique().alias("unique")).item()
+        duplicates = total_rows - unique_rows
+        status = RuleStatus.PASSED if duplicates == 0 else RuleStatus.FAILED
+        message = (
+            "column values are unique"
+            if status is RuleStatus.PASSED
+            else f"{duplicates} duplicate rows found"
+        )
+        return RuleResult(
+            rule_name=self.name,
+            status=status,
+            message=message,
+            severity=self.severity,
+            metrics={"duplicate_count": duplicates},
+        )
+
+
+class AcceptedValuesRule(ColumnRule):
+    def __init__(
+        self,
+        column: str,
+        allowed_values: Iterable[str | int | float],
+        severity: RuleSeverity = RuleSeverity.ERROR,
+    ):
+        super().__init__(column=column, severity=severity)
+        self.allowed_values = tuple(dict.fromkeys(allowed_values))  # stable + deduped
+
+    def evaluate(self, df: pl.DataFrame) -> RuleResult:
+        violations = (
+            df.filter(~pl.col(self.column).is_in(self.allowed_values))
+            .select(pl.len())
+            .item()
+        )
+        status = RuleStatus.PASSED if violations == 0 else RuleStatus.FAILED
+        message = (
+            "column values match allowed set"
+            if status is RuleStatus.PASSED
+            else f"{violations} disallowed values detected"
+        )
+        return RuleResult(
+            rule_name=self.name,
+            status=status,
+            message=message,
+            severity=self.severity,
+            metrics={
+                "violation_count": violations,
+                "allowed_values": self.allowed_values,
+            },
+        )
+
+
+class RelationshipRule(ColumnRule):
+    def __init__(
+        self,
+        column: str,
+        reference_df: pl.DataFrame,
+        reference_column: str,
+        severity: RuleSeverity = RuleSeverity.ERROR,
+    ) -> None:
+        super().__init__(column=column, severity=severity)
+        self._reference_df = reference_df.select(reference_column)
+        self._reference_column = reference_column
+
+    def evaluate(self, df: pl.DataFrame) -> RuleResult:
+        reference_set = set(self._reference_df[self._reference_column].to_list())
+        violations = (
+            df.filter(~pl.col(self.column).is_in(reference_set)).select(pl.len()).item()
+        )
+        status = RuleStatus.PASSED if violations == 0 else RuleStatus.FAILED
+        message = (
+            "referential integrity holds"
+            if status is RuleStatus.PASSED
+            else f"{violations} values missing from reference {self._reference_column}"
+        )
+        return RuleResult(
+            rule_name=self.name,
+            status=status,
+            message=message,
+            severity=self.severity,
+            metrics={
+                "violation_count": violations,
+                "reference_column": self._reference_column,
+                "reference_size": len(reference_set),
+            },
+        )

aqualisys/cli.py

@@ -0,0 +1,44 @@
+import json
+from pathlib import Path
+
+import click
+
+from .config import ValidationSuiteConfig
+
+
+@click.group()
+def cli() -> None:
+    """CLI entry point for running data quality suites."""
+
+
+@cli.command("validate")
+@click.argument(
+    "config_path",
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+)
+def validate_command(config_path: Path) -> None:
+    """Run the configured validation suite and emit a JSON summary."""
+
+    suite = ValidationSuiteConfig.from_yaml(config_path)
+    dataframe = suite.load_dataframe()
+    checker = suite.build_checker()
+    report = checker.run(dataframe, dataset_name=suite.dataset_name)
+
+    summary = {
+        "run_id": report.run_id,
+        "dataset": report.dataset_name,
+        "passed": report.passed,
+        "failed_rules": [result.rule_name for result in report.failed_rules],
+    }
+    click.echo(json.dumps(summary, indent=2))
+
+    if not report.passed:
+        raise SystemExit(1)
+
+
+def run() -> None:
+    cli(prog_name="aqualisys")
+
+
+if __name__ == "__main__":  # pragma: no cover - script entry point
+    run()

aqualisys/config.py

@@ -0,0 +1,112 @@
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, ClassVar
+
+import yaml
+
+try:
+    import polars as pl
+except ModuleNotFoundError:
+    # pragma: no cover - optional dependency
+    pl = None  # type: ignore
+
+from .checker import DataQualityChecker
+from .checks.base import BaseRule
+from .checks.rules import AcceptedValuesRule, NotNullRule, RelationshipRule, UniqueRule
+from .logging.sqlite import SQLiteRunLogger
+
+RuleFactory = Callable[[Mapping[str, Any]], BaseRule]
+
+
+def _build_not_null(config: Mapping[str, Any]) -> BaseRule:
+    return NotNullRule(column=config["column"])
+
+
+def _build_unique(config: Mapping[str, Any]) -> BaseRule:
+    return UniqueRule(column=config["column"])
+
+
+def _build_accepted(config: Mapping[str, Any]) -> BaseRule:
+    return AcceptedValuesRule(
+        column=config["column"],
+        allowed_values=config["allowed_values"],
+    )
+
+
+def _build_relationship(config: Mapping[str, Any]) -> BaseRule:
+    if pl is None:
+        # pragma: no cover - config is still valid without runtime Polars
+        raise RuntimeError("polars is required for relationship rules")
+    ref_path = Path(config["reference"]["path"])
+    ref_format = config["reference"].get("format", "parquet")
+    if ref_format == "parquet":
+        reference_df = pl.read_parquet(ref_path)
+    elif ref_format == "csv":
+        reference_df = pl.read_csv(ref_path)
+    else:  # pragma: no cover - validated elsewhere
+        raise ValueError(f"unsupported reference format: {ref_format}")
+    return RelationshipRule(
+        column=config["column"],
+        reference_df=reference_df,
+        reference_column=config["reference"]["column"],
+    )
+
+
+RULE_BUILDERS: dict[str, RuleFactory] = {
+    "not_null": _build_not_null,
+    "unique": _build_unique,
+    "accepted_values": _build_accepted,
+    "relationship": _build_relationship,
+}
+
+
+@dataclass(slots=True)
+class ValidationSuiteConfig:
+    dataset_name: str
+    dataset_path: Path
+    dataset_format: str = "parquet"
+    fail_fast: bool = False
+    rules: list[Mapping[str, Any]] | None = None
+    logger_path: Path = Path("aqualisys_runs.db")
+
+    SUPPORTED_FORMATS: ClassVar[set[str]] = {"parquet", "csv"}
+
+    @classmethod
+    def from_yaml(cls, path: str | Path) -> "ValidationSuiteConfig":
+        data = yaml.safe_load(Path(path).read_text())
+        return cls(
+            dataset_name=data["dataset"]["name"],
+            dataset_path=Path(data["dataset"]["path"]),
+            dataset_format=data["dataset"].get("format", "parquet"),
+            fail_fast=data.get("fail_fast", False),
+            rules=data.get("rules", []),
+            logger_path=Path(data.get("logger", {}).get("path", "aqualisys_runs.db")),
+        )
+
+    def load_dataframe(self) -> "pl.DataFrame":
+        if pl is None:  # pragma: no cover - guard for environments lacking polars
+            raise RuntimeError("polars is required to load dataframes")
+        if self.dataset_format not in self.SUPPORTED_FORMATS:
+            raise ValueError(f"unsupported dataset format: {self.dataset_format}")
+        if self.dataset_format == "parquet":
+            return pl.read_parquet(self.dataset_path)
+        return pl.read_csv(self.dataset_path)
+
+    def build_rules(self) -> list[BaseRule]:
+        all_rules: list[BaseRule] = []
+        for config in self.rules or []:
+            rule_type = config["type"]
+            builder = RULE_BUILDERS.get(rule_type)
+            if not builder:
+                raise ValueError(f"unknown rule type: {rule_type}")
+            all_rules.append(builder(config))
+        return all_rules
+
+    def build_checker(self) -> DataQualityChecker:
+        logger = SQLiteRunLogger(self.logger_path)
+        return DataQualityChecker(
+            rules=self.build_rules(),
+            logger=logger,
+            fail_fast=self.fail_fast,
+        )

aqualisys/logging/__init__.py

@@ -0,0 +1,3 @@
+from .sqlite import SQLiteRunLogger
+
+__all__ = ["SQLiteRunLogger"]

aqualisys/logging/base.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+
+from ..checks.base import RuleContext, RuleResult
+
+
+@dataclass(slots=True)
+class RunSummary:
+    run_id: str
+    dataset_name: str
+    started_at: datetime
+    finished_at: datetime = field(default_factory=lambda: datetime.now(tz=UTC))
+
+
+class RunLogger(ABC):
+    """Interface for persisting run metadata + rule outcomes."""
+
+    @abstractmethod
+    def log_run_started(self, context: RuleContext) -> None:
+        """Persist metadata that a run has started."""
+        ...  # pragma: no cover - interface
+
+    @abstractmethod
+    def log_rule_result(self, context: RuleContext, result: RuleResult) -> None:
+        """Persist the outcome of a single rule execution."""
+        ...  # pragma: no cover - interface
+
+    @abstractmethod
+    def log_run_completed(
+        self,
+        context: RuleContext,
+        results: Iterable[RuleResult],
+    ) -> None:
+        """Persist that a run finished, including summary counts."""
+        ...  # pragma: no cover

aqualisys/logging/sqlite.py

@@ -0,0 +1,113 @@
+import json
+import sqlite3
+from collections.abc import Iterable
+from datetime import UTC, datetime
+from pathlib import Path
+
+from ..checks.base import RuleContext, RuleResult
+from .base import RunLogger
+
+
+class SQLiteRunLogger(RunLogger):
+    """Persists run + rule records to a lightweight SQLite database."""
+
+    def __init__(self, db_path: str | Path = "aqualisys_runs.db") -> None:
+        self.db_path = Path(db_path)
+        self._ensure_schema()
+
+    def _connect(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self.db_path)
+        conn.execute("PRAGMA journal_mode=WAL;")
+        return conn
+
+    def _ensure_schema(self) -> None:
+        with self._connect() as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS runs
+                (
+                    run_id       TEXT PRIMARY KEY,
+                    dataset_name TEXT NOT NULL,
+                    started_at   TEXT NOT NULL,
+                    finished_at  TEXT,
+                    total_rules  INTEGER DEFAULT 0,
+                    failed_rules INTEGER DEFAULT 0
+                )
+                """)
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS rule_results
+                (
+                    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                    run_id      TEXT NOT NULL,
+                    rule_name   TEXT NOT NULL,
+                    status      TEXT NOT NULL,
+                    severity    TEXT NOT NULL,
+                    message     TEXT NOT NULL,
+                    metrics     TEXT,
+                    recorded_at TEXT NOT NULL,
+                    FOREIGN KEY (run_id) REFERENCES runs (run_id)
+                )
+                """)
+            conn.commit()
+
+    def log_run_started(self, context: RuleContext) -> None:
+        with self._connect() as conn:
+            conn.execute(
+                """
+                INSERT OR REPLACE INTO runs(run_id, dataset_name, started_at)
+                VALUES (?, ?, ?)
+                """,
+                (context.run_id, context.dataset_name, context.executed_at.isoformat()),
+            )
+            conn.commit()
+
+    def log_rule_result(self, context: RuleContext, result: RuleResult) -> None:
+        with self._connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO rule_results(
+                    run_id,
+                    rule_name,
+                    status,
+                    severity,
+                    message,
+                    metrics,
+                    recorded_at
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    context.run_id,
+                    result.rule_name,
+                    result.status.value,
+                    result.severity.value,
+                    result.message,
+                    json.dumps(result.metrics or {}, default=str),
+                    datetime.now(tz=UTC).isoformat(),
+                ),
+            )
+            conn.commit()
+
+    def log_run_completed(
+        self,
+        context: RuleContext,
+        results: Iterable[RuleResult],
+    ) -> None:
+        results_list = list(results)
+        failed = sum(1 for result in results_list if not result.passed)
+        with self._connect() as conn:
+            conn.execute(
+                """
+                UPDATE runs
+                SET finished_at  = ?,
+                    total_rules  = ?,
+                    failed_rules = ?
+                WHERE run_id = ?
+                """,
+                (
+                    datetime.now(tz=UTC).isoformat(),
+                    len(results_list),
+                    failed,
+                    context.run_id,
+                ),
+            )
+            conn.commit()

aqualisys-0.1.0.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: aqualisys
+Version: 0.1.0
+Summary: Polars-first data-quality and data-validation toolkit.
+Author-email: Aqualisys Maintainers <maintainers@aqualisys.dev>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1.7
+Requires-Dist: polars>=0.20.0
+Requires-Dist: pyyaml>=6.0.1
+Provides-Extra: dev
+Requires-Dist: black>=24.3.0; extra == 'dev'
+Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.4; extra == 'dev'
+Requires-Dist: ruff>=0.2.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Aqualisys
+
+Polars-first data-quality toolkit delivering deterministic validation, structured logging, and a composable rule registry.
+
+## Why Aqualisys?
+- **Declarative rules**: ship reusable expectations such as not-null, uniqueness, accepted-values, and referential checks.
+- **Deterministic logging**: every run is persisted to SQLite (JSON-friendly) for audits and debugging.
+- **Pipeline-ready**: run from Python code or via `aqualisys validate configs/orders.yml` in CI.
+
+## Quick Start
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e .[dev]
+pytest
+aqualisys validate configs/orders.yml
+```
+
+## Usage Example
+```python
+import polars as pl
+from aqualisys import DataQualityChecker, NotNullRule, UniqueRule, SQLiteRunLogger
+
+df = pl.DataFrame({"order_id": [1, 2, 3], "status": ["pending", "shipped", "shipped"]})
+checker = DataQualityChecker(
+    rules=[NotNullRule("order_id"), UniqueRule("order_id")],
+    logger=SQLiteRunLogger("artifacts/example_runs.db"),
+)
+report = checker.run(df, dataset_name="orders")
+assert report.passed
+```
+
+## Project Structure
+- `src/aqualisys/`: library source (rules, checker, logging, CLI).
+- `tests/`: pytest suites (unit + integration).
+- `configs/`: sample validation suite definitions.
+- `docs/`: roadmap and design notes.
+
+See `docs/PUBLISHING.md` for uv-based build and release steps once you are ready to publish a new version.
+
+See `docs/ROADMAP.md` for the multi-week implementation plan inspired by the Start Data Engineering guide.

aqualisys-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+aqualisys/__init__.py,sha256=uoq8i4KvvZP8LE42T0bWcAyIGYiZBB5QhAWNQptcQmI,483
+aqualisys/checker.py,sha256=2-t8c-kuTxeEimMzWoXgPc_sOw3Pz5MtQVs-XZ2ocEY,2774
+aqualisys/cli.py,sha256=muaadBuLCIPLxuIaPM0Bo4bVh8gjhFaMATukyUnTm_4,1082
+aqualisys/config.py,sha256=qL9VLXv7ROTZrzfi3tQBaBsrugwVr_54fkR2Jqrl81I,3893
+aqualisys/checks/__init__.py,sha256=LgjTJqFLU0cjrSfbsz9WArlz1zFhUusYsIBDlfry-8g,164
+aqualisys/checks/base.py,sha256=TKjpufvSWwR12JtW63ubWMOFcSf3wyS5MTKQlo76eg8,1204
+aqualisys/checks/rules.py,sha256=sBQWtWNbzSqFiuElcZAjqQWHw3ax07B3nHf-mcJTJk8,4303
+aqualisys/logging/__init__.py,sha256=4dQpKjbidZeB6yLBP1TvcpcNQ8q4r2vZOnaptpx9nis,67
+aqualisys/logging/base.py,sha256=nSIzV1uu9MVuKBEHqI0wQwgiWBVl1QaVFUSFdGp2yUY,1111
+aqualisys/logging/sqlite.py,sha256=Zrcp-myNrpPqJeb1330fwGqHcP5uMbucbWQvWoPHNaA,3782
+aqualisys-0.1.0.dist-info/METADATA,sha256=B18N61ONqgz3anSXYxIW30ZBGPa55HnEueIKEmXXLEc,2121
+aqualisys-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+aqualisys-0.1.0.dist-info/entry_points.txt,sha256=FN2StKUy9iH4Q1-dLZk_tF4uWeFqjJ8-LRLhw8jCEmQ,48
+aqualisys-0.1.0.dist-info/licenses/LICENSE,sha256=nPSYvbzst5Xo16pBTGo5Ju5BwC32lsEmKh8IPT4hxxA,1067
+aqualisys-0.1.0.dist-info/RECORD,,

aqualisys-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

aqualisys-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aqualisys = aqualisys.cli:run

aqualisys-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Absolentia
+
+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.