dataowl 0.1.0__py3-none-any.whl

dataowl/__init__.py

@@ -0,0 +1,62 @@
+"""dataowl: facts about Databricks data products for building dbt staging models."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from dataowl.collect.columns import collect_columns
+from dataowl.collect.counts import collect_row_count
+from dataowl.collect.detail import collect_detail
+from dataowl.collect.properties import collect_properties
+from dataowl.collect.tables import collect_table_info
+from dataowl.errors import TableNotFoundError
+from dataowl.identifiers import parse_table
+from dataowl.model.overview import Overview
+from dataowl.runner import get_runner
+
+if TYPE_CHECKING:
+    from pyspark.sql import SparkSession
+
+__all__ = ["Overview", "TableNotFoundError", "inspect"]
+
+
+def inspect(
+    table: str, *, spark: SparkSession | None = None, count_views: bool = False
+) -> Overview:
+    """Collect overview facts for a table.
+
+    Raises ValueError for an invalid table name, RuntimeError when no SparkSession is
+    available, and TableNotFoundError when the table does not exist or is not accessible.
+    Every other failure makes the affected facts unavailable.
+    """
+    ref = parse_table(table)
+    runner = get_runner(spark)
+
+    info = collect_table_info(runner, ref)
+    detail = collect_detail(runner, ref, info.object_type)
+    columns = collect_columns(runner, ref)
+    properties = collect_properties(runner, ref, info.object_type)
+    num_rows = collect_row_count(runner, ref, info.object_type, count_views=count_views)
+
+    return Overview(
+        table=ref,
+        object_type=info.object_type,
+        object_type_raw=info.table_type_raw,
+        format=info.format,
+        owner=info.owner,
+        comment=info.comment,
+        created=info.created,
+        last_modified=detail.last_modified,
+        size_bytes=detail.size_bytes,
+        num_files=detail.num_files,
+        avg_file_size_bytes=detail.avg_file_size_bytes,
+        num_rows=num_rows,
+        num_columns=columns.num_columns,
+        num_fields_nested=columns.num_fields_nested,
+        partition_columns=detail.partition_columns,
+        clustering_columns=detail.clustering_columns,
+        change_data_feed=properties.change_data_feed,
+        log_retention=properties.log_retention,
+        deleted_file_retention=properties.deleted_file_retention,
+        columns=columns.columns,
+    )

dataowl/collect/__init__.py

@@ -0,0 +1,40 @@
+"""Collection layer: queries to raw data to model objects. The only layer that knows SQL."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from dataowl.model.facts import Fact
+from dataowl.model.overview import ObjectType
+from dataowl.runner import SqlRunner
+
+_MAX_REASON_LENGTH = 200
+
+NOT_FOR_VIEWS = "Not available for views"
+
+
+def is_view(object_type: Fact[ObjectType]) -> bool:
+    """True only when the object type is known to be VIEW."""
+    return object_type.available and object_type.value is ObjectType.VIEW
+
+
+def safe_query(
+    runner: SqlRunner, sql: str, params: dict[str, Any] | None = None
+) -> list[dict[str, Any]] | Exception:
+    """Run a query and return the rows, or the exception instead of raising it."""
+    try:
+        return runner.query(sql, params)
+    except Exception as exc:
+        return exc
+
+
+def short_reason(exc: Exception) -> str:
+    """First line of the error message, at most 200 characters.
+
+    Falls back to the exception type name when the message is empty.
+    """
+    lines = str(exc).strip().splitlines()
+    reason = lines[0].strip() if lines else type(exc).__name__
+    if len(reason) > _MAX_REASON_LENGTH:
+        reason = reason[: _MAX_REASON_LENGTH - 1] + "…"
+    return reason

dataowl/collect/columns.py

