deltacat 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

deltacat/__init__.py

@@ -44,7 +44,7 @@ from deltacat.types.tables import TableWriteMode
 
 deltacat.logs.configure_deltacat_logger(logging.getLogger(__name__))
 
-__version__ = "0.2.7"
+__version__ = "0.2.9"
 
 
 __all__ = [

deltacat/aws/s3u.py

@@ -383,6 +383,12 @@ def upload_table(
                 # s3fs may swallow S3 errors - we were probably throttled
                 raise RetryableError(f"Retry table upload to: {s3_url}") from e
             raise NonRetryableError(f"Failed table upload to: {s3_url}") from e
+        except BaseException as e:
+            logger.warn(
+                f"Upload has failed for {s3_url} and content_type={content_type}. Error: {e}",
+                exc_info=True,
+            )
+            raise e
     return manifest_entries
 
 

deltacat/compute/compactor/compaction_session.py

@@ -52,7 +52,7 @@ from deltacat.compute.compactor.model.compaction_session_audit_info import (
 )
 from deltacat.compute.compactor.model.compactor_version import CompactorVersion
 from deltacat.compute.compactor.utils.sort_key import validate_sort_keys
-from deltacat.utils.resources import get_current_node_peak_memory_usage_in_bytes
+from deltacat.utils.resources import get_current_process_peak_memory_usage_in_bytes
 
 
 if importlib.util.find_spec("memray"):
@@ -293,7 +293,6 @@ def _execute_compaction_round(
             f"{node_resource_keys}"
         )
 
-    compaction_audit.set_cluster_cpu_max(cluster_cpus)
     # create a remote options provider to round-robin tasks across all nodes or allocated bundles
     logger.info(f"Setting round robin scheduling with node id:{node_resource_keys}")
     round_robin_opt_provider = functools.partial(
@@ -680,7 +679,7 @@ def _execute_compaction_round(
         [m.pyarrow_write_result for m in mat_results]
     )
 
-    session_peak_memory = get_current_node_peak_memory_usage_in_bytes()
+    session_peak_memory = get_current_process_peak_memory_usage_in_bytes()
     compaction_audit.set_peak_memory_used_bytes_by_compaction_session_process(
         session_peak_memory
     )

deltacat/compute/compactor/model/compaction_session_audit_info.py

@@ -98,14 +98,6 @@ class CompactionSessionAuditInfo(dict):
         """
         return self.get("hashBucketCount")
 
-    @property
-    def cluster_cpu_max(self) -> float:
-        """
-        Total cluster cpu allocated for the compaction job. If it is autoscaling cluster,
-        max cpu at any time will be reported.
-        """
-        return self.get("clusterCpuMax")
-
     @property
     def compaction_time_in_seconds(self) -> float:
         """
@@ -423,35 +415,6 @@ class CompactionSessionAuditInfo(dict):
         """
         return self.get("hashBucketProcessedSizeBytes")
 
-    @property
-    def total_cpu_seconds(self) -> float:
-        """
-        Total number of vCPUs provisioned in the cluster weighted over time.
-        """
-        return self.get("totalCPUSeconds")
-
-    @property
-    def used_cpu_seconds(self) -> float:
-        """
-        Total used vCPU in the cluster weighted over time.
-        """
-        return self.get("usedCPUSeconds")
-
-    @property
-    def used_memory_gb_seconds(self) -> float:
-        """
-        The used memory in the cluster weighted over time. This
-        determines opportunities for better memory estimation.
-        """
-        return self.get("usedMemoryGBSeconds")
-
-    @property
-    def total_memory_gb_seconds(self) -> float:
-        """
-        Total memory in the cluster weighted over time in GB.
-        """
-        return self.get("totalMemoryGBSeconds")
-
     @property
     def pyarrow_version(self) -> str:
         """
@@ -510,10 +473,6 @@ class CompactionSessionAuditInfo(dict):
         self["hashBucketCount"] = hash_bucket_count
         return self
 
-    def set_cluster_cpu_max(self, cluster_cpu_max: float) -> CompactionSessionAuditInfo:
-        self["clusterCpuMax"] = cluster_cpu_max
-        return self
-
     def set_compaction_time_in_seconds(
         self, compaction_time_in_seconds: float
     ) -> CompactionSessionAuditInfo:
@@ -778,22 +737,6 @@ class CompactionSessionAuditInfo(dict):
         self["hashBucketProcessedSizeBytes"] = size
         return self
 
-    def set_total_cpu_seconds(self, value: float) -> CompactionSessionAuditInfo:
-        self["totalCPUSeconds"] = value
-        return self
-
-    def set_used_cpu_seconds(self, value: float) -> CompactionSessionAuditInfo:
-        self["usedCPUSeconds"] = value
-        return self
-
-    def set_used_memory_gb_seconds(self, value: float) -> CompactionSessionAuditInfo:
-        self["usedMemoryGBSeconds"] = value
-        return self
-
-    def set_total_memory_gb_seconds(self, value: float) -> CompactionSessionAuditInfo:
-        self["totalMemoryGBSeconds"] = value
-        return self
-
     def set_pyarrow_version(self, value: str) -> CompactionSessionAuditInfo:
         self["pyarrowVersion"] = value
         return self

deltacat/compute/compactor/steps/dedupe.py

@@ -25,7 +25,7 @@ from deltacat.utils.ray_utils.runtime import (
 from deltacat.utils.performance import timed_invocation
 from deltacat.utils.metrics import emit_timer_metrics, MetricsConfig
 from deltacat.io.object_store import IObjectStore
-from deltacat.utils.resources import get_current_node_peak_memory_usage_in_bytes
+from deltacat.utils.resources import get_current_process_peak_memory_usage_in_bytes
 
 if importlib.util.find_spec("memray"):
     import memray
@@ -228,7 +228,7 @@ def _timed_dedupe(
             f"{len(mat_bucket_to_dd_idx_obj_id)}"
         )
 
-        peak_memory_usage_bytes = get_current_node_peak_memory_usage_in_bytes()
+        peak_memory_usage_bytes = get_current_process_peak_memory_usage_in_bytes()
         return DedupeResult(
             mat_bucket_to_dd_idx_obj_id,
             np.int64(total_deduped_records),

deltacat/compute/compactor/steps/hash_bucket.py

@@ -32,7 +32,7 @@ from deltacat.utils.common import ReadKwargsProvider
 from deltacat.utils.performance import timed_invocation
 from deltacat.utils.metrics import emit_timer_metrics, MetricsConfig
 from deltacat.io.object_store import IObjectStore
-from deltacat.utils.resources import get_current_node_peak_memory_usage_in_bytes
+from deltacat.utils.resources import get_current_process_peak_memory_usage_in_bytes
 
 if importlib.util.find_spec("memray"):
     import memray
@@ -228,7 +228,7 @@ def _timed_hash_bucket(
             delta_file_envelope_groups, num_buckets, num_groups, object_store
         )
 
-        peak_memory_usage_bytes = get_current_node_peak_memory_usage_in_bytes()
+        peak_memory_usage_bytes = get_current_process_peak_memory_usage_in_bytes()
         return HashBucketResult(
             hash_bucket_group_to_obj_id,
             np.int64(total_record_count),

deltacat/compute/compactor/steps/materialize.py

@@ -44,7 +44,7 @@ from deltacat.utils.ray_utils.runtime import (
     get_current_ray_worker_id,
 )
 from deltacat.utils.metrics import emit_timer_metrics, MetricsConfig
-from deltacat.utils.resources import get_current_node_peak_memory_usage_in_bytes
+from deltacat.utils.resources import get_current_process_peak_memory_usage_in_bytes
 
 if importlib.util.find_spec("memray"):
     import memray
@@ -314,7 +314,7 @@ def materialize(
             emit_metrics_time = latency
         logger.info(f"Materialize task ended in {end - start}s")
 
-        peak_memory_usage_bytes = get_current_node_peak_memory_usage_in_bytes()
+        peak_memory_usage_bytes = get_current_process_peak_memory_usage_in_bytes()
 
         # Merge all new deltas into one for this materialize bucket index
         merged_materialize_result = MaterializeResult.of(

deltacat/compute/compactor_v2/compaction_session.py

@@ -41,13 +41,12 @@ from deltacat.compute.compactor.model.compaction_session_audit_info import (
     CompactionSessionAuditInfo,
 )
 from deltacat.utils.resources import (
-    get_current_node_peak_memory_usage_in_bytes,
+    get_current_process_peak_memory_usage_in_bytes,
 )
 from deltacat.compute.compactor_v2.utils.task_options import (
     hash_bucket_resource_options_provider,
     merge_resource_options_provider,
 )
-from deltacat.utils.resources import ClusterUtilizationOverTimeRange
 from deltacat.compute.compactor.model.compactor_version import CompactorVersion
 
 if importlib.util.find_spec("memray"):
@@ -65,10 +64,9 @@ def compact_partition(params: CompactPartitionParams, **kwargs) -> Optional[str]
 
     with memray.Tracker(
         f"compaction_partition.bin"
-    ) if params.enable_profiler else nullcontext(), ClusterUtilizationOverTimeRange() as cluster_util:
+    ) if params.enable_profiler else nullcontext():
         (new_partition, new_rci, new_rcf_partition_locator,) = _execute_compaction(
             params,
-            cluster_util=cluster_util,
             **kwargs,
         )
 
@@ -469,7 +467,7 @@ def _execute_compaction(
         [m.pyarrow_write_result for m in mat_results]
     )
 
-    session_peak_memory = get_current_node_peak_memory_usage_in_bytes()
+    session_peak_memory = get_current_process_peak_memory_usage_in_bytes()
     compaction_audit.set_peak_memory_used_bytes_by_compaction_session_process(
         session_peak_memory
     )
@@ -478,17 +476,6 @@ def _execute_compaction(
         mat_results, telemetry_time_hb + telemetry_time_merge
     )
 
-    cluster_util: ClusterUtilizationOverTimeRange = kwargs.get("cluster_util")
-
-    if cluster_util:
-        compaction_audit.set_total_cpu_seconds(cluster_util.total_vcpu_seconds)
-        compaction_audit.set_used_cpu_seconds(cluster_util.used_vcpu_seconds)
-        compaction_audit.set_used_memory_gb_seconds(cluster_util.used_memory_gb_seconds)
-        compaction_audit.set_total_memory_gb_seconds(
-            cluster_util.total_memory_gb_seconds
-        )
-        compaction_audit.set_cluster_cpu_max(cluster_util.max_cpu)
-
     input_inflation = None
     input_average_record_size_bytes = None
     # Note: we only consider inflation for incremental delta

deltacat/compute/compactor_v2/steps/hash_bucket.py

@@ -27,7 +27,11 @@ from deltacat.utils.ray_utils.runtime import (
 from deltacat.utils.common import ReadKwargsProvider
 from deltacat.utils.performance import timed_invocation
 from deltacat.utils.metrics import emit_timer_metrics
-from deltacat.utils.resources import get_current_node_peak_memory_usage_in_bytes
+from deltacat.utils.resources import (
+    get_current_process_peak_memory_usage_in_bytes,
+    ProcessUtilizationOverTimeRange,
+)
+from deltacat.constants import BYTES_PER_GIBIBYTE
 
 if importlib.util.find_spec("memray"):
     import memray
@@ -166,7 +170,10 @@ def _timed_hash_bucket(input: HashBucketInput):
             object_store=input.object_store,
         )
 
-        peak_memory_usage_bytes = get_current_node_peak_memory_usage_in_bytes()
+        peak_memory_usage_bytes = get_current_process_peak_memory_usage_in_bytes()
+        logger.info(
+            f"Peak memory usage in bytes after hash bucketing: {peak_memory_usage_bytes}"
+        )
         return HashBucketResult(
             hash_bucket_group_to_obj_id_tuple,
             np.int64(total_size_bytes),
@@ -179,28 +186,38 @@ def _timed_hash_bucket(input: HashBucketInput):
 
 @ray.remote
 def hash_bucket(input: HashBucketInput) -> HashBucketResult:
+    with ProcessUtilizationOverTimeRange() as process_util:
+        logger.info(f"Starting hash bucket task...")
 
-    logger.info(f"Starting hash bucket task...")
-    hash_bucket_result, duration = timed_invocation(
-        func=_timed_hash_bucket, input=input
-    )
+        # Log node peak memory utilization every 10 seconds
+        def log_peak_memory():
+            logger.debug(
+                f"Process peak memory utilization so far: {process_util.max_memory} bytes "
+                f"({process_util.max_memory/BYTES_PER_GIBIBYTE} GB)"
+            )
+
+        process_util.schedule_callback(log_peak_memory, 10)
 
-    emit_metrics_time = 0.0
-    if input.metrics_config:
-        emit_result, latency = timed_invocation(
-            func=emit_timer_metrics,
-            metrics_name="hash_bucket",
-            value=duration,
-            metrics_config=input.metrics_config,
+        hash_bucket_result, duration = timed_invocation(
+            func=_timed_hash_bucket, input=input
+        )
+
+        emit_metrics_time = 0.0
+        if input.metrics_config:
+            emit_result, latency = timed_invocation(
+                func=emit_timer_metrics,
+                metrics_name="hash_bucket",
+                value=duration,
+                metrics_config=input.metrics_config,
+            )
+            emit_metrics_time = latency
+
+        logger.info(f"Finished hash bucket task...")
+        return HashBucketResult(
+            hash_bucket_result[0],
+            hash_bucket_result[1],
+            hash_bucket_result[2],
+            hash_bucket_result[3],
+            np.double(emit_metrics_time),
+            hash_bucket_result[5],
         )
-        emit_metrics_time = latency
-
-    logger.info(f"Finished hash bucket task...")
-    return HashBucketResult(
-        hash_bucket_result[0],
-        hash_bucket_result[1],
-        hash_bucket_result[2],
-        hash_bucket_result[3],
-        np.double(emit_metrics_time),
-        hash_bucket_result[5],
-    )

deltacat/compute/compactor_v2/steps/merge.py

@@ -30,7 +30,10 @@ from deltacat.compute.compactor.utils import system_columns as sc
 
 from deltacat.utils.performance import timed_invocation
 from deltacat.utils.metrics import emit_timer_metrics
-from deltacat.utils.resources import get_current_node_peak_memory_usage_in_bytes
+from deltacat.utils.resources import (
+    get_current_process_peak_memory_usage_in_bytes,
+    ProcessUtilizationOverTimeRange,
+)
 from deltacat.compute.compactor_v2.utils.primary_key_index import (
     generate_pk_hash_column,
     hash_group_index_to_hash_bucket_indices,
@@ -44,6 +47,7 @@ from deltacat.storage import (
     interface as unimplemented_deltacat_storage,
 )
 from deltacat.compute.compactor_v2.utils.dedupe import drop_duplicates
+from deltacat.constants import BYTES_PER_GIBIBYTE
 
 
 if importlib.util.find_spec("memray"):
@@ -436,7 +440,10 @@ def _timed_merge(input: MergeInput) -> MergeResult:
             f"{total_dfes_found} != {len(hb_index_to_delta_file_envelopes_list)}"
         )
 
-        peak_memory_usage_bytes = get_current_node_peak_memory_usage_in_bytes()
+        peak_memory_usage_bytes = get_current_process_peak_memory_usage_in_bytes()
+        logger.info(
+            f"Peak memory usage in bytes after merge: {peak_memory_usage_bytes}"
+        )
 
         return MergeResult(
             materialized_results,
@@ -449,25 +456,35 @@ def _timed_merge(input: MergeInput) -> MergeResult:
 
 @ray.remote
 def merge(input: MergeInput) -> MergeResult:
+    with ProcessUtilizationOverTimeRange() as process_util:
+        logger.info(f"Starting merge task...")
+
+        # Log node peak memory utilization every 10 seconds
+        def log_peak_memory():
+            logger.debug(
+                f"Process peak memory utilization so far: {process_util.max_memory} bytes "
+                f"({process_util.max_memory/BYTES_PER_GIBIBYTE} GB)"
+            )
+
+        process_util.schedule_callback(log_peak_memory, 10)
 
-    logger.info(f"Starting merge task...")
-    merge_result, duration = timed_invocation(func=_timed_merge, input=input)
+        merge_result, duration = timed_invocation(func=_timed_merge, input=input)
 
-    emit_metrics_time = 0.0
-    if input.metrics_config:
-        emit_result, latency = timed_invocation(
-            func=emit_timer_metrics,
-            metrics_name="merge",
-            value=duration,
-            metrics_config=input.metrics_config,
+        emit_metrics_time = 0.0
+        if input.metrics_config:
+            emit_result, latency = timed_invocation(
+                func=emit_timer_metrics,
+                metrics_name="merge",
+                value=duration,
+                metrics_config=input.metrics_config,
+            )
+            emit_metrics_time = latency
+
+        logger.info(f"Finished merge task...")
+        return MergeResult(
+            merge_result[0],
+            merge_result[1],
+            merge_result[2],
+            np.double(emit_metrics_time),
+            merge_result[4],
         )
-        emit_metrics_time = latency
-
-    logger.info(f"Finished merge task...")
-    return MergeResult(
-        merge_result[0],
-        merge_result[1],
-        merge_result[2],
-        np.double(emit_metrics_time),
-        merge_result[4],
-    )

deltacat/compute/compactor_v2/utils/primary_key_index.py

@@ -17,6 +17,7 @@ from deltacat import logs
 from deltacat.compute.compactor.utils import system_columns as sc
 from deltacat.io.object_store import IObjectStore
 from deltacat.utils.performance import timed_invocation
+from deltacat.utils.pyarrow import sliced_string_cast
 
 logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
 
@@ -182,7 +183,7 @@ def generate_pk_hash_column(
     def _generate_pk_hash(table: pa.Table) -> pa.Array:
         pk_columns = []
         for pk_name in primary_keys:
-            pk_columns.append(pc.cast(table[pk_name], pa.string()))
+            pk_columns.append(sliced_string_cast(table[pk_name]))
 
         pk_columns.append(PK_DELIMITER)
         hash_column = pc.binary_join_element_wise(*pk_columns)

deltacat/tests/compute/test_compact_partition_incremental.py

@@ -6,6 +6,8 @@ import boto3
 from typing import Any, Callable, Dict, List, Optional, Set
 from boto3.resources.base import ServiceResource
 import pyarrow as pa
+from pytest_benchmark.fixture import BenchmarkFixture
+
 from deltacat.tests.compute.test_util_common import (
     get_rcf,
 )
@@ -161,6 +163,7 @@ def test_compact_partition_incremental(
     read_kwargs_provider_param: Any,
     skip_enabled_compact_partition_drivers,
     compact_partition_func: Callable,
+    benchmark: BenchmarkFixture,
 ):
     import deltacat.tests.local_deltacat_storage as ds
     from deltacat.types.media import ContentType
@@ -235,8 +238,22 @@ def test_compact_partition_incremental(
             "sort_keys": sort_keys if sort_keys else None,
         }
     )
+
     # execute
-    rcf_file_s3_uri = compact_partition_func(compact_partition_params)
+    def _incremental_compaction_setup():
+        """
+        This callable runs right before invoking the benchmark target function (compaction).
+        This is needed as the benchmark module will invoke the target function multiple times
+        in a single test run, which can lead to non-idempotent behavior if RCFs are generated.
+
+        Returns: args, kwargs
+        """
+        setup_s3_resource.Bucket(TEST_S3_RCF_BUCKET_NAME).objects.all().delete()
+        return (compact_partition_params,), {}
+
+    rcf_file_s3_uri = benchmark.pedantic(
+        compact_partition_func, setup=_incremental_compaction_setup
+    )
     # validate
     round_completion_info = get_rcf(setup_s3_resource, rcf_file_s3_uri)
     compacted_delta_locator: DeltaLocator = (

deltacat/tests/compute/test_compact_partition_rebase_then_incremental.py

@@ -5,6 +5,8 @@ import pytest
 import boto3
 from boto3.resources.base import ServiceResource
 import pyarrow as pa
+from pytest_benchmark.fixture import BenchmarkFixture
+
 from deltacat.tests.compute.test_util_constant import (
     BASE_TEST_SOURCE_NAMESPACE,
     BASE_TEST_SOURCE_TABLE_NAME,
@@ -182,6 +184,7 @@ def test_compact_partition_rebase_then_incremental(
     rebase_expected_compact_partition_result: pa.Table,
     skip_enabled_compact_partition_drivers,
     compact_partition_func: Callable,
+    benchmark: BenchmarkFixture,
 ):
     import deltacat.tests.local_deltacat_storage as ds
     from deltacat.types.media import ContentType
@@ -265,7 +268,7 @@ def test_compact_partition_rebase_then_incremental(
         }
     )
     # execute
-    rcf_file_s3_uri = compact_partition_func(compact_partition_params)
+    rcf_file_s3_uri = benchmark(compact_partition_func, compact_partition_params)
     compacted_delta_locator: DeltaLocator = get_compacted_delta_locator_from_rcf(
         setup_s3_resource, rcf_file_s3_uri
     )

deltacat/tests/utils/test_resources.py

@@ -49,3 +49,24 @@ class TestClusterUtilizationOverTimeRange(unittest.TestCase):
             self.assertIsNotNone(cu.total_memory_gb_seconds)
             self.assertIsNotNone(cu.used_memory_gb_seconds)
             self.assertIsNotNone(cu.max_cpu)
+
+
+class TestProcessUtilizationOverTimeRange(unittest.TestCase):
+    def test_sanity(self):
+        from deltacat.utils.resources import ProcessUtilizationOverTimeRange
+
+        with ProcessUtilizationOverTimeRange() as nu:
+            time.sleep(3)
+            self.assertIsNotNone(nu.max_memory)
+
+    def test_callback(self):
+        from deltacat.utils.resources import ProcessUtilizationOverTimeRange
+
+        with ProcessUtilizationOverTimeRange() as nu:
+
+            def test_callback():
+                nu.test_field_set = True
+
+            nu.schedule_callback(test_callback, 1)
+            time.sleep(3)
+            self.assertTrue(nu.test_field_set)

deltacat/utils/daft.py

@@ -66,6 +66,8 @@ def daft_s3_file_to_table(
         )
     )
 
+    logger.debug(f"Preparing to read S3 object from {s3_url} into daft table")
+
     pa_table, latency = timed_invocation(
         read_parquet_into_pyarrow,
         path=s3_url,

deltacat/utils/pyarrow.py

@@ -11,6 +11,8 @@ from pyarrow.parquet import ParquetFile
 from deltacat.exceptions import ValidationError
 
 import pyarrow as pa
+import numpy as np
+import pyarrow.compute as pc
 from fsspec import AbstractFileSystem
 from pyarrow import csv as pacsv
 from pyarrow import feather as paf
@@ -38,6 +40,7 @@ from deltacat.utils.arguments import (
     sanitize_kwargs_to_callable,
     sanitize_kwargs_by_supported_kwargs,
 )
+from functools import lru_cache
 
 logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
 
@@ -738,3 +741,69 @@ class RecordBatchTables:
         """
         self._remaining_tables.clear()
         self._remaining_record_count = 0
+
+
+@lru_cache(maxsize=1)
+def _int_max_string_len() -> int:
+    PA_UINT64_MAX_STR_BYTES = pc.binary_length(
+        pc.cast(pa.scalar(2**64 - 1, type=pa.uint64()), pa.string())
+    ).as_py()
+    PA_INT64_MAX_STR_BYTES = pc.binary_length(
+        pc.cast(pa.scalar(-(2**63), type=pa.int64()), pa.string())
+    ).as_py()
+    return max(PA_UINT64_MAX_STR_BYTES, PA_INT64_MAX_STR_BYTES)
+
+
+@lru_cache(maxsize=1)
+def _float_max_string_len() -> int:
+    PA_POS_FLOAT64_MAX_STR_BYTES = pc.binary_length(
+        pc.cast(pa.scalar(np.finfo(np.float64).max, type=pa.float64()), pa.string())
+    ).as_py()
+    PA_NEG_FLOAT64_MAX_STR_BYTES = pc.binary_length(
+        pc.cast(pa.scalar(np.finfo(np.float64).min, type=pa.float64()), pa.string())
+    ).as_py()
+    return max(PA_POS_FLOAT64_MAX_STR_BYTES, PA_NEG_FLOAT64_MAX_STR_BYTES)
+
+
+def _max_decimal128_string_len():
+    return 40  # "-" + 38 digits + decimal
+
+
+def _max_decimal256_string_len():
+    return 78  # "-" + 76 digits + decimal
+
+
+def sliced_string_cast(array: pa.ChunkedArray) -> pa.ChunkedArray:
+    """performs slicing of a pyarrow array prior casting to a string.
+    This prevents a pyarrow from allocating too large of an array causing a failure.
+    Issue: https://github.com/apache/arrow/issues/38835
+    TODO: deprecate this function when pyarrow performs proper ChunkedArray -> ChunkedArray casting
+    """
+    dtype = array.type
+    MAX_BYTES = 2147483646
+    max_str_len = None
+    if pa.types.is_integer(dtype):
+        max_str_len = _int_max_string_len()
+    elif pa.types.is_floating(dtype):
+        max_str_len = _float_max_string_len()
+    elif pa.types.is_decimal128(dtype):
+        max_str_len = _max_decimal128_string_len()
+    elif pa.types.is_decimal256(dtype):
+        max_str_len = _max_decimal256_string_len()
+
+    if max_str_len is not None:
+        max_elems_per_chunk = MAX_BYTES // (2 * max_str_len)  # safety factor of 2
+        all_chunks = []
+        for chunk in array.chunks:
+            if len(chunk) < max_elems_per_chunk:
+                all_chunks.append(chunk)
+            else:
+                curr_pos = 0
+                total_len = len(chunk)
+                while curr_pos < total_len:
+                    sliced = chunk.slice(curr_pos, max_elems_per_chunk)
+                    curr_pos += len(sliced)
+                    all_chunks.append(sliced)
+        array = pa.chunked_array(all_chunks, type=dtype)
+
+    return pc.cast(array, pa.string())

deltacat/utils/resources.py

@@ -77,6 +77,7 @@ class ClusterUtilizationOverTimeRange(AbstractContextManager):
         self.total_memory_gb_seconds = 0.0
         self.used_memory_gb_seconds = 0.0
         self.max_cpu = 0.0
+        self.max_memory = 0.0
 
     def __enter__(self) -> Any:
         schedule.every().second.do(self._update_resources)
@@ -131,6 +132,11 @@ class ClusterUtilizationOverTimeRange(AbstractContextManager):
             + float(str(cluster_resources["memory"])) / BYTES_PER_GIBIBYTE
         )
 
+        self.max_memory = max(
+            self.max_memory,
+            float(str(cluster_resources["memory"] - available_resources["memory"])),
+        )
+
     def _run_schedule(self, interval: Optional[float] = 1.0):
         cease_continuous_run = threading.Event()
 
@@ -146,9 +152,9 @@ class ClusterUtilizationOverTimeRange(AbstractContextManager):
         return cease_continuous_run
 
 
-def get_current_node_peak_memory_usage_in_bytes():
+def get_current_process_peak_memory_usage_in_bytes():
     """
-    Returns the peak memory usage of the node in bytes. This method works across
+    Returns the peak memory usage of the process in bytes. This method works across
     Windows, Darwin and Linux platforms.
     """
     current_platform = platform.system()
@@ -172,3 +178,53 @@ def get_size_of_object_in_bytes(obj: object) -> float:
     if isinstance(obj, (list, tuple, set, frozenset)):
         return size + sum(map(get_size_of_object_in_bytes, obj))
     return size
+
+
+class ProcessUtilizationOverTimeRange(AbstractContextManager):
+    """
+    This class can be used to compute the process utilization metrics
+    which requires us to compute it over time as memory utilization changes.
+    """
+
+    def __init__(self) -> None:
+        self.max_memory = 0.0
+
+    def __enter__(self) -> Any:
+        schedule.every().second.do(self._update_resources)
+        self.stop_run_schedules = self._run_schedule()
+        return super().__enter__()
+
+    def __exit__(
+        self,
+        __exc_type: type[BaseException] | None,
+        __exc_value: BaseException | None,
+        __traceback: TracebackType | None,
+    ) -> bool | None:
+        if __exc_value:
+            logger.error(
+                f"Error ocurred while calculating process resources: {__exc_value}"
+            )
+        self.stop_run_schedules.set()
+        return super().__exit__(__exc_type, __exc_value, __traceback)
+
+    def schedule_callback(self, callback, callback_frequency_in_seconds) -> None:
+        schedule.every(callback_frequency_in_seconds).seconds.do(callback)
+
+    # It is not truely parallel(due to GIL Ref: https://wiki.python.org/moin/GlobalInterpreterLock)
+    # even if we are using threading library. However, it averages out and gives a very good approximation.
+    def _update_resources(self):
+        self.max_memory = get_current_process_peak_memory_usage_in_bytes()
+
+    def _run_schedule(self, interval: Optional[float] = 1.0):
+        cease_continuous_run = threading.Event()
+
+        class ScheduleThread(threading.Thread):
+            @classmethod
+            def run(cls):
+                while not cease_continuous_run.is_set():
+                    schedule.run_pending()
+                    time.sleep(float(str(interval)))
+
+        continuous_thread = ScheduleThread()
+        continuous_thread.start()
+        return cease_continuous_run

{deltacat-0.2.7.dist-info → deltacat-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltacat
-Version: 0.2.7
+Version: 0.2.9
 Summary: A scalable, fast, ACID-compliant Data Catalog powered by Ray.
 Home-page: https://github.com/ray-project/deltacat
 Author: Ray Team
@@ -27,7 +27,7 @@ Requires-Dist: tenacity ==8.1.0
 Requires-Dist: typing-extensions ==4.4.0
 Requires-Dist: pymemcache ==4.0.0
 Requires-Dist: redis ==4.6.0
-Requires-Dist: getdaft ==0.1.17
+Requires-Dist: getdaft ==0.2.4
 Requires-Dist: schedule ==1.2.0
 
 # DeltaCAT

{deltacat-0.2.7.dist-info → deltacat-0.2.9.dist-info}/RECORD

@@ -1,11 +1,11 @@
-deltacat/__init__.py,sha256=T4RqUqNoz87AZZa7tZreJh3AE6mTxFmJjLYFPubO8so,1777
+deltacat/__init__.py,sha256=9x12tKzGJVcmgVKVWjPCgZHxla7VH_PQf3HUvflyJZc,1777
 deltacat/constants.py,sha256=_6oRI-3yp5c8J1qKGQZrt89I9-ttT_gSSvVsJ0h8Duc,1939
 deltacat/exceptions.py,sha256=xqZf8CwysNYP2d39pf27OnXGStPREgBgIM-e2Tts-TI,199
 deltacat/logs.py,sha256=9XWuTBoWhhAF9rAL6t9veXmnAlJHsaqk0lTxteVPqyQ,5674
 deltacat/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/aws/clients.py,sha256=wWiqXyZPWXezdEbhQ7DLwEVnYV6KiitqzBc5B4UAwc0,6184
 deltacat/aws/constants.py,sha256=luXWMO_8eatq8f9NlFjNM7q362j77JwzTM2BEVS_8-8,353
-deltacat/aws/s3u.py,sha256=mdJrX9z5O8kh00jUL0w8CYBxKAemVYs26sRDzwSonfg,18390
+deltacat/aws/s3u.py,sha256=s2On5X3IQiCsCMKw4lpfV1GfKQVWOXNsdAmIJK5PEM0,18610
 deltacat/aws/redshift/__init__.py,sha256=fjuv3jWdPE8IgF4uSrL0YEqV3XUfqDULX3xV27ICceo,266
 deltacat/aws/redshift/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/aws/redshift/model/manifest.py,sha256=N1RRGi1Rbou_9HQieoRCI_wE7eAf5eU_FTZ7dNPvUyY,9682
@@ -20,11 +20,11 @@ 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=JpKBLuDqtDQtC1OgvEF9S-xeIXtRJiIh3f3dOrtHOC0,27661
+deltacat/compute/compactor/compaction_session.py,sha256=bJpNBSTW7Raoa1gpojDpmVVqQGpvX0AwrusHQhUANcI,27612
 deltacat/compute/compactor/repartition_session.py,sha256=f5BTTGNv365qSuTioL7QUuVm-px_l8-zz-OC_p7gXt4,7240
 deltacat/compute/compactor/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor/model/compact_partition_params.py,sha256=DWge5I72zKBg_dodn4ekEOAnoHWs1jo21QuVmQi8I0M,14343
-deltacat/compute/compactor/model/compaction_session_audit_info.py,sha256=WzpWrRTIYFYSc2bKYceKbLD3PqQVFPUGFPz8xnkxl4A,32013
+deltacat/compute/compactor/model/compaction_session_audit_info.py,sha256=o8O0v3nOc7m1ZR4W0wQkTdsMyFL24LoMc9kzUo8i5uc,30174
 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
@@ -37,9 +37,9 @@ deltacat/compute/compactor/model/pyarrow_write_result.py,sha256=WYIa0DRcyaemR6yU
 deltacat/compute/compactor/model/repartition_result.py,sha256=HZy7Ls6toI4rXgVW2yIKMIkVS8o9kxvlIJPvo5_pCxA,140
 deltacat/compute/compactor/model/round_completion_info.py,sha256=CDlafUX6MSbdBK_zQyzEwD0mYwu-Xs2rtU0-DsEwroM,4940
 deltacat/compute/compactor/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor/steps/dedupe.py,sha256=PzWnOmD_PWUvzqKwd8S5b1O5t-xxU1U3m8H41v2JfXU,10184
-deltacat/compute/compactor/steps/hash_bucket.py,sha256=7y6uliSc8DhIfoYJ-Ex1tG1fsbb29D7cAzM2O-prZuI,10649
-deltacat/compute/compactor/steps/materialize.py,sha256=GY-N6c4EOVr2Y-HTM0YDWpilJ-1PGq1Nj7Lsgp3Hco8,14240
+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/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
 deltacat/compute/compactor/utils/io.py,sha256=oZmjU0hp5GbCbLF7PZXEc4lgLeeicyjUPE08GffByT4,17300
@@ -48,7 +48,7 @@ deltacat/compute/compactor/utils/round_completion_file.py,sha256=DmZfHeAXlQn0DDd
 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=nuHfagKs2_DULQU6LVEmrW3AB5rfB3DZsA3zRPAeL6Y,21104
+deltacat/compute/compactor_v2/compaction_session.py,sha256=YnKG2LlrgYYsVKt_6txcXzCgolaQWF4SuQz0eZmChZM,20422
 deltacat/compute/compactor_v2/constants.py,sha256=yZgzFD59wiXbXiTVgYPWRodZGpngiSBNFB2jmoZ4fps,1471
 deltacat/compute/compactor_v2/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor_v2/model/hash_bucket_input.py,sha256=pgE2o8Z9-Dvs75C15LAkmfuJFFi5pRIuuxA9GGyDlLM,2631
@@ -56,13 +56,13 @@ deltacat/compute/compactor_v2/model/hash_bucket_result.py,sha256=EsY9BPPywhmxlcL
 deltacat/compute/compactor_v2/model/merge_input.py,sha256=A-_Oq54sx1vrT-Ewv2_yKARdIh928yJvEuheCkw5tvQ,5049
 deltacat/compute/compactor_v2/model/merge_result.py,sha256=L53i9iL_XpzqBr7HETixD5v5qfLvitkGcjoML_hHfcs,368
 deltacat/compute/compactor_v2/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor_v2/steps/hash_bucket.py,sha256=NR-IDva6iB2YeNgxim_WsuZfEk5ooV8jAwzDJjdrsDE,7375
-deltacat/compute/compactor_v2/steps/merge.py,sha256=pEbVWBa2FpYqZntYFogKiVo3K2SVh0gYWPIS_NoJKrA,17383
+deltacat/compute/compactor_v2/steps/hash_bucket.py,sha256=wFu4vAS8PR0_SxxLIfGPmtLjUV9hCfPeHG56CFpoLIM,8100
+deltacat/compute/compactor_v2/steps/merge.py,sha256=QI8ovaO6yPw_VgDYqTzQOxw2oov4ipuW2gR-w01FWGY,18087
 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/io.py,sha256=jgIfwrfH2mTFUx1M0TgwZGGfrS4IXjP1PmqwaQmNAJM,5092
-deltacat/compute/compactor_v2/utils/primary_key_index.py,sha256=MbM5UK0k_kGmtdETf3TWTwEq8864Y5Asr9Nm-Do9fCE,11341
+deltacat/compute/compactor_v2/utils/primary_key_index.py,sha256=MAscmL35WfwN7Is72aFlD_cGhxtZgjRwwR5kS9Yn2uU,11393
 deltacat/compute/compactor_v2/utils/task_options.py,sha256=1-wIIXP0gDUJGdl8omMF5Q9kZs2oeu5WddgCnwBh3RE,8681
 deltacat/compute/metastats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/metastats/meta_stats.py,sha256=78hN3aN5wLHUFJsZXuv2JLeqA35HZ8mLUWJDMslMj5Q,18731
@@ -119,9 +119,9 @@ deltacat/tests/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 deltacat/tests/aws/test_clients.py,sha256=23GMWfz27WWBDXSqphG9mfputsyS7j3I5P_HRk4YoKE,3790
 deltacat/tests/compute/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/tests/compute/compact_partition_test_cases.py,sha256=EyZwh-7qKiMmzJT8E_V74cvle5uONYZyt89jmdAu1TI,47952
-deltacat/tests/compute/test_compact_partition_incremental.py,sha256=SajKOt3l_z0lWDY1iW1hzhijHBCLmB2fehohgnRy4aI,9370
+deltacat/tests/compute/test_compact_partition_incremental.py,sha256=-nIQev0FYWbp76LwM0H4KpMEgP2GMqVRFFJHMsLUN2E,10011
 deltacat/tests/compute/test_compact_partition_params.py,sha256=MIzIcBscwFA1W-cfTTxVx0zcgbrs8D4bI9Hy4TF5eRo,8322
-deltacat/tests/compute/test_compact_partition_rebase_then_incremental.py,sha256=cX_6f6VC-kMc50XcLoE1riKOtupAFb6rGz2WhH2VfCo,13119
+deltacat/tests/compute/test_compact_partition_rebase_then_incremental.py,sha256=-yFmEGqWMTIq9iShFU9rn4cX7ky1Zmm3pv4F9NwsQUo,13218
 deltacat/tests/compute/test_util_common.py,sha256=Skz0ZfHzidArZhIzRDHOYt-5uGBwx6MRfKZpeBnzh9w,6055
 deltacat/tests/compute/test_util_constant.py,sha256=4o-W3E7r7jhFl1A3OFLLrdKnwcF46zx4lEIDY8ONJ3c,929
 deltacat/tests/compute/test_util_create_table_deltas_repo.py,sha256=5yP285lY539CP1UuyYe8Kz14CnBUpE1kZJZjxBAaXew,6530
@@ -155,7 +155,7 @@ deltacat/tests/utils/test_cloudpickle.py,sha256=J0pnBY3-PxlUh6MamZAN1PuquKQPr2iy
 deltacat/tests/utils/test_daft.py,sha256=iN6rAwGXw5F4xT2UZ72bN276hkKVD7XD4WNp5DKgm2Q,5098
 deltacat/tests/utils/test_pyarrow.py,sha256=eZAuYp9MUf8lmpIilH57JkURuNsTGZ3IAGC4Gm5hdrM,17307
 deltacat/tests/utils/test_record_batch_tables.py,sha256=AkG1WyljQmjnl-AxhbFWyo5LnMIKRyLScfgC2B_ES-s,11321
-deltacat/tests/utils/test_resources.py,sha256=aXjprf7NvBFENdNlam5HvavBrKfj6-fclsoTgJgkQCA,1901
+deltacat/tests/utils/test_resources.py,sha256=HtpvDrfPZQNtGDXUlsIzc_yd7Vf1cDscZ3YbN0oTvO8,2560
 deltacat/tests/utils/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/types/media.py,sha256=RALwafQ0SwMyPUIcENhURk7Sor_2CIfEMztvFUnvZFQ,2227
@@ -165,14 +165,14 @@ deltacat/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/utils/arguments.py,sha256=5y1Xz4HSAD8M8Jt83i6gOEKoYjy_fMQe1V43IhIE4hY,1191
 deltacat/utils/cloudpickle.py,sha256=XE7YDmQe56ksfl3NdYZkzOAhbHSuhNcBZGOehQpgZr0,1187
 deltacat/utils/common.py,sha256=RG_-enXNpLKaYrqyx1ne2lL10lxN9vK7F631oJP6SE8,1375
-deltacat/utils/daft.py,sha256=RKMV8UMD_K1RzwsboH3GRthnj1GXO7oRbFkcfAFKr-I,3254
+deltacat/utils/daft.py,sha256=eZG1AjK21lM7bzEc3_BniDqpqMGDrlp_qj9Du4dxaV0,3334
 deltacat/utils/metrics.py,sha256=Ob-RXGoNnfTMRXaNbSHoqW8y-n8KfRA9nLuo9AvsReI,6201
 deltacat/utils/numpy.py,sha256=ZiGREobTVT6IZXgPxkSUpLJFN2Hn8KEZcrqybLDXCIA,2027
 deltacat/utils/pandas.py,sha256=eGOpiZE1zLznTtuwoN80j4PBp1_bUV8SE4c951r0a3o,9561
 deltacat/utils/performance.py,sha256=7ZLaMkS1ehPSIhT5uOQVBHvjC70iKHzoFquFo-KL0PI,645
 deltacat/utils/placement.py,sha256=S80CwD1eEK47lQNr0xTmF9kq092-z6lTTmOOBv8cW_o,11723
-deltacat/utils/pyarrow.py,sha256=8ohXWFC6XfcvZnWsvlXdjcpYjNrmaqpBMX_2KpT-dn0,26461
-deltacat/utils/resources.py,sha256=nnInssW73rTV_U5rjyG36A5aF3bdBG5pavRhjtbvC8A,6150
+deltacat/utils/pyarrow.py,sha256=gYcoRhQoBoAFo69WNijMobrLGta4VASg8VarWPiB34Y,28979
+deltacat/utils/resources.py,sha256=sS4Rzuoy_kZJ0QuiKnq0M3wTEio1h52IRehi9JRjQDg,8216
 deltacat/utils/s3fs.py,sha256=PmUJ5Fm1WmD-_zp_M6yd9VbXvIoJuBeK6ApOdJJApLE,662
 deltacat/utils/schema.py,sha256=m4Wm4ZQcpttzOUxex4dVneGlHy1_E36HspTcjNYzvVM,1564
 deltacat/utils/ray_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -181,8 +181,8 @@ deltacat/utils/ray_utils/concurrency.py,sha256=JDVwMiQWrmuSlyCWAoiq9ctoJ0XADEfDD
 deltacat/utils/ray_utils/dataset.py,sha256=SIljK3UkSqQ6Ntit_iSiYt9yYjN_gGrCTX6_72XdQ3w,3244
 deltacat/utils/ray_utils/performance.py,sha256=d7JFM7vTXHzkGx9qNQcZzUWajnqINvYRwaM088_FpsE,464
 deltacat/utils/ray_utils/runtime.py,sha256=xOVkqL6o8qGsewGvzhMKxmCcqcFZDnNILuz5IGMgxSc,4991
-deltacat-0.2.7.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-deltacat-0.2.7.dist-info/METADATA,sha256=RBnpgwInaejZ143EcgdHzEu7X1HoBjFXb6eG3OuYQyY,1780
-deltacat-0.2.7.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-deltacat-0.2.7.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
-deltacat-0.2.7.dist-info/RECORD,,
+deltacat-0.2.9.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+deltacat-0.2.9.dist-info/METADATA,sha256=XnXwpmM03bCIv-C-znj2rwE_6FDmI68H6zFL4icWMII,1779
+deltacat-0.2.9.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+deltacat-0.2.9.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
+deltacat-0.2.9.dist-info/RECORD,,

{deltacat-0.2.7.dist-info → deltacat-0.2.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.3)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any