deltacat 1.1.13__py3-none-any.whl → 1.1.15__py3-none-any.whl

deltacat/tests/compute/compactor_v2/test_compaction_session.py

@@ -178,7 +178,7 @@ class TestCompactionSession:
                     },
                     "primary_keys": [],
                     "rebase_source_partition_locator": source_delta.partition_locator,
-                    "rebase_source_partition_high_watermark": None,
+                    "rebase_source_partition_high_watermark": source_delta.stream_position,
                     "records_per_compacted_file": 4000,
                     "s3_client_kwargs": {},
                     "source_partition_locator": source_delta.partition_locator,

deltacat/tests/compute/test_compact_partition_multiple_rounds.py

@@ -0,0 +1,330 @@
+import ray
+import os
+from moto import mock_s3
+import pytest
+import boto3
+from boto3.resources.base import ServiceResource
+import pyarrow as pa
+from deltacat.io.ray_plasma_object_store import RayPlasmaObjectStore
+from pytest_benchmark.fixture import BenchmarkFixture
+
+from deltacat.tests.compute.test_util_constant import (
+    TEST_S3_RCF_BUCKET_NAME,
+    DEFAULT_NUM_WORKERS,
+    DEFAULT_WORKER_INSTANCE_CPUS,
+)
+from deltacat.tests.compute.test_util_common import (
+    get_rcf,
+)
+from deltacat.tests.test_utils.utils import read_s3_contents
+from deltacat.compute.compactor.model.compactor_version import CompactorVersion
+from deltacat.tests.compute.test_util_common import (
+    get_compacted_delta_locator_from_rcf,
+)
+from deltacat.compute.compactor.model.compaction_session_audit_info import (
+    CompactionSessionAuditInfo,
+)
+from deltacat.tests.compute.test_util_create_table_deltas_repo import (
+    multiple_rounds_create_src_w_deltas_destination_rebase_w_deltas_strategy,
+)
+from deltacat.tests.compute.compact_partition_multiple_rounds_test_cases import (
+    MULTIPLE_ROUNDS_TEST_CASES,
+)
+from typing import Any, Callable, Dict, List, Optional, Set
+from deltacat.types.media import StorageType
+from deltacat.storage import (
+    DeltaLocator,
+    Partition,
+)
+from deltacat.types.media import ContentType
+from deltacat.compute.compactor.model.compact_partition_params import (
+    CompactPartitionParams,
+)
+from deltacat.compute.compactor import (
+    RoundCompletionInfo,
+)
+from deltacat.utils.placement import (
+    PlacementGroupManager,
+)
+
+DATABASE_FILE_PATH_KEY, DATABASE_FILE_PATH_VALUE = (
+    "db_file_path",
+    "deltacat/tests/local_deltacat_storage/db_test.sqlite",
+)
+
+
+"""
+MODULE scoped fixtures
+"""
+
+
+@pytest.fixture(autouse=True, scope="module")
+def setup_ray_cluster():
+    ray.init(local_mode=True, ignore_reinit_error=True)
+    yield
+    ray.shutdown()
+
+
+@pytest.fixture(autouse=True, scope="module")
+def mock_aws_credential():
+    os.environ["AWS_ACCESS_KEY_ID"] = "testing"
+    os.environ["AWS_SECRET_ACCESS_ID"] = "testing"
+    os.environ["AWS_SECURITY_TOKEN"] = "testing"
+    os.environ["AWS_SESSION_TOKEN"] = "testing"
+    os.environ["AWS_DEFAULT_REGION"] = "us-east-1"
+    yield
+
+
+@pytest.fixture(autouse=True, scope="module")
+def cleanup_the_database_file_after_all_compaction_session_package_tests_complete():
+    # make sure the database file is deleted after all the compactor package tests are completed
+    if os.path.exists(DATABASE_FILE_PATH_VALUE):
+        os.remove(DATABASE_FILE_PATH_VALUE)
+
+
+@pytest.fixture(scope="module")
+def s3_resource(mock_aws_credential):
+    with mock_s3():
+        yield boto3.resource("s3")
+
+
+@pytest.fixture(autouse=True, scope="module")
+def setup_compaction_artifacts_s3_bucket(s3_resource: ServiceResource):
+    s3_resource.create_bucket(
+        ACL="authenticated-read",
+        Bucket=TEST_S3_RCF_BUCKET_NAME,
+    )
+    yield
+
+
+"""
+FUNCTION scoped fixtures
+"""
+
+
+@pytest.fixture(scope="function")
+def local_deltacat_storage_kwargs(request: pytest.FixtureRequest):
+    # see deltacat/tests/local_deltacat_storage/README.md for documentation
+    kwargs_for_local_deltacat_storage: Dict[str, Any] = {
+        DATABASE_FILE_PATH_KEY: DATABASE_FILE_PATH_VALUE,
+    }
+    yield kwargs_for_local_deltacat_storage
+    if os.path.exists(DATABASE_FILE_PATH_VALUE):
+        os.remove(DATABASE_FILE_PATH_VALUE)
+
+
+@pytest.mark.parametrize(
+    [
+        "test_name",
+        "primary_keys",
+        "sort_keys",
+        "partition_keys_param",
+        "partition_values_param",
+        "input_deltas_param",
+        "expected_terminal_compact_partition_result",
+        "expected_terminal_exception",
+        "expected_terminal_exception_message",
+        "create_placement_group_param",
+        "records_per_compacted_file_param",
+        "hash_bucket_count_param",
+        "read_kwargs_provider_param",
+        "drop_duplicates_param",
+        "skip_enabled_compact_partition_drivers",
+        "assert_compaction_audit",
+        "rebase_expected_compact_partition_result",
+        "num_rounds_param",
+        "compact_partition_func",
+        "compactor_version",
+    ],
+    [
+        (
+            test_name,
+            primary_keys,
+            sort_keys,
+            partition_keys_param,
+            partition_values_param,
+            input_deltas,
+            expected_terminal_compact_partition_result,
+            expected_terminal_exception,
+            expected_terminal_exception_message,
+            create_placement_group_param,
+            records_per_compacted_file_param,
+            hash_bucket_count_param,
+            drop_duplicates_param,
+            read_kwargs_provider,
+            skip_enabled_compact_partition_drivers,
+            assert_compaction_audit,
+            rebase_expected_compact_partition_result,
+            num_rounds_param,
+            compact_partition_func,
+            compactor_version,
+        )
+        for test_name, (
+            primary_keys,
+            sort_keys,
+            partition_keys_param,
+            partition_values_param,
+            input_deltas,
+            expected_terminal_compact_partition_result,
+            expected_terminal_exception,
+            expected_terminal_exception_message,
+            create_placement_group_param,
+            records_per_compacted_file_param,
+            hash_bucket_count_param,
+            drop_duplicates_param,
+            read_kwargs_provider,
+            skip_enabled_compact_partition_drivers,
+            assert_compaction_audit,
+            rebase_expected_compact_partition_result,
+            num_rounds_param,
+            compact_partition_func,
+            compactor_version,
+        ) in MULTIPLE_ROUNDS_TEST_CASES.items()
+    ],
+    ids=[test_name for test_name in MULTIPLE_ROUNDS_TEST_CASES],
+)
+def test_compact_partition_rebase_multiple_rounds_same_source_and_destination(
+    mocker,
+    s3_resource: ServiceResource,
+    local_deltacat_storage_kwargs: Dict[str, Any],
+    test_name: str,
+    primary_keys: Set[str],
+    sort_keys: List[Optional[Any]],
+    partition_keys_param: Optional[List[Any]],
+    partition_values_param: List[Optional[str]],
+    input_deltas_param: List[pa.Array],
+    expected_terminal_compact_partition_result: pa.Table,
+    expected_terminal_exception: BaseException,
+    expected_terminal_exception_message: Optional[str],
+    create_placement_group_param: bool,
+    records_per_compacted_file_param: int,
+    hash_bucket_count_param: int,
+    drop_duplicates_param: bool,
+    read_kwargs_provider_param: Any,
+    rebase_expected_compact_partition_result: pa.Table,
+    skip_enabled_compact_partition_drivers: List[CompactorVersion],
+    assert_compaction_audit: Optional[Callable],
+    compactor_version: Optional[CompactorVersion],
+    compact_partition_func: Callable,
+    num_rounds_param: int,
+    benchmark: BenchmarkFixture,
+):
+    import deltacat.tests.local_deltacat_storage as ds
+
+    ds_mock_kwargs = local_deltacat_storage_kwargs
+    """
+    This test tests different multi-round compaction rebase configurations,
+    as specified in compact_partition_multiple_rounds_test_cases.py
+    These tests do not test multi-round compaction backfill, which is
+    currently unsupported.
+    """
+    (
+        source_table_stream,
+        _,
+        rebased_table_stream,
+        _,
+    ) = multiple_rounds_create_src_w_deltas_destination_rebase_w_deltas_strategy(
+        primary_keys,
+        sort_keys,
+        partition_keys_param,
+        input_deltas_param,
+        partition_values_param,
+        ds_mock_kwargs,
+    )
+    source_partition: Partition = ds.get_partition(
+        source_table_stream.locator,
+        partition_values_param,
+        **ds_mock_kwargs,
+    )
+    rebased_partition: Partition = ds.get_partition(
+        rebased_table_stream.locator,
+        partition_values_param,
+        **ds_mock_kwargs,
+    )
+    total_cpus = DEFAULT_NUM_WORKERS * DEFAULT_WORKER_INSTANCE_CPUS
+    pgm = None
+    if create_placement_group_param:
+        pgm = PlacementGroupManager(
+            1, total_cpus, DEFAULT_WORKER_INSTANCE_CPUS, memory_per_bundle=4000000
+        ).pgs[0]
+    compact_partition_params = CompactPartitionParams.of(
+        {
+            "compaction_artifact_s3_bucket": TEST_S3_RCF_BUCKET_NAME,
+            "compacted_file_content_type": ContentType.PARQUET,
+            "dd_max_parallelism_ratio": 1.0,
+            "deltacat_storage": ds,
+            "deltacat_storage_kwargs": ds_mock_kwargs,
+            "destination_partition_locator": rebased_partition.locator,
+            "hash_bucket_count": hash_bucket_count_param,
+            "last_stream_position_to_compact": source_partition.stream_position,
+            "list_deltas_kwargs": {**ds_mock_kwargs, **{"equivalent_table_types": []}},
+            "object_store": RayPlasmaObjectStore(),
+            "pg_config": pgm,
+            "primary_keys": primary_keys,
+            "read_kwargs_provider": read_kwargs_provider_param,
+            "rebase_source_partition_locator": source_partition.locator,
+            "rebase_source_partition_high_watermark": rebased_partition.stream_position,
+            "records_per_compacted_file": records_per_compacted_file_param,
+            "s3_client_kwargs": {},
+            "source_partition_locator": rebased_partition.locator,
+            "sort_keys": sort_keys if sort_keys else None,
+            "num_rounds": num_rounds_param,
+            "drop_duplicates": drop_duplicates_param,
+            "min_delta_bytes": 560,
+        }
+    )
+    if expected_terminal_exception:
+        with pytest.raises(expected_terminal_exception) as exc_info:
+            benchmark(compact_partition_func, compact_partition_params)
+        assert expected_terminal_exception_message in str(exc_info.value)
+        return
+    from deltacat.compute.compactor_v2.model.evaluate_compaction_result import (
+        ExecutionCompactionResult,
+    )
+
+    execute_compaction_result_spy = mocker.spy(ExecutionCompactionResult, "__init__")
+
+    # execute
+    rcf_file_s3_uri = benchmark(compact_partition_func, compact_partition_params)
+
+    round_completion_info: RoundCompletionInfo = get_rcf(s3_resource, rcf_file_s3_uri)
+    audit_bucket, audit_key = RoundCompletionInfo.get_audit_bucket_name_and_key(
+        round_completion_info.compaction_audit_url
+    )
+
+    compaction_audit_obj: Dict[str, Any] = read_s3_contents(
+        s3_resource, audit_bucket, audit_key
+    )
+    compaction_audit: CompactionSessionAuditInfo = CompactionSessionAuditInfo(
+        **compaction_audit_obj
+    )
+
+    # Assert not in-place compacted
+    assert (
+        execute_compaction_result_spy.call_args.args[-1] is False
+    ), "Table version erroneously marked as in-place compacted!"
+    compacted_delta_locator: DeltaLocator = get_compacted_delta_locator_from_rcf(
+        s3_resource, rcf_file_s3_uri
+    )
+    tables = ds.download_delta(
+        compacted_delta_locator, storage_type=StorageType.LOCAL, **ds_mock_kwargs
+    )
+    actual_rebase_compacted_table = pa.concat_tables(tables)
+    # if no primary key is specified then sort by sort_key for consistent assertion
+    sorting_cols: List[Any] = (
+        [(val, "ascending") for val in primary_keys] if primary_keys else sort_keys
+    )
+    rebase_expected_compact_partition_result = (
+        rebase_expected_compact_partition_result.combine_chunks().sort_by(sorting_cols)
+    )
+    actual_rebase_compacted_table = (
+        actual_rebase_compacted_table.combine_chunks().sort_by(sorting_cols)
+    )
+    assert actual_rebase_compacted_table.equals(
+        rebase_expected_compact_partition_result
+    ), f"{actual_rebase_compacted_table} does not match {rebase_expected_compact_partition_result}"
+
+    if assert_compaction_audit:
+        if not assert_compaction_audit(compactor_version, compaction_audit):
+            assert False, "Compaction audit assertion failed"
+    return