@@ -0,0 +1,135 @@
+"""Schema facts from information_schema.columns and the Spark schema."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from dataowl.collect import safe_query, short_reason
+from dataowl.identifiers import TableRef
+from dataowl.model.facts import Fact
+from dataowl.model.overview import ColumnInfo, ColumnsInfo
+from dataowl.runner import SqlRunner
+
+if TYPE_CHECKING:
+    from pyspark.sql.types import DataType, StructType
+
+T = TypeVar("T")
+
+NO_COLUMNS = "information_schema.columns returned no rows"
+
+_QUERY = """
+SELECT
+  column_name AS column_name,
+  ordinal_position AS ordinal_position,
+  full_data_type AS full_data_type,
+  data_type AS data_type,
+  is_nullable AS is_nullable,
+  comment AS comment
+FROM {catalog}.information_schema.columns
+WHERE table_schema = :schema
+  AND table_name = :table
+ORDER BY ordinal_position
+"""
+
+
+def collect_columns(runner: SqlRunner, ref: TableRef) -> ColumnsInfo:
+    """Read top-level columns from information_schema and count nested fields from the schema.
+
+    The two sources fail independently.
+    """
+    columns, num_columns = _top_level_columns(runner, ref)
+    return ColumnsInfo(
+        columns=columns,
+        num_columns=num_columns,
+        num_fields_nested=_nested_field_count(runner, ref),
+    )
+
+
+def count_fields(schema: StructType) -> int:
+    """Count all fields in a schema, including nested fields.
+
+    Every StructField counts 1. Fields inside a struct, inside the element type of an
+    array and inside the key and value types of a map are added recursively.
+
+    Example: ``a INT, b STRUCT<x INT, y ARRAY<STRUCT<z INT>>>, m MAP<STRING, STRUCT<v INT>>``
+    counts a, b, x, y, z, m and v, which gives 7.
+    """
+    from pyspark.sql.types import ArrayType, MapType, StructType
+
+    def nested(data_type: DataType) -> int:
+        if isinstance(data_type, StructType):
+            return sum(1 + nested(field.dataType) for field in data_type.fields)
+        if isinstance(data_type, ArrayType):
+            return nested(data_type.elementType)
+        if isinstance(data_type, MapType):
+            return nested(data_type.keyType) + nested(data_type.valueType)
+        return 0
+
+    return nested(schema)
+
+
+def _top_level_columns(
+    runner: SqlRunner, ref: TableRef
+) -> tuple[Fact[tuple[ColumnInfo, ...]], Fact[int]]:
+    result = safe_query(
+        runner,
+        _QUERY.format(catalog=ref.quoted_catalog()),
+        # Unity Catalog stores names in lower case. Lowering the parameters instead of
+        # the columns keeps the WHERE clause free of functions on information_schema columns.
+        {"schema": ref.schema.lower(), "table": ref.table.lower()},
+    )
+    if isinstance(result, Exception):
+        reason = short_reason(result)
+        return Fact.unavailable("metadata", reason), Fact.unavailable("metadata", reason)
+    if not result:
+        return Fact.unavailable("metadata", NO_COLUMNS), Fact.unavailable("metadata", NO_COLUMNS)
+
+    try:
+        columns = tuple(_column(row) for row in result)
+    except ValueError as exc:
+        reason = f"Unexpected row format in information_schema.columns: {exc}"
+        return Fact.unavailable("metadata", reason), Fact.unavailable("metadata", reason)
+    return Fact(columns, source="metadata"), Fact(len(columns), source="metadata")
+
+
+def _column(row: dict[str, Any]) -> ColumnInfo:
+    """Convert one row. Raises ValueError if a key is missing or has an unexpected type."""
+    name = _get(row, "column_name", str)
+    position = _get(row, "ordinal_position", int)
+    full_data_type = row.get("full_data_type")
+    if full_data_type is None:
+        data_type = _get(row, "data_type", str)
+    elif isinstance(full_data_type, str):
+        data_type = full_data_type
+    else:
+        raise ValueError(f"full_data_type has type {type(full_data_type).__name__}")
+    is_nullable = _get(row, "is_nullable", str)
+    if is_nullable not in ("YES", "NO"):
+        raise ValueError(f"is_nullable has value {is_nullable!r}")
+    comment = row.get("comment")
+    if comment is not None and not isinstance(comment, str):
+        raise ValueError(f"comment has type {type(comment).__name__}")
+    return ColumnInfo(
+        name=name,
+        position=position,
+        data_type=data_type,
+        nullable=is_nullable == "YES",
+        comment=comment,
+    )
+
+
+def _get(row: dict[str, Any], key: str, expected: type[T]) -> T:
+    if key not in row:
+        raise ValueError(f"missing {key}")
+    value = row[key]
+    if not isinstance(value, expected) or isinstance(value, bool):
+        raise ValueError(f"{key} has type {type(value).__name__}")
+    return value
+
+
+def _nested_field_count(runner: SqlRunner, ref: TableRef) -> Fact[int]:
+    try:
+        schema = runner.schema(ref)
+    except Exception as exc:
+        return Fact.unavailable("metadata", short_reason(exc))
+    return Fact(count_fields(schema), source="metadata")

dataowl/collect/counts.py

@@ -0,0 +1,46 @@
+"""Exact row count."""
+
+from __future__ import annotations
+
+from dataowl.collect import safe_query, short_reason
+from dataowl.identifiers import TableRef
+from dataowl.model.facts import Fact
+from dataowl.model.overview import ObjectType
+from dataowl.runner import SqlRunner
+
+_SKIPPED_TYPES = frozenset({ObjectType.VIEW, ObjectType.MATERIALIZED_VIEW, ObjectType.FOREIGN})
+
+NO_ROWS = "COUNT(*) returned no rows"
+
+
+def collect_row_count(
+    runner: SqlRunner,
+    ref: TableRef,
+    object_type: Fact[ObjectType],
+    *,
+    count_views: bool = False,
+) -> Fact[int]:
+    """Count rows with COUNT(*).
+
+    Unless count_views is True, the count is skipped for views, materialized views and
+    foreign tables, and when the object type is unavailable. UNKNOWN is counted.
+    """
+    if not count_views:
+        if not object_type.available:
+            return Fact.unavailable("exact", "Skipped: object type unknown; use count_views=True")
+        if object_type.value in _SKIPPED_TYPES:
+            assert object_type.value is not None
+            return Fact.unavailable(
+                "exact", f"Skipped for {object_type.value.value}; use count_views=True"
+            )
+
+    result = safe_query(runner, f"SELECT COUNT(*) AS n FROM {ref.quoted()}")
+    if isinstance(result, Exception):
+        return Fact.unavailable("exact", short_reason(result))
+    if not result:
+        return Fact.unavailable("exact", NO_ROWS)
+
+    n = result[0].get("n")
+    if not isinstance(n, int) or isinstance(n, bool):
+        return Fact.unavailable("exact", f"Unexpected COUNT(*) result type: {type(n).__name__}")
+    return Fact(n, source="exact")

dataowl/collect/detail.py

@@ -0,0 +1,80 @@
+"""Size, files and Delta metadata from DESCRIBE DETAIL."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from dataowl.collect import NOT_FOR_VIEWS, is_view, safe_query, short_reason
+from dataowl.identifiers import TableRef
+from dataowl.model.facts import Fact, derive
+from dataowl.model.overview import DetailInfo, ObjectType
+from dataowl.runner import SqlRunner
+
+NOT_PRESENT = "Not present in DESCRIBE DETAIL output"
+NO_ROWS = "DESCRIBE DETAIL returned no rows"
+
+
+def collect_detail(runner: SqlRunner, ref: TableRef, object_type: Fact[ObjectType]) -> DetailInfo:
+    """Run DESCRIBE DETAIL, except for views.
+
+    It also runs when the object type is UNKNOWN or unavailable. Errors make every fact
+    unavailable.
+    """
+    if is_view(object_type):
+        return _unavailable(NOT_FOR_VIEWS)
+
+    result = safe_query(runner, f"DESCRIBE DETAIL {ref.quoted()}")
+    if isinstance(result, Exception):
+        return _unavailable(short_reason(result))
+    if not result:
+        return _unavailable(NO_ROWS)
+
+    row = result[0]
+    size_bytes: Fact[int] = _field(row, "sizeInBytes")
+    num_files: Fact[int] = _field(row, "numFiles")
+    return DetailInfo(
+        format=_field(row, "format"),
+        size_bytes=size_bytes,
+        num_files=num_files,
+        avg_file_size_bytes=_avg_file_size(size_bytes, num_files),
+        created=_field(row, "createdAt"),
+        last_modified=_field(row, "lastModified"),
+        partition_columns=_columns(row, "partitionColumns"),
+        clustering_columns=_columns(row, "clusteringColumns"),
+    )
+
+
+def _field(row: dict[str, Any], key: str) -> Fact[Any]:
+    if key not in row:
+        return Fact.unavailable("metadata", NOT_PRESENT)
+    return Fact(row[key], source="metadata")
+
+
+def _columns(row: dict[str, Any], key: str) -> Fact[tuple[str, ...]]:
+    fact: Fact[Any] = _field(row, key)
+    if fact.available and fact.value is not None:
+        return Fact(tuple(fact.value), source="metadata")
+    return fact
+
+
+def _avg_file_size(size_bytes: Fact[int], num_files: Fact[int]) -> Fact[float]:
+    if num_files.available and num_files.value == 0:
+        return Fact.unavailable("derived", "No files")
+    if (size_bytes.available and size_bytes.value is None) or (
+        num_files.available and num_files.value is None
+    ):
+        return Fact.unavailable("derived", "Input value is null")
+    return derive(lambda size, files: size / files, size_bytes, num_files)
+
+
+def _unavailable(reason: str) -> DetailInfo:
+    return DetailInfo(
+        format=Fact.unavailable("metadata", reason),
+        size_bytes=Fact.unavailable("metadata", reason),
+        num_files=Fact.unavailable("metadata", reason),
+        avg_file_size_bytes=Fact.unavailable("derived", reason),
+        created=Fact.unavailable("metadata", reason),
+        last_modified=Fact.unavailable("metadata", reason),
+        partition_columns=Fact.unavailable("metadata", reason),
+        clustering_columns=Fact.unavailable("metadata", reason),
+    )

