opteryx-catalog 0.4.11__py3-none-any.whl → 0.4.26__py3-none-any.whl

tests/test_describe_uncompressed.py

@@ -0,0 +1,127 @@
+import io
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from opteryx_catalog.catalog.dataset import SimpleDataset
+from opteryx_catalog.catalog.metadata import DatasetMetadata, Snapshot
+
+
+class _MemInput:
+    def __init__(self, data: bytes):
+        self._data = data
+
+    def open(self):
+        # Provide a file-like BytesIO which .read() returns the bytes
+        return io.BytesIO(self._data)
+
+
+class _MemIO:
+    def __init__(self, mapping: dict):
+        self._mapping = mapping
+
+    def new_input(self, path: str):
+        return _MemInput(self._mapping[path])
+
+
+def _build_manifest_bytes():
+    # Construct a parquet manifest with two entries, two columns per file
+    schema = pa.schema(
+        [
+            ("file_path", pa.string()),
+            ("file_format", pa.string()),
+            ("record_count", pa.int64()),
+            ("file_size_in_bytes", pa.int64()),
+            ("uncompressed_size_in_bytes", pa.int64()),
+            ("column_uncompressed_sizes_in_bytes", pa.list_(pa.int64())),
+            ("null_counts", pa.list_(pa.int64())),
+            ("min_k_hashes", pa.list_(pa.int64())),
+            ("histogram_counts", pa.list_(pa.int64())),
+            ("histogram_bins", pa.int64()),
+            ("min_values", pa.list_(pa.int64())),
+            ("max_values", pa.list_(pa.int64())),
+            ("min_values_display", pa.list_(pa.string())),
+            ("max_values_display", pa.list_(pa.string())),
+        ]
+    )
+
+    file_path = pa.array(["f1.parquet", "f2.parquet"], type=pa.string())
+    file_format = pa.array(["parquet", "parquet"], type=pa.string())
+    record_count = pa.array([10, 20], type=pa.int64())
+    file_size_in_bytes = pa.array([100, 200], type=pa.int64())
+    uncompressed_size_in_bytes = pa.array([1000, 2000], type=pa.int64())
+    column_uncompressed_sizes_in_bytes = pa.array(
+        [[100, 400], [300, 200]], type=pa.list_(pa.int64())
+    )
+    null_counts = pa.array([[0, 0], [0, 0]], type=pa.list_(pa.int64()))
+    min_k_hashes = pa.array([[1, 2], [1]], type=pa.list_(pa.int64()))
+    histogram_counts = pa.array([[1, 2], [3, 4]], type=pa.list_(pa.int64()))
+    histogram_bins = pa.array([32, 32], type=pa.int64())
+    min_values = pa.array([[10, 20], [5, 30]], type=pa.list_(pa.int64()))
+    max_values = pa.array([[100, 400], [300, 200]], type=pa.list_(pa.int64()))
+    min_values_display = pa.array([[None, None], [None, None]], type=pa.list_(pa.string()))
+    max_values_display = pa.array([[None, None], [None, None]], type=pa.list_(pa.string()))
+
+    table = pa.Table.from_arrays(
+        [
+            file_path,
+            file_format,
+            record_count,
+            file_size_in_bytes,
+            uncompressed_size_in_bytes,
+            column_uncompressed_sizes_in_bytes,
+            null_counts,
+            min_k_hashes,
+            histogram_counts,
+            histogram_bins,
+            min_values,
+            max_values,
+            min_values_display,
+            max_values_display,
+        ],
+        schema=schema,
+    )
+
+    buf = io.BytesIO()
+    pq.write_table(table, buf)
+    return buf.getvalue()
+
+
+def test_describe_includes_uncompressed_bytes():
+    manifest_bytes = _build_manifest_bytes()
+    manifest_path = "mem://manifest"
+
+    meta = DatasetMetadata(
+        dataset_identifier="tests_temp.test",
+        location="mem://",
+        schema=None,
+        properties={},
+    )
+
+    # Add a schema with two columns so describe() can map names -> indices
+    meta.schemas.append({"schema_id": "s1", "columns": [{"name": "a"}, {"name": "b"}]})
+    meta.current_schema_id = "s1"
+
+    # Prepare snapshot referencing our in-memory manifest
+    snap = Snapshot(
+        snapshot_id=1,
+        timestamp_ms=1,
+        manifest_list=manifest_path,
+    )
+    meta.snapshots.append(snap)
+    meta.current_snapshot_id = 1
+
+    ds = SimpleDataset(identifier="tests_temp.test", _metadata=meta)
+
+    # Inject our in-memory IO mapping
+    ds.io = _MemIO({manifest_path: manifest_bytes})
+
+    desc = ds.describe()
+
+    assert "a" in desc
+    assert "b" in desc
+
+    # Column 'a' should have uncompressed bytes = 100 + 300 = 400
+    assert desc["a"]["uncompressed_bytes"] == 400
+    # Column 'b' should have uncompressed bytes = 400 + 200 = 600
+    assert desc["b"]["uncompressed_bytes"] == 600

