deltacat 0.1.18b1__py3-none-any.whl → 0.1.18b3__py3-none-any.whl

deltacat/tests/test_repartition.py

@@ -0,0 +1,193 @@
+import unittest
+from unittest.mock import MagicMock
+import pyarrow as pa
+from deltacat.compute.compactor.steps.repartition import repartition_range
+from deltacat.types.media import ContentType
+from deltacat.compute.compactor.model.repartition_result import RepartitionResult
+from deltacat.storage import (
+    PartitionLocator,
+)
+
+"""
+Summary of Test Cases:
+0. Given empty ranges, error should be raised
+1. Given one value in ranges, e.g., [1678665487112747], Two range deltas should be produced
+2. Given two values in ranges, e.g., [1678665487112747, 1678665487112999], three range deltas should be produced
+3. No enough records exist for all ranges, i.e., some range will have empty file, such that number of returned range deltas should be less
+4. column doens't exist in any table, error should be raised
+5. column exists in some table, but not all, error should be raised
+6. Given ranges is unsorted , e.g., [1678665487112747, 1678665487112745, 1678665487112748]
+7. Given ranges may have same values, e.g., [1678665487112747, 1678665487112747]
+8. Ranges with pre-dfined inf, e.g., [1678665487112747, inf]
+"""
+
+
+class TestRepartitionRange(unittest.TestCase):
+    def setUp(self):
+        self.tables = [
+            pa.table(
+                {
+                    "last_updated": [
+                        1678665487112745,
+                        1678665487112746,
+                        1678665487112747,
+                        1678665487112748,
+                    ]
+                }
+            ),
+            pa.table(
+                {
+                    "last_updated": [
+                        1678665487112748,
+                        1678665487112749,
+                        1678665487112750,
+                        1678665487112751,
+                    ]
+                }
+            ),
+        ]
+        self.destination_partition: PartitionLocator = MagicMock()
+        self.repartition_args = {"column": "last_updated", "ranges": [1678665487112747]}
+        self.max_records_per_output_file = 2
+        self.repartitioned_file_content_type = ContentType.PARQUET
+        self.deltacat_storage = MagicMock()
+
+    def test_repartition_range(self):
+        result = repartition_range(
+            self.tables,
+            self.destination_partition,
+            self.repartition_args,
+            self.max_records_per_output_file,
+            self.repartitioned_file_content_type,
+            self.deltacat_storage,
+        )
+        # Assert that a RepartitionResult object is returned
+        self.assertIsInstance(result, RepartitionResult)
+
+        # Assert that the correct number of range_deltas was produced
+        self.assertEqual(
+            len(result.range_deltas), len(self.repartition_args["ranges"]) + 1
+        )
+
+        # Assert that the function called the deltacat_storage.stage_delta method the correct number of times
+        self.assertEqual(
+            self.deltacat_storage.stage_delta.call_count,
+            len(self.repartition_args["ranges"]) + 1,
+        )
+
+    def test_repartition_range_nonexistent_column(self):
+        self.repartition_args["column"] = "nonexistent_column"
+        with self.assertRaises(ValueError):
+            repartition_range(
+                self.tables,
+                self.destination_partition,
+                self.repartition_args,
+                self.max_records_per_output_file,
+                self.repartitioned_file_content_type,
+                self.deltacat_storage,
+            )
+
+    def test_empty_ranges(self):
+        self.repartition_args["ranges"] = []
+        with self.assertRaises(ValueError):
+            repartition_range(
+                self.tables,
+                self.destination_partition,
+                self.repartition_args,
+                self.max_records_per_output_file,
+                self.repartitioned_file_content_type,
+                self.deltacat_storage,
+            )
+
+    def test_one_value_in_ranges(self):
+        self.repartition_args["ranges"] = [1678665487112747]
+        result = repartition_range(
+            self.tables,
+            self.destination_partition,
+            self.repartition_args,
+            self.max_records_per_output_file,
+            self.repartitioned_file_content_type,
+            self.deltacat_storage,
+        )
+        self.assertEqual(len(result.range_deltas), 2)
+
+    def test_two_values_in_ranges(self):
+        self.repartition_args["ranges"] = [1678665487112747, 1678665487112749]
+        result = repartition_range(
+            self.tables,
+            self.destination_partition,
+            self.repartition_args,
+            self.max_records_per_output_file,
+            self.repartitioned_file_content_type,
+            self.deltacat_storage,
+        )
+        self.assertEqual(len(result.range_deltas), 3)
+
+    def test_not_enough_records_for_all_ranges(self):
+        reduced_tables = [self.tables[0]]  # use only the first table
+        self.repartition_args["ranges"] = [1678665487112749, 1678665487112999]
+        result = repartition_range(
+            reduced_tables,
+            self.destination_partition,
+            self.repartition_args,
+            self.max_records_per_output_file,
+            self.repartitioned_file_content_type,
+            self.deltacat_storage,
+        )
+        self.assertLess(len(result.range_deltas), 2)
+
+    def test_column_does_not_exist_in_all_tables(self):
+        self.tables.append(pa.table({"other_column": [1, 2, 3]}))
+        with self.assertRaises(ValueError):
+            repartition_range(
+                self.tables,
+                self.destination_partition,
+                self.repartition_args,
+                self.max_records_per_output_file,
+                self.repartitioned_file_content_type,
+                self.deltacat_storage,
+            )
+
+    def test_unsorted_ranges(self):
+        self.repartition_args["ranges"] = [
+            1678665487112747,
+            1678665487112745,
+            1678665487112748,
+        ]
+        result = repartition_range(
+            self.tables,
+            self.destination_partition,
+            self.repartition_args,
+            self.max_records_per_output_file,
+            self.repartitioned_file_content_type,
+            self.deltacat_storage,
+        )
+        self.assertEqual(len(result.range_deltas), 4)
+
+    def test_same_values_in_ranges(self):
+        self.repartition_args["ranges"] = [1678665487112747, 1678665487112747]
+        result = repartition_range(
+            self.tables,
+            self.destination_partition,
+            self.repartition_args,
+            self.max_records_per_output_file,
+            self.repartitioned_file_content_type,
+            self.deltacat_storage,
+        )
+        self.assertEqual(len(result.range_deltas), 2)
+
+    def test_ranges_with_inf(self):
+        self.repartition_args["ranges"] = [1678665487112747, float("inf")]
+        result = repartition_range(
+            self.tables,
+            self.destination_partition,
+            self.repartition_args,
+            self.max_records_per_output_file,
+            self.repartitioned_file_content_type,
+            self.deltacat_storage,
+        )
+        self.assertEqual(len(result.range_deltas), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

deltacat/tests/test_utils/constants.py

@@ -0,0 +1,7 @@
+import json
+from deltacat.storage import Delta
+
+test_delta_file = open("deltacat/tests/test_utils/resources/test_delta.json")
+test_delta_dict = json.load(test_delta_file)
+
+TEST_DELTA = Delta(test_delta_dict)

deltacat/tests/utils/test_resources.py

@@ -0,0 +1,36 @@
+import unittest
+from unittest import mock
+
+
+class TestGetCurrentClusterUtilization(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.ray_mock = mock.MagicMock()
+        cls.ray_mock.cluster_resources.return_value = {
+            "CPU": 10,
+            "memory": 10,
+            "object_store_memory": 5,
+        }
+        cls.ray_mock.available_resources.return_value = {
+            "CPU": 6,
+            "memory": 4,
+            "object_store_memory": 5,
+        }
+
+        cls.module_patcher = mock.patch.dict("sys.modules", {"ray": cls.ray_mock})
+        cls.module_patcher.start()
+
+        super().setUpClass()
+
+    def test_sanity(self):
+        from deltacat.utils.resources import ClusterUtilization
+
+        result = ClusterUtilization.get_current_cluster_utilization()
+
+        self.assertEqual(10, result.total_cpu)
+        self.assertEqual(4, result.used_cpu)
+        self.assertEqual(10, result.total_memory_bytes)
+        self.assertEqual(5, result.total_object_store_memory_bytes)
+        self.assertEqual(0, result.used_object_store_memory_bytes)
+        self.assertEqual(6, result.used_memory_bytes)
+        self.assertIsNotNone(result.used_resources)

deltacat/utils/ray_utils/concurrency.py

@@ -7,6 +7,7 @@ from ray._private.ray_constants import MIN_RESOURCE_GRANULARITY
 from ray.types import ObjectRef
 
 from deltacat.utils.ray_utils.runtime import current_node_resource_key
+from deltacat.utils.resources import log_current_cluster_utilization
 
 
 def invoke_parallel(
@@ -46,6 +47,7 @@ def invoke_parallel(
     Returns:
         List of Ray object references returned from the submitted tasks.
     """
+    log_current_cluster_utilization(log_identifier=ray_task.__name__)
     if max_parallelism is not None and max_parallelism <= 0:
         raise ValueError(f"Max parallelism ({max_parallelism}) must be > 0.")
     pending_ids = []

deltacat/utils/resources.py

@@ -0,0 +1,72 @@
+# Allow classes to use self-referencing Type hints in Python 3.7.
+from __future__ import annotations
+
+import ray
+from typing import Dict, Any
+from dataclasses import dataclass
+from deltacat import logs
+import logging
+from deltacat.utils.performance import timed_invocation
+
+logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
+
+
+@dataclass
+class ClusterUtilization:
+    def __init__(
+        self, cluster_resources: Dict[str, Any], available_resources: Dict[str, Any]
+    ):
+        used_resources = {}
+
+        for key in cluster_resources:
+            if (
+                isinstance(cluster_resources[key], float)
+                or isinstance(cluster_resources[key], int)
+            ) and key in available_resources:
+                used_resources[key] = cluster_resources[key] - available_resources[key]
+
+        self.total_memory_bytes = cluster_resources.get("memory")
+        self.used_memory_bytes = used_resources.get("memory")
+        self.total_cpu = cluster_resources.get("CPU")
+        self.used_cpu = used_resources.get("CPU")
+        self.total_object_store_memory_bytes = cluster_resources.get(
+            "object_store_memory"
+        )
+        self.used_object_store_memory_bytes = used_resources.get("object_store_memory")
+        self.used_memory_percent = (
+            self.used_memory_bytes / self.total_memory_bytes
+        ) * 100
+        self.used_object_store_memory_percent = (
+            self.used_object_store_memory_bytes / self.total_object_store_memory_bytes
+        ) * 100
+        self.used_cpu_percent = (self.used_cpu / self.total_cpu) * 100
+        self.used_resources = used_resources
+
+    @staticmethod
+    def get_current_cluster_utilization() -> ClusterUtilization:
+        cluster_resources = ray.cluster_resources()
+        available_resources = ray.available_resources()
+
+        return ClusterUtilization(
+            cluster_resources=cluster_resources, available_resources=available_resources
+        )
+
+
+def log_current_cluster_utilization(log_identifier: str):
+    cluster_utilization, latency = timed_invocation(
+        ClusterUtilization.get_current_cluster_utilization
+    )
+    logger.info(f"Retrieved cluster utilization metrics. Took {latency}s")
+
+    logger.info(
+        f"Log ID={log_identifier} | Cluster Object store memory used: {cluster_utilization.used_object_store_memory_bytes} "
+        f"which is {cluster_utilization.used_object_store_memory_percent}%"
+    )
+    logger.info(
+        f"Log ID={log_identifier} | Total Cluster Memory used: {cluster_utilization.used_memory_bytes} which is "
+        f"{cluster_utilization.used_memory_percent}%"
+    )
+    logger.info(
+        f"Log ID={log_identifier} | Total Cluster CPU used: {cluster_utilization.used_cpu} which is "
+        f"{cluster_utilization.used_cpu_percent}%"
+    )

{deltacat-0.1.18b1.dist-info → deltacat-0.1.18b3.dist-info}/METADATA

@@ -1,11 +1,9 @@
 Metadata-Version: 2.1
 Name: deltacat
-Version: 0.1.18b1
+Version: 0.1.18b3
 Summary: A scalable, fast, ACID-compliant Data Catalog powered by Ray.
 Home-page: https://github.com/ray-project/deltacat
 Author: Ray Team
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -15,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: boto3 (~=1.20)
 Requires-Dist: numpy (==1.21.5)
 Requires-Dist: pandas (==1.3.5)
@@ -43,5 +42,3 @@ change-data-capture, data consistency checks, and table repair.
 ```
 pip install deltacat
 ```
-
-

{deltacat-0.1.18b1.dist-info → deltacat-0.1.18b3.dist-info}/RECORD

@@ -1,5 +1,5 @@
-deltacat/__init__.py,sha256=vke9_qc-PT1YaVfsrjeReyBqHGHubuxq-DX3msx9Olw,1814
-deltacat/constants.py,sha256=VjY266lCiUN9KB4_1FAUyyZFj5s0ogm1JEN4lXvwgEY,1904
+deltacat/__init__.py,sha256=pO2phs6VUPzLj5RhW3ZxBJ0X7DU-Zu2UGOsa4waCmHk,1810
+deltacat/constants.py,sha256=oMU8ypqvDBTG54-6MLGWrt9iJKTN-HKsSWxEWnWp77c,1969
 deltacat/exceptions.py,sha256=x7qem7FLujXf-DzPsNcQ-XYkW3cF3A0YGIbxkcpz0Mw,146
 deltacat/logs.py,sha256=yyve_6Y4bLWAdCOnxFOPrSR9FRXwZuh68_rRoPpmg08,5633
 deltacat/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -17,29 +17,32 @@ 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=kmWC-Qnw861k7mPhLH4fQEL6CaMeBql2AipHeFqJ2uI,1127
-deltacat/compute/compactor/compaction_session.py,sha256=1Y-PBSBnYGpCgLLFIAhwG-lz076JiygZGfpmrpRTtME,19930
+deltacat/compute/compactor/compaction_session.py,sha256=m0i9Jt7FFuqC1UZr-fYqWsQ_rExHa55Mac7VSgLqwlY,21233
+deltacat/compute/compactor/repartition_session.py,sha256=7e-5exas25725aNh326wK8m9qDmzlcchS7GT6fh0a2o,6776
 deltacat/compute/compactor/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor/model/dedupe_result.py,sha256=gc3E8aS39LKylb_USJeittCfwKZBT4lHctxAal33vN0,179
-deltacat/compute/compactor/model/delta_annotated.py,sha256=PCNKP0UCcVLjfyQd5oi8_jh3kO7dj7Y0lhU-MVwLSG8,8346
+deltacat/compute/compactor/model/delta_annotated.py,sha256=0nlfu3CwMadBd2ENBvlmsCEuOb-CNrzjx-kzA6cjsHo,8353
 deltacat/compute/compactor/model/delta_file_envelope.py,sha256=wjJIjrbM2dhTh3YLFi7pICHtkWRYI40eduwxsKicNIg,2291
 deltacat/compute/compactor/model/delta_file_locator.py,sha256=Cc-YzxxyrXK6FlY8ek2L92XzfT0qkMCxs6yrC_FsEwU,1766
 deltacat/compute/compactor/model/hash_bucket_result.py,sha256=-IBtuwYWArDgJivZbc0ih2ZOEpgq7BqX-lPCiIJkRsI,162
-deltacat/compute/compactor/model/materialize_result.py,sha256=b1Pwa89fgvr7rX3uSWwIt2ld-ElmqOSu-BXkZ1wwXdA,1253
+deltacat/compute/compactor/model/materialize_result.py,sha256=2IlDD-kDrvhfOZE4JvCuCOgI5hmI2MdZglssWP2WJRM,1738
 deltacat/compute/compactor/model/primary_key_index.py,sha256=MT4zqwhzh3e9qZotWvZavT_MtWXm_81ojfcOCv1t17w,10459
 deltacat/compute/compactor/model/pyarrow_write_result.py,sha256=WYIa0DRcyaemR6yUS8_8RLQ2voTmCVNFUL99qxPmt70,1324
-deltacat/compute/compactor/model/round_completion_info.py,sha256=hLiVXmYgAz3pNli4mD6tohTt0JlLtyc3vEbDgnlxhNI,3074
+deltacat/compute/compactor/model/repartition_result.py,sha256=HZy7Ls6toI4rXgVW2yIKMIkVS8o9kxvlIJPvo5_pCxA,140
+deltacat/compute/compactor/model/round_completion_info.py,sha256=2iayH0TGi-5ffo4tu4MuskwZlhG2a8VMnT015_3taB4,3413
 deltacat/compute/compactor/model/sort_key.py,sha256=XDIoYrV18FciomV5yWxu1OaDsD78trmUUtseyRurIKo,4124
 deltacat/compute/compactor/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor/steps/dedupe.py,sha256=Bu-Yf5YQ3QJxNuzujjQ_PjO1Z0i0JwiYFNL-BU5GzBs,9592
 deltacat/compute/compactor/steps/hash_bucket.py,sha256=2aOdC91zTL50BiA94BZdpaROpdsf8AB0ziGXMlRaCm8,8781
-deltacat/compute/compactor/steps/materialize.py,sha256=pKA9KjEmIAHI_ncInlWF_2hoZqebypCn15HHsfzYYmg,10209
+deltacat/compute/compactor/steps/materialize.py,sha256=_Hpq6QmsTeI11iZOlNxKfbbC5f72ecGf9bdaF3WHBoM,13522
+deltacat/compute/compactor/steps/repartition.py,sha256=lpvxhiTC27MKqUXPN70H5L-FcLA1-yCCElERQq74Zig,9487
 deltacat/compute/compactor/steps/rehash/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor/steps/rehash/rehash_bucket.py,sha256=yh-sBuUI3hqw2vk_nK9o-KDrgSww4oSvAz2hBxTkv8s,1765
 deltacat/compute/compactor/steps/rehash/rewrite_index.py,sha256=-HVM08pk5ROHEgDP-FVty55-a_0dsGRiSnPlNJw7C6Q,1838
 deltacat/compute/compactor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor/utils/io.py,sha256=agAH2rILzOhfQpt5nWewZRkhrI-_UvqKS20Ptvx9vlA,12618
+deltacat/compute/compactor/utils/io.py,sha256=u7gNcPiaGoCyj3vfwWz7P9M9BwXJyzDUbu8FfxFXFec,15840
 deltacat/compute/compactor/utils/primary_key_index.py,sha256=taYw1AjGIFlD9c8OXyj9ps816a15B61aoV4I00EAUyo,12072
-deltacat/compute/compactor/utils/round_completion_file.py,sha256=XwirlbitX8ZXMDAuAd6YPr0rQZ5k0efdxM_dzrFgiJY,1887
+deltacat/compute/compactor/utils/round_completion_file.py,sha256=nv_-pl8FRIWPWY5xWLuBXVJkGH4LYBhDwnrWKIaSRms,1935
 deltacat/compute/compactor/utils/system_columns.py,sha256=or9yqPk2QY6Ws3sq-G5JMDbizYO3MUZeFgLb5nCPrL0,7153
 deltacat/compute/metastats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/metastats/meta_stats.py,sha256=-Fb0yQAdUUgm2IShcWlPZto-qdivF-nK05sQqJu7K5s,18588
@@ -73,7 +76,7 @@ deltacat/io/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/io/aws/redshift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/io/aws/redshift/redshift_datasource.py,sha256=X183O4tgBqtaZOSFmMFvp-9mv8NX5kGvRvX0eoSX8rA,22599
 deltacat/storage/__init__.py,sha256=ElzZuG5zrX9nUIe7f0Sp21WDX7yBoclclq3TIL-doag,1371
-deltacat/storage/interface.py,sha256=pw8t0jCqPakw13wDpg_cW0eBGBpqG1GO0djg-ZNNW6Q,21133
+deltacat/storage/interface.py,sha256=czzC0iourcqteNNw_drMEyeOXsMOMLiBsSt--g5le8o,21143
 deltacat/storage/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/storage/model/delta.py,sha256=bmcG1rF6mwUdM3YHh6M9gLV6uqxbwHZVNS3WHkXFeDw,13734
 deltacat/storage/model/list_result.py,sha256=FgD6oYeKo0EPe8z7jC8T4pAFjBOuBwd4axxGrnYyBG4,2466
@@ -83,12 +86,19 @@ deltacat/storage/model/partition.py,sha256=6Sknqi2GhtaSpkM--3oMjR9agRLHS4i7izFWM
 deltacat/storage/model/stream.py,sha256=XZ-c4EQR89NWydEOEG5GCaT8zST10OmjLZBKHZPdrzA,7738
 deltacat/storage/model/table.py,sha256=IOu1ZOrdRkVDB-FOxYMRvnNf5TukIDfbdHWTqHYN_OY,4225
 deltacat/storage/model/table_version.py,sha256=j57er3zlN0_2kwVMpWZ3iouABO-Kl8_Txi0UWIZ0dtk,7034
-deltacat/storage/model/types.py,sha256=LQPe_CxcoW2N67Leu3fNbnSXhbl9ubDa8LVvBY0JUiY,1580
+deltacat/storage/model/types.py,sha256=-9yPA5wjZf9jOd-iErf4sN-YD-6fbl2z8m8t1lGa0I0,2061
 deltacat/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deltacat/tests/test_repartition.py,sha256=xzqdfRzZS-bA1yBdPNxelecTFe2MtON5Lrd-jTGZ4Xk,7245
+deltacat/tests/compactor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deltacat/tests/compactor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deltacat/tests/compactor/utils/test_io.py,sha256=FWguDt03ErItYluXBWaPOAUKwQKfUtGXJYDwP_O1cMM,2282
 deltacat/tests/stats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/tests/stats/test_intervals.py,sha256=S92DgkALQ1WmbLWcxtvS7RlVGvL-XoPJKUUbkdn9_CQ,1955
+deltacat/tests/test_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deltacat/tests/test_utils/constants.py,sha256=zgqFmfIE5ZCtDw4NF-Y4ZEEnaPUP5nDY5768WPod0Fc,208
 deltacat/tests/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/tests/utils/test_record_batch_tables.py,sha256=yLExx5jZfi65uSjkdhOCGnP7Km6zWqKCzmULf1PEKA0,11322
+deltacat/tests/utils/test_resources.py,sha256=ubd2tSusagWLSuRXDA2L_2cWr5Xnt6UXpKp3NGGe1ww,1193
 deltacat/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/types/media.py,sha256=py1BnfMqNpJlW1RKzHWwB0NmQ33oCk9qg1fz7alvi3E,2187
 deltacat/types/tables.py,sha256=yUzkzmUij8kssEYI_dfVDSLXf8HfMm_jpgWkPxDHAas,3893
@@ -99,16 +109,16 @@ deltacat/utils/numpy.py,sha256=ZiGREobTVT6IZXgPxkSUpLJFN2Hn8KEZcrqybLDXCIA,2027
 deltacat/utils/pandas.py,sha256=eGOpiZE1zLznTtuwoN80j4PBp1_bUV8SE4c951r0a3o,9561
 deltacat/utils/performance.py,sha256=rC3CPfroZP3T5TbRNZXB9GRBr0F9i2KUeZYL45JBgCU,610
 deltacat/utils/placement.py,sha256=JE6OsW16VonlMhdH5B2IYuLJxItoYguaKpZNgbpMNLw,11066
-deltacat/utils/profiling.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/utils/pyarrow.py,sha256=dgAruwOpWYSlnJ5w8iJz_NWpfQoZHA_iG-F7CBDieko,18245
+deltacat/utils/resources.py,sha256=gdw8_79GkYyD6FYLgB51bDbxHpviGAt8-Mhrt4lqG4I,2817
 deltacat/utils/ray_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/utils/ray_utils/collections.py,sha256=hj20s4D2RF2jZETU_44r6mFbsczA0JI_I_4kWKTmqes,1951
-deltacat/utils/ray_utils/concurrency.py,sha256=AyL7hpvYjkmsz-KcpYjVgPpNsmu-x8-rlLyG0qXoV_c,5123
+deltacat/utils/ray_utils/concurrency.py,sha256=GmWjrpaB9Ad3i8miOJwdkmwIbOqR6KjaS8e5BYXFzAU,5262
 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.1.18b1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-deltacat-0.1.18b1.dist-info/METADATA,sha256=KkYH5jv7MbQrn99cNSGlJ4-hLt0_8UVjtWVKTafye58,1490
-deltacat-0.1.18b1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-deltacat-0.1.18b1.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
-deltacat-0.1.18b1.dist-info/RECORD,,
+deltacat-0.1.18b3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+deltacat-0.1.18b3.dist-info/METADATA,sha256=nBwFBXeWcqAe92M7yzEypKrDgJqhJyet1Gf_GrlkyQY,1475
+deltacat-0.1.18b3.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+deltacat-0.1.18b3.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
+deltacat-0.1.18b3.dist-info/RECORD,,

{deltacat-0.1.18b1.dist-info → deltacat-0.1.18b3.dist-info}/WHEEL

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