dataowl/collect/history.py

@@ -0,0 +1 @@
+from __future__ import annotations

dataowl/collect/keys.py

@@ -0,0 +1 @@
+from __future__ import annotations

dataowl/collect/properties.py

@@ -0,0 +1,75 @@
+"""Selected Delta table properties from SHOW TBLPROPERTIES."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from dataowl.collect import NOT_FOR_VIEWS, is_view, safe_query, short_reason
+from dataowl.identifiers import TableRef
+from dataowl.model.facts import Fact
+from dataowl.model.overview import ObjectType, PropertiesInfo
+from dataowl.runner import SqlRunner
+
+_CHANGE_DATA_FEED = "delta.enablechangedatafeed"
+_LOG_RETENTION = "delta.logretentionduration"
+_DELETED_FILE_RETENTION = "delta.deletedfileretentionduration"
+_KEYS = frozenset({_CHANGE_DATA_FEED, _LOG_RETENTION, _DELETED_FILE_RETENTION})
+
+
+def collect_properties(
+    runner: SqlRunner, ref: TableRef, object_type: Fact[ObjectType]
+) -> PropertiesInfo:
+    """Run SHOW TBLPROPERTIES, except for views.
+
+    It also runs when the object type is UNKNOWN or unavailable. Keys are matched case
+    insensitively. A property that is not set gives Fact(None, source="metadata").
+    """
+    if is_view(object_type):
+        return _unavailable(NOT_FOR_VIEWS)
+
+    result = safe_query(runner, f"SHOW TBLPROPERTIES {ref.quoted()}")
+    if isinstance(result, Exception):
+        return _unavailable(short_reason(result))
+
+    facts = _property_facts(result)
+    return PropertiesInfo(
+        change_data_feed=facts[_CHANGE_DATA_FEED],
+        log_retention=facts[_LOG_RETENTION],
+        deleted_file_retention=facts[_DELETED_FILE_RETENTION],
+    )
+
+
+def _property_facts(rows: list[dict[str, Any]]) -> dict[str, Fact[str]]:
+    """Return one fact per relevant property, keyed by lower-case key.
+
+    Rows whose key is not a string, and rows for other properties, are skipped. A relevant
+    row whose value is not a string makes only that property unavailable.
+    """
+    facts: dict[str, Fact[str]] = {key: Fact(None, source="metadata") for key in _KEYS}
+    seen: set[str] = set()
+    for row in rows:
+        key = row.get("key")
+        if not isinstance(key, str):
+            continue
+        normalized = key.lower()
+        if normalized not in _KEYS or normalized in seen:
+            continue
+        seen.add(normalized)
+        value = row.get("value")
+        if isinstance(value, str):
+            facts[normalized] = Fact(value, source="metadata")
+        else:
+            facts[normalized] = Fact.unavailable(
+                "metadata",
+                f"Unexpected row format in SHOW TBLPROPERTIES: value of {key} has type "
+                f"{type(value).__name__}",
+            )
+    return facts
+
+
+def _unavailable(reason: str) -> PropertiesInfo:
+    return PropertiesInfo(
+        change_data_feed=Fact.unavailable("metadata", reason),
+        log_retention=Fact.unavailable("metadata", reason),
+        deleted_file_retention=Fact.unavailable("metadata", reason),
+    )

dataowl/collect/tables.py

@@ -0,0 +1,80 @@
+"""Object type and basic catalog metadata from information_schema.tables."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from dataowl.collect import safe_query, short_reason
+from dataowl.errors import TableNotFoundError
+from dataowl.identifiers import TableRef
+from dataowl.model.facts import Fact
+from dataowl.model.overview import ObjectType, TableInfo
+from dataowl.runner import SqlRunner
+
+_QUERY = """
+SELECT
+  table_type AS table_type,
+  data_source_format AS data_source_format,
+  table_owner AS table_owner,
+  comment AS comment,
+  created AS created,
+  last_altered AS last_altered
+FROM {catalog}.information_schema.tables
+WHERE table_schema = :schema
+  AND table_name = :table
+"""
+
+
+def collect_table_info(runner: SqlRunner, ref: TableRef) -> TableInfo:
+    """Read catalog metadata for the table.
+
+    Raises TableNotFoundError if the query succeeds but returns no rows. Any other
+    failure makes every fact unavailable.
+    """
+    result = safe_query(
+        runner,
+        _QUERY.format(catalog=ref.quoted_catalog()),
+        # Unity Catalog stores names in lower case. Lowering the parameters instead of
+        # the columns keeps the WHERE clause free of functions on information_schema columns.
+        {"schema": ref.schema.lower(), "table": ref.table.lower()},
+    )
+
+    if isinstance(result, Exception):
+        reason = short_reason(result)
+        return TableInfo(
+            object_type=Fact.unavailable("metadata", reason),
+            table_type_raw=Fact.unavailable("metadata", reason),
+            format=Fact.unavailable("metadata", reason),
+            owner=Fact.unavailable("metadata", reason),
+            comment=Fact.unavailable("metadata", reason),
+            created=Fact.unavailable("metadata", reason),
+            last_altered=Fact.unavailable("metadata", reason),
+        )
+
+    if not result:
+        raise TableNotFoundError(f"Table {ref.quoted()} not found or no access")
+
+    row = result[0]
+    raw_type = row.get("table_type")
+    return TableInfo(
+        object_type=Fact(_object_type(raw_type), source="metadata"),
+        table_type_raw=_metadata(raw_type),
+        format=_metadata(row.get("data_source_format")),
+        owner=_metadata(row.get("table_owner")),
+        comment=_metadata(row.get("comment")),
+        created=_metadata(row.get("created")),
+        last_altered=_metadata(row.get("last_altered")),
+    )
+
+
+def _object_type(raw: str | None) -> ObjectType:
+    if raw is None:
+        return ObjectType.UNKNOWN
+    try:
+        return ObjectType(raw.strip().upper())
+    except ValueError:
+        return ObjectType.UNKNOWN
+
+
+def _metadata(value: Any) -> Fact[Any]:
+    return Fact(value, source="metadata")

