vastdb 1.3.11__py3-none-any.whl → 2.0.0__py3-none-any.whl

vastdb/tests/test_tables.py

@@ -8,23 +8,24 @@ from contextlib import closing
 from tempfile import NamedTemporaryFile
 
 import ibis
+import pandas as pd
 import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.parquet as pq
 import pytest
 from requests.exceptions import HTTPError
 
-from vastdb.errors import BadRequest
+from vastdb import errors
+from vastdb.session import Session
+from vastdb.table import INTERNAL_ROW_ID, QueryConfig
 
-from .. import errors
-from ..table import INTERNAL_ROW_ID, QueryConfig
-from .util import prepare_data
+from .util import assert_row_ids_ascending_on_first_insertion_to_table, prepare_data
 
 log = logging.getLogger(__name__)
 
 
 @pytest.fixture
-def elysium_session(session):
+def elysium_session(session: Session) -> Session:
     with session.transaction() as tx:
         try:
             tx._rpc.features.check_elysium()
@@ -125,7 +126,7 @@ def test_insert_empty(session, clean_bucket_name):
         assert row_ids == []
 
 
-def test_exists(session, clean_bucket_name):
+def test_exists(session: Session, clean_bucket_name: str):
     with session.transaction() as tx:
         s = tx.bucket(clean_bucket_name).create_schema('s1')
         assert s.tables() == []
@@ -899,7 +900,7 @@ def test_select_stop(session, clean_bucket_name):
     # the tabular server splits the batches is not true anymore and we need to
     # rewrite the test.
     assert read_batches == qc.num_splits * qc.num_sub_splits
-    qc.query_id = str(random.randint(0, 2**32))
+    qc.query_id = str(random.randint(0, 2 ** 32 - 1))
     log.info("query id is: %s", qc.query_id)
 
     def active_threads():
@@ -953,12 +954,18 @@ def test_audit_log_select(session, clean_bucket_name):
 def test_catalog_snapshots_select(session, clean_bucket_name):
     with session.transaction() as tx:
         snaps = tx.catalog_snapshots()
-        if not snaps:
+        filtered_snaps = []
+        for snap in snaps:
+            log.info("Snapshot: %s", snap)
+            if snap.name.startswith("vast-big-catalog-bucket/.snapshot/bc_table"):
+                filtered_snaps.append(snap)
+        if not filtered_snaps:
             raise NotReady
-        latest = snaps[-1]
+        latest = filtered_snaps[-1]
+        log.info("Latest snapshot: %s", latest)
         t = tx.catalog(latest)
         assert t.columns()
-        rows = t.select().read_all()
+        rows = t.select(limit_rows=10).read_all()
         if not rows:
             raise NotReady
 
@@ -1131,7 +1138,7 @@ def test_tables_elysium(elysium_session, clean_bucket_name):
 #         assert sorted_columns[1].name == 'b'
 
 
-def test_elysium_tx(elysium_session, clean_bucket_name):
+def test_elysium_tx(elysium_session: Session, clean_bucket_name: str):
     columns = pa.schema([
         ('a', pa.int8()),
         ('b', pa.int32()),
@@ -1150,7 +1157,7 @@ def test_elysium_tx(elysium_session, clean_bucket_name):
         t = s.create_table(table_name, arrow_table.schema)
         row_ids_array = t.insert(arrow_table)
         row_ids = row_ids_array.to_pylist()
-        assert row_ids == list(range(arrow_table.num_rows))
+        assert_row_ids_ascending_on_first_insertion_to_table(row_ids, arrow_table.num_rows, t.sorted_table)
         sorted_columns = t.sorted_columns()
         assert len(sorted_columns) == 0
         t.add_sorting_key(sorting)
@@ -1178,7 +1185,7 @@ def test_elysium_double_enable(elysium_session, clean_bucket_name):
         [111, 222, 333],
     ])
     sorting = [2, 1]
-    with pytest.raises(BadRequest):
+    with pytest.raises(errors.BadRequest):
         with prepare_data(elysium_session, clean_bucket_name, 's', 't', expected, sorting_key=sorting) as t:
             sorted_columns = t.sorted_columns()
             assert sorted_columns[0].name == 'c'
@@ -1186,7 +1193,7 @@ def test_elysium_double_enable(elysium_session, clean_bucket_name):
             t.add_sorting_key(sorting)
 
 