tests/test_refresh_manifest.py

@@ -0,0 +1,275 @@
+import io
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+import os
+import sys
+
+# Add local paths to sys.path to use local code instead of installed packages
+sys.path.insert(0, os.path.join(sys.path[0], ".."))  # Add parent dir for pyiceberg_firestore_gcs
+sys.path.insert(1, os.path.join(sys.path[0], "../opteryx-core"))
+sys.path.insert(1, os.path.join(sys.path[0], "../pyiceberg-firestore-gcs"))
+
+
+from opteryx_catalog.catalog.dataset import SimpleDataset
+from opteryx_catalog.catalog.metadata import DatasetMetadata, Snapshot
+from opteryx_catalog.catalog.manifest import (
+    build_parquet_manifest_entry_from_bytes,
+    get_manifest_metrics,
+    reset_manifest_metrics,
+)
+from opteryx_catalog.opteryx_catalog import OpteryxCatalog
+import pytest
+
+
+def test_min_k_hashes_for_string_and_binary():
+    try:
+        pass  # type: ignore
+    except Exception:
+        pytest.skip("opteryx.draken not available")
+
+    import pyarrow as pa
+
+    # short binary and short string columns should get min-k
+    t = _make_parquet_table(
+        [("bin", pa.binary()), ("s", pa.string())], [(b"a", "x"), (b"b", "y"), (b"c", "z")]
+    )
+    buf = pa.BufferOutputStream()
+    pq.write_table(t, buf, compression="zstd")
+    data = buf.getvalue().to_pybytes()
+    e = build_parquet_manifest_entry_from_bytes(data, "mem://f", len(data), orig_table=t)
+    assert len(e.min_k_hashes[0]) > 0
+    assert len(e.min_k_hashes[1]) > 0
+
+
+# Step 1: Create a local catalog
+catalog = OpteryxCatalog(
+    "opteryx",
+    firestore_project="mabeldev",
+    firestore_database="catalogs",
+    gcs_bucket="opteryx_data",
+)
+
+# print(catalog.load_dataset("ops.stdout_log").describe())
+
+
+class _MemInput:
+    def __init__(self, data: bytes):
+        self._data = data
+
+    def open(self):
+        return io.BytesIO(self._data)
+
+
+class _MemIO:
+    def __init__(self, mapping: dict):
+        self._mapping = mapping
+
+    def new_input(self, path: str):
+        return _MemInput(self._mapping[path])
+
+    def new_output(self, path: str):
+        class Out:
+            def __init__(self, mapping, path):
+                self._buf = io.BytesIO()
+                self._mapping = mapping
+                self._path = path
+
+            def write(self, data: bytes):
+                self._buf.write(data)
+
+            def close(self):
+                self._mapping[self._path] = self._buf.getvalue()
+
+            def create(self):
+                return self
+
+        return Out(self._mapping, path)
+
+
+class _FakeCatalog:
+    def __init__(self, io):
+        self.io = io
+
+    def write_parquet_manifest(
+        self, snapshot_id: int, entries: list[dict], dataset_location: str
+    ) -> str:
+        # Minimal manifest writer using same schema as production
+        schema = pa.schema(
+            [
+                ("file_path", pa.string()),
+                ("file_format", pa.string()),
+                ("record_count", pa.int64()),
+                ("file_size_in_bytes", pa.int64()),
+                ("uncompressed_size_in_bytes", pa.int64()),
+                ("column_uncompressed_sizes_in_bytes", pa.list_(pa.int64())),
+                ("null_counts", pa.list_(pa.int64())),
+                ("min_k_hashes", pa.list_(pa.list_(pa.uint64()))),
+                ("histogram_counts", pa.list_(pa.list_(pa.int64()))),
+                ("histogram_bins", pa.int32()),
+                ("min_values", pa.list_(pa.int64())),
+                ("max_values", pa.list_(pa.int64())),
+                ("min_values_display", pa.list_(pa.string())),
+                ("max_values_display", pa.list_(pa.string())),
+            ]
+        )
+        normalized = []
+        for ent in entries:
+            if not isinstance(ent, dict):
+                normalized.append(ent)
+                continue
+            e = dict(ent)
+            e.setdefault("min_k_hashes", [])
+            e.setdefault("histogram_counts", [])
+            e.setdefault("histogram_bins", 0)
+            e.setdefault("column_uncompressed_sizes_in_bytes", [])
+            e.setdefault("null_counts", [])
+            e.setdefault("min_values_display", [])
+            e.setdefault("max_values_display", [])
+            mv = e.get("min_values") or []
+            xv = e.get("max_values") or []
+            mv_disp = e.get("min_values_display") or []
+            xv_disp = e.get("max_values_display") or []
+            e["min_values"] = [int(v) if v is not None else None for v in mv]
+            e["max_values"] = [int(v) if v is not None else None for v in xv]
+            e["min_values_display"] = [str(v) if v is not None else None for v in mv_disp]
+            e["max_values_display"] = [str(v) if v is not None else None for v in xv_disp]
+            normalized.append(e)
+
+        table = pa.Table.from_pylist(normalized, schema=schema)
+        buf = pa.BufferOutputStream()
+        pq.write_table(table, buf, compression="zstd")
+        data = buf.getvalue().to_pybytes()
+        path = f"{dataset_location}/metadata/manifest-{snapshot_id}.parquet"
+        out = self.io.new_output(path).create()
+        out.write(data)
+        out.close()
+        return path
+
+
+def _make_parquet_table(columns: list[tuple[str, pa.DataType]], rows: list[tuple]):
+    arrays = []
+    for i, (name, dtype) in enumerate(columns):
+        col_vals = [r[i] for r in rows]
+        arrays.append(pa.array(col_vals, type=dtype))
+    return pa.Table.from_arrays(arrays, names=[c[0] for c in columns])
+
+
+def test_build_manifest_from_bytes_matches_table():
+    # ensure the bytes-based builder matches the table-based one
+    t = _make_parquet_table([("a", pa.int64()), ("b", pa.int64())], [(1, 10), (2, 20)])
+    buf = pa.BufferOutputStream()
+    pq.write_table(t, buf, compression="zstd")
+    data = buf.getvalue().to_pybytes()
+
+    e_bytes = build_parquet_manifest_entry_from_bytes(data, "mem://f", len(data), orig_table=t)
+    # basic sanity checks (parity is enforced by using orig_table when available)
+    assert e_bytes.record_count == 2
+    assert e_bytes.file_size_in_bytes == len(data)
+
+
+def test_manifest_metrics_increments():
+    reset_manifest_metrics()
+    t = _make_parquet_table([("a", pa.int64()), ("b", pa.int64())], [(1, 10), (2, 20)])
+    buf = pa.BufferOutputStream()
+    pq.write_table(t, buf, compression="zstd")
+    data = buf.getvalue().to_pybytes()
+
+    _ = build_parquet_manifest_entry_from_bytes(data, "mem://f", len(data), orig_table=t)
+    m = get_manifest_metrics()
+    assert m.get("files_read", 0) >= 1
+    assert m.get("hash_calls", 0) >= 1
+    assert m.get("compress_calls", 0) >= 1
+
+
+def test_table_based_builder_is_removed():
+    from opteryx_catalog.catalog.manifest import build_parquet_manifest_entry
+
+    t = _make_parquet_table([("a", pa.int64())], [(1,)])
+    with pytest.raises(RuntimeError):
+        _ = build_parquet_manifest_entry(t, "mem://f", 0)
+
+
+def test_manifest_uses_rugo_for_sizes():
+    # Ensure the bytes-based builder uses rugo metadata to compute per-column sizes
+    reset_manifest_metrics()
+    t = _make_parquet_table([("a", pa.int64()), ("b", pa.int64())], [(1, 10), (2, 20)])
+    buf = pa.BufferOutputStream()
+    pq.write_table(t, buf, compression="zstd")
+    data = buf.getvalue().to_pybytes()
+
+    entry = build_parquet_manifest_entry_from_bytes(data, "mem://f", len(data))
+    m = get_manifest_metrics()
+
+    # rugo should report sizes (non-zero) for these synthetic files
+    assert m.get("sizes_from_rugo", 0) >= 1 or m.get("sizes_from_rugo_missing", 0) == 0
+    assert entry.uncompressed_size_in_bytes >= 0
+    assert isinstance(entry.column_uncompressed_sizes_in_bytes, list)
+    assert len(entry.column_uncompressed_sizes_in_bytes) == 2
+    # column sizes may be non-zero when metadata is available
+    assert all(isinstance(x, int) for x in entry.column_uncompressed_sizes_in_bytes)
+
+
+def test_refresh_manifest_with_single_file():
+    # single file with columns a,b for quick iteration
+    t1 = _make_parquet_table([("a", pa.int64()), ("b", pa.int64())], [(1, 10), (2, 20)])
+
+    # Write parquet file to mem
+    buf = pa.BufferOutputStream()
+    pq.write_table(t1, buf, compression="zstd")
+    d1 = buf.getvalue().to_pybytes()
+
+    f1 = "mem://data/f1.parquet"
+    manifest_path = "mem://manifest-old"
+
+    # Build initial manifest entry for single file (bytes-based builder)
+    e1 = build_parquet_manifest_entry_from_bytes(d1, f1, len(d1), orig_table=t1).to_dict()
+
+    # Create in-memory IO mapping including manifest and data file
+    mapping = {f1: d1}
+
+    # Write initial manifest with the single entry using the same writer as the catalog
+    fake_writer = _FakeCatalog(_MemIO(mapping))
+    manifest_path = fake_writer.write_parquet_manifest(1, [e1], "mem://")
+    # Ensure the manifest bytes are present in the mapping
+    mapping[manifest_path] = mapping[manifest_path]
+
+    # Persist the single-file manifest as JSON for quick inspection during
+    # iterative debugging (writes to repo `artifacts/` so you can open it).
+    import os
+    import json
+
+    artifacts_dir = os.path.join(os.getcwd(), "artifacts")
+    os.makedirs(artifacts_dir, exist_ok=True)
+    with open(
+        os.path.join(artifacts_dir, "single_file_manifest.json"), "w", encoding="utf-8"
+    ) as fh:
+        json.dump(e1, fh, indent=2, default=str)
+
+    # Create metadata and snapshot
+    meta = DatasetMetadata(
+        dataset_identifier="tests_temp.test", location="mem://", schema=None, properties={}
+    )
+    meta.schemas.append({"schema_id": "s1", "columns": [{"name": "a"}, {"name": "b"}]})
+    meta.current_schema_id = "s1"
+    snap = Snapshot(snapshot_id=1, timestamp_ms=1, manifest_list=manifest_path)
+    meta.snapshots.append(snap)
+    meta.current_snapshot_id = 1
+
+    ds = SimpleDataset(identifier="tests_temp.test", _metadata=meta)
+    ds.io = _MemIO(mapping)
+    ds.catalog = _FakeCatalog(ds.io)
+
+    # Refresh manifest (should re-read f1 and write a new manifest)
+    new_snap_id = ds.refresh_manifest(agent="test-agent", author="tester")
+    assert new_snap_id is not None
+
+    # Describe should include both columns and count bytes appropriately
+    desc = ds.describe()
+    assert "a" in desc
+    assert "b" in desc
+
+    # ensure uncompressed bytes are present and non-zero for both cols
+    assert desc["a"]["uncompressed_bytes"] > 0
+    assert desc["b"]["uncompressed_bytes"] > 0