dataowl/collect/timestamps.py

@@ -0,0 +1 @@
+from __future__ import annotations

dataowl/errors.py

@@ -0,0 +1,7 @@
+"""Exceptions raised by dataowl."""
+
+from __future__ import annotations
+
+
+class TableNotFoundError(Exception):
+    """The table does not exist, or the current user has no access to it."""

dataowl/identifiers.py

@@ -0,0 +1,112 @@
+"""Parsing, validation and quoting of table and column names."""
+
+from __future__ import annotations
+
+import string
+from dataclasses import dataclass
+
+_UNQUOTED_CHARS = frozenset(string.ascii_letters + string.digits + "_")
+
+
+@dataclass(frozen=True)
+class TableRef:
+    """A three-part table name. Parts are stored raw (unquoted), with case preserved."""
+
+    catalog: str
+    schema: str
+    table: str
+
+    def __post_init__(self) -> None:
+        if not (self.catalog and self.schema and self.table):
+            raise ValueError("TableRef parts must be non-empty")
+
+    def quoted(self) -> str:
+        return ".".join(_quote(part) for part in (self.catalog, self.schema, self.table))
+
+    def quoted_catalog(self) -> str:
+        return _quote(self.catalog)
+
+    def display_name(self) -> str:
+        """Name for display: parts with only letters, digits and underscore are unquoted."""
+        return ".".join(
+            part if all(char in _UNQUOTED_CHARS for char in part) else _quote(part)
+            for part in (self.catalog, self.schema, self.table)
+        )
+
+
+def parse_table(name: str) -> TableRef:
+    """Parse `catalog.schema.table`. Parts may be quoted with backticks."""
+    if not name:
+        raise ValueError("Table name is empty")
+    if name != name.strip():
+        raise ValueError(f"Table name has leading or trailing whitespace: {name!r}")
+
+    parts: list[str] = []
+    i = 0
+    while True:
+        if i < len(name) and name[i] == "`":
+            part, i = _read_quoted(name, i)
+        else:
+            part, i = _read_unquoted(name, i)
+        if not part:
+            raise ValueError(f"Table name has an empty part: {name!r}")
+        parts.append(part)
+
+        if i == len(name):
+            break
+        if name[i] != ".":
+            raise ValueError(
+                f"Unexpected character {name[i]!r} after closing backtick in table name: {name!r}"
+            )
+        i += 1
+
+    if len(parts) != 3:
+        raise ValueError(
+            f"Table name must have exactly three parts (catalog.schema.table), "
+            f"got {len(parts)}: {name!r}"
+        )
+    return TableRef(*parts)
+
+
+def quote_column(name: str) -> str:
+    """Quote a column name as a single identifier. Dots are not treated as separators."""
+    if not name:
+        raise ValueError("Column name is empty")
+    return _quote(name)
+
+
+def _quote(identifier: str) -> str:
+    return "`" + identifier.replace("`", "``") + "`"
+
+
+def _read_quoted(name: str, start: int) -> tuple[str, int]:
+    """Read a backtick-quoted part starting at the opening backtick.
+
+    Returns the raw part and the index after the closing backtick.
+    """
+    chars: list[str] = []
+    i = start + 1
+    while i < len(name):
+        if name[i] == "`":
+            if i + 1 < len(name) and name[i + 1] == "`":
+                chars.append("`")
+                i += 2
+                continue
+            return "".join(chars), i + 1
+        chars.append(name[i])
+        i += 1
+    raise ValueError(f"Unterminated backtick in table name: {name!r}")
+
+
+def _read_unquoted(name: str, start: int) -> tuple[str, int]:
+    """Read an unquoted part. Returns the part and the index of the next '.' or the end."""
+    i = start
+    while i < len(name) and name[i] != ".":
+        if name[i] not in _UNQUOTED_CHARS:
+            raise ValueError(
+                f"Invalid character {name[i]!r} in unquoted part of table name: {name!r}. "
+                "Use backticks for names with characters other than letters, digits "
+                "and underscore."
+            )
+        i += 1
+    return name[start:i], i