deltacat/tests/compute/test_compact_partition_rebase.py

@@ -279,7 +279,7 @@ def test_compact_partition_rebase_same_source_and_destination(
     execute_compaction_result_spy = mocker.spy(ExecutionCompactionResult, "__init__")
 
     # execute
-    rcf_file_s3_uri = compact_partition_func(compact_partition_params)
+    rcf_file_s3_uri = benchmark(compact_partition_func, compact_partition_params)
 
     round_completion_info: RoundCompletionInfo = get_rcf(s3_resource, rcf_file_s3_uri)
     audit_bucket, audit_key = RoundCompletionInfo.get_audit_bucket_name_and_key(

deltacat/tests/compute/test_util_create_table_deltas_repo.py

@@ -269,3 +269,121 @@ def create_src_w_deltas_destination_rebase_w_deltas_strategy(
         destination_table_stream,
         rebased_stream_after_committed,
     )
+
+
+def multiple_rounds_create_src_w_deltas_destination_rebase_w_deltas_strategy(
+    primary_keys: Set[str],
+    sort_keys: Optional[List[Any]],
+    partition_keys: Optional[List[PartitionKey]],
+    input_deltas: List[pa.Table],
+    partition_values: Optional[List[Any]],
+    ds_mock_kwargs: Optional[Dict[str, Any]],
+) -> Tuple[Stream, Stream, Optional[Stream], bool]:
+    import deltacat.tests.local_deltacat_storage as ds
+    from deltacat.storage import Partition, Stream
+
+    source_namespace, source_table_name, source_table_version = create_src_table(
+        primary_keys, sort_keys, partition_keys, ds_mock_kwargs
+    )
+
+    source_table_stream: Stream = ds.get_stream(
+        namespace=source_namespace,
+        table_name=source_table_name,
+        table_version=source_table_version,
+        **ds_mock_kwargs,
+    )
+    staged_partition: Partition = ds.stage_partition(
+        source_table_stream, partition_values, **ds_mock_kwargs
+    )
+    is_delete = False
+    input_delta_length = 0
+    for (
+        input_delta,
+        input_delta_type,
+        input_delta_parameters,
+    ) in input_deltas:
+        if input_delta_type is DeltaType.DELETE:
+            is_delete = True
+        staged_delta = ds.stage_delta(
+            input_delta,
+            staged_partition,
+            input_delta_type,
+            delete_parameters=input_delta_parameters,
+            **ds_mock_kwargs,
+        )
+        ds.commit_delta(
+            staged_delta,
+            **ds_mock_kwargs,
+        )
+        input_delta_length += len(input_delta) if input_delta else 0
+    ds.commit_partition(staged_partition, **ds_mock_kwargs)
+    source_table_stream_after_committed: Stream = ds.get_stream(
+        namespace=source_namespace,
+        table_name=source_table_name,
+        table_version=source_table_version,
+        **ds_mock_kwargs,
+    )
+    # create the destination table
+    (
+        destination_table_namespace,
+        destination_table_name,
+        destination_table_version,
+    ) = create_destination_table(
+        primary_keys, sort_keys, partition_keys, ds_mock_kwargs
+    )
+    # create the rebase table
+    (
+        rebase_table_namespace,
+        rebase_table_name,
+        rebase_table_version,
+    ) = create_rebase_table(primary_keys, sort_keys, partition_keys, ds_mock_kwargs)
+    rebasing_table_stream: Stream = ds.get_stream(
+        namespace=rebase_table_namespace,
+        table_name=rebase_table_name,
+        table_version=rebase_table_version,
+        **ds_mock_kwargs,
+    )
+    staged_partition: Partition = ds.stage_partition(
+        rebasing_table_stream, partition_values, **ds_mock_kwargs
+    )
+    input_delta_length = 0
+    for (
+        input_delta,
+        input_delta_type,
+        input_delta_parameters,
+    ) in input_deltas:
+        if input_delta_type is DeltaType.DELETE:
+            is_delete = True
+        staged_delta = ds.stage_delta(
+            input_delta,
+            staged_partition,
+            input_delta_type,
+            delete_parameters=input_delta_parameters,
+            **ds_mock_kwargs,
+        )
+        ds.commit_delta(
+            staged_delta,
+            **ds_mock_kwargs,
+        )
+        input_delta_length += len(input_delta) if input_delta else 0
+    ds.commit_partition(staged_partition, **ds_mock_kwargs)
+
+    # get streams
+    destination_table_stream: Stream = ds.get_stream(
+        namespace=destination_table_namespace,
+        table_name=destination_table_name,
+        table_version=destination_table_version,
+        **ds_mock_kwargs,
+    )
+    rebased_stream_after_committed: Stream = ds.get_stream(
+        namespace=rebase_table_namespace,
+        table_name=rebase_table_name,
+        table_version=rebase_table_version,
+        **ds_mock_kwargs,
+    )
+    return (
+        source_table_stream_after_committed,
+        destination_table_stream,
+        rebased_stream_after_committed,
+        is_delete,
+    )

deltacat/tests/local_deltacat_storage/__init__.py

@@ -394,12 +394,13 @@ def download_delta(
     **kwargs,
 ) -> Union[LocalDataset, DistributedDataset]:  # type: ignore
     result = []
-    manifest = get_delta_manifest(delta_like, *args, **kwargs)
-
+    if isinstance(delta_like, Delta) and delta_like.manifest is not None:
+        manifest = Delta(delta_like).manifest
+    else:
+        manifest = get_delta_manifest(delta_like, *args, **kwargs)
     partition_values: PartitionValues = None
     if partition_filter is not None:
         partition_values = partition_filter.partition_values
-
     for entry_index in range(len(manifest.entries)):
         if (
             partition_values is not None
@@ -440,8 +441,10 @@ def download_delta_manifest_entry(
     **kwargs,
 ) -> LocalTable:
     cur, con = _get_sqlite3_cursor_con(kwargs)
-
-    manifest = get_delta_manifest(delta_like, *args, **kwargs)
+    if isinstance(delta_like, Delta) and delta_like.manifest is not None:
+        manifest = Delta(delta_like).manifest
+    else:
+        manifest = get_delta_manifest(delta_like, *args, **kwargs)
     if entry_index >= len(manifest.entries):
         raise IndexError(
             f"Manifest entry index {entry_index} does not exist. "

{deltacat-1.1.13.dist-info → deltacat-1.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltacat
-Version: 1.1.13
+Version: 1.1.15
 Summary: A scalable, fast, ACID-compliant Data Catalog powered by Ray.
 Home-page: https://github.com/ray-project/deltacat
 Author: Ray Team

{deltacat-1.1.13.dist-info → deltacat-1.1.15.dist-info}/RECORD

@@ -1,4 +1,4 @@
-deltacat/__init__.py,sha256=v91QDtZ0JmhMu7T4rGn0ioNLAMn-0Ha7zC-0EACz2LM,1778
+deltacat/__init__.py,sha256=B3feGTJ_HURh5NXPYw8eS-uft2b2FuwzVsZjfVXCa5c,1778
 deltacat/constants.py,sha256=_6oRI-3yp5c8J1qKGQZrt89I9-ttT_gSSvVsJ0h8Duc,1939
 deltacat/exceptions.py,sha256=yWM4RXK7uRrQc1VgJv6Lv2UiNZWAx2wolLq7cBwjlkg,12770
 deltacat/logs.py,sha256=6g16VkEFidbaMjgenAjggE1r2l664drMVhreRs8B1IQ,8438
@@ -21,14 +21,14 @@ deltacat/catalog/model/catalog.py,sha256=-Ho7a3rV1hiOS9cSRCAor9AtXV9nJn9t_MDVql9
 deltacat/catalog/model/table_definition.py,sha256=tKrM1mmaQlvxqXrLt3QJVZK5BZfaJnhjTZ6KjybYlhE,727
 deltacat/compute/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor/__init__.py,sha256=ivpOPve1yKi3Vz3tVgp-eeFMNEeUSf-dlRJNSCM85sE,1022
-deltacat/compute/compactor/compaction_session.py,sha256=sGlSpfZaC_RYG2n8NGpT9z2X8V521nlLJktYtzafpmg,27715
+deltacat/compute/compactor/compaction_session.py,sha256=YthBYNpj6qvr6SqfVfXTy5ylKFOo8zUKI3bn4tHt0e8,27766
 deltacat/compute/compactor/repartition_session.py,sha256=AAPwNZtPpC_Mtoja855_alBdXDA6efp7zcvkE-MANaQ,7254
 deltacat/compute/compactor/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor/model/compact_partition_params.py,sha256=RuyYQVuoxKlt4vYTbVpCgoM6K8S_-TFhVuOnPVkxLfE,15850
-deltacat/compute/compactor/model/compaction_session_audit_info.py,sha256=Aoae5KNmbdYt48utFQR_zrjHTkC9JNd4jPhQmyJji-A,30547
+deltacat/compute/compactor/model/compact_partition_params.py,sha256=MOgSmprPw6AN4u0CIDrFTzKwuJEE3QgTkdGcvJwdKVA,16076
+deltacat/compute/compactor/model/compaction_session_audit_info.py,sha256=3BipvaREfk4l0DjdkH1ryy1E46NQdyYi33DPv3O5i7U,30462
 deltacat/compute/compactor/model/compactor_version.py,sha256=RwRvManiCxZmzjAWzm1OPDxjB1BEHu1d0fBJyGhXKxA,87
 deltacat/compute/compactor/model/dedupe_result.py,sha256=1OCV944qJdLQ_-8scisVKl45ej1eRv9OV539QYZtQ-U,292
-deltacat/compute/compactor/model/delta_annotated.py,sha256=NERB9rOtYg-xzBwvqGJ7_hBOzBC7g6X5M9-Cq5pbdH8,12258
+deltacat/compute/compactor/model/delta_annotated.py,sha256=NmL1Dgso1OLenduGSmIrFf_IE5n4sbAolrch8ry5ABc,12230
 deltacat/compute/compactor/model/delta_file_envelope.py,sha256=6P-3qM4HE1dIGqbKmiyk8cyJAJD1WbwnN22_ppQocHc,3676
 deltacat/compute/compactor/model/delta_file_locator.py,sha256=AmhPGPDsmahVhp91rohJMx4ByumcIY5feqRLZTrNu4s,1905
 deltacat/compute/compactor/model/hash_bucket_result.py,sha256=71qGmaT1Mks-r3-aatjNbn2x3yWIgT8RmV0bRWe6pdA,275
@@ -40,7 +40,7 @@ deltacat/compute/compactor/model/round_completion_info.py,sha256=SGR6WeGBGwRNDz6
 deltacat/compute/compactor/model/table_object_store.py,sha256=7BsBsuV8TBudGzy_NfQc7QyzLIP0EXf04DvqaOJNeJE,1487
 deltacat/compute/compactor/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor/steps/dedupe.py,sha256=iAPRIeMdGxNxaCy2QC_XzRWiNDVkKbkplJY0DVoWwsE,10190
-deltacat/compute/compactor/steps/hash_bucket.py,sha256=CbNbE0rizrsG-7rvB90J-iHtr7OajDat-4tyi2Ftz10,10655
+deltacat/compute/compactor/steps/hash_bucket.py,sha256=r4DOf1M8brsloiVyOKyplSvFG72Ao86N7YaH2l4mwEk,10646
 deltacat/compute/compactor/steps/materialize.py,sha256=j2r01KL5GGhGss9FSN9vpYmgsCQdm2uUpKMDVPtk6_k,14246
 deltacat/compute/compactor/steps/repartition.py,sha256=_ITw4yvvnNv3wwOYxprzlIz5J6t3b72re6lllpzJD9U,10960
 deltacat/compute/compactor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -50,8 +50,8 @@ deltacat/compute/compactor/utils/round_completion_file.py,sha256=_rl8lBSO9KFW07Z
 deltacat/compute/compactor/utils/sort_key.py,sha256=oK6otg-CSsma6zlGPaKg-KNEvcZRG2NqBlCw1X3_FBc,2397
 deltacat/compute/compactor/utils/system_columns.py,sha256=CNIgAGos0xAGEpdaQIH7KfbSRrGZgjRbItXMararqXQ,9399
 deltacat/compute/compactor_v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor_v2/compaction_session.py,sha256=1V7EgtSF3gmqoaN6iRQ1Yw66Epvmlh2Hj6-y_rE83zI,7755
-deltacat/compute/compactor_v2/constants.py,sha256=RoVJb86km-0ghtEFB0z24H7yuCJCbQ2t7_-LuXFNYak,2304
+deltacat/compute/compactor_v2/compaction_session.py,sha256=mRy7Rh2hIejKmfmVUXTbAD8ArUDRudDAY5YxlKV8dBM,8186
+deltacat/compute/compactor_v2/constants.py,sha256=4HkSebuRWlAzOnZ-_nYmMsf6d3koTwfrlBx9KxuoGe4,2417
 deltacat/compute/compactor_v2/deletes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor_v2/deletes/delete_file_envelope.py,sha256=AeuH9JRMwp6mvQf6P2cqL92hUEtResQq6qUTS0kIKac,3111
 deltacat/compute/compactor_v2/deletes/delete_strategy.py,sha256=SMEJOxR-5r92kvKNqtu2w6HmwtmhljcZX1wcNEuS-4w,2833
@@ -65,15 +65,17 @@ deltacat/compute/compactor_v2/model/hash_bucket_result.py,sha256=EsY9BPPywhmxlcL
 deltacat/compute/compactor_v2/model/merge_file_group.py,sha256=1o86t9lc3K6ZvtViVO1SVljCj6f0B3MfB3hqtGm2S0s,7410
 deltacat/compute/compactor_v2/model/merge_input.py,sha256=-SxTE0e67z2V7MiMEVz5aMu4E0k8h3-vqohvUUOC0do,5659
 deltacat/compute/compactor_v2/model/merge_result.py,sha256=_IZTCStpb4UKiRCJYA3g6EhAqjrw0t9vmoDAN8kIK-Y,436
+deltacat/compute/compactor_v2/private/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deltacat/compute/compactor_v2/private/compaction_utils.py,sha256=B1i9y74gAhAQCu2vpjuN2muH425GHffnc2BhK-l6wQk,30061
 deltacat/compute/compactor_v2/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor_v2/steps/hash_bucket.py,sha256=1R5xLUkl7GqL1nY-apAgY1czKDEHjIVYSRi9qLOMass,6726
-deltacat/compute/compactor_v2/steps/merge.py,sha256=ukCn312igxq7jNiCn7a2Vzk309LKdYZ902HTcEZhjM4,21774
+deltacat/compute/compactor_v2/steps/merge.py,sha256=LpktsDPfj7Of6RgUw9w1f3Y3OBkPDjvtyXjzFaIDoSo,21771
 deltacat/compute/compactor_v2/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor_v2/utils/content_type_params.py,sha256=rNKZisxGrLQOkwX8eHUQiFoTR1V-E66pMqWigtrs618,2156
 deltacat/compute/compactor_v2/utils/dedupe.py,sha256=62tFCY2iRP7I3-45GCIYs6_SJsQl8C5lBEr8gbNfbsw,1932
-deltacat/compute/compactor_v2/utils/delta.py,sha256=8hjkDeIIkSX-gAQ2utQSp2sZcO2tWZHMTxpFusZwBHw,3635
-deltacat/compute/compactor_v2/utils/io.py,sha256=autXlE3uHICdCCuJoS7mfdeJbRRiz2_xlz-3izlccB4,5264
-deltacat/compute/compactor_v2/utils/merge.py,sha256=7UHxm71iJ1dgRoz8v73CqoeylNzO36t90OJsVVBDFxk,5312
+deltacat/compute/compactor_v2/utils/delta.py,sha256=I7Yvda8NVbpKXG3nM2Ku1utvR2r2OpHvUMqUL2ja3aw,3626
+deltacat/compute/compactor_v2/utils/io.py,sha256=5zwJEW_UHv9ttQ2exJ23ZnExwBQXn1KgN7FDx1MGYv0,5262
+deltacat/compute/compactor_v2/utils/merge.py,sha256=EV_iKhNc3WflgfLW1Q46dXUvyClx8VebWHGtninEfsI,5311
 deltacat/compute/compactor_v2/utils/primary_key_index.py,sha256=ghyIifjXtqXgi8lN3lfnVQ2vi8uk_ny0FE7hsQlLjRQ,11538
 deltacat/compute/compactor_v2/utils/task_options.py,sha256=VXvoVVUq5re8NiOoyrfz34qSRiOTB0IkxHJlMqKsBmk,14066
 deltacat/compute/merge_on_read/__init__.py,sha256=ckbgngmqPjYBYz_NySsR1vNTOb_hNpeL1sYkZKvBI9M,214
@@ -143,16 +145,18 @@ deltacat/tests/aws/test_s3u.py,sha256=FsYCH8K8DsDRPOtTp-w1Nu3ATqt4p1mqDo6aVJV-Sb
 deltacat/tests/catalog/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/tests/catalog/test_default_catalog_impl.py,sha256=2l5uwmtLlUJ9yH1LDggtj81fa-pHqbE0-VBt6G4Hyc0,3180
 deltacat/tests/compute/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deltacat/tests/compute/compact_partition_multiple_rounds_test_cases.py,sha256=vyqwuKYOb4FtRwC5r1SJf7kcZNYXoiGb-BUrBgr5_Xw,34852
 deltacat/tests/compute/compact_partition_rebase_test_cases.py,sha256=NfcB1aTq6HeYMFrtooIIoifzLp5U0xFTN6F7Lpk8cYQ,3143
 deltacat/tests/compute/compact_partition_rebase_then_incremental_test_cases.py,sha256=Kl5A7hoJ0pVOE-rZna_4XcuIjhuzQbJudvnfNYKHgGo,75436
 deltacat/tests/compute/compact_partition_test_cases.py,sha256=R9eiKvxCLqcoHjAx3iOogdnXZEO9TvLbRf0wA7bcJN4,26170
 deltacat/tests/compute/test_compact_partition_incremental.py,sha256=Z0hyQGhMZjCaOn1Vk4qUbgDiS7HDhtdNeFQyG1PJhqA,14559
+deltacat/tests/compute/test_compact_partition_multiple_rounds.py,sha256=xhKCurTA29Y78_1eksUVJ0W35zNNZYm40rMpMM9ynvM,11853
 deltacat/tests/compute/test_compact_partition_params.py,sha256=Dm5eLyHo8oGMeO3XBbpj1rZqHtPZ1hAB7z2qvzc4Lxk,8497
-deltacat/tests/compute/test_compact_partition_rebase.py,sha256=hKMSQ-BQG6w0O_4TlzESY6pA5Ft5c5WSHLIFvj5hePI,11434
+deltacat/tests/compute/test_compact_partition_rebase.py,sha256=p97zJmEoC2t6R12luSkCKjjBl50l4UGzh-IHdiQdpCs,11445
 deltacat/tests/compute/test_compact_partition_rebase_then_incremental.py,sha256=CHHfNFEJW8S1We7NE1Gg6EaoKEWnaOMRxWrLyirrahc,14643
 deltacat/tests/compute/test_util_common.py,sha256=oTkTuo6wscVN8hmoQASIKP_DJN-M0um_ySCOcXv9AJA,11699
 deltacat/tests/compute/test_util_constant.py,sha256=4o-W3E7r7jhFl1A3OFLLrdKnwcF46zx4lEIDY8ONJ3c,929
-deltacat/tests/compute/test_util_create_table_deltas_repo.py,sha256=oY7ZMrvooDVOkhoAJnfdLGO0ejQAwgkqKrt7UmgiObU,9037
+deltacat/tests/compute/test_util_create_table_deltas_repo.py,sha256=k9lq_3r_kNMzruTSn4JE7yjdBBUT3Lh-l8khSYdYpYs,12945
 deltacat/tests/compute/compactor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/tests/compute/compactor/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/tests/compute/compactor/steps/test_repartition.py,sha256=0uRguPEKeLSYs746Jv8io-HZMWdyXNcOMBu8GO2mA0M,9305
@@ -160,7 +164,7 @@ deltacat/tests/compute/compactor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JC
 deltacat/tests/compute/compactor/utils/test_io.py,sha256=st5mlU4cVU-eQl7B4mvPgNA3izuNwbVawYOp-NcoyrI,4326
 deltacat/tests/compute/compactor/utils/test_round_completion_file.py,sha256=LAQ4usiRF4oTx4cA85L0eOcBa_Z-febc-CuzUijSGrI,7439
 deltacat/tests/compute/compactor_v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/tests/compute/compactor_v2/test_compaction_session.py,sha256=2wIXQW0Jm_FtWB5EviUR6Uk2ddVCJKs-CYGKE1xSPu4,9617
+deltacat/tests/compute/compactor_v2/test_compaction_session.py,sha256=X1B47USzXXGt-b_BL6WyFENOXx2aqp6NLIdL_gCukNw,9641
 deltacat/tests/compute/compactor_v2/test_hashlib.py,sha256=8csF2hFWtBvY2MbX3-6iphCsVXxRp0zP1NTnKhfdmkg,328
 deltacat/tests/compute/compactor_v2/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/tests/compute/compactor_v2/utils/test_task_options.py,sha256=4fc5MJTLm3hFlFHK_-5MfyfzeZtOo8D2kBqDE2b8lh4,862
@@ -171,7 +175,7 @@ deltacat/tests/io/test_memcached_object_store.py,sha256=g2lOYSCH6JQvTzcrMOVvCabK
 deltacat/tests/io/test_ray_plasma_object_store.py,sha256=-wJZP6lRtEOogR25wjEiIBGz_lpvWVihwlZ5GqandZU,1911
 deltacat/tests/io/test_redis_object_store.py,sha256=sZrXrYjkw8u_XrvFilhBbLc8PPnZiuMKa1_Bt9ka5qs,3838
 deltacat/tests/io/test_s3_object_store.py,sha256=4b7PYEfQJnYGUz6fcLFWVVyRHTlH_yd8CIaCv9l33Gg,1900
-deltacat/tests/local_deltacat_storage/__init__.py,sha256=jRJH0eqtH43bEJl1G18nDykZSZM_N4jmKPzmcpIkzmE,39839
+deltacat/tests/local_deltacat_storage/__init__.py,sha256=5T9ubNIS42-BotEH0yrUiWEU92feW7lkoSA1-wMeAnQ,40104
 deltacat/tests/local_deltacat_storage/exceptions.py,sha256=oxZ0psmrEO0M6P2r8gHQ2E8E-Y8UBfUCBUIwfuHcx38,251
 deltacat/tests/stats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/tests/stats/test_intervals.py,sha256=S92DgkALQ1WmbLWcxtvS7RlVGvL-XoPJKUUbkdn9_CQ,1955
@@ -216,8 +220,8 @@ deltacat/utils/ray_utils/concurrency.py,sha256=JDVwMiQWrmuSlyCWAoiq9ctoJ0XADEfDD
 deltacat/utils/ray_utils/dataset.py,sha256=waHdtH0c835a-2t51HYRHnulfC0_zBxx8mFSAPvPSPM,3274
 deltacat/utils/ray_utils/performance.py,sha256=d7JFM7vTXHzkGx9qNQcZzUWajnqINvYRwaM088_FpsE,464
 deltacat/utils/ray_utils/runtime.py,sha256=rB0A-tU9WZHz0J11LzJdANYtL397YyuemcA1l-K9dAw,5029
-deltacat-1.1.13.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-deltacat-1.1.13.dist-info/METADATA,sha256=vkq5iB16UJ0Ziot6trDCmsRgfKLoKmU_TC8B33M7qLs,1734
-deltacat-1.1.13.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-deltacat-1.1.13.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
-deltacat-1.1.13.dist-info/RECORD,,
+deltacat-1.1.15.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+deltacat-1.1.15.dist-info/METADATA,sha256=KT4i-8YvQv2xdRV4DsIF7Htj5U-mJEsY68uornP81hg,1734
+deltacat-1.1.15.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+deltacat-1.1.15.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
+deltacat-1.1.15.dist-info/RECORD,,