tests/test_webhooks.py

@@ -0,0 +1,177 @@
+"""Tests for the webhook system."""
+
+import os
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+import pytest
+
+
+def test_webhook_manager_disabled_without_domain():
+    """Test that webhook manager is disabled when no domain is configured."""
+    from opteryx_catalog.webhooks import WebhookManager
+
+    # Clear any existing env vars
+    os.environ.pop("OPTERYX_WEBHOOK_DOMAIN", None)
+    os.environ.pop("OPTERYX_WEBHOOK_QUEUE", None)
+
+    manager = WebhookManager()
+    assert not manager.enabled
+
+    # Should return False without making any HTTP calls
+    result = manager.send(
+        action="create",
+        workspace="test",
+        collection="test",
+        resource_type="dataset",
+        resource_name="test",
+    )
+    assert result is False
+
+
+def test_webhook_manager_direct_http():
+    """Test that webhooks are sent via direct HTTP when queue is not configured."""
+    from opteryx_catalog.webhooks import WebhookManager
+
+    with patch("opteryx_catalog.webhooks.requests.post") as mock_post:
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_post.return_value = mock_response
+
+        manager = WebhookManager(domain="router.example.com", queue_path=None)
+        assert manager.enabled
+        assert manager._tasks_client is None
+
+        result = manager.send(
+            action="create",
+            workspace="test-workspace",
+            collection="test-collection",
+            resource_type="dataset",
+            resource_name="test-dataset",
+            payload={"location": "gs://bucket/path"},
+        )
+
+        assert result is True
+        mock_post.assert_called_once()
+
+        # Verify the call arguments
+        call_args = mock_post.call_args
+        assert call_args.args[0] == "https://router.example.com/event"
+        assert call_args.kwargs["json"]["event"]["action"] == "create"
+        assert call_args.kwargs["json"]["event"]["resource_type"] == "dataset"
+        assert call_args.kwargs["json"]["event"]["resource_name"] == "test-dataset"
+        assert call_args.kwargs["json"]["data"]["location"] == "gs://bucket/path"
+
+
+def test_webhook_manager_payload_building():
+    """Test that webhook payloads are built correctly."""
+    from opteryx_catalog.webhooks import WebhookManager
+
+    manager = WebhookManager(domain="hook.example.com")
+
+    payload = manager._build_payload(
+        action="update",
+        workspace="ws",
+        collection="col",
+        resource_type="dataset",
+        resource_name="ds",
+        additional={"description": "New description"},
+    )
+
+    assert payload["event"]["action"] == "update"
+    assert payload["event"]["workspace"] == "ws"
+    assert payload["event"]["collection"] == "col"
+    assert payload["event"]["resource_type"] == "dataset"
+    assert payload["event"]["resource_name"] == "ds"
+    assert "timestamp" in payload["event"]
+    assert payload["data"]["description"] == "New description"
+
+
+def test_webhook_http_failure_returns_false():
+    """Test that HTTP failures return False without raising exceptions."""
+    from opteryx_catalog.webhooks import WebhookManager
+
+    with patch("opteryx_catalog.webhooks.requests.post") as mock_post:
+        # Simulate HTTP error
+        mock_post.side_effect = Exception("Connection failed")
+
+        manager = WebhookManager(domain="router.example.com")
+        result = manager.send(
+            action="create",
+            workspace="test",
+            collection="test",
+            resource_type="dataset",
+            resource_name="test",
+        )
+
+        assert result is False
+
+
+def test_send_webhook_convenience_function():
+    """Test the convenience send_webhook function."""
+    from opteryx_catalog.webhooks import send_webhook
+
+    with patch("opteryx_catalog.webhooks.requests.post") as mock_post:
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_post.return_value = mock_response
+
+        os.environ["OPTERYX_WEBHOOK_DOMAIN"] = "router.example.com"
+        os.environ.pop("OPTERYX_WEBHOOK_QUEUE", None)
+
+        # Reset the global manager to pick up new env vars
+        import opteryx_catalog.webhooks as webhook_module
+
+        webhook_module._webhook_manager = None
+
+        result = send_webhook(
+            action="create",
+            workspace="test",
+            collection="test",
+            resource_type="dataset",
+            resource_name="test",
+            payload={"snapshot_id": 123},
+        )
+
+        assert result is True
+        mock_post.assert_called_once()
+
+        # Clean up
+        os.environ.pop("OPTERYX_WEBHOOK_DOMAIN", None)
+
+
+def test_event_payload_builders():
+    """Test the event payload builder functions."""
+    from opteryx_catalog.webhooks.events import dataset_commit_payload
+    from opteryx_catalog.webhooks.events import dataset_created_payload
+    from opteryx_catalog.webhooks.events import view_created_payload
+    from opteryx_catalog.webhooks.events import view_executed_payload
+
+    # Test dataset created
+    payload = dataset_created_payload(
+        schema=None, location="gs://bucket/path", properties={"key": "value"}
+    )
+    assert payload["location"] == "gs://bucket/path"
+    assert payload["properties"]["key"] == "value"
+
+    # Test dataset commit
+    payload = dataset_commit_payload(
+        snapshot_id=123, sequence_number=5, record_count=1000, file_count=2
+    )
+    assert payload["snapshot_id"] == 123
+    assert payload["sequence_number"] == 5
+    assert payload["record_count"] == 1000
+    assert payload["file_count"] == 2
+
+    # Test view created
+    payload = view_created_payload(definition="SELECT * FROM table", properties={})
+    assert payload["definition"] == "SELECT * FROM table"
+
+    # Test view executed
+    payload = view_executed_payload(execution_time_ms=1500, row_count=100)
+    assert payload["execution_time_ms"] == 1500
+    assert payload["row_count"] == 100
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

