dash-observe 0.1.2__py3-none-any.whl

dash_observe-0.1.2.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: dash-observe
+Version: 0.1.2
+Summary: Data observability for Databricks — freshness, volume, and schema-change monitoring
+Project-URL: Homepage, https://github.com/dash-libs/dash-observe
+Project-URL: Repository, https://github.com/dash-libs/dash-observe
+Project-URL: Issues, https://github.com/dash-libs/dash-observe/issues
+Project-URL: Changelog, https://github.com/dash-libs/dash-observe/blob/main/CHANGELOG.md
+Author-email: Darshan Shah <darshan.innovation@icloud.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: data-observability,databricks,delta,monitoring,pyspark
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Jupyter
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software 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
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: dash-uis>=0.1.0
+Requires-Dist: ipywidgets>=8.0
+Provides-Extra: dev
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: pandas; extra == 'dev'
+Requires-Dist: pdoc; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# DashObserve — Databricks Library
+
+[![CI](https://github.com/dash-libs/dash-observe/actions/workflows/ci.yml/badge.svg)](https://github.com/dash-libs/dash-observe/actions)
+[![PyPI](https://img.shields.io/pypi/v/dash-observe)](https://pypi.org/project/dash-observe/)
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue)](LICENSE)
+
+Part of the **[Dashlibs](https://github.com/dash-libs)** suite — Databricks libraries built for business users.
+
+Monte Carlo-style data observability that runs natively in a Databricks notebook —
+no external service, no agent to deploy. v1 covers:
+
+- **Freshness monitoring** — alert when a table's most recent timestamp value is older than expected
+- **Volume monitoring** — alert on row-count bounds, or on deviation from a rolling historical baseline
+- **Schema-change detection** — alert when columns are added, removed, or change type since the last run
+
+All monitor results are appended to a Delta history table, which also feeds the volume
+baseline and schema-diff comparisons for future runs.
+
+## Installation
+
+```bash
+%pip install dash-observe
+```
+
+## Quick Start
+
+```python
+import dashobserve
+dashobserve.launch()   # Opens interactive UI in your Databricks notebook
+```
+
+## What it looks like
+
+![DashObserve UI](https://raw.githubusercontent.com/dash-libs/dash-observe/main/docs/screenshots/launch.png)
+
+## Python API
+
+```python
+from dashobserve import MonitorConfig, run_monitors
+
+cfg = MonitorConfig(
+    table="catalog.schema.orders",
+    freshness_column="updated_at", max_staleness_minutes=60,
+    min_rows=1000, volume_tolerance_pct=20,
+    track_schema=True,
+)
+report = run_monitors(cfg, history_table="catalog.schema.observe_history")
+report.display()
+print(report.summary())
+```
+
+## Part of Dashlibs
+
+| Library | Purpose |
+|---|---|
+| dash-dq | Data Quality |
+| dash-synthetic | Synthetic Data Generation |
+| dash-observe | Data Observability (freshness, volume, schema) |
+| dash-ml | ML Model Monitoring |
+| dash-ingest | Data Ingestion |
+| dash-gov | Data Governance |
+| dash-relate | Ontology & Lineage for AI |
+| dash-ui | Shared UI components (PyPI: `dash-uis`) |
+
+## Quality & Contributing
+
+- 25 unit tests, zero Spark dependency to run them — `pytest tests/ -v`
+  (freshness/volume/schema-diff checks are pure Python and fully covered;
+  only the Spark/Delta glue in `runner.py` needs a live cluster)
+- Lint-clean (`ruff check dashobserve/`), PEP 561 typed (`py.typed`)
+- Every change ships through a reviewed pull request; CI (lint → test on
+  Python 3.9–3.12 → build) gates every PR and every release
+- See [CONTRIBUTING.md](CONTRIBUTING.md) for dev setup,
+  [CHANGELOG.md](CHANGELOG.md) for release history,
+  [SECURITY.md](SECURITY.md) to report a vulnerability, and
+  [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md)
+
+## License
+
+Apache 2.0

dash_observe-0.1.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+dashobserve/__init__.py,sha256=1j6JGNwgSmmb0p_glZzOOTw3-31a4LS4FCxQQjUcbNQ,607
+dashobserve/monitors.py,sha256=3ZdK5aSFirR-eApRm1ip8r7BFZAe8dosQqdNW0BTtlQ,3781
+dashobserve/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dashobserve/runner.py,sha256=U1rDpjBxhuCyi1tT6DztDBqgEeA3t6gL41aiwtaatn4,5337
+dashobserve/ui.py,sha256=xK9q_y8yWu6l-SijuoC9Dlsa1Bzz_gS8d7SW75w8Sfw,4615
+dash_observe-0.1.2.dist-info/METADATA,sha256=wnnRm2qB3m_GRbEdpBg2MGdeMlplNrHGWPnP9TNgOrQ,4487
+dash_observe-0.1.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+dash_observe-0.1.2.dist-info/licenses/LICENSE,sha256=c28WHQZJ-cmeyAGcLW2azQqfzdx9BMVTwrG7NhPII34,11342
+dash_observe-0.1.2.dist-info/RECORD,,

dash_observe-0.1.2.dist-info/WHEEL

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

dash_observe-0.1.2.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 Darshan Shah
+
+   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.

dashobserve/__init__.py

@@ -0,0 +1,21 @@
+"""
+DashObserve — Data observability for Databricks: freshness, volume, and
+schema-change monitoring. Launch the UI with dashobserve.launch() inside
+a Databricks notebook.
+"""
+from dashobserve.monitors import MonitorResult, check_freshness, check_schema, check_volume, diff_schema
+from dashobserve.runner import MonitorConfig, MonitorReport, run_monitors
+from dashobserve.ui import launch
+
+__version__ = "0.1.2"
+__all__ = [
+    "MonitorConfig",
+    "MonitorReport",
+    "MonitorResult",
+    "run_monitors",
+    "check_freshness",
+    "check_volume",
+    "check_schema",
+    "diff_schema",
+    "launch",
+]

dashobserve/monitors.py

@@ -0,0 +1,81 @@
+"""
+Pure-logic monitor checks — freshness, volume, and schema-change detection.
+No Spark/datetime-now dependency baked in, so every function here is testable
+with plain Python values; the Spark-touching glue lives in runner.py.
+"""
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime, timezone
+
+
+@dataclass
+class MonitorResult:
+    table_name: str
+    monitor_type: str      # freshness | volume | schema
+    monitor_name: str
+    status: str             # PASS | FAIL | ERROR
+    message: str
+    run_timestamp: str = ""
+    details: str = "{}"     # json-encoded dict of monitor-specific details
+
+    def to_dict(self) -> dict:
+        return dict(self.__dict__)
+
+
+def check_freshness(latest_timestamp, max_staleness_minutes: float, now: datetime = None) -> tuple[bool, str]:
+    """Most recent value in the freshness column must be within max_staleness_minutes of now."""
+    if latest_timestamp is None:
+        return False, "No timestamp values found — table may be empty"
+    now = now or datetime.now(timezone.utc).replace(tzinfo=None)
+    if getattr(latest_timestamp, "tzinfo", None) is not None:
+        latest_timestamp = latest_timestamp.replace(tzinfo=None)
+    staleness_minutes = (now - latest_timestamp).total_seconds() / 60
+    ok = staleness_minutes <= max_staleness_minutes
+    msg = f"Data is {staleness_minutes:.1f} min old (threshold {max_staleness_minutes} min)"
+    return ok, msg
+
+
+def check_volume(row_count: int, min_rows: int = None, max_rows: int = None,
+                  baseline_avg: float = None, tolerance_pct: float = None) -> tuple[bool, str]:
+    """Row count must satisfy absolute bounds and/or stay within tolerance_pct of a historical baseline."""
+    if min_rows is not None and row_count < min_rows:
+        return False, f"Row count {row_count} below min_rows {min_rows}"
+    if max_rows is not None and row_count > max_rows:
+        return False, f"Row count {row_count} above max_rows {max_rows}"
+    if baseline_avg is not None and tolerance_pct is not None and baseline_avg > 0:
+        deviation_pct = abs(row_count - baseline_avg) / baseline_avg * 100
+        if deviation_pct > tolerance_pct:
+            return False, (
+                f"Row count {row_count} deviates {deviation_pct:.1f}% from baseline "
+                f"{baseline_avg:.0f} (tolerance {tolerance_pct}%)"
+            )
+    return True, f"Row count {row_count} within expected bounds"
+
+
+def diff_schema(old_schema: dict, new_schema: dict) -> dict:
+    """Compare two {column_name: dtype_string} schemas. Pure set/dict logic, no I/O."""
+    old_cols, new_cols = set(old_schema), set(new_schema)
+    added = sorted(new_cols - old_cols)
+    removed = sorted(old_cols - new_cols)
+    type_changed = sorted(c for c in (old_cols & new_cols) if old_schema[c] != new_schema[c])
+    return {"added": added, "removed": removed, "type_changed": type_changed}
+
+
+def check_schema(old_schema: dict, new_schema: dict) -> tuple[bool, str, dict]:
+    """old_schema=None means no prior snapshot exists yet — treated as a baseline, not a failure."""
+    if old_schema is None:
+        return True, "Initial schema snapshot recorded", {"added": [], "removed": [], "type_changed": []}
+
+    diff = diff_schema(old_schema, new_schema)
+    changed = diff["added"] or diff["removed"] or diff["type_changed"]
+    if not changed:
+        return True, "No schema changes detected", diff
+
+    parts = []
+    if diff["added"]:
+        parts.append(f"added: {', '.join(diff['added'])}")
+    if diff["removed"]:
+        parts.append(f"removed: {', '.join(diff['removed'])}")
+    if diff["type_changed"]:
+        parts.append(f"type changed: {', '.join(diff['type_changed'])}")
+    return False, "Schema changed — " + "; ".join(parts), diff

dashobserve/runner.py

@@ -0,0 +1,150 @@
+"""
+MonitorConfig + run_monitors() — the Spark-touching glue around the pure
+checks in monitors.py. Reads/writes a Delta "history" table so volume
+baselines and schema snapshots can be compared run over run.
+"""
+from __future__ import annotations
+import json
+from dataclasses import dataclass
+from datetime import datetime
+
+from dashobserve.monitors import MonitorResult, check_freshness, check_schema, check_volume
+
+
+@dataclass
+class MonitorConfig:
+    table: str
+    freshness_column: str = None
+    max_staleness_minutes: float = None
+    min_rows: int = None
+    max_rows: int = None
+    volume_tolerance_pct: float = None
+    track_schema: bool = False
+
+
+class MonitorReport:
+    def __init__(self, results: list):
+        self.results = results
+
+    def to_dict(self) -> list:
+        return [r.to_dict() for r in self.results]
+
+    def to_pandas(self):
+        import pandas as pd
+        return pd.DataFrame(self.to_dict())
+
+    def summary(self) -> dict:
+        total = len(self.results)
+        passed = sum(1 for r in self.results if r.status == "PASS")
+        return {
+            "total_monitors": total,
+            "passed": passed,
+            "failed": total - passed,
+            "pass_rate_pct": round(passed / total * 100, 1) if total else 0,
+        }
+
+    def display(self):
+        for r in self.results:
+            icon = "✅" if r.status == "PASS" else "❌"
+            print(f"{icon} [{r.monitor_type}] {r.table_name} — {r.message}")
+
+
+def run_monitors(config: MonitorConfig, history_table: str = None, spark=None) -> MonitorReport:
+    """Run every monitor configured on config.table and return a MonitorReport."""
+    if spark is None:
+        from pyspark.sql import SparkSession
+        spark = SparkSession.getActiveSession()
+    from pyspark.sql import functions as F
+
+    df = spark.table(config.table)
+    run_ts = datetime.now().isoformat(timespec="seconds")
+    results = []
+
+    if config.freshness_column and config.max_staleness_minutes is not None:
+        latest = df.agg(F.max(config.freshness_column)).collect()[0][0]
+        ok, msg = check_freshness(latest, config.max_staleness_minutes)
+        results.append(MonitorResult(
+            config.table, "freshness", "data_freshness",
+            "PASS" if ok else "FAIL", msg, run_ts,
+        ))
+
+    if config.min_rows is not None or config.max_rows is not None or config.volume_tolerance_pct is not None:
+        row_count = df.count()
+        baseline_avg = None
+        if config.volume_tolerance_pct is not None and history_table:
+            baseline_avg = _read_volume_baseline(spark, history_table, config.table)
+        ok, msg = check_volume(row_count, config.min_rows, config.max_rows, baseline_avg, config.volume_tolerance_pct)
+        results.append(MonitorResult(
+            config.table, "volume", "row_count",
+            "PASS" if ok else "FAIL", msg, run_ts,
+            details=json.dumps({"row_count": row_count}),
+        ))
+
+    if config.track_schema:
+        new_schema = {f.name: str(f.dataType) for f in df.schema.fields}
+        old_schema = _read_last_schema(spark, history_table, config.table) if history_table else None
+        ok, msg, diff = check_schema(old_schema, new_schema)
+        results.append(MonitorResult(
+            config.table, "schema", "schema_change",
+            "PASS" if ok else "FAIL", msg, run_ts,
+            details=json.dumps({"schema": new_schema, "diff": diff}),
+        ))
+
+    if history_table and results:
+        _save_results(spark, history_table, results)
+
+    return MonitorReport(results)
+
+
+def _read_volume_baseline(spark, history_table: str, table: str, window: int = 7):
+    """Average row_count from the last `window` volume monitor runs for this table."""
+    from pyspark.sql import functions as F
+    try:
+        rows = (
+            spark.table(history_table)
+                 .filter((F.col("table_name") == table) & (F.col("monitor_type") == "volume"))
+                 .orderBy(F.col("run_timestamp").desc())
+                 .limit(window)
+                 .select("details")
+                 .collect()
+        )
+    except Exception:
+        return None
+    counts = []
+    for r in rows:
+        try:
+            counts.append(json.loads(r["details"])["row_count"])
+        except Exception:
+            continue
+    return sum(counts) / len(counts) if counts else None
+
+
+def _read_last_schema(spark, history_table: str, table: str):
+    """The most recently saved schema snapshot for this table, or None if there isn't one."""
+    from pyspark.sql import functions as F
+    try:
+        row = (
+            spark.table(history_table)
+                 .filter((F.col("table_name") == table) & (F.col("monitor_type") == "schema"))
+                 .orderBy(F.col("run_timestamp").desc())
+                 .limit(1)
+                 .select("details")
+                 .collect()
+        )
+    except Exception:
+        return None
+    if not row:
+        return None
+    try:
+        return json.loads(row[0]["details"])["schema"]
+    except Exception:
+        return None
+
+
+def _save_results(spark, history_table: str, results: list):
+    rows = [r.to_dict() for r in results]
+    (spark.createDataFrame(rows)
+          .write.format("delta")
+          .mode("append")
+          .option("mergeSchema", "true")
+          .saveAsTable(history_table))

dashobserve/ui.py

@@ -0,0 +1,110 @@
+"""DashObserve interactive UI for Databricks notebooks."""
+from __future__ import annotations
+
+
+def launch():
+    try:
+        import ipywidgets as w
+        from IPython.display import display
+    except ImportError:
+        raise RuntimeError("ipywidgets required. Run: %pip install ipywidgets")
+
+    import dashui
+
+    monitors: list[dict] = []
+
+    # ── Add monitor ───────────────────────────────────────────────────────
+    m_table = w.Text(description="UC Table:", placeholder="catalog.schema.table")
+
+    m_freshness_col = w.Text(description="Freshness col:", placeholder="updated_at (optional)")
+    m_max_staleness = w.IntText(description="Max staleness (min):", value=1440)
+
+    m_min_rows = w.Text(description="Min rows:", placeholder="optional")
+    m_max_rows = w.Text(description="Max rows:", placeholder="optional")
+    m_tolerance = w.Text(description="Baseline tolerance %:", placeholder="optional, e.g. 20")
+
+    m_track_schema = w.Checkbox(value=True, description="Track schema changes")
+
+    add_btn = dashui.action_button("Add Monitor", style="info", emoji="＋")
+    monitors_output, render_monitors = dashui.running_list(
+        lambda i, m: (
+            f"  {i}. {m['table']} — "
+            f"freshness:{'on' if m['freshness_column'] else 'off'}, "
+            f"volume:{'on' if (m['min_rows'] or m['max_rows'] or m['volume_tolerance_pct']) else 'off'}, "
+            f"schema:{'on' if m['track_schema'] else 'off'}"
+        )
+    )
+
+    def _parse_int(text):
+        text = text.strip()
+        return int(text) if text else None
+
+    def _parse_float(text):
+        text = text.strip()
+        return float(text) if text else None
+
+    def on_add(b):
+        table = m_table.value.strip()
+        if not table:
+            return
+        monitors.append({
+            "table": table,
+            "freshness_column": m_freshness_col.value.strip() or None,
+            "max_staleness_minutes": m_max_staleness.value,
+            "min_rows": _parse_int(m_min_rows.value),
+            "max_rows": _parse_int(m_max_rows.value),
+            "volume_tolerance_pct": _parse_float(m_tolerance.value),
+            "track_schema": m_track_schema.value,
+        })
+        render_monitors(monitors)
+        m_table.value = m_freshness_col.value = m_min_rows.value = m_max_rows.value = m_tolerance.value = ""
+
+    add_btn.on_click(on_add)
+
+    # ── Run ──────────────────────────────────────────────────────────────
+    history_table = w.Text(description="History table:", placeholder="catalog.schema.observe_history (optional)")
+    run_btn = dashui.action_button("Run All Monitors", style="success", emoji="▶")
+    output = dashui.output_panel()
+
+    def on_run(b):
+        with output:
+            output.clear_output()
+            if not monitors:
+                print("⚠️  No monitors configured — add at least one above")
+                return
+            try:
+                from dashobserve.runner import MonitorConfig, run_monitors
+                hist = history_table.value.strip() or None
+                for m in monitors:
+                    cfg = MonitorConfig(
+                        table=m["table"],
+                        freshness_column=m["freshness_column"],
+                        max_staleness_minutes=m["max_staleness_minutes"] if m["freshness_column"] else None,
+                        min_rows=m["min_rows"],
+                        max_rows=m["max_rows"],
+                        volume_tolerance_pct=m["volume_tolerance_pct"],
+                        track_schema=m["track_schema"],
+                    )
+                    report = run_monitors(cfg, history_table=hist)
+                    report.display()
+                    s = report.summary()
+                    print(f"   → {s['passed']}/{s['total_monitors']} passed\n")
+            except Exception as e:
+                print(f"❌ {e}")
+
+    run_btn.on_click(on_run)
+
+    ui = dashui.card([
+        dashui.header("DashObserve — Data Observability", library="dashobserve", emoji="👁️"),
+        dashui.section("Step 1: Configure a monitor"),
+        m_table,
+        w.HBox([m_freshness_col, m_max_staleness]),
+        w.HBox([m_min_rows, m_max_rows, m_tolerance]),
+        m_track_schema,
+        add_btn, monitors_output,
+        dashui.section("Step 2: Run"),
+        history_table,
+        run_btn,
+        output,
+    ])
+    display(ui)