deltacat 1.1.20__py3-none-any.whl → 1.1.22__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__ = "1.1.20"
+__version__ = "1.1.22"
 
 
 __all__ = [

deltacat/compute/compactor_v2/private/compaction_utils.py

@@ -365,7 +365,6 @@ def _run_hash_and_merge(
     mutable_compaction_audit.set_telemetry_time_in_seconds(
         telemetry_this_round + previous_telemetry
     )
-    params.object_store.clear()
 
     return merge_results
 

deltacat/compute/stats/models/delta_column_stats.py

@@ -0,0 +1,98 @@
+# Allow classes to use self-referencing Type hints in Python 3.7.
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from deltacat.compute.stats.models.manifest_entry_stats import ManifestEntryStats
+from deltacat.compute.stats.models.stats_result import StatsResult
+from deltacat.compute.stats.types import StatsType
+
+
+class DeltaColumnStats(dict):
+    """
+    Stats container for an individual column of a Delta.
+    Provides distinct stats results for each manifest entry of the Delta.
+
+    Example:
+        Manifest Entry 1
+        =======
+        foo bar baz
+        A   B   C
+        D   E   F
+
+        Manifest Entry 2
+        =======
+        foo bar baz
+        G   H   I
+        J   K   L
+
+        DeltaColumnStats("foo",
+            ManifestEntryStats([
+                StatsResult([A, D]),     #  Manifest Entry 1
+                StatsResult([G, J]),     #  Manifest Entry 2
+            ]))
+        DeltaColumnStats("bar",
+            ManifestEntryStats([
+                StatsResult([B, E]),     #  Manifest Entry 1
+                StatsResult([H, K]),     #  Manifest Entry 2
+            ]))
+        DeltaColumnStats("baz",
+            ManifestEntryStats([
+                StatsResult([C, F]),     #  Manifest Entry 1
+                StatsResult([I, L]),     #  Manifest Entry 2
+            ]))
+    """
+
+    @staticmethod
+    def of(column: str, manifest_stats: ManifestEntryStats) -> DeltaColumnStats:
+        """
+        Creates a container of a column name and the column stats for one or more manifest entries.
+        """
+        dcs = DeltaColumnStats()
+        dcs["column"] = column
+        dcs["manifestStats"] = manifest_stats
+
+        if manifest_stats:
+            # Omit row count for columnar-centric stats
+            dcs["stats"] = dcs._merge_manifest_stats()
+
+        return dcs
+
+    @staticmethod
+    def build_from_dict(delta_column_stats: List[str, Any]) -> List[DeltaColumnStats]:
+        return DeltaColumnStats.of(
+            delta_column_stats["column"],
+            ManifestEntryStats.build_from_dict(delta_column_stats["manifestStats"]),
+        )
+
+    @property
+    def column(self) -> str:
+        """Returns the column name."""
+        return self.get("column")
+
+    @property
+    def manifest_stats(self) -> Optional[ManifestEntryStats]:
+        """Returns a container that represents stats at the manifest level.
+
+        A container holds a list of computed stats for each manifest entry.
+        """
+        val: Dict[str, Any] = self.get("manifestStats")
+        if val is not None and not isinstance(val, ManifestEntryStats):
+            self["manifestStats"] = val = ManifestEntryStats(val)
+        return val
+
+    @property
+    def stats(self) -> Optional[StatsResult]:
+        """Combines the numerical stats for every manifest entry and returns it."""
+        val: Dict[str, Any] = self.get("stats")
+        if val is not None and not isinstance(val, StatsResult):
+            self["stats"] = val = StatsResult(val)
+        elif val is None and self.manifest_stats:
+            self["stats"] = val = self._merge_manifest_stats()
+
+        return val
+
+    def _merge_manifest_stats(self) -> StatsResult:
+        return StatsResult.merge(
+            self.manifest_stats.stats, {StatsType.PYARROW_TABLE_BYTES}
+        )

deltacat/compute/stats/models/delta_stats.py

@@ -0,0 +1,233 @@
+# Allow classes to use self-referencing Type hints in Python 3.7.
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Dict, List, NamedTuple, Optional, Set
+
+from deltacat.compute.stats.models.delta_column_stats import DeltaColumnStats
+from deltacat.compute.stats.models.manifest_entry_stats import ManifestEntryStats
+from deltacat.compute.stats.models.stats_result import StatsResult
+from deltacat.compute.stats.types import StatsType
+from deltacat.storage import DeltaLocator
+
+
+class DeltaStats(dict):
+    """
+    Stats container for all columns of a delta.
+
+    Provides distinct stats for each delta manifest entry, aggregate stats across all manifest entries,
+    and a DeltaColumnStats reference for each column.
+
+    Each DeltaColumnStats has a column name and a ManifestEntryStats object,
+    which contains column-level stats for each delta manifest entry.
+
+    Example of visual representation:
+        Manifest Entry 1
+        =======
+        foo bar baz
+        A   B   C
+        D   E   F
+
+        Manifest Entry 2
+        =======
+        foo bar baz
+        G   H   I
+        J   K   L
+
+        DeltaStats([
+            DeltaColumnStats("foo",
+                ManifestEntryStats([
+                    StatsResult([A, D]),     #  Manifest Entry 1
+                    StatsResult([G, J]),     #  Manifest Entry 2
+                ]))
+            DeltaColumnStats("bar",
+                ManifestEntryStats([
+                    StatsResult([B, E]),     #  Manifest Entry 1
+                    StatsResult([H, K]),     #  Manifest Entry 2
+                ]))
+            DeltaColumnStats("baz",
+                ManifestEntryStats([
+                    StatsResult([C, F]),     #  Manifest Entry 1
+                    StatsResult([I, L]),     #  Manifest Entry 2
+                ]))
+        ], Stats(AllDeltaColumnStats))
+    """
+
+    @staticmethod
+    def of(column_stats: List[DeltaColumnStats]) -> DeltaStats:
+        ds = DeltaStats()
+        ds["column_stats"] = column_stats
+        ds["stats"] = DeltaStats.get_delta_stats(column_stats)
+        return ds
+
+    @staticmethod
+    def build_from_dict(delta_stats: dict) -> DeltaStats:
+        delta_column_stats_list = []
+        for dcs in delta_stats["column_stats"]:
+            delta_column_stats_list.append(DeltaColumnStats.build_from_dict(dcs))
+        return DeltaStats.of(delta_column_stats_list)
+
+    @property
+    def column_stats(self) -> List[DeltaColumnStats]:
+        """
+        Returns a list of stats associated to each column in this delta.
+        """
+        return self["column_stats"]
+
+    @property
+    def stats(self) -> Optional[StatsResult]:
+        """Returns a StatsResult object that represents this delta, aggregated by the column stats of this delta."""
+        val: Dict[str, Any] = self.get("stats")
+        if val is not None and not isinstance(val, StatsResult):
+            self["stats"] = val = StatsResult(val)
+        elif val is None and self.column_stats:
+            self["stats"] = val = DeltaStats.get_delta_stats(self.column_stats)
+
+        return val
+
+    @property
+    def columns(self) -> List[str]:
+        """Returns a list of column names associated to this delta.
+
+        Returns:
+            A list of column names
+        """
+        return DeltaStats.get_column_names(self.column_stats)
+
+    def manifest_entry_stats(self, manifest_entry_idx: int) -> StatsResult:
+        """Calculate the stats of a manifest entry by combining its columnar stats.
+
+        Args:
+            manifest_entry_idx: The manifest entry table to calculate stats for
+
+        Returns:
+            Stats for the manifest entry.
+        """
+        return StatsResult.merge(
+            DeltaStats.get_manifest_entry_column_stats(
+                self.column_stats, manifest_entry_idx
+            ),
+            record_row_count_once=True,
+        )
+
+    def manifest_entry_column_stats(self, manifest_entry_idx: int) -> List[StatsResult]:
+        """Fetch a list of stats for each column in a manifest entry.
+
+        Args:
+            manifest_entry_idx: The manifest entry table to calculate stats for
+
+        Returns:
+            A list of columnar stats for the manifest entry
+        """
+        return DeltaStats.get_manifest_entry_column_stats(
+            self.column_stats, manifest_entry_idx
+        )
+
+    @staticmethod
+    def get_manifest_entry_column_stats(
+        columns: List[DeltaColumnStats], manifest_entry_idx: int
+    ) -> List[StatsResult]:
+        """Helper method to provide a list of columnar stats for a specific manifest entry.
+
+        Returns:
+            A list of columnar stats for the manifest entry
+        """
+        dataset_columnar_stats_list: List[ManifestEntryStats] = [
+            column.manifest_stats
+            for column in columns
+            if column.manifest_stats is not None
+        ]
+        try:
+            return [
+                stats.stats[manifest_entry_idx] for stats in dataset_columnar_stats_list
+            ]
+        except IndexError:
+            sci: ManifestEntryStats = dataset_columnar_stats_list[0]
+            raise ValueError(
+                f"Table index {manifest_entry_idx} is not present in this dataset of {sci.delta_locator} "
+                f"with manifest table count of {len(sci.stats)}"
+            )
+
+    @staticmethod
+    def get_column_names(columns: List[DeltaColumnStats]) -> List[str]:
+        """Helper method to get the names of each column from a list of delta column stats
+
+        Args:
+            columns: A list of delta column stats
+
+        Returns:
+            A list of column names
+        """
+        return [column_stats.column for column_stats in columns] if columns else []
+
+    @staticmethod
+    def get_delta_stats(
+        columns: List[DeltaColumnStats], stat_types: Optional[Set[StatsType]] = None
+    ) -> Optional[StatsResult]:
+        """Calculate the sum of provided column stats and return it
+
+        Args:
+            columns: A list of delta column stats
+
+        Returns:
+            Stats for the calculated sum
+        """
+        assert columns and len(columns) > 0, (
+            f"Expected columns `{columns}` of type `{type(columns)}` "
+            f"to be a non-empty list of DeltaColumnStats"
+        )
+
+        assert all(
+            [col.manifest_stats for col in columns]
+        ), f"Expected stats completion info to be present in each item of {columns} "
+
+        manifest_entry_count = len(columns[0].manifest_stats.stats)
+        column_stats_map: Dict[str, List[Optional[StatsResult]]] = defaultdict(
+            lambda: [None] * manifest_entry_count
+        )
+
+        for column_stats in columns:
+            for file_idx, entry_stats in enumerate(column_stats.manifest_stats.stats):
+                column_stats_map[column_stats.column][file_idx] = entry_stats
+
+        return DeltaStats._merge_stats_from_columns_to_dataset(
+            DeltaStats.get_column_names(columns),
+            column_stats_map,
+            manifest_entry_count,
+            stat_types,
+        )
+
+    @staticmethod
+    def _merge_stats_from_columns_to_dataset(
+        column_names: List[str],
+        column_stats: Dict[str, List[Optional[StatsResult]]],
+        manifest_entries_size: int,
+        stat_types: Optional[Set[StatsType]] = None,
+    ) -> StatsResult:
+        manifest_entry_stats_summary_list: List[StatsResult] = []
+        for manifest_entry_idx in range(manifest_entries_size):
+            curr_manifest_entry_column_stats_list: List[StatsResult] = []
+            for column_name in column_names:
+                current_table_column_stats: StatsResult = column_stats[column_name][
+                    manifest_entry_idx
+                ]
+                curr_manifest_entry_column_stats_list.append(current_table_column_stats)
+
+            curr_manifest_entry_stats_summary = StatsResult.merge(
+                curr_manifest_entry_column_stats_list,
+                stat_types,
+                record_row_count_once=True,
+            )
+            manifest_entry_stats_summary_list.append(curr_manifest_entry_stats_summary)
+        return StatsResult.merge(manifest_entry_stats_summary_list, stat_types)
+
+
+class DeltaStatsCacheMiss(NamedTuple):
+    """A helper class for cache miss results from DeltaStatsCacheResult.
+
+    `column_names` represents missing dataset column names from the file system (ex: S3).
+    delta_locator` is tied to the missing dataset columns and provided for future calculations.
+    """
+
+    column_names: List[str]
+    delta_locator: DeltaLocator

deltacat/compute/stats/models/delta_stats_cache_result.py

@@ -0,0 +1,49 @@
+# Allow classes to use self-referencing Type hints in Python 3.7.
+from __future__ import annotations
+
+from typing import Optional
+
+from deltacat.compute.stats.models.delta_stats import DeltaStats, DeltaStatsCacheMiss
+
+
+class DeltaStatsCacheResult(dict):
+    """A helper class containing the results from a cache query.
+
+    Stats are fetched and cached at the column level, and each column may represent one
+    or more manifest entries.
+    """
+
+    @staticmethod
+    def of(
+        hits: Optional[DeltaStats], misses: Optional[DeltaStatsCacheMiss]
+    ) -> DeltaStatsCacheResult:
+        cds = DeltaStatsCacheResult()
+        cds["hits"] = hits
+        cds["misses"] = misses
+        return cds
+
+    @property
+    def hits(self) -> Optional[DeltaStats]:
+        """Retrieve stats that were found in the cache
+
+        `hits` represents a DeltaStats object that contains dataset-wide statistics across
+        many of its tables (or manifest entries) and is composed of one or more column-wide
+        DeltaColumnStats.
+
+        Returns:
+            A delta wide stats container
+        """
+        return self["hits"]
+
+    @property
+    def misses(self) -> Optional[DeltaStatsCacheMiss]:
+        """Retrieve stats that were missing from the cache
+
+        `misses` represents a DeltaStatsCacheMiss object that contains a list of
+        column names that were not found in the file system (ex: S3) and a `delta_locator`
+        as a reference to the delta metadata tied to the missing dataset columns.
+
+        Returns:
+            A tuple with metadata regarding the cache miss
+        """
+        return self["misses"]

deltacat/compute/stats/models/manifest_entry_stats.py

@@ -0,0 +1,72 @@
+# Allow classes to use self-referencing Type hints in Python 3.7.
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+import pyarrow as pa
+
+from deltacat.compute.stats.models.stats_result import StatsResult
+from deltacat.storage import DeltaLocator
+
+
+class ManifestEntryStats(dict):
+    """Holds computed statistics for one or more manifest entries (tables) and their corresponding delta locator.
+
+    To be stored/retrieved from a file system (ex: S3).
+    """
+
+    @staticmethod
+    def of(
+        manifest_entries_stats: List[StatsResult], delta_locator: DeltaLocator
+    ) -> ManifestEntryStats:
+        """
+        Creates a stats container that represents a particular manifest.
+
+        `manifest_entries_stats` are a list of distinct stats for each manifest entry file
+        tied to this manifest. `delta_locator` is provided as a reference to the delta where the
+        manifest entries reside.
+        """
+
+        mes = ManifestEntryStats()
+        mes["deltaLocator"] = delta_locator
+        mes["stats"] = manifest_entries_stats
+        mes["pyarrowVersion"] = pa.__version__
+        return mes
+
+    @staticmethod
+    def build_from_dict(manifest_entries_stats: dict) -> ManifestEntryStats:
+        stats_res_list = []
+        for stats_res in manifest_entries_stats["stats"]:
+            stats_res_list.append(
+                StatsResult.of(stats_res["rowCount"], stats_res["pyarrowTableBytes"])
+            )
+        return ManifestEntryStats.of(
+            stats_res_list, manifest_entries_stats["deltaLocator"]
+        )
+
+    @property
+    def delta_locator(self) -> DeltaLocator:
+        """Reference to the delta that holds the manifest entries
+
+        Returns:
+            A delta locator object
+        """
+        val: Dict[str, Any] = self.get("deltaLocator")
+        if val is not None and not isinstance(val, DeltaLocator):
+            self["deltaLocator"] = val = DeltaLocator(val)
+        return val
+
+    @property
+    def stats(self) -> List[StatsResult]:
+        """
+        Returns a list of distinct stats for each manifest entry file.
+        """
+        val = self["stats"]
+        return [StatsResult(_) for _ in val] if val else []
+
+    @property
+    def pyarrow_version(self) -> str:
+        """
+        Read-only property which returns the PyArrow version number as it was written into a file system.
+        """
+        return self.get("pyarrowVersion")

deltacat/compute/stats/models/stats_result.py

@@ -0,0 +1,104 @@
+# Allow classes to use self-referencing Type hints in Python 3.7.
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, Dict, List, Optional, Set
+
+from deltacat.compute.stats.types import ALL_STATS_TYPES, StatsType
+
+
+class StatsResult(dict):
+    """A generic container that holds stats for a single manifest entry file."""
+
+    @staticmethod
+    def of(
+        row_count: Optional[int] = 0, pyarrow_table_bytes: Optional[int] = 0
+    ) -> StatsResult:
+        """Static factory for building a stats result object
+
+        Args:
+            row_count: The total number of rows of a manifest entry
+            pyarrow_table_bytes: The total number of bytes when loaded into memory as a PyArrow Table
+
+        Returns:
+            A stats result object
+        """
+        sr = StatsResult()
+        sr[StatsType.ROW_COUNT.value] = row_count
+        sr[StatsType.PYARROW_TABLE_BYTES.value] = pyarrow_table_bytes
+        return sr
+
+    @property
+    def row_count(self) -> int:
+        """Represents the row count of a manifest entry file.
+
+        Returns:
+            The total number of rows of a manifest entry
+        """
+        return self[StatsType.ROW_COUNT.value]
+
+    @property
+    def pyarrow_table_bytes(self) -> int:
+        """Represents the size of a manifest entry file (in bytes) as it was loaded into a PyArrow table.
+
+        Returns:
+            The total number of bytes when loaded into memory as a PyArrow Table
+        """
+        return self[StatsType.PYARROW_TABLE_BYTES.value]
+
+    @staticmethod
+    def from_stats_types(stats_types: Dict[StatsType, Any]) -> StatsResult:
+        """A helper method to filter a dictionary by supported stats and returns a stats result object.
+
+        Args:
+            stats_types: Stats that should be included for constructing a stats result
+
+        Returns:
+            A stats result object
+        """
+        return StatsResult(
+            {
+                k: v
+                for k, v in stats_types.items()
+                if k in [StatsType.ROW_COUNT, StatsType.PYARROW_TABLE_BYTES]
+            }
+        )
+
+    @staticmethod
+    def merge(
+        stats_list: List[StatsResult],
+        stat_types: Optional[Set[StatsType]] = None,
+        record_row_count_once: bool = False,
+    ) -> StatsResult:
+        """Helper method to merge any list of StatsResult objects into one.
+
+        StatsResult objects are merged by adding up their numerical stats.
+        TODO (ricmiyam): Handle non-numerical stats when they are added
+
+        Args:
+            stat_types: If provided, the calculation will only include the requested stats.
+            record_row_count_once: If optionally set to `True`, then row counts are only added
+                from the first stats entry. One use case for this is merging table-centric stats
+                by columns, since the row count is expected to be the same across different columns.
+
+        Returns:
+            A stats result object
+        """
+        assert isinstance(stats_list, list) and len(stats_list) > 0, (
+            f"Expected stats list: {stats_list} of type {type(stats_list)} to be a "
+            f"non-empty list of StatsResult objects."
+        )
+
+        # Fallback to all stat types if not provided
+        stats_to_collect: Set = stat_types or ALL_STATS_TYPES
+
+        merged_stats: Dict[StatsType, int] = defaultdict(int)
+        for stats_result in stats_list:
+            for stat_type in stats_to_collect:
+                if stats_result:
+                    merged_stats[stat_type.value] += stats_result[stat_type.value]
+
+        if record_row_count_once and StatsType.ROW_COUNT in stats_to_collect:
+            merged_stats[StatsType.ROW_COUNT.value] = stats_list[0].row_count
+
+        return StatsResult.from_stats_types(merged_stats)

{deltacat-1.1.20.dist-info → deltacat-1.1.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltacat
-Version: 1.1.20
+Version: 1.1.22
 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.20.dist-info → deltacat-1.1.22.dist-info}/RECORD

@@ -1,4 +1,4 @@
-deltacat/__init__.py,sha256=zFGIgjOwr8hWxHVCYMBLdLZVeRScD36BMr8lXcBQj1o,1778
+deltacat/__init__.py,sha256=DA3ai-LdX6TopktWC4tQPRs9GXGxAjSkEz-TeJbnWdE,1778
 deltacat/constants.py,sha256=TUJLXUJ9xq1Ryil72yLkKR8EDH_Irp5wUg56QstbRNE,2181
 deltacat/exceptions.py,sha256=7sjk3BuMY5Oo-6OvAfHncZx_OcvtEL47BblWr2F7waE,12740
 deltacat/logs.py,sha256=EQSDin1deehzz5xlLV1_TrFJrO_IBZ9Ahp7MdL-4cK8,9363
@@ -66,7 +66,7 @@ deltacat/compute/compactor_v2/model/merge_file_group.py,sha256=1o86t9lc3K6ZvtViV
 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=u8SwKc5JTcTHu1TjHQdEw366mwRUU8cThyJp7D1wZrg,30448
+deltacat/compute/compactor_v2/private/compaction_utils.py,sha256=QKGekJQWL_S1DifnENSQ7PQm5k7x27CoDT0m4QQWBIk,30416
 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=LpktsDPfj7Of6RgUw9w1f3Y3OBkPDjvtyXjzFaIDoSo,21771
@@ -91,6 +91,12 @@ deltacat/compute/resource_estimation/model.py,sha256=psyagFXdpLGt8DfDqy7c8DWiuXC
 deltacat/compute/resource_estimation/parquet.py,sha256=5_apma4EKbKcm-nfV73-qN2nfnCeyhFW23ZHX3jz0Kw,3158
 deltacat/compute/stats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/stats/types.py,sha256=cp0lT8nITTKbnkc03OysRjXfcfXzQml9a4wqCnR6kqs,215
+deltacat/compute/stats/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deltacat/compute/stats/models/delta_column_stats.py,sha256=-wXjB2c0BC1RDheumjL_j5-DfRNql4WsK9GpMFQI1cg,3300
+deltacat/compute/stats/models/delta_stats.py,sha256=hBith8_hbF9TVr6HocLAt6RJ_kZZKO4zrGP8VOP05vA,8556
+deltacat/compute/stats/models/delta_stats_cache_result.py,sha256=mbJYxpZd5jaER_BWrCD2hROFy3p1nNdBrj66nUpc6io,1624
+deltacat/compute/stats/models/manifest_entry_stats.py,sha256=NCDAe2nPDEI4kOkuwNkRFgGPS-rqQaQqLuaLoKk20KQ,2419
+deltacat/compute/stats/models/stats_result.py,sha256=XQAlmzhUqRmg4jzEMUAOqcYn1HUOBTMryBH1CCVlet8,3820
 deltacat/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/io/dataset.py,sha256=pFU5UfK-fD9C4fIeffJtrA6yVQSgAx2UPbxzQ4GMFL8,3203
 deltacat/io/file_object_store.py,sha256=HCFeXu9cWXPXVk54MHel_nw3-wIuzhMt2RI6jKzjRYM,1346
@@ -204,8 +210,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.20.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-deltacat-1.1.20.dist-info/METADATA,sha256=AkZB0iLFMFCTtfb7RxGTTK0Dl5TyIp5WvKHCAfWJ3Ok,1733
-deltacat-1.1.20.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-deltacat-1.1.20.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
-deltacat-1.1.20.dist-info/RECORD,,
+deltacat-1.1.22.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+deltacat-1.1.22.dist-info/METADATA,sha256=uaAF2wK6KSi4pooJGoqJERmH_zBIz7WZgUgORbQCnaA,1733
+deltacat-1.1.22.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+deltacat-1.1.22.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
+deltacat-1.1.22.dist-info/RECORD,,