opteryx_catalog-0.4.11.dist-info/RECORD

@@ -1,25 +0,0 @@
-opteryx_catalog/__init__.py,sha256=cqGY7bl6iMBIqY_x6VTc5fAFH23M3XQeJYrHPX6FglY,902
-opteryx_catalog/exceptions.py,sha256=ZEaXmrrn030V8pfy8YMaLwzBWFms9OgZG21zVRGKlxM,652
-opteryx_catalog/opteryx_catalog.py,sha256=sgcCiBbIv8mUZQbNb34JwEf6Wq0iByoEvpqkoD_F1bc,39111
-opteryx_catalog/catalog/__init__.py,sha256=yD7egf-dLd1z_CNXunz3ldLyLMMkSNbS3aKjGp3dKQY,119
-opteryx_catalog/catalog/compaction.py,sha256=HGkDnlVBv5GjRiZhdGubxCVxRLScL9N667a19U01g1I,19100
-opteryx_catalog/catalog/dataset.py,sha256=3Q_lLZ1Y0I1E_R47pMFgql81Y1dy955NKlsgk9edfJE,46796
-opteryx_catalog/catalog/manifest.py,sha256=xTV3u_i8s7jxulLvATyBoP9FHTdxOB8b0__SabqhH6g,17045
-opteryx_catalog/catalog/metadata.py,sha256=a4UFj5xUqjqtuLu2_mYQaBHRWtjjX3KU2Ufp63Uo2AM,2870
-opteryx_catalog/catalog/metastore.py,sha256=mS4qaaOMzcIu730Jm0K_Nq-4sNI8kIX3UscevYO5E08,1997
-opteryx_catalog/catalog/view.py,sha256=mUzfRGYqLRx_9BfZdGY5HNz6na9VMEPITrYKiI5m694,219
-opteryx_catalog/iops/__init__.py,sha256=_CxR-hg8XUD2cIFucb3aHyTFqwi41QmEDf9gXzXt3ZU,171
-opteryx_catalog/iops/base.py,sha256=1IW9qjDkQEMXvrA2J73VSBCdzkf2W5xVsWVnpNglL1U,1206
-opteryx_catalog/iops/fileio.py,sha256=cjBl9fN-vutvXskzZkwJjjbBcUlE0O1WrQe5Ryx7pIg,4315
-opteryx_catalog/iops/gcs.py,sha256=aB6hvSAQhbKTSyaLbAPgpXtSnvkI7fndXCRjaAZ1Dxo,8155
-opteryx_catalog-0.4.11.dist-info/licenses/LICENSE,sha256=mc5l20siqdcNQM54xALIWJhyaWsmQJ-NZt81UjgJejo,11351
-scripts/create_dataset.py,sha256=K8zmQo3xbwc_yz2BxNK0IKj-DkDt3pFf13ycI6rgTHo,7798
-scripts/read_dataset.py,sha256=hpBa8Qv1Oj6ffVIUmELGSri2eYHPpdqLnWFKgKpG-FM,9610
-tests/test_compaction.py,sha256=7MLnfbGi3j17ZON8Qi9oq4i1UWkW0JigX46BBFWecMk,7871
-tests/test_dataset_metadata.py,sha256=bMzX2HiUnzFTyU3VkFuW5xjmFEP8cJSYPt1XF6IS0Qk,1019
-tests/test_import.py,sha256=ZvoHW-rmcYqkW6TJKD_brgeePqHHbz2iTyRWKIBHGHk,137
-tests/test_pyproject.py,sha256=o3rS_GOems1oYQDH3UATfqc6XUwDTKZF2Q4cspU-NYc,206
-opteryx_catalog-0.4.11.dist-info/METADATA,sha256=BV0mk_GugipH7BAhKWIJtJq_55ML4kipL8RbF-Cm7t4,22384
-opteryx_catalog-0.4.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-opteryx_catalog-0.4.11.dist-info/top_level.txt,sha256=HWATr4Wgxbg3c1X3EcsJ6cnHoR6ZAdTe1LQ2VssIBUo,30
-opteryx_catalog-0.4.11.dist-info/RECORD,,