pytest-duckdb 0.1.0__py3-none-any.whl

pytest_duckdb/__init__.py

@@ -0,0 +1,3 @@
+"""pytest-duckdb: SQL pipeline testing made trivial."""
+
+__version__ = "0.1.0"

pytest_duckdb/fixtures.py

@@ -0,0 +1,50 @@
+"""CSV fixture loading — reads CSV files from a directory into DuckDB tables."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import duckdb
+
+
+def load_csvs(conn: duckdb.DuckDBPyConnection, fixtures_dir: str) -> None:
+    """Load all CSV files from *fixtures_dir* as DuckDB tables.
+
+    Each CSV file becomes a table named after its stem (filename without extension).
+    Uses ``read_csv_auto`` for schema inference.  Non-existent directories are
+    silently ignored so that tests without fixtures work out of the box.
+
+    Args:
+        conn: An open DuckDB connection.
+        fixtures_dir: Absolute or project-relative path to the CSV directory.
+    """
+    path = Path(fixtures_dir)
+    if not path.is_dir():
+        return
+
+    csv_files = sorted(path.glob("*.csv"))
+    for csv_file in csv_files:
+        table_name = csv_file.stem
+        conn.execute(
+            f'CREATE TABLE "{table_name}" AS '
+            f"SELECT * FROM read_csv_auto('{csv_file}')"
+        )
+
+
+def read_sql_file(path: str) -> str:
+    """Read and return the contents of a SQL file.
+
+    Args:
+        path: Absolute or relative path to the ``.sql`` file.
+
+    Returns:
+        The file contents as a string.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+    """
+    if not os.path.isfile(path):
+        raise FileNotFoundError(f"SQL file not found: {path}")
+    with open(path) as fh:
+        return fh.read()

pytest_duckdb/plugin.py

@@ -0,0 +1,254 @@
+"""pytest plugin registration — fixtures, markers, and CLI options.
+
+Provides three fixtures:
+
+* ``duckdb_session`` – function-scoped in-memory DuckDB with CSV fixtures
+  auto-loaded.
+* ``sql_result`` – executes a ``.sql`` file referenced via ``@pytest.mark.sql``.
+* ``sql_snapshot`` – callable fixture for Parquet snapshot testing.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+import pytest
+
+from .fixtures import load_csvs, read_sql_file
+from .snapshot import compare, save
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    """Register CLI options and ini-file keys."""
+    parser.addini(
+        "duckdb_fixtures_dir",
+        type="string",
+        default="tests/fixtures",
+        help="Directory containing CSV fixture files",
+    )
+    parser.addini(
+        "duckdb_snapshots_dir",
+        type="string",
+        default="tests/__snapshots__",
+        help="Directory for Parquet snapshot files",
+    )
+    group = parser.getgroup("duckdb")
+    group.addoption(
+        "--snapshot-update",
+        action="store_true",
+        default=False,
+        help="Regenerate all Parquet snapshots instead of comparing",
+    )
+    group.addoption(
+        "--duckdb-fixtures-dir",
+        action="store",
+        default=None,
+        metavar="PATH",
+        help="Directory containing CSV fixture files (default: tests/fixtures)",
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    """Register the ``sql`` marker and expand docstring."""
+    config.addinivalue_line(
+        "markers",
+        "sql(path): mark a test to run a SQL file; "
+        "the path is resolved relative to the project root.",
+    )
+
+    # Persist resolved config options.
+    config.duckdb_fixtures_dir = _resolve_option(
+        config,
+        cli_name="--duckdb-fixtures-dir",
+        ini_name="duckdb_fixtures_dir",
+        default="tests/fixtures",
+    )
+
+    config.duckdb_snapshots_dir = _resolve_ini_option(
+        config,
+        ini_name="duckdb_snapshots_dir",
+        default="tests/__snapshots__",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="function")
+def duckdb_session(request: pytest.FixtureRequest):
+    """Function-scoped DuckDB in-memory session with auto-loaded CSV fixtures.
+
+    CSVs in the configured fixtures directory are loaded as tables named
+    after the file stem.  If the directory does not exist the session is
+    returned empty with no error.
+
+    Yields:
+        ``duckdb.DuckDBPyConnection`` -- close on teardown.
+    """
+    import duckdb
+
+    conn = duckdb.connect(":memory:")
+    fixtures_dir = _resolve_path(
+        request.config.duckdb_fixtures_dir,
+        request.config.rootpath,
+    )
+    load_csvs(conn, fixtures_dir)
+    yield conn
+    conn.close()
+
+
+@pytest.fixture(scope="function")
+def sql_result(
+    duckdb_session,        # noqa: ANN001, ANN201
+    request: pytest.FixtureRequest,
+):
+    """Fixture that executes a SQL file referenced by ``@pytest.mark.sql``.
+
+    Usage::
+
+        @pytest.mark.sql("tests/queries/my_query.sql")
+        def test_something(sql_result):
+            assert len(sql_result) > 0
+
+    Returns a ``pandas.DataFrame`` if pandas is installed, otherwise a
+    :class:`~pytest_duckdb.snapshot.QueryResult` with ``.columns``.
+
+    Raises:
+        FileNotFoundError: The referenced SQL file does not exist.
+    """
+    marker = request.node.get_closest_marker("sql")
+    if marker is None:
+        return None
+
+    sql_path = _resolve_marker_path(marker, request)
+    query = read_sql_file(sql_path)
+    result = duckdb_session.execute(query)
+
+    from .snapshot import _cursor_to_result
+
+    return _cursor_to_result(result)
+
+
+@pytest.fixture(scope="function")
+def sql_snapshot(
+    duckdb_session,        # noqa: ANN001, ANN201
+    request: pytest.FixtureRequest,
+) -> Callable[..., None]:
+    """Callable fixture for Parquet snapshot testing.
+
+    Usage::
+
+        def test_query(sql_snapshot):
+            result = duckdb_session.execute("SELECT ...").fetchdf()
+            sql_snapshot(result)
+
+    **First run:** saves the result to ``{snapshots_dir}/{module}_{test}.parquet``
+    and passes.
+
+    **Subsequent runs:** loads the Parquet snapshot and asserts equality.  Raises
+    ``AssertionError`` with a clear diff on mismatch.
+
+    Pass ``--snapshot-update`` on the CLI to regenerate all snapshots.
+    """
+    snapshots_dir = _resolve_path(
+        request.config.duckdb_snapshots_dir,
+        request.config.rootpath,
+    )
+    update = request.config.getoption("--snapshot-update", default=False)
+
+    # Build a deterministic snapshot file name.
+    module_name = _module_name(request.node)
+    test_name = _test_name(request.node)
+    snapshot_path = os.path.join(
+        snapshots_dir, f"{module_name}_{test_name}.parquet",
+    )
+
+    def _snapshot(result: Any, name: Optional[str] = None) -> None:
+        """Save or compare *result* against the Parquet snapshot.
+
+        Args:
+            result: DataFrame or list-of-tuples to snapshot.
+            name: Optional override for the snapshot file name stem.
+
+        Raises:
+            AssertionError: On mismatch (when not updating).
+        """
+        nonlocal snapshot_path
+        if name is not None:
+            snapshot_path = os.path.join(
+                snapshots_dir, f"{module_name}_{name}.parquet",
+            )
+
+        if update or not os.path.isfile(snapshot_path):
+            save(duckdb_session, result, snapshot_path)
+        else:
+            compare(duckdb_session, result, snapshot_path)
+
+    return _snapshot
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _resolve_option(
+    config: pytest.Config,
+    cli_name: str,
+    ini_name: str,
+    default: str,
+) -> str:
+    """Resolve a config value from CLI → ini → default."""
+    cli_val = config.getoption(cli_name.replace("--", "").replace("-", "_"))
+    if cli_val is not None:
+        return cli_val
+    ini_val = config.getini(ini_name)
+    if ini_val:
+        return ini_val
+    return default
+
+
+def _resolve_ini_option(
+    config: pytest.Config,
+    ini_name: str,
+    default: str,
+) -> str:
+    """Resolve a config value from ini → default."""
+    ini_val = config.getini(ini_name)
+    if ini_val:
+        return ini_val
+    return default
+
+
+def _resolve_path(path_str: str, root: Path) -> str:
+    """Resolve a possibly-relative path against the project root."""
+    if not os.path.isabs(path_str):
+        return os.path.join(str(root), path_str)
+    return path_str
+
+
+def _resolve_marker_path(marker: pytest.Mark, request: pytest.FixtureRequest) -> str:
+    """Resolve the path from a ``@pytest.mark.sql`` marker."""
+    path = marker.args[0] if marker.args else marker.kwargs.get("path", "")
+    if not os.path.isabs(path):
+        return os.path.join(str(request.config.rootpath), path)
+    return path
+
+
+def _module_name(node: pytest.Item) -> str:
+    """Return a sanitised module name for snapshot file naming."""
+    # node.path gives the file path, e.g. tests/test_fixtures.py
+    fspath = getattr(node, "path", None) or getattr(node, "fspath", None)
+    if fspath:
+        stem = Path(str(fspath)).stem  # e.g. test_fixtures
+        return stem
+    return "unknown_module"
+
+
+def _test_name(node: pytest.Item) -> str:
+    """Return a sanitised test function name."""
+    return node.name.replace("[", "_").replace("]", "_").replace("/", "_")

pytest_duckdb/snapshot.py

@@ -0,0 +1,274 @@
+"""Parquet snapshot save / load / compare.
+
+Snapshots provide deterministic regression testing for SQL queries.  The first
+run saves the result as a Parquet file.  Subsequent runs compare against the
+stored snapshot and raise ``AssertionError`` with a clear diff on mismatch.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, List, Sequence
+
+import duckdb
+
+# ---------------------------------------------------------------------------
+# Public helpers
+# ---------------------------------------------------------------------------
+
+
+def save(conn: duckdb.DuckDBPyConnection, result: Any, path: str) -> None:
+    """Save *result* (DataFrame or list-of-tuples) to a Parquet file.
+
+    The parent directory is created if it does not exist.
+    """
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    _register_temp(conn, result, "__snapshot_to_save__")
+    conn.execute(f"COPY __snapshot_to_save__ TO '{path}' (FORMAT PARQUET)")
+    conn.execute("DROP TABLE IF EXISTS __snapshot_to_save__")
+
+
+def load(conn: duckdb.DuckDBPyConnection, path: str) -> Any:
+    """Load a Parquet snapshot as a pandas DataFrame (if available) or
+    :class:`QueryResult`."""
+    if not os.path.isfile(path):
+        raise FileNotFoundError(f"Snapshot file not found: {path}")
+    cur = conn.execute(f"SELECT * FROM read_parquet('{path}')")
+    return _cursor_to_result(cur)
+
+
+def compare(
+    conn: duckdb.DuckDBPyConnection,
+    actual: Any,
+    path: str,
+) -> None:
+    """Compare *actual* against the Parquet snapshot at *path*.
+
+    Raises ``AssertionError`` with a human-readable diff if they differ.
+
+    Args:
+        conn: DuckDB connection used for comparison queries.
+        actual: DataFrame or list-of-tuples (the current query result).
+        path: Path to the stored Parquet snapshot.
+
+    Raises:
+        FileNotFoundError: The snapshot has not been created yet.
+        AssertionError: The result does not match the snapshot.
+    """
+    if not os.path.isfile(path):
+        raise FileNotFoundError(
+            f"Snapshot does not exist yet — run without --snapshot-update "
+            f"to create it first (expected: {path})"
+        )
+
+    _register_temp(conn, actual, "__snapshot_actual__")
+
+    # Load the snapshot into a temp table for SQL-based comparison.
+    conn.execute(
+        "CREATE TEMP TABLE __snapshot_expected__ AS "
+        f"SELECT * FROM read_parquet('{path}')"
+    )
+
+    try:
+        # 1. Column / type matching.
+        actual_cols = _describe(conn, "__snapshot_actual__")
+        expected_cols = _describe(conn, "__snapshot_expected__")
+
+        if actual_cols != expected_cols:
+            _raise_schema_diff(actual_cols, expected_cols)
+
+        # 2. Row-level comparison via EXCEPT.
+        differing = conn.execute(
+            "SELECT * FROM __snapshot_actual__ "
+            "EXCEPT "
+            "SELECT * FROM __snapshot_expected__"
+        ).fetchall()
+
+        missing = conn.execute(
+            "SELECT * FROM __snapshot_expected__ "
+            "EXCEPT "
+            "SELECT * FROM __snapshot_actual__"
+        ).fetchall()
+
+        if differing or missing:
+            col_names = [c[0] for c in expected_cols] if expected_cols else []
+            _raise_row_diff(differing, missing, col_names)
+
+    finally:
+        conn.execute("DROP TABLE IF EXISTS __snapshot_actual__")
+        conn.execute("DROP TABLE IF EXISTS __snapshot_expected__")
+
+
+# ---------------------------------------------------------------------------
+# Result types
+# ---------------------------------------------------------------------------
+
+
+class QueryResult:
+    """Wrapper around a list of result rows with a ``.columns`` attribute.
+
+    Used when pandas is not installed so that consumers can access column
+    metadata in a uniform way.
+    """
+
+    __slots__ = ("_rows", "columns")
+
+    def __init__(self, rows: Sequence[tuple], columns: Sequence[str]) -> None:
+        self._rows = list(rows)
+        self.columns = tuple(columns)
+
+    def __iter__(self):  # noqa: ANN201
+        return iter(self._rows)
+
+    def __len__(self) -> int:
+        return len(self._rows)
+
+    def __getitem__(self, idx: int) -> tuple:
+        return self._rows[idx]
+
+    def __repr__(self) -> str:  # noqa: D105
+        return f"QueryResult(rows={len(self)}, columns={self.columns})"
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _register_temp(conn: duckdb.DuckDBPyConnection, result: Any, name: str) -> None:
+    """Register *result* as a temporary DuckDB table called *name*."""
+    # If it has a `columns` attribute it's a QueryResult (list-of-tuples).
+    if hasattr(result, "_rows"):
+        rows = list(result)
+        if not rows:
+            columns = list(result.columns)
+            # Create an empty table with VARCHAR columns.
+            col_defs = ",\n".join(f'"{c}" VARCHAR' for c in columns)
+            conn.execute(f"CREATE TEMP TABLE {name} ({col_defs})")
+        else:
+            _register_tuple_list(conn, rows, list(result.columns), name)
+        return
+
+    # Check for pandas DataFrame.
+    try:
+        import pandas as pd
+
+        if isinstance(result, pd.DataFrame):
+            conn.register(name, result)
+            return
+    except ImportError:
+        pass
+
+    # Fallback: treat as list-of-tuples with no column metadata.
+    if isinstance(result, (list, tuple)):
+        rows = list(result)
+        if rows:
+            cols = [f"col{i}" for i in range(len(rows[0]))]
+        else:
+            cols = []
+        _register_tuple_list(conn, rows, cols, name)
+        return
+
+    # DuckDB-compatible type (e.g. a relation).
+    conn.execute(f"CREATE TEMP TABLE {name} AS SELECT * FROM result")
+
+
+def _register_tuple_list(
+    conn: duckdb.DuckDBPyConnection,
+    rows: list,
+    columns: List[str],
+    name: str,
+) -> None:
+    """Create a temp table from a list of Python tuples, preserving types."""
+    col_list = ", ".join(f'"{c}"' for c in columns)
+    quoted = ", ".join("?" for _ in columns)
+    head = rows[0]
+
+    # Let DuckDB infer types from the first row.
+    placeholders = "(" + ", ".join(
+        _py_value_repr(v) for v in head
+    ) + ")"
+    conn.execute(
+        f"CREATE TEMP TABLE {name} AS "
+        f"SELECT * FROM (VALUES {placeholders}) AS t ({col_list}) WHERE FALSE"
+    )
+    conn.executemany(
+        f"INSERT INTO {name} ({col_list}) VALUES ({quoted})",
+        rows,
+    )
+
+
+def _py_value_repr(val: Any) -> str:
+    """Return a DuckDB-compatible literal for a Python value."""
+    if val is None:
+        return "NULL"
+    if isinstance(val, bool):
+        return "TRUE" if val else "FALSE"
+    if isinstance(val, (int, float)):
+        return str(val)
+    if isinstance(val, str):
+        escaped = val.replace("'", "''")
+        return f"'{escaped}'"
+    return f"'{val}'"
+
+
+def _cursor_to_result(cur: duckdb.DuckDBPyConnection) -> Any:
+    """Convert a DuckDB cursor to a DataFrame (preferred) or QueryResult."""
+    columns = [desc[0] for desc in cur.description] if cur.description else []
+    rows = cur.fetchall()
+    try:
+        import pandas as pd
+
+        return pd.DataFrame(rows, columns=columns)
+    except ImportError:
+        return QueryResult(rows, columns)
+
+
+def _describe(conn: duckdb.DuckDBPyConnection, table: str) -> List[tuple]:
+    """Return ``[(column_name, data_type), ...]`` for *table*."""
+    return conn.execute(f"DESCRIBE {table}").fetchall()
+
+
+def _raise_schema_diff(
+    actual: List[tuple],
+    expected: List[tuple],
+) -> None:
+    """Raise ``AssertionError`` with a schema diff message."""
+    actual_map = {r[0]: r[1] for r in actual}
+    expected_map = {r[0]: r[1] for r in expected}
+    lines: list[str] = []
+
+    for col in sorted(set(list(actual_map) + list(expected_map))):
+        a_type = actual_map.get(col, "<missing>")
+        e_type = expected_map.get(col, "<missing>")
+        if a_type != e_type:
+            lines.append(f"  {col}:  expected={e_type}  actual={a_type}")
+
+    msg = "Schema mismatch:\n" + "\n".join(lines)
+    raise AssertionError(msg)
+
+
+def _raise_row_diff(
+    differing: List[tuple],
+    missing: List[tuple],
+    col_names: List[str],
+) -> None:
+    """Raise ``AssertionError`` with a row-level diff message."""
+    lines: list[str] = []
+    if differing:
+        lines.append(f"Rows in actual but not expected ({len(differing)}):")
+        for row in differing[:10]:
+            lines.append(f"  {row}")
+        if len(differing) > 10:
+            lines.append(f"  ... and {len(differing) - 10} more")
+    if missing:
+        lines.append(f"Rows in expected but not actual ({len(missing)}):")
+        for row in missing[:10]:
+            lines.append(f"  {row}")
+        if len(missing) > 10:
+            lines.append(f"  ... and {len(missing) - 10} more")
+    if col_names:
+        lines.insert(0, f"Columns: {col_names}")
+    msg = "Snapshot mismatch:\n" + "\n".join(lines)
+    raise AssertionError(msg)

pytest_duckdb-0.1.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: pytest-duckdb
+Version: 0.1.0
+Summary: pytest plugin for SQL pipeline testing with DuckDB — load fixtures, run queries, snapshot results
+Project-URL: Homepage, https://github.com/AnnasMazhar/pytest-duckdb
+Project-URL: Issues, https://github.com/AnnasMazhar/pytest-duckdb/issues
+Project-URL: Source, https://github.com/AnnasMazhar/pytest-duckdb
+Author-email: Annas Mazhar <annas.mazhar10@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: data-engineering,duckdb,pytest,snapshot,sql,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Requires-Dist: duckdb>=0.9.0
+Requires-Dist: pytest>=7.0
+Provides-Extra: dev
+Requires-Dist: coverage>=7.0; extra == 'dev'
+Requires-Dist: pandas>=2.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pytest-duckdb
+
+[![CI](https://github.com/AnnasMazhar/pytest-duckdb/actions/workflows/ci.yml/badge.svg)](https://github.com/AnnasMazhar/pytest-duckdb/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/pytest-duckdb.svg)](https://pypi.org/project/pytest-duckdb/)
+[![Python](https://img.shields.io/pypi/pyversions/pytest-duckdb.svg)](https://pypi.org/project/pytest-duckdb/)
+
+SQL pipeline testing made trivial. Load fixture CSVs as tables, run your queries, snapshot the results.
+
+## Install
+
+```bash
+pip install pytest-duckdb
+```
+
+## Quick Start
+
+Place CSV files in `tests/fixtures/`:
+
+```
+tests/
+  fixtures/
+    orders.csv
+    customers.csv
+  test_queries.py
+```
+
+They become tables automatically:
+
+```python
+def test_revenue_query(duckdb_session, sql_snapshot):
+    result = duckdb_session.execute(
+        "SELECT * FROM orders WHERE amount > 100"
+    ).fetchall()
+
+    # First run saves the snapshot, subsequent runs diff against it
+    sql_snapshot(result)
+```
+
+## Features
+
+- **Zero config** — fixture CSVs in `tests/fixtures/` auto-load as tables
+- **Snapshot testing** — first run saves output, subsequent runs diff
+- **Raw SQL files** — test `.sql` files directly without dbt
+- **Ephemeral** — each test gets a fresh in-memory DuckDB
+- **Fast** — DuckDB is embedded, no Docker, no network
+
+## Fixture Loading
+
+CSVs loaded by file stem become table names. `orders.csv` → `orders` table.
+
+```python
+def test_join(duckdb_session):
+    result = duckdb_session.execute("""
+        SELECT c.name, o.amount
+        FROM orders o JOIN customers c ON o.customer_id = c.id
+    """).fetchall()
+    assert len(result) > 0
+```
+
+## SQL File Testing
+
+```python
+@pytest.mark.sql("queries/revenue_by_month.sql")
+def test_revenue_by_month(sql_result, sql_snapshot):
+    sql_snapshot(sql_result)
+```
+
+## Snapshot Update
+
+Regenerate all snapshots when your expected output changes:
+
+```bash
+pytest --snapshot-update
+```
+
+## License
+
+MIT

pytest_duckdb-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+pytest_duckdb/__init__.py,sha256=4OGvmHcZdLQ1gI2k2wFuJpNJRojabdEZ-D-K7OIKL0I,79
+pytest_duckdb/fixtures.py,sha256=kOaTUlAZBqYKnbDL5ENoeKbtdzVYJmj45n-ly_MMObw,1444
+pytest_duckdb/plugin.py,sha256=sjWPHno3G6MU2b17qGTpZBDDav7m_-_CN9KXbLrsA9Y,7663
+pytest_duckdb/snapshot.py,sha256=UReiv5Z8oXeHciLsEpZ-eBY5JtOAbAUCBNaopQVkdfI,9034
+pytest_duckdb-0.1.0.dist-info/METADATA,sha256=3-dQpOKenzLanbPyemLZgyiouZlqRQ5PCACpY6IkV4w,3361
+pytest_duckdb-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pytest_duckdb-0.1.0.dist-info/entry_points.txt,sha256=m6c8cR8sma92kzR8ZYc6Uq8Z99egktJge8Kq1G23jZo,41
+pytest_duckdb-0.1.0.dist-info/licenses/LICENSE,sha256=o83nYDkVVPK53SMcq6N6vVcAdhD0SCtkjo4yyDrygk0,1069
+pytest_duckdb-0.1.0.dist-info/RECORD,,

pytest_duckdb-0.1.0.dist-info/WHEEL

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

pytest_duckdb-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+duckdb = pytest_duckdb.plugin

pytest_duckdb-0.1.0.dist-info/licenses/LICENSE

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