dataowl/model/__init__.py

@@ -0,0 +1,3 @@
+"""Data model. Dataclasses only; no Spark import."""
+
+from __future__ import annotations

dataowl/model/analysis.py

@@ -0,0 +1 @@
+from __future__ import annotations

dataowl/model/facts.py

@@ -0,0 +1,75 @@
+"""Fact: a single value together with its source and availability."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, fields, is_dataclass
+from datetime import date
+from enum import Enum
+from typing import Any, Generic, Literal, TypeVar
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+SourceType = Literal["metadata", "exact", "derived"]
+
+
+@dataclass(frozen=True)
+class Fact(Generic[T]):
+    """A fact with its source.
+
+    An unavailable fact requires value None and a non-empty reason. An available fact
+    requires reason None. An available fact may still have value None, e.g. a table
+    property that is not set.
+    """
+
+    value: T | None
+    source: SourceType
+    available: bool = True
+    reason: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.available and self.reason is not None:
+            raise ValueError("An available fact must not have a reason")
+        if not self.available and not self.reason:
+            raise ValueError("An unavailable fact requires a non-empty reason")
+        if not self.available and self.value is not None:
+            raise ValueError("An unavailable fact must have value None")
+
+    @classmethod
+    def unavailable(cls, source: SourceType, reason: str) -> Fact[T]:
+        return cls(value=None, source=source, available=False, reason=reason)
+
+
+def derive(fn: Callable[..., R], *facts: Fact[Any]) -> Fact[R]:
+    """Apply fn to the values of facts, or propagate the first unavailable input."""
+    for fact in facts:
+        if not fact.available:
+            assert fact.reason is not None  # guaranteed by Fact.__post_init__
+            return Fact.unavailable("derived", fact.reason)
+    return Fact(fn(*(fact.value for fact in facts)), source="derived")
+
+
+def to_jsonable(obj: Any) -> Any:
+    """Convert facts and model objects to JSON-serializable types.
+
+    Fact becomes {"value", "source", "available", "reason"}. Other dataclasses become a
+    dict of their fields. Tuples and lists become lists, enums their value, and datetime
+    and date ISO 8601 strings. Other values are returned unchanged.
+    """
+    if isinstance(obj, Fact):
+        return {
+            "value": to_jsonable(obj.value),
+            "source": obj.source,
+            "available": obj.available,
+            "reason": obj.reason,
+        }
+    if is_dataclass(obj) and not isinstance(obj, type):
+        return {field.name: to_jsonable(getattr(obj, field.name)) for field in fields(obj)}
+    if isinstance(obj, (tuple, list)):
+        return [to_jsonable(item) for item in obj]
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, date):
+        return obj.isoformat()
+    return obj

dataowl/model/history.py

@@ -0,0 +1 @@
+from __future__ import annotations

dataowl/model/overview.py

@@ -0,0 +1,130 @@
+"""Overview model: facts from step 1 (inspect)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+from dataowl.identifiers import TableRef
+from dataowl.model.facts import Fact, to_jsonable
+
+
+class ObjectType(Enum):
+    MANAGED = "MANAGED"
+    EXTERNAL = "EXTERNAL"
+    VIEW = "VIEW"
+    MATERIALIZED_VIEW = "MATERIALIZED_VIEW"
+    STREAMING_TABLE = "STREAMING_TABLE"
+    FOREIGN = "FOREIGN"
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclass(frozen=True)
+class TableInfo:
+    """Catalog metadata from information_schema.tables.
+
+    table_type_raw holds the original table_type value, also when object_type is UNKNOWN.
+    """
+
+    object_type: Fact[ObjectType]
+    table_type_raw: Fact[str]
+    format: Fact[str]
+    owner: Fact[str]
+    comment: Fact[str]
+    created: Fact[datetime]
+    last_altered: Fact[datetime]
+
+
+@dataclass(frozen=True)
+class DetailInfo:
+    """Size, files and Delta metadata from DESCRIBE DETAIL."""
+
+    format: Fact[str]
+    size_bytes: Fact[int]
+    num_files: Fact[int]
+    avg_file_size_bytes: Fact[float]
+    created: Fact[datetime]
+    last_modified: Fact[datetime]
+    partition_columns: Fact[tuple[str, ...]]
+    clustering_columns: Fact[tuple[str, ...]]
+
+
+@dataclass(frozen=True)
+class PropertiesInfo:
+    """Selected Delta table properties from SHOW TBLPROPERTIES, as raw strings.
+
+    A property that is not set is an available fact with value None, e.g.
+    Fact(None, source="metadata"). The model holds no display text for this; rendering
+    decides how to show it.
+    """
+
+    change_data_feed: Fact[str]
+    log_retention: Fact[str]
+    deleted_file_retention: Fact[str]
+
+
+@dataclass(frozen=True)
+class ColumnInfo:
+    """One top-level column from information_schema.columns.
+
+    position is the raw ordinal_position from information_schema.columns. The Databricks
+    documentation says it is numbered from 1, but it has been observed to be 0-based in
+    Databricks (serverless, October 2026). Do not use it as a display number.
+    """
+
+    name: str
+    position: int
+    data_type: str
+    nullable: bool
+    comment: str | None
+
+
+@dataclass(frozen=True)
+class ColumnsInfo:
+    """Schema facts: top-level columns and the field count including nested fields."""
+
+    columns: Fact[tuple[ColumnInfo, ...]]
+    num_columns: Fact[int]
+    num_fields_nested: Fact[int]
+
+
+@dataclass(frozen=True)
+class Overview:
+    """All facts from inspect().
+
+    format and created come from information_schema; last_modified is the last data change
+    from DESCRIBE DETAIL. object_type_raw is the original table_type, also when object_type
+    is UNKNOWN.
+    """
+
+    table: TableRef
+    object_type: Fact[ObjectType]
+    object_type_raw: Fact[str]
+    format: Fact[str]
+    owner: Fact[str]
+    comment: Fact[str]
+    created: Fact[datetime]
+    last_modified: Fact[datetime]
+    size_bytes: Fact[int]
+    num_files: Fact[int]
+    avg_file_size_bytes: Fact[float]
+    num_rows: Fact[int]
+    num_columns: Fact[int]
+    num_fields_nested: Fact[int]
+    partition_columns: Fact[tuple[str, ...]]
+    clustering_columns: Fact[tuple[str, ...]]
+    change_data_feed: Fact[str]
+    log_retention: Fact[str]
+    deleted_file_retention: Fact[str]
+    columns: Fact[tuple[ColumnInfo, ...]]
+
+    def to_dict(self) -> dict[str, Any]:
+        result: dict[str, Any] = to_jsonable(self)
+        return result
+
+    def show(self) -> None:
+        from dataowl.render.terminal import render_overview
+
+        print(render_overview(self))