-def test_elysium_update_table_tx(elysium_session, clean_bucket_name):
+def test_elysium_update_table_tx(elysium_session: Session, clean_bucket_name):
     columns = pa.schema([
         ('a', pa.int64()),
         ('b', pa.float32()),
@@ -1205,7 +1212,7 @@ def test_elysium_update_table_tx(elysium_session, clean_bucket_name):
         t = s.create_table(table_name, arrow_table.schema, sorting_key=sorting)
         row_ids_array = t.insert(arrow_table)
         row_ids = row_ids_array.to_pylist()
-        assert row_ids == list(range(arrow_table.num_rows))
+        assert_row_ids_ascending_on_first_insertion_to_table(row_ids, arrow_table.num_rows, t.sorted_table)
         sorted_columns = t.sorted_columns()
         assert sorted_columns[0].name == 's'
         assert sorted_columns[1].name == 'b'
@@ -1278,7 +1285,7 @@ def test_elysium_splits(elysium_session, clean_bucket_name):
         t = s.create_table(table_name, arrow_table.schema, sorting_key=sorting)
         row_ids_array = t.insert(arrow_table)
         row_ids = row_ids_array.to_pylist()
-        assert row_ids == list(range(arrow_table.num_rows))
+        assert_row_ids_ascending_on_first_insertion_to_table(row_ids, arrow_table.num_rows, t.sorted_table)
         sorted_columns = t.sorted_columns()
         assert sorted_columns[0].name == 'a'
 
@@ -1291,3 +1298,43 @@ def test_elysium_splits(elysium_session, clean_bucket_name):
 
         actual = t.select(columns=['a'], predicate=(t['a'] == 1), config=config).read_all()
         assert len(actual) == 10000
+
+
+def to_df(table: pa.Table) -> pd.DataFrame:
+    return table.to_pandas().sort_values(by='a').reset_index(drop=True)
+
+
+def test_select_splits_sanity(session, clean_bucket_name, check):
+    columns = pa.schema([
+        ('a', pa.int64()),
+        ('b', pa.float32()),
+        ('c', pa.utf8()),
+    ])
+
+    length = 1000000
+
+    expected = pa.table(schema=columns, data=[
+        list(range(length)),
+        [i * 0.001 for i in range(length)],
+        [f'a{i}' for i in range(length)],
+    ])
+
+    query_config = QueryConfig(
+        num_sub_splits=1,
+        num_splits=4,
+        limit_rows_per_sub_split=2500,
+        num_row_groups_per_sub_split=1,
+    )
+
+    with prepare_data(session, clean_bucket_name, 's', 't', expected) as t:
+        splits_readers = t.select_splits(
+            columns=['a', 'b', 'c'], config=query_config)
+        splits_reader_tables = [splits_reader.read_all().combine_chunks()
+                            for splits_reader in splits_readers]
+
+        for splits_reader_table in splits_reader_tables:
+            check.greater(splits_reader_table.num_rows, 0, "if splits readers are empty test is not interesting")
+
+        actual = pa.concat_tables(splits_reader_tables).combine_chunks()
+
+        check.is_true(to_df(actual).equals(to_df(expected)))

vastdb/tests/util.py

@@ -1,24 +1,53 @@
 import logging
 from contextlib import contextmanager
+from typing import Any, Iterator, List, cast
 
+import numpy as np
+import pandas as pd
 import pyarrow as pa
+from packaging.version import Version
+
+from vastdb.session import Session
+from vastdb.table import Table
+from vastdb.transaction import Transaction
 
 log = logging.getLogger(__name__)
 
 
+def assert_row_ids_ascending_on_first_insertion_to_table(row_ids, expected_num_rows, sorted_table):
+    adjusted_row_ids = [
+        int(row_id) & 0xFFFFFFFFFFFFFF for row_id in row_ids
+        ] if sorted_table else row_ids
+
+    assert adjusted_row_ids == list(range(expected_num_rows))
+
+
 @contextmanager
-def prepare_data(session, clean_bucket_name, schema_name, table_name, arrow_table, sorting_key=[]):
+def prepare_data(session: Session,
+                 clean_bucket_name: str, schema_name: str, table_name: str,
+                 arrow_table: pa.Table, sorting_key: List[str] = []) -> Iterator[Table]:
     with session.transaction() as tx:
         s = tx.bucket(clean_bucket_name).create_schema(schema_name)
         t = s.create_table(table_name, arrow_table.schema, sorting_key=sorting_key)
         row_ids_array = t.insert(arrow_table)
         row_ids = row_ids_array.to_pylist()
-        assert row_ids == list(range(arrow_table.num_rows))
+        assert_row_ids_ascending_on_first_insertion_to_table(row_ids, arrow_table.num_rows, t.sorted_table)
         yield t
         t.drop()
         s.drop()
 
 
+@contextmanager
+def prepare_data_get_tx(session: Session,
+                        clean_bucket_name: str,
+                        schema_name: str,
+                        table_name: str,
+                        arrow_table: pa.Table,
+                        sorting_key: List[str] = []) -> Iterator[Transaction]:
+    with prepare_data(session, clean_bucket_name, schema_name, table_name, arrow_table, sorting_key) as table:
+        yield table.tx
+
+
 def compare_pyarrow_tables(t1, t2):
 
     def sort_table(table):
@@ -36,3 +65,81 @@ def compare_pyarrow_tables(t1, t2):
     sorted_table1 = sort_table(t1)
     sorted_table2 = sort_table(t2)
     return compare_tables(sorted_table1, sorted_table2)
+
+
+def convert_pandas_df_to_hashable_values(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Convert all values in the DataFrame to hashable types.
+    This is useful for comparing DataFrames or using them as keys in dictionaries.
+
+    :param df: Input DataFrame.
+    :return: DataFrame with all values converted to hashable types.
+    """
+
+    def _to_hashable(x: Any) -> Any:
+        if isinstance(x, (list, set, np.ndarray)):
+            return tuple(x)  # type: ignore
+        return x
+
+    if Version(pd.__version__) >= Version("2.1.0"):
+        return df.map(_to_hashable)  # type: ignore
+    else:
+        return df.applymap(_to_hashable)  # type: ignore
+
+
+def assert_pandas_df_equal(a: pd.DataFrame, b: pd.DataFrame, ignore_columns_order: bool = True,
+                           ignore_rows_order: bool = True, **kwargs) -> None:
+    """ Assert 2 Pandas DataFrames are equal.
+
+    :param a: First DataFrame.
+    :param b: Second DataFrame.
+    :param ignore_columns_order: Whether to ignore the column order.
+    :param ignore_rows_order: Whether to ignore the rows order.
+    :param kwargs: Additional keyword arguments to pass to `pd.testing.assert_frame_equal`.
+    """
+    assert set(a.columns) == set(b.columns), f'unmatched columns {a.columns} {b.columns}'
+    # Sort columns. Done instead of using pd.testing.assert_frame_equal(check_like=False) in order to allow the sort
+    # of the rows according to the same order, their columns order.
+    if ignore_columns_order:
+        b = b[a.columns]
+    pd.testing.assert_index_equal(a.columns, b.columns)
+
+    # Sort rows.
+    if ignore_rows_order:
+        a = convert_pandas_df_to_hashable_values(a)
+        b = convert_pandas_df_to_hashable_values(b)
+        a = a.sort_values(by=a.columns.tolist()).reset_index(drop=True)
+        b = b.sort_values(by=b.columns.tolist()).reset_index(drop=True)
+
+    pd.testing.assert_frame_equal(a, b, **kwargs)
+
+
+def assert_pandas_df_contained(a: pd.DataFrame, b: pd.DataFrame, ignore_value_count=False, ignore_columns_order=True):
+    """
+    Assert A is contained in B.
+
+    :param a: First DataFrame.
+    :param b: Second DataFrame.
+    :param ignore_value_count: Succeed even in case a value in A exists in B, but has more occurrences in A.
+    :param ignore_columns_order: Whether to ignore the column order.
+    :note: Expecting A and B to have the same columns.
+    """
+    assert set(a.columns) == set(b.columns), f'unmatched columns {a.columns} {b.columns}'
+    if ignore_columns_order:
+        b = b[a.columns]
+    pd.testing.assert_index_equal(a.columns, b.columns)
+
+    a = convert_pandas_df_to_hashable_values(a)
+    b = convert_pandas_df_to_hashable_values(b)
+
+    if ignore_value_count:
+        merged = a.merge(b, on=a.columns, how='left', indicator=True)
+        assert cast(pd.Series, (merged['_merge'] == 'both')).all(), f'values are not contained {merged=}'
+    else:
+        a_counts = a.value_counts(dropna=False) if Version(pd.__version__) >= Version("1.3.0") else a.value_counts()
+        b_counts = b.value_counts(dropna=False) if Version(pd.__version__) >= Version("1.3.0") else b.value_counts()
+
+        # Check that each row in A occurs in B with at least the same frequency.
+        count_compare = cast(pd.Series, a_counts <= b_counts.reindex(a_counts.index, fill_value=0))
+        assert count_compare.all(), (f'some values have lower frequency, all values with False has higher frequency in '
+                                     f'A than B {count_compare=}')

vastdb/transaction.py

@@ -7,9 +7,14 @@ A transcation is used as a context manager, since every Database-related operati
 """
 
 import logging
+from copy import deepcopy
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Iterable, Optional
 
+from vastdb._table_interface import ITable
+from vastdb.table import TableInTransaction
+from vastdb.table_metadata import TableMetadata
+
 from . import bucket, errors, schema, session
 
 if TYPE_CHECKING:
@@ -28,6 +33,12 @@ AUDIT_LOG_SCHEMA_NAME = 'vast_audit_log_schema'
 AUDIT_LOG_TABLE_NAME = 'vast_audit_log_table'
 
 
+class TransactionNotActiveError(Exception):
+    """Transaction is not active error."""
+
+    pass
+
+
 @dataclass
 class Transaction:
     """A holder of a single VAST transaction."""
@@ -83,3 +94,19 @@ class Transaction:
         b = bucket.Bucket(AUDIT_LOG_BUCKET_NAME, self)
         s = schema.Schema(AUDIT_LOG_SCHEMA_NAME, b)
         return s.table(name=AUDIT_LOG_TABLE_NAME, fail_if_missing=fail_if_missing)
+
+    @property
+    def is_active(self) -> bool:
+        """Return whether transaction is active."""
+        return self.txid is not None
+
+    @property
+    def active_txid(self) -> int:
+        """Return active transaction ID."""
+        if self.txid is None:
+            raise TransactionNotActiveError()
+        return self.txid
+
+    def table_from_metadata(self, metadata: TableMetadata) -> ITable:
+        """Create Table from TableMetadata."""
+        return TableInTransaction(deepcopy(metadata), tx=self)

{vastdb-1.3.11.dist-info → vastdb-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: vastdb
-Version: 1.3.11
+Version: 2.0.0
 Summary: VAST Data SDK
 Home-page: https://github.com/vast-data/vastdb_sdk
 Author: VAST DATA
@@ -9,22 +9,37 @@ License: Copyright (C) VAST Data Ltd.
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Database
 Classifier: Topic :: Database :: Front-Ends
-Requires-Python: >=3.9.0
+Requires-Python: >=3.10.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aws-requests-auth
+Requires-Dist: ibis-framework~=10.1
+Requires-Dist: pyarrow~=18.0
+Requires-Dist: pyarrow-hotfix==0.7
 Requires-Dist: flatbuffers
-Requires-Dist: ibis-framework==9.0.0
-Requires-Dist: pyarrow
+Requires-Dist: packaging
+Requires-Dist: pandas
+Requires-Dist: numpy
 Requires-Dist: requests
 Requires-Dist: xmltodict
 Requires-Dist: backoff==2.2.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 `vastdb` is a Python-based SDK designed for interacting

{vastdb-1.3.11.dist-info → vastdb-2.0.0.dist-info}/RECORD

@@ -1,14 +1,17 @@
 vastdb/__init__.py,sha256=uf-AXdzsD4nPxFP7WxkcAXGG0whv8BHLrrXCJtsPGaQ,436
-vastdb/_internal.py,sha256=YoZGgliQfNYNKuKG8M9ziZpu4R1pmp3PLdLcyOgo9Hc,108129
-vastdb/bucket.py,sha256=aomUbrfK5Oa6FdGPVsoBXgRW39IzYnmsorF8642r990,2549
+vastdb/_ibis_support.py,sha256=sJieOMvDWpsciPKh1mJzS56jxLtCRVlvK41hW84vexM,866
+vastdb/_internal.py,sha256=ZR9da7t-dQGtax0Cz-3CgtX1C0nLKc5VI9dkfO349RY,108764
+vastdb/_table_interface.py,sha256=EdS50_x9ZVzRWDyV6b5hB9qIUdA7S4hNBgNq3t8deHo,3611
+vastdb/bucket.py,sha256=ulkTI_7xw5FYVzcrTFC7G2ijmTTVSmvJZUdgzycGHR0,2588
 vastdb/config.py,sha256=OehnsWrjzv0-SUouEXmkrKBugiWyhXOn4XiSLV3s9yk,2342
-vastdb/conftest.py,sha256=Cl98Hg4kkLmx83F5dFMbVb-sTnn0zHxruE5B1hYXbMk,3866
+vastdb/conftest.py,sha256=Xa9N0N3176_dbk4GdSKn57sfOiIUOijBoTEDgoGUo5s,4813
 vastdb/errors.py,sha256=NiKdwbfVsWJIixP2Tf3JgiBoEt8rRaZ0VeCyD9mXnoM,5645
 vastdb/features.py,sha256=ivYbvhiGA858B00vhs_CNzlVV9QDUe53yW6V3J5EoxM,1874
-vastdb/schema.py,sha256=5BZ0f3b_c-fGRKAaBBL6B3avHel5EDwwxte7t17WeTw,6718
-vastdb/session.py,sha256=toMR0BXwTaECdWDKnIZky1F3MA1SmelRBiqCrqQ3GCM,2067
-vastdb/table.py,sha256=fUAmOaVdMSzas1XHldRgT0UbHEG-hYJjuWkDIz3hchs,36936
-vastdb/transaction.py,sha256=NlVkEowJ_pmtffjWBBDaKExYDKPekjSZyj_fK_bZPJE,3026
+vastdb/schema.py,sha256=0o7HOGR2STJQ6itCDP5Lez6OOfKBl6tS0T7KLgL5Gbk,7104
+vastdb/session.py,sha256=Au0L67SzSQXG9ZlrfN5MEqIEX2LeIgzUpdFkGLIpjMs,2126
+vastdb/table.py,sha256=DipsklV03_oEvQGcE67ST8uQbtC_s-HtyCTs_majfNQ,44756
+vastdb/table_metadata.py,sha256=ecQ7u0fMbJtdKByQ9CZ0kPnZN20QGZU8_YGCM3RXQe4,6685
+vastdb/transaction.py,sha256=GR-urtN4XCIUbbK5TV4xWGvDY6vit-HJyMGRvfnIi8k,3799
 vastdb/util.py,sha256=8CUnVRsJukC3uNHNoB5D0qPf0FxS8OSdVB84nNoLJKc,6290
 vastdb/bench/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/bench/test_perf.py,sha256=0kbCxK8U9vYO0zCMUYcZHzEICaaII3I0-6FeR5-CNtM,4040
@@ -30,7 +33,7 @@ vastdb/bench/perf_bench/dataset/schemas.py,sha256=CvCAxCWHsWdI6jE9on2Mm6b0NTDhZX
 vastdb/bench/perf_bench/dataset/secmaster.py,sha256=Y3yt8B_RsFvGlhMWKvDqax31UV_ShxZM-7CJO4YmxL0,188169
 vastdb/bench/perf_bench/orchestrate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/bench/perf_bench/orchestrate/bench_spec.py,sha256=XMUVlKPyWuhkRkz_Z2-iKYxqDlMj0EKcA3N46MLIX2c,2469
-vastdb/bench/perf_bench/orchestrate/results_helpers.py,sha256=u-GeDjbdKZLhAfDdecg9xYe7mnbJ0q_xu3xJ8rrRWG0,4172
+vastdb/bench/perf_bench/orchestrate/results_helpers.py,sha256=lioubu6LjAgHAiYW0ZqMqAirua4XH5o6cJqvnGhE_fI,4188
 vastdb/bench/perf_bench/orchestrate/scenario.py,sha256=DUsIWyVmoLyYbKqPcLpd4veNHVbJsmL9JE-RTdmmyiw,3482
 vastdb/bench/perf_bench/orchestrate/scenario_generator.py,sha256=Plnij1hHqwmMndYpG4EA6L-HNAMJUB-M6-KXm3KZtlk,5978
 vastdb/bench/perf_bench/query/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -40,16 +43,17 @@ vastdb/bench/perf_bench/query/query_pyarrow.py,sha256=Dj5YPUvb4dAj7RskHfJcPijJnM
 vastdb/bench/perf_bench/query/query_vastdb.py,sha256=SZYem_EmsaynEftAa_VFobjSJZDAcli9BckyRS3SFvg,2810
 vastdb/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/tests/metrics.py,sha256=ZCSeBYFSPMG3yI0JrAHs2CrY6wFjx_5GwRTYHVAwLKA,1026
-vastdb/tests/test_duckdb.py,sha256=STw_1PwTQR8Naz6s0p6lQTV1ZTKKhe3LPBUbhqzTCu0,1880
-vastdb/tests/test_fixed_list.py,sha256=qwtFNvw5fdMkOsYAcFfqPN3JOnJn31XGYtFWVe0vuOQ,11187
-vastdb/tests/test_imports.py,sha256=1Xi5s0qWxuoVunW5iMQGzofTNOXxXP8eOARs9HWOiGE,21734
-vastdb/tests/test_nested.py,sha256=c7q9a3MsyDymqAtShPC4cMHlzjCr18kbu_Db3u_c4IQ,6893
+vastdb/tests/test_duckdb.py,sha256=XZxlw3SXb8tbd2BsJdr9F7jBBka4dW9PVtwvwqEcOXo,2057
+vastdb/tests/test_fixed_list.py,sha256=1KpsijmGvxHcM-pHJcm4zn2o_G8-ISbCFuoKSkXjmfk,14099
+vastdb/tests/test_imports.py,sha256=FhIHjYpttiQW_x3fMe8ENd9ynn7OyUtjxr2ca4z1F-s,21783
+vastdb/tests/test_nested.py,sha256=SKiXDX8RhR20DSdJNTZLHOGWduXVUPuG1uwfC_C5hTk,6663
 vastdb/tests/test_projections.py,sha256=3y1kubwVrzO-xoR0hyps7zrjOJI8niCYspaFTN16Q9w,4540
 vastdb/tests/test_sanity.py,sha256=bv1ypGDzvOgmMvGbucDYiLQu8krQLlE6NB3M__q87x8,3303
 vastdb/tests/test_schemas.py,sha256=l70YQMlx2UL1KRQhApriiG2ZM7GJF-IzWU31H3Yqn1U,3312
-vastdb/tests/test_tables.py,sha256=Bl0ldJApPCFEL94jRNycsCi8M_2jTHWDXiA-7JHVlzk,51260
+vastdb/tests/test_table_in_tx.py,sha256=-OFGaZMZQc78HOmR23xHIsH7d0VBneFG3tGdDlogceM,9105
+vastdb/tests/test_tables.py,sha256=pMlOOu_7Tg2x75zYRmLDl8Imm1PuGM0CUD2vz_4Pt34,53142
 vastdb/tests/test_util.py,sha256=n7gvT5Wg6b6bxgqkFXkYqvFd_W1GlUdVfmPv66XYXyA,1956
-vastdb/tests/util.py,sha256=YsCBCcx7n1QOH-IPDpCsl6KEaUQQJRZwGPeayijHNb4,1307
+vastdb/tests/util.py,sha256=f-0sAij1uv5p7hu-YLZ-cmsNolU4KWNUjezeP5b2nwk,5915
 vastdb/vast_flatbuf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/vast_flatbuf/org/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/vast_flatbuf/org/apache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -210,8 +214,8 @@ vastdb/vast_flatbuf/tabular/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 vastdb/vast_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vastdb/vast_tests/test_ha.py,sha256=744P4G6VJ09RIkHhMQL4wlipCBJWQVMhyvUrSc4k1HQ,975
 vastdb/vast_tests/test_scale.py,sha256=5jGwOdZH6Tv5tPdZYPWoqcxOceI2jA5i2D1zNKZHER4,3958
-vastdb-1.3.11.dist-info/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
-vastdb-1.3.11.dist-info/METADATA,sha256=KwME3q5diBEN8GTagURPqGDDBv41TS7xFN348qr26lw,1341
-vastdb-1.3.11.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-vastdb-1.3.11.dist-info/top_level.txt,sha256=nnKAaZaQa8GFbYpWAexr_B9HrhonZbUlX6hL6AC--yA,7
-vastdb-1.3.11.dist-info/RECORD,,
+vastdb-2.0.0.dist-info/licenses/LICENSE,sha256=obffan7LYrq7hLHNrY7vHcn2pKUTBUYXMKu-VOAvDxU,11333
+vastdb-2.0.0.dist-info/METADATA,sha256=GeJUYt9gomO12Gouliy_4TtHlx1-IwuZU6hwtpaT9mA,1686
+vastdb-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vastdb-2.0.0.dist-info/top_level.txt,sha256=nnKAaZaQa8GFbYpWAexr_B9HrhonZbUlX6hL6AC--yA,7
+vastdb-2.0.0.dist-info/RECORD,,

{vastdb-1.3.11.dist-info → vastdb-2.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any