deltacat 1.1.18__py3-none-any.whl → 1.1.20__py3-none-any.whl

deltacat/compute/stats/basic.py

@@ -1,226 +0,0 @@
-from typing import Dict, List, Optional, Set, Tuple
-
-import ray
-from ray.types import ObjectRef
-
-from deltacat.compute.stats.models.delta_stats import DeltaStats
-from deltacat.compute.stats.models.delta_stats_cache_result import DeltaStatsCacheResult
-from deltacat.compute.stats.models.stats_result import StatsResult
-from deltacat.compute.stats.types import StatsType
-from deltacat.compute.stats.utils.intervals import DeltaRange, merge_intervals
-from deltacat.compute.stats.utils.io import (
-    cache_delta_column_stats,
-    get_delta_stats,
-    get_deltas_from_range,
-    read_cached_delta_stats,
-)
-from deltacat.storage import Delta, DeltaLocator, PartitionLocator
-from deltacat.storage import interface as unimplemented_deltacat_storage
-
-# TODO (ricmiyam): Decouple DeltaCAT from S3-based paths
-# TODO (ricmiyam): Determine cache eviction policy
-
-
-def collect(
-    source_partition_locator: PartitionLocator,
-    delta_stream_position_range_set: Optional[Set[DeltaRange]] = None,
-    columns: Optional[List[str]] = None,
-    stat_results_s3_bucket: Optional[str] = None,
-    deltacat_storage=unimplemented_deltacat_storage,
-) -> Dict[int, DeltaStats]:
-    """Collects statistics on deltas, given a set of delta stream position ranges.
-
-    Example:
-        >>> collect(locator, set((1, 5), (4, 8), (13, 16)))
-        {
-            1: DeltaStats(),  # DeltaStats for stream positions 1 - 8
-            13: DeltaStats()  # DeltaStats for stream positions 13 - 16
-        }
-
-    Args:
-        source_partition_locator: Reference to the partition locator tied to the given delta stream positions
-        delta_stream_position_range_set: A set of intervals with an int type representing finite,
-            closed bounded values, and a None type representing unbounded infinity.
-        columns: Columns can be optionally included to collect stats on specific columns.
-            By default, all columns will be calculated.
-        stat_results_s3_bucket: Used as a cache file storage for computed delta stats
-        deltacat_storage: Client implementation of the DeltaCAT storage interface
-
-    Returns:
-        A mapping of stream positions to their corresponding delta stats.
-    """
-    if delta_stream_position_range_set is None:
-        delta_stream_position_range_set = {(None, None)}
-    delta_stream_range_stats: Dict[int, DeltaStats] = {}
-    delta_range_lookup_pending: List[ObjectRef[List[Delta]]] = []
-
-    if not columns:
-        columns = deltacat_storage.get_table_version_column_names(
-            source_partition_locator.namespace,
-            source_partition_locator.table_name,
-            source_partition_locator.table_version,
-        )
-    for range_pair in merge_intervals(delta_stream_position_range_set):
-        begin, end = range_pair
-        promise: ObjectRef[List[Delta]] = get_deltas_from_range.remote(
-            source_partition_locator, begin, end, deltacat_storage
-        )
-        delta_range_lookup_pending.append(promise)
-
-    delta_list_by_ranges: List[List[Delta]] = ray.get(delta_range_lookup_pending)
-    deltas = [delta for delta_list in delta_list_by_ranges for delta in delta_list]
-
-    delta_stats_processed_list: List[DeltaStats] = _collect_stats_from_deltas(
-        deltas, columns, stat_results_s3_bucket, deltacat_storage
-    )
-
-    for delta_column_stats in delta_stats_processed_list:
-        assert (
-            len(delta_column_stats.column_stats) > 0
-        ), f"Expected columns of `{delta_column_stats}` to be non-empty"
-        stream_position = delta_column_stats.column_stats[
-            0
-        ].manifest_stats.delta_locator.stream_position
-        delta_stream_range_stats[stream_position] = delta_column_stats
-
-    return delta_stream_range_stats
-
-
-def collect_from_deltas(
-    deltas: List[Delta],
-    stat_types: Set[StatsType],
-    columns: Optional[List[str]] = None,
-    stat_results_s3_bucket: Optional[str] = None,
-    deltacat_storage=unimplemented_deltacat_storage,
-) -> StatsResult:
-    """
-    Variant of the `collect` function that takes a list of deltas and computes
-    the aggregate of all the delta stats.
-    """
-    if columns is None and deltas:
-        delta_locator: DeltaLocator = deltas[0].locator
-        columns = deltacat_storage.get_table_version_column_names(
-            delta_locator.namespace,
-            delta_locator.table_name,
-            delta_locator.table_version,
-        )
-
-    delta_stats_processed_list: List[DeltaStats] = _collect_stats_from_deltas(
-        deltas, columns, stat_results_s3_bucket, deltacat_storage
-    )
-
-    return StatsResult.merge(
-        [delta_ds.stats for delta_ds in delta_stats_processed_list], stat_types
-    )
-
-
-def _collect_stats_from_deltas(
-    deltas: List[Delta],
-    columns: Optional[List[str]] = None,
-    stat_results_s3_bucket: Optional[str] = None,
-    deltacat_storage=unimplemented_deltacat_storage,
-) -> List[DeltaStats]:
-    delta_cache_lookup_pending: List[ObjectRef[DeltaStatsCacheResult]] = []
-    delta_stats_compute_pending: List[ObjectRef[DeltaStats]] = []
-
-    for delta in deltas:
-        if stat_results_s3_bucket:
-            promise: ObjectRef[DeltaStatsCacheResult] = read_cached_delta_stats.remote(
-                delta, columns, stat_results_s3_bucket
-            )
-            delta_cache_lookup_pending.append(promise)
-            continue
-
-        delta_stats_compute_pending.append(
-            get_delta_stats.remote(delta.locator, columns, deltacat_storage)
-        )
-
-    return _process_stats(
-        delta_cache_lookup_pending,
-        delta_stats_compute_pending,
-        stat_results_s3_bucket,
-        deltacat_storage,
-    )
-
-
-def _process_stats(
-    delta_cache_lookup_pending: List[ObjectRef[DeltaStatsCacheResult]],
-    delta_stats_compute_pending: List[ObjectRef[DeltaStats]],
-    stat_results_s3_bucket: Optional[str] = None,
-    deltacat_storage=unimplemented_deltacat_storage,
-) -> List[DeltaStats]:
-    if stat_results_s3_bucket:
-        delta_stats_processed_list: List[DeltaStats] = _resolve_pending_stats_and_cache(
-            delta_cache_lookup_pending, stat_results_s3_bucket, deltacat_storage
-        )
-    else:
-        delta_stats_processed_list: List[DeltaStats] = _resolve_pending_stats(
-            delta_stats_compute_pending
-        )
-
-    return delta_stats_processed_list
-
-
-def _resolve_pending_stats_and_cache(
-    delta_cache_lookup_pending: List[ObjectRef[DeltaStatsCacheResult]],
-    stat_results_s3_bucket: str,
-    deltacat_storage,
-) -> List[DeltaStats]:
-    delta_stats_cached_list, delta_stats_pending_list = _get_cached_and_pending_stats(
-        delta_cache_lookup_pending, deltacat_storage
-    )
-    delta_stats_resolved_list: List[DeltaStats] = _resolve_pending_stats(
-        delta_stats_pending_list
-    )
-
-    # Cache the stats into the file store
-    delta_stats_to_cache: List[ObjectRef] = [
-        cache_delta_column_stats.remote(stat_results_s3_bucket, dcs)
-        for dataset_stats in delta_stats_resolved_list
-        for dcs in dataset_stats.column_stats
-    ]
-    ray.get(delta_stats_to_cache)
-
-    return [*delta_stats_cached_list, *delta_stats_resolved_list]
-
-
-def _get_cached_and_pending_stats(
-    discover_deltas_pending: List[ObjectRef[DeltaStatsCacheResult]],
-    deltacat_storage=unimplemented_deltacat_storage,
-) -> Tuple[List[DeltaStats], List[ObjectRef[DeltaStats]]]:
-    """
-    Returns a tuple of a list of delta stats fetched from the cache, and a list of Ray tasks which will
-    calculate the stats for deltas on cache miss.
-    """
-    delta_stats_processed: List[DeltaStats] = []
-    delta_stats_pending: List[ObjectRef[DeltaStats]] = []
-    while discover_deltas_pending:
-        ready, discover_deltas_pending = ray.wait(discover_deltas_pending)
-
-        cached_results: List[DeltaStatsCacheResult] = ray.get(ready)
-        for cached_result in cached_results:
-            if cached_result.hits:
-                delta_stats_processed.append(cached_result.hits)
-
-            if cached_result.misses:
-                missed_column_names: List[str] = cached_result.misses.column_names
-                delta_locator: DeltaLocator = cached_result.misses.delta_locator
-                delta_stats_pending.append(
-                    get_delta_stats.remote(
-                        delta_locator, missed_column_names, deltacat_storage
-                    )
-                )
-
-    return delta_stats_processed, delta_stats_pending
-
-
-def _resolve_pending_stats(
-    delta_stats_pending_list: List[ObjectRef[DeltaStats]],
-) -> List[DeltaStats]:
-    delta_stats_processed_list: List[DeltaStats] = []
-    while delta_stats_pending_list:
-        ready, delta_stats_pending_list = ray.wait(delta_stats_pending_list)
-        processed_stats_batch: List[DeltaStats] = ray.get(ready)
-        delta_stats_processed_list.extend(processed_stats_batch)
-
-    return delta_stats_processed_list

deltacat/compute/stats/models/delta_column_stats.py

@@ -1,98 +0,0 @@
-# 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

@@ -1,233 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# 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

@@ -1,72 +0,0 @@
-# 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")