dataowl/render/__init__.py

@@ -0,0 +1,3 @@
+"""Rendering to text. No Spark import."""
+
+from __future__ import annotations

dataowl/render/format.py

@@ -0,0 +1,44 @@
+"""Formatting of single values for display."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from datetime import datetime
+from typing import TypeVar
+
+from dataowl.model.facts import Fact
+
+T = TypeVar("T")
+
+_UNITS = ("KB", "MB", "GB", "TB")
+
+
+def format_bytes(n: float) -> str:
+    """Bytes below 1024 as an integer with B, then KB to TB with one decimal (base 1024)."""
+    if round(n) < 1024:
+        return f"{round(n)} B"
+    value = float(n)
+    for unit in _UNITS:
+        value /= 1024
+        if round(value, 1) < 1024 or unit == _UNITS[-1]:
+            return f"{value:.1f} {unit}"
+    raise AssertionError("unreachable")
+
+
+def format_int(n: int) -> str:
+    """Integer with a space as thousands separator."""
+    return f"{n:,}".replace(",", " ")
+
+
+def format_datetime(value: datetime) -> str:
+    """YYYY-MM-DD HH:MM, without time zone conversion."""
+    return value.strftime("%Y-%m-%d %H:%M")
+
+
+def format_fact(fact: Fact[T], fmt: Callable[[T], str] | None = None, none_text: str = "–") -> str:
+    """Format a fact: 'n/a (<reason>)' if unavailable, none_text if the value is None."""
+    if not fact.available:
+        return f"n/a ({fact.reason})"
+    if fact.value is None:
+        return none_text
+    return fmt(fact.value) if fmt is not None else str(fact.value)

dataowl/render/terminal.py

@@ -0,0 +1,138 @@
+"""Terminal rendering. Formatting only; no Spark import."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from dataowl.render.format import format_bytes, format_datetime, format_fact, format_int
+
+if TYPE_CHECKING:
+    from dataowl.model.facts import Fact
+    from dataowl.model.overview import ColumnInfo, Overview
+
+T = TypeVar("T")
+
+NOT_SET = "not set (default)"
+_COLUMN_COMMENT_WIDTH = 40
+_TABLE_COMMENT_WIDTH = 80
+
+
+def render_overview(overview: Overview) -> str:
+    header = (
+        f"{overview.table.display_name()}   "
+        f"({_header_value(overview.object_type_raw)}, {_header_value(overview.format)})"
+    )
+    rows = [
+        ("Size:", format_fact(overview.size_bytes, format_bytes)),
+        ("Files:", _files(overview)),
+        ("Rows:", format_fact(overview.num_rows, format_int)),
+        ("Columns:", _columns_count(overview)),
+        ("Partitioned by:", format_fact(overview.partition_columns, _names)),
+        ("Clustered by:", format_fact(overview.clustering_columns, _names)),
+        ("Change Data Feed:", format_fact(overview.change_data_feed, none_text=NOT_SET)),
+        ("Log retention:", format_fact(overview.log_retention, none_text=NOT_SET)),
+        (
+            "Deleted file retention:",
+            format_fact(overview.deleted_file_retention, none_text=NOT_SET),
+        ),
+        ("Created:", format_fact(overview.created, format_datetime)),
+        ("Last modified:", format_fact(overview.last_modified, format_datetime)),
+        ("Owner:", format_fact(overview.owner)),
+        ("Comment:", format_fact(overview.comment, _table_comment)),
+    ]
+    width = max(len(label) for label, _ in rows) + 2
+    lines = [header, ""]
+    lines += [f"{label:<{width}}{value}" for label, value in rows]
+    lines += ["", "SCHEMA"]
+    lines += _schema(overview.columns)
+    return "\n".join(lines)
+
+
+def _files(overview: Overview) -> str:
+    return _with_secondary(
+        format_fact(overview.num_files, format_int),
+        overview.num_files,
+        overview.avg_file_size_bytes,
+        format_bytes,
+        "avg {}",
+        "avg",
+    )
+
+
+def _columns_count(overview: Overview) -> str:
+    return _with_secondary(
+        format_fact(overview.num_columns, format_int),
+        overview.num_columns,
+        overview.num_fields_nested,
+        format_int,
+        "{} incl. nested",
+        "incl. nested",
+    )
+
+
+def _with_secondary(
+    text: str,
+    primary: Fact[Any],
+    secondary: Fact[T],
+    fmt: Callable[[T], str],
+    template: str,
+    label: str,
+) -> str:
+    """Append '  (<secondary>)' to text.
+
+    The secondary part is left out when both facts are unavailable for the same reason.
+    """
+    if not secondary.available and secondary.reason == primary.reason:
+        return text
+    if not secondary.available or secondary.value is None:
+        return f"{text}  ({label}: {format_fact(secondary)})"
+    return f"{text}  ({template.format(fmt(secondary.value))})"
+
+
+def _names(names: tuple[str, ...]) -> str:
+    return ", ".join(names) if names else "–"
+
+
+def _schema(columns: Fact[tuple[ColumnInfo, ...]]) -> list[str]:
+    if not columns.available or columns.value is None:
+        return [f"  {format_fact(columns)}"]
+
+    table = [("#", "name", "type", "nullable", "comment")]
+    table += [
+        (
+            str(number),
+            column.name,
+            column.data_type,
+            "yes" if column.nullable else "no",
+            _shorten(column.comment or "", _COLUMN_COMMENT_WIDTH),
+        )
+        for number, column in enumerate(columns.value, start=1)
+    ]
+    widths = [max(len(row[i]) for row in table) for i in range(4)]
+    return [
+        (
+            "  "
+            + "  ".join(cell.ljust(width) for cell, width in zip(row[:4], widths, strict=True))
+            + "  "
+            + row[4]
+        ).rstrip()
+        for row in table
+    ]
+
+
+def _header_value(fact: Fact[str]) -> str:
+    """Header value; the reason for an unavailable fact is shown on the lines below."""
+    return format_fact(fact) if fact.available else "n/a"
+
+
+def _table_comment(comment: str) -> str:
+    return _shorten(comment, _TABLE_COMMENT_WIDTH) or "–"
+
+
+def _shorten(text: str, width: int) -> str:
+    """Collapse line breaks and whitespace, and cut to width characters including '…'."""
+    text = " ".join(text.split())
+    if len(text) > width:
+        return text[: width - 1] + "…"
+    return text

dataowl/runner.py

@@ -0,0 +1,47 @@
+"""SqlRunner protocol and SparkRunner.
+
+PySpark is imported lazily, so this module can be imported without PySpark installed.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Protocol
+
+from dataowl.identifiers import TableRef
+
+if TYPE_CHECKING:
+    from pyspark.sql import SparkSession
+    from pyspark.sql.types import StructType
+
+
+class SqlRunner(Protocol):
+    def query(self, sql: str, params: dict[str, Any] | None = None) -> list[dict[str, Any]]: ...
+
+    def schema(self, table: TableRef) -> StructType: ...
+
+
+class SparkRunner:
+    def __init__(self, spark: SparkSession) -> None:
+        self._spark = spark
+
+    def query(self, sql: str, params: dict[str, Any] | None = None) -> list[dict[str, Any]]:
+        rows = self._spark.sql(sql, args=params).collect()
+        return [row.asDict(recursive=True) for row in rows]
+
+    def schema(self, table: TableRef) -> StructType:
+        # spark.table() is lazy; reading .schema does not scan data.
+        return self._spark.table(table.quoted()).schema
+
+
+def get_runner(spark: SparkSession | None = None) -> SparkRunner:
+    """Return a SparkRunner for the given session, or for the active session."""
+    if spark is None:
+        from pyspark.sql import SparkSession
+
+        spark = SparkSession.getActiveSession()
+    if spark is None:
+        raise RuntimeError(
+            "No active SparkSession found. Run dataowl in a Databricks notebook or job, "
+            "or pass a session explicitly with spark=."
+        )
+    return SparkRunner(spark)

dataowl-0.1.0.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.5
+Name: dataowl
+Version: 0.1.0
+Summary: Facts about Databricks data products for building dbt staging models.
+Project-URL: Homepage, https://github.com/alexD1990/dataowl
+Project-URL: Repository, https://github.com/alexD1990/dataowl
+Project-URL: Changelog, https://github.com/alexD1990/dataowl/blob/master/CHANGELOG.md
+Project-URL: Issues, https://github.com/alexD1990/dataowl/issues
+Author: Alexandro Dronnen
+License-Expression: MIT
+License-File: LICENSE
+Keywords: data-engineering,databricks,dbt,delta-lake,unity-catalog
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: mypy==2.3.1; extra == 'dev'
+Requires-Dist: pyspark>=3.4; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff==0.16.9; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dataowl
+
+dataowl reports facts about a table in Databricks (Unity Catalog / Delta Lake): size, files,
+rows, schema and table properties. It is meant for data engineers who build a dbt staging
+model and want the facts without writing exploratory SQL. It reports what exists and never
+gives recommendations.
+
+## Requirements
+
+- Unity Catalog.
+- Databricks Runtime 14.3 LTS or above, or serverless compute.
+  Verified on serverless (Spark Connect).
+- PySpark is provided by Databricks. dataowl has no other runtime dependencies.
+
+## Installation
+
+In a Databricks notebook:
+
+```python
+%pip install dataowl==0.1.0
+```
+
+## Usage
+
+```python
+import dataowl
+
+dataowl.inspect("catalog.schema.table").show()
+```
+
+As a JSON-serializable dict, where every fact has a value, a source and a reason when it
+is unavailable:
+
+```python
+overview = dataowl.inspect("catalog.schema.table")
+overview.to_dict()
+```
+
+Row counts are skipped for views, materialized views and foreign tables unless you ask for
+them:
+
+```python
+dataowl.inspect("catalog.schema.some_view", count_views=True).show()
+```
+
+Names with characters other than letters, digits and underscore are quoted with backticks:
+`` dataowl.inspect("`my-catalog`.schema.table") ``.
+
+## Example output
+
+Output for Databricks' public sample data (`samples.nyctaxi.trips`):
+
+```text
+samples.nyctaxi.trips   (MANAGED, DELTA)
+
+Size:                    354.2 KB
+Files:                   1  (avg 354.2 KB)
+Rows:                    21 932
+Columns:                 6  (6 incl. nested)
+Partitioned by:          –
+Clustered by:            –
+Change Data Feed:        true
+Log retention:           not set (default)
+Deleted file retention:  not set (default)
+Created:                 2025-09-30 11:28
+Last modified:           2026-09-14 15:07
+Owner:                   System user
+Comment:                 –
+
+SCHEMA
+  #  name                   type       nullable  comment
+  1  tpep_pickup_datetime   timestamp  yes
+  2  tpep_dropoff_datetime  timestamp  yes
+  3  trip_distance          double     yes
+  4  fare_amount            double     yes
+  5  pickup_zip             int        yes
+  6  dropoff_zip            int        yes
+```
+
+## Principles
+
+- **Read-only.** Only `SELECT`, `DESCRIBE` and `SHOW`. Nothing is written, optimized or
+  analyzed.
+- **Facts only.** No recommendations or assessments.
+- **No row values leave Spark.** Only aggregates and metadata are collected.
+- **Unavailable facts are reported with a reason.** Missing permissions or an unsupported
+  object type make the affected facts `n/a (<reason>)`; the rest of the report is still
+  produced. Only a table that does not exist or is not accessible raises
+  `TableNotFoundError`.
+
+## Facts per object type
+
+| Facts | Source | MANAGED, EXTERNAL | STREAMING_TABLE, MATERIALIZED_VIEW | FOREIGN | VIEW | UNKNOWN or n/a type |
+|---|---|---|---|---|---|---|
+| Object type, format, owner, comment, created | `information_schema.tables` | yes | yes | yes | yes | yes (n/a if the query fails) |
+| Size, files, avg file size, last modified, partitioning, clustering | `DESCRIBE DETAIL` | yes | attempted¹ | attempted¹ | no | attempted¹ |
+| Columns and schema | `information_schema.columns` | yes | yes | yes | yes | yes |
+| Field count incl. nested | Spark schema | yes | yes | yes | yes | yes |
+| Change Data Feed, log and deleted file retention | `SHOW TBLPROPERTIES` | yes | attempted¹ | attempted¹ | no | attempted¹ |
+| Rows | `COUNT(*)` | yes | MATERIALIZED_VIEW: with `count_views=True`; STREAMING_TABLE: yes | with `count_views=True` | with `count_views=True` | UNKNOWN: yes; n/a type: with `count_views=True` |
+
+¹ The query runs. If Databricks does not support it for the object, the facts are shown as
+`n/a (<reason>)`.
+
+"UNKNOWN" is a `table_type` dataowl does not recognize, such as `MANAGED_SHALLOW_CLONE`. The
+original value is shown in the header. "n/a type" means the object type could not be read.
+
+## Fields
+
+- **Last modified** is the last data change, from `DESCRIBE DETAIL`. **Created** is from
+  `information_schema.tables`.
+- **Rows** is an exact `COUNT(*)`. On large tables this costs compute.
+- **Files (avg ...)** is the size divided by the number of files.
+- **Columns (... incl. nested)** counts every field, including fields inside structs, array
+  elements and map keys and values.
+- **not set (default)** means the table property is not set, so Databricks uses its default.
+  dataowl does not report what the default is.
+- **#** in the schema table is a running number from 1 in column order.
+
+## Known deviations
+
+- `information_schema.columns.ordinal_position` is documented as numbered from 1, but has
+  been observed 0-based in Databricks (serverless, October 2026). dataowl keeps the raw
+  value in `ColumnInfo.position` and shows a running number in the `#` column.
+
+## License
+
+MIT. Copyright (c) 2026 Alexandro Dronnen. See [LICENSE](LICENSE).

dataowl-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+dataowl/__init__.py,sha256=1w3A_hT9E3P7__pJvcbl_zWXhdUPk7zwLDaOyfKzXBU,2320
+dataowl/errors.py,sha256=E4zTLIA-W8DwS8gw77qKGSEVFC6iIGNVfD1Xg3eC_8w,188
+dataowl/identifiers.py,sha256=kWF0UR0OYukQrfW0hLqlEreFeWlMWnIZVt7-OSP9oZg,3600
+dataowl/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataowl/runner.py,sha256=94hsS2sZCj3HZIxkE0qstJOYhR2MAufkuKgriHbVlyw,1541
+dataowl/collect/__init__.py,sha256=X3PmsdPlylbxQpOdz2uccoTb98yA3Nzy-uBKq1il9eg,1248
+dataowl/collect/columns.py,sha256=_tO4kp58gxZ9h6cnkZgYaI9EXFDadGIANbGrVLj8yjM,4899
+dataowl/collect/counts.py,sha256=2EyvOjKBTOJV7ecSdkuuHazkJRi2YTIEkD5YUxISt2s,1635
+dataowl/collect/detail.py,sha256=QYKHnt6xfQXTVSnfIInMm3h9Xsh1hzOSx-CPN7A8Wu4,2987
+dataowl/collect/history.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+dataowl/collect/keys.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+dataowl/collect/properties.py,sha256=-RcrYz1AZLGf3waO7s_gQQuwR1rmex20pQEY2AfTMEs,2766
+dataowl/collect/tables.py,sha256=FmbwGxXfhZ6KuJTUuQcPt8x5as9pXASi17mJaJbt7Do,2698
+dataowl/collect/timestamps.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+dataowl/model/__init__.py,sha256=xpc0GSN5DNctiUqc0s5lBSvpfoCxAZ7ly119pctfUT4,89
+dataowl/model/analysis.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+dataowl/model/facts.py,sha256=8mB5Y43KC3lm-K-BHQsyLGI072rM9-afHAhNXK1ShNg,2723
+dataowl/model/history.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+dataowl/model/overview.py,sha256=FQwgu6LGhHsTXCYL6iKfZtfluzBbHCz7-oI5zZNwod8,3544
+dataowl/render/__init__.py,sha256=HBBTqO_j52tlMDbPWgOiNY1yPCGpaLj2hdFmyRMMKzk,78
+dataowl/render/format.py,sha256=WDwKrI0LjauuY1RAxtduReTni5-UpMmyEppfV4Ar_yc,1312
+dataowl/render/terminal.py,sha256=iIQEAz_28IX0zy8dCK-QknAE9bDLb4qqPaeH9wLAif0,4470
+dataowl-0.1.0.dist-info/METADATA,sha256=marLaf09bCi5ViXqjhlqvUf2RVGZIYABFXWQmyzzcw0,6131
+dataowl-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+dataowl-0.1.0.dist-info/licenses/LICENSE,sha256=bO2mV8F0lNY78kr-gUhW-EA7YI9uFmOXD3KmktyNjlI,1074
+dataowl-0.1.0.dist-info/RECORD,,

dataowl-0.1.0.dist-info/WHEEL

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

dataowl-0.1.0.dist-info/licenses/LICENSE

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