deltacat 2.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

deltacat/{storage → experimental/storage}/rivulet/dataset_executor.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 from typing import List, Callable, Any
 
-from deltacat.storage.rivulet.field_group import FieldGroup
-from deltacat.storage.rivulet.mvp.Table import MvpTable
-from deltacat.storage.rivulet import Schema
-from deltacat.storage.rivulet.reader.data_scan import DataScan
-from deltacat.storage.rivulet.reader.dataset_metastore import DatasetMetastore
-from deltacat.storage.rivulet.reader.dataset_reader import DatasetReader
-from deltacat.storage.rivulet.reader.query_expression import QueryExpression
+from deltacat.experimental.storage.rivulet.mvp.Table import MvpTable
+from deltacat.experimental.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet.reader.data_scan import DataScan
+from deltacat.experimental.storage.rivulet.reader.dataset_metastore import (
+    DatasetMetastore,
+)
+from deltacat.experimental.storage.rivulet.reader.dataset_reader import DatasetReader
+from deltacat.experimental.storage.rivulet.reader.query_expression import (
+    QueryExpression,
+)
 
 
 class DatasetExecutor:
@@ -22,12 +25,10 @@ class DatasetExecutor:
 
     def __init__(
         self,
-        field_groups: List[FieldGroup],
         schema: Schema,
         metastore: DatasetMetastore,
     ):
         self.effective_schema: Schema = schema.__deepcopy__()
-        self.field_groups = field_groups
         self.output: MvpTable | None = None
         self._metastore = metastore
 
@@ -64,18 +65,9 @@ class DatasetExecutor:
 
         TODO for now this is doing dumb in-memory implementation and later this is going to be replaced by rust library
         """
-        if len(self.field_groups) == 1:
-            return self._read_as_mvp_table(schema, self.field_groups[0])
-        else:
-            ds1 = self._read_as_mvp_table(schema, self.field_groups[0])
-            ds2 = self._read_as_mvp_table(schema, self.field_groups[1])
-            merged = MvpTable.merge(ds1, ds2, schema.primary_key.name)
-            for i in range(2, len(self.field_groups)):
-                ds_i = self._read_as_mvp_table(schema, self.field_groups[i])
-                merged = MvpTable.merge(merged, ds_i, schema.primary_key.name)
-            return merged
+        return self._read_as_mvp_table(schema)
 
-    def _read_as_mvp_table(self, schema: Schema, field_group: FieldGroup):
+    def _read_as_mvp_table(self, schema: Schema):
         data = list(
             DataScan(
                 schema, QueryExpression(), DatasetReader(self._metastore)

deltacat/experimental/storage/rivulet/feather/__init__.py

@@ -0,0 +1,7 @@
+# TODO later on this will be moved to a dedicated package
+from deltacat.experimental.storage.rivulet.feather.file_reader import FeatherFileReader
+from deltacat.experimental.storage.rivulet.reader.reader_type_registrar import (
+    FileReaderRegistrar,
+)
+
+FileReaderRegistrar.register_reader("feather", FeatherFileReader)

deltacat/{storage → experimental/storage}/rivulet/feather/file_reader.py

@@ -5,15 +5,17 @@ from typing import Optional
 import pyarrow.ipc
 from pyarrow import RecordBatch, RecordBatchFileReader
 
-from deltacat.storage.rivulet.fs.file_provider import FileProvider
-from deltacat.storage.rivulet.metastore.sst import SSTableRow
-from deltacat.storage.rivulet.reader.data_reader import (
+from deltacat.experimental.storage.rivulet.fs.file_provider import FileProvider
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTableRow
+from deltacat.experimental.storage.rivulet.reader.data_reader import (
     RowAndKey,
     FileReader,
     FILE_FORMAT,
 )
-from deltacat.storage.rivulet.reader.pyarrow_data_reader import RecordBatchRowIndex
-from deltacat.storage.rivulet.schema.schema import Schema
+from deltacat.experimental.storage.rivulet.reader.pyarrow_data_reader import (
+    RecordBatchRowIndex,
+)
+from deltacat.experimental.storage.rivulet.schema.schema import Schema
 
 
 class FeatherFileReader(FileReader[RecordBatchRowIndex]):

deltacat/{storage → experimental/storage}/rivulet/feather/serializer.py

@@ -3,10 +3,10 @@ from typing import List
 import pyarrow as pa
 from pyarrow import feather
 
-from deltacat.storage.rivulet.metastore.sst import SSTableRow
-from deltacat.storage.rivulet import Schema
-from deltacat.storage.rivulet.arrow.serializer import ArrowSerializer
-from deltacat.storage.rivulet.fs.file_provider import FileProvider
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTableRow
+from deltacat.experimental.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet.arrow.serializer import ArrowSerializer
+from deltacat.experimental.storage.rivulet.fs.file_provider import FileProvider
 
 
 class FeatherDataSerializer(ArrowSerializer):

deltacat/{storage → experimental/storage}/rivulet/fs/file_provider.py

@@ -3,9 +3,9 @@ import time
 from typing import List, Generator
 
 from deltacat.storage.model.partition import PartitionLocator
-from deltacat.storage.rivulet.fs.file_store import FileStore
-from deltacat.storage.rivulet.fs.input_file import InputFile
-from deltacat.storage.rivulet.fs.output_file import OutputFile
+from deltacat.experimental.storage.rivulet.fs.file_store import FileStore
+from deltacat.experimental.storage.rivulet.fs.input_file import InputFile
+from deltacat.experimental.storage.rivulet.fs.output_file import OutputFile
 from deltacat.utils.metafile_locator import _find_partition_path
 
 

deltacat/{storage → experimental/storage}/rivulet/fs/file_store.py

@@ -4,8 +4,8 @@ from pyarrow.fs import FileSystem, FileType, FileSelector
 # TODO(deltacat): Rely on deltacat implementation to resolve path and filesystem.
 from ray.data.datasource.path_util import _resolve_paths_and_filesystem
 
-from deltacat.storage.rivulet.fs.input_file import FSInputFile
-from deltacat.storage.rivulet.fs.output_file import FSOutputFile
+from deltacat.experimental.storage.rivulet.fs.input_file import FSInputFile
+from deltacat.experimental.storage.rivulet.fs.output_file import FSOutputFile
 
 
 class FileStore:

deltacat/{storage → experimental/storage}/rivulet/fs/output_file.py

@@ -5,7 +5,7 @@ from typing import Protocol
 
 from pyarrow.fs import FileSystem, FileType
 
-from deltacat.storage.rivulet.fs.input_file import FSInputFile, InputFile
+from deltacat.experimental.storage.rivulet.fs.input_file import FSInputFile, InputFile
 
 
 class OutputStream(Protocol):  # pragma: no cover

deltacat/{storage → experimental/storage}/rivulet/logical_plan.py

@@ -1,9 +1,9 @@
 from dataclasses import dataclass
 from typing import List, Callable, Any, Protocol
 
-from deltacat.storage.rivulet.dataset_executor import DatasetExecutor
-from deltacat.storage.rivulet.mvp.Table import MvpTable
-from deltacat.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet.dataset_executor import DatasetExecutor
+from deltacat.experimental.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet.mvp.Table import MvpTable
 
 
 class DatasetOperation(Protocol):
@@ -99,7 +99,7 @@ class LogicalPlan:
         self.operations.append(CollectOperation())
         return self
 
-    def execute(self, executor: DatasetExecutor) -> "MvpTable":
+    def execute(self, executor: DatasetExecutor) -> MvpTable:
         for operation in self.operations:
             operation.visit(executor)
         return executor.output

deltacat/{storage → experimental/storage}/rivulet/metastore/delta.py

@@ -10,7 +10,6 @@ from deltacat.storage import (
     Delta,
     DeltaType,
     Transaction,
-    TransactionType,
     TransactionOperation,
     TransactionOperationType,
 )
@@ -19,7 +18,7 @@ from deltacat.storage.model.partition import PartitionLocator
 from deltacat.storage.model.transaction import TransactionOperationList
 
 from deltacat.storage.model.types import StreamFormat
-from deltacat.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet import Schema
 
 StreamPosition = int
 """The stream position for creating a consistent ordering of manifests."""
@@ -169,7 +168,6 @@ class DeltacatManifestIO(ManifestIO):
         delta["level"] = level
 
         tx_results = Transaction.of(
-            txn_type=TransactionType.APPEND,
             txn_operations=TransactionOperationList.of(
                 [
                     TransactionOperation.of(

deltacat/{storage → experimental/storage}/rivulet/metastore/json_sst.py

@@ -4,9 +4,9 @@ import json
 from itertools import zip_longest
 from typing import List
 
-from deltacat.storage.rivulet.fs.input_file import InputFile
-from deltacat.storage.rivulet.fs.output_file import OutputFile
-from deltacat.storage.rivulet.metastore.sst import (
+from deltacat.experimental.storage.rivulet.fs.input_file import InputFile
+from deltacat.experimental.storage.rivulet.fs.output_file import OutputFile
+from deltacat.experimental.storage.rivulet.metastore.sst import (
     SSTWriter,
     SSTableRow,
     SSTReader,

deltacat/{storage → experimental/storage}/rivulet/metastore/sst.py

@@ -1,8 +1,8 @@
 from dataclasses import dataclass
 from typing import Protocol, Any, List
 
-from deltacat.storage.rivulet.fs.input_file import InputFile
-from deltacat.storage.rivulet.fs.output_file import OutputFile
+from deltacat.experimental.storage.rivulet.fs.input_file import InputFile
+from deltacat.experimental.storage.rivulet.fs.output_file import OutputFile
 
 
 @dataclass(frozen=True)

deltacat/{storage → experimental/storage}/rivulet/metastore/sst_interval_tree.py

@@ -8,9 +8,9 @@ from typing import Any, Dict, Set, List, FrozenSet, Iterable, TypeVar, NamedTupl
 
 from intervaltree import Interval, IntervalTree
 
-from deltacat.storage.rivulet.metastore.delta import DeltaContext
-from deltacat.storage.rivulet.metastore.sst import SSTable, SSTableRow
-from deltacat.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet.metastore.delta import DeltaContext
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTable, SSTableRow
+from deltacat.experimental.storage.rivulet import Schema
 
 T = TypeVar("T")
 

deltacat/experimental/storage/rivulet/parquet/__init__.py

@@ -0,0 +1,7 @@
+# TODO later on this will be moved to a dedicated package
+from deltacat.experimental.storage.rivulet.parquet.file_reader import ParquetFileReader
+from deltacat.experimental.storage.rivulet.reader.reader_type_registrar import (
+    FileReaderRegistrar,
+)
+
+FileReaderRegistrar.register_reader("parquet", ParquetFileReader)

deltacat/{storage → experimental/storage}/rivulet/parquet/file_reader.py

@@ -4,15 +4,17 @@ from typing import Optional
 
 from pyarrow import RecordBatch
 
-from deltacat.storage.rivulet.fs.file_provider import FileProvider
-from deltacat.storage.rivulet.metastore.sst import SSTableRow
-from deltacat.storage.rivulet.reader.data_reader import (
+from deltacat.experimental.storage.rivulet.fs.file_provider import FileProvider
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTableRow
+from deltacat.experimental.storage.rivulet.reader.data_reader import (
     RowAndKey,
     FileReader,
     FILE_FORMAT,
 )
-from deltacat.storage.rivulet.reader.pyarrow_data_reader import RecordBatchRowIndex
-from deltacat.storage.rivulet.schema.schema import Schema
+from deltacat.experimental.storage.rivulet.reader.pyarrow_data_reader import (
+    RecordBatchRowIndex,
+)
+from deltacat.experimental.storage.rivulet.schema.schema import Schema
 import pyarrow.parquet as pq
 import pyarrow as pa
 

deltacat/{storage → experimental/storage}/rivulet/parquet/serializer.py

@@ -3,11 +3,11 @@ from typing import List, Any
 import pyarrow as pa
 from pyarrow.parquet import FileMetaData
 
-from deltacat.storage.rivulet.metastore.sst import SSTableRow
-from deltacat.storage.rivulet import Schema
-from deltacat.storage.rivulet.arrow.serializer import ArrowSerializer
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTableRow
+from deltacat.experimental.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet.arrow.serializer import ArrowSerializer
 
-from deltacat.storage.rivulet.fs.file_provider import FileProvider
+from deltacat.experimental.storage.rivulet.fs.file_provider import FileProvider
 
 
 class ParquetDataSerializer(ArrowSerializer):

deltacat/{storage → experimental/storage}/rivulet/reader/block_scanner.py

@@ -15,19 +15,30 @@ from typing import (
     AbstractSet,
 )
 
-from deltacat.storage.rivulet.metastore.delta import DeltaContext
-from deltacat.storage.rivulet.metastore.sst import SSTableRow
-from deltacat.storage.rivulet.metastore.sst_interval_tree import (
+from deltacat.experimental.storage.rivulet.metastore.delta import DeltaContext
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTableRow
+from deltacat.experimental.storage.rivulet.metastore.sst_interval_tree import (
     OrderedBlockGroups,
     BlockGroup,
     Block,
 )
-from deltacat.storage.rivulet.reader.data_reader import RowAndKey, FileReader
-from deltacat.storage.rivulet.reader.dataset_metastore import DatasetMetastore
-from deltacat.storage.rivulet.reader.pyarrow_data_reader import ArrowDataReader
-from deltacat.storage.rivulet.reader.query_expression import QueryExpression
-from deltacat.storage.rivulet.reader.reader_type_registrar import FileReaderRegistrar
-from deltacat.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet.reader.data_reader import (
+    RowAndKey,
+    FileReader,
+)
+from deltacat.experimental.storage.rivulet.reader.dataset_metastore import (
+    DatasetMetastore,
+)
+from deltacat.experimental.storage.rivulet.reader.pyarrow_data_reader import (
+    ArrowDataReader,
+)
+from deltacat.experimental.storage.rivulet.reader.query_expression import (
+    QueryExpression,
+)
+from deltacat.experimental.storage.rivulet.reader.reader_type_registrar import (
+    FileReaderRegistrar,
+)
+from deltacat.experimental.storage.rivulet import Schema
 from deltacat import logs
 
 logger = logs.configure_deltacat_logger(logging.getLogger(__name__))

deltacat/{storage → experimental/storage}/rivulet/reader/data_reader.py

@@ -13,9 +13,9 @@ from typing import (
     Optional,
 )
 
-from deltacat.storage.rivulet.fs.file_provider import FileProvider
-from deltacat.storage.rivulet.metastore.sst import SSTableRow
-from deltacat.storage.rivulet.schema.schema import Schema
+from deltacat.experimental.storage.rivulet.fs.file_provider import FileProvider
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTableRow
+from deltacat.experimental.storage.rivulet.schema.schema import Schema
 
 FILE_FORMAT = TypeVar("FILE_FORMAT")
 MEMORY_FORMAT = TypeVar("MEMORY_FORMAT")

deltacat/{storage → experimental/storage}/rivulet/reader/data_scan.py

@@ -3,9 +3,11 @@ from typing import Generator, Dict, Optional
 import pyarrow as pa
 
 from deltacat.storage.model.shard import Shard
-from deltacat.storage.rivulet.reader.dataset_reader import DatasetReader
-from deltacat.storage.rivulet.reader.query_expression import QueryExpression
-from deltacat.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet.reader.dataset_reader import DatasetReader
+from deltacat.experimental.storage.rivulet.reader.query_expression import (
+    QueryExpression,
+)
+from deltacat.experimental.storage.rivulet import Schema
 
 
 class DataScan:

deltacat/{storage → experimental/storage}/rivulet/reader/dataset_metastore.py

@@ -5,18 +5,19 @@ from typing import Generator, Optional
 import pyarrow
 import pyarrow.fs
 
+from deltacat.constants import REV_DIR_NAME
 from deltacat.storage import Delta
 from deltacat.storage.model.partition import PartitionLocator
-from deltacat.storage.rivulet.fs.file_provider import FileProvider
+from deltacat.experimental.storage.rivulet.fs.file_provider import FileProvider
 from deltacat.utils.filesystem import resolve_path_and_filesystem
-from deltacat.storage.rivulet.metastore.json_sst import JsonSstReader
-from deltacat.storage.rivulet.metastore.delta import (
+from deltacat.experimental.storage.rivulet.metastore.json_sst import JsonSstReader
+from deltacat.experimental.storage.rivulet.metastore.delta import (
     ManifestIO,
     DeltaContext,
     RivuletDelta,
     DeltacatManifestIO,
 )
-from deltacat.storage.rivulet.metastore.sst import SSTReader, SSTable
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTReader, SSTable
 from deltacat.utils.metafile_locator import _find_table_path
 from deltacat import logs
 
@@ -83,7 +84,7 @@ class DatasetMetastore:
         param: filesystem: The filesystem to search for the revisions.
         returns: The latest revision as a RivuletDelta.
         """
-        rev_directory = posixpath.join(delta_dir, "rev")
+        rev_directory = posixpath.join(delta_dir, REV_DIR_NAME)
         revisions = filesystem.get_file_info(
             pyarrow.fs.FileSelector(rev_directory, allow_not_found=True)
         )
@@ -128,7 +129,7 @@ class DatasetMetastore:
             return
 
         # Locate "rev" directory inside the partition
-        rev_directory = posixpath.join(partition_path, "rev")
+        rev_directory = posixpath.join(partition_path, REV_DIR_NAME)
         rev_info = filesystem.get_file_info(rev_directory)
 
         if rev_info.type != pyarrow.fs.FileType.Directory:

deltacat/{storage → experimental/storage}/rivulet/reader/dataset_reader.py

@@ -2,18 +2,20 @@ import logging
 from typing import Generator, Optional, Set, Type, TypeVar, Any
 
 from deltacat.storage.model.shard import Shard
-from deltacat.storage.rivulet.metastore.sst import SSTableRow, SSTable
-from deltacat.storage.rivulet.metastore.sst_interval_tree import (
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTableRow, SSTable
+from deltacat.experimental.storage.rivulet.metastore.sst_interval_tree import (
     BlockIntervalTree,
     OrderedBlockGroups,
 )
-from deltacat.storage.rivulet.reader.block_scanner import BlockScanner
-from deltacat.storage.rivulet.reader.dataset_metastore import (
+from deltacat.experimental.storage.rivulet.reader.block_scanner import BlockScanner
+from deltacat.experimental.storage.rivulet.reader.dataset_metastore import (
     DatasetMetastore,
     ManifestAccessor,
 )
-from deltacat.storage.rivulet.reader.query_expression import QueryExpression
-from deltacat.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet.reader.query_expression import (
+    QueryExpression,
+)
+from deltacat.experimental.storage.rivulet import Schema
 
 # The type of data returned to reader
 T = TypeVar("T")

deltacat/{storage → experimental/storage}/rivulet/reader/pyarrow_data_reader.py

@@ -4,7 +4,10 @@ from typing import Generator, Dict, Type, NamedTuple, List
 
 from pyarrow import RecordBatch
 
-from deltacat.storage.rivulet.reader.data_reader import DataReader, MEMORY_FORMAT
+from deltacat.experimental.storage.rivulet.reader.data_reader import (
+    DataReader,
+    MEMORY_FORMAT,
+)
 import pyarrow as pa
 
 

deltacat/{storage → experimental/storage}/rivulet/reader/reader_type_registrar.py

@@ -1,9 +1,9 @@
-from deltacat.storage.rivulet.fs.file_provider import FileProvider
-from deltacat.storage.rivulet.metastore.sst import SSTableRow
-from deltacat.storage.rivulet.reader.data_reader import FileReader
+from deltacat.experimental.storage.rivulet.fs.file_provider import FileProvider
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTableRow
+from deltacat.experimental.storage.rivulet.reader.data_reader import FileReader
 from typing import Type, Dict
 
-from deltacat.storage.rivulet.schema.schema import Schema
+from deltacat.experimental.storage.rivulet.schema.schema import Schema
 
 
 class FileReaderRegistrar:

deltacat/{storage → experimental/storage}/rivulet/schema/schema.py

@@ -5,7 +5,7 @@ from typing import MutableMapping, Dict, Iterable, Tuple, Optional
 
 import pyarrow as pa
 
-from deltacat.storage.rivulet.schema.datatype import Datatype
+from deltacat.experimental.storage.rivulet.schema.datatype import Datatype
 
 
 @dataclass(frozen=True)

deltacat/{storage → experimental/storage}/rivulet/serializer.py

@@ -1,6 +1,6 @@
 from typing import Protocol, Iterable, List, Union, Any, Dict
 
-from deltacat.storage.rivulet.metastore.sst import SSTableRow
+from deltacat.experimental.storage.rivulet.metastore.sst import SSTableRow
 import pyarrow as pa
 
 MEMTABLE_DATA = Union[Iterable[Dict[str, Any]], pa.Table]

deltacat/{storage → experimental/storage}/rivulet/serializer_factory.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
-from deltacat.storage.rivulet.parquet.serializer import ParquetDataSerializer
-from deltacat.storage.rivulet import Schema
-from deltacat.storage.rivulet.serializer import DataSerializer
-from deltacat.storage.rivulet.fs.file_provider import FileProvider
+from deltacat.experimental.storage.rivulet.parquet.serializer import (
+    ParquetDataSerializer,
+)
+from deltacat.experimental.storage.rivulet import Schema
+from deltacat.experimental.storage.rivulet.serializer import DataSerializer
+from deltacat.experimental.storage.rivulet.fs.file_provider import FileProvider
 
-from deltacat.storage.rivulet.feather.serializer import FeatherDataSerializer
+from deltacat.experimental.storage.rivulet.feather.serializer import (
+    FeatherDataSerializer,
+)
 
 
 class DataSerializerFactory:

deltacat/experimental/storage/rivulet/shard/range_shard.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+from typing import Generic, List, Union, Iterable
+from deltacat.storage.model.shard import T, Shard, ShardingStrategy
+from deltacat.experimental.storage.rivulet.reader.dataset_metastore import (
+    DatasetMetastore,
+)
+
+
+class RangeShard(Shard, Generic[T]):
+    """
+    Represents a range-based shard with minimum and maximum keys.
+
+    param: min_key: The minimum key for the shard.
+    param: max_key: The maximum key for the shard.
+    """
+
+    def __init__(self, min_key: T, max_key: T):
+        self.min_key = min_key
+        self.max_key = max_key
+
+    def __repr__(self) -> str:
+        return f"Shard(type=range, min_key={self.min_key}, max_key={self.max_key})"
+
+    @staticmethod
+    def split(
+        global_min: Union[int, str], global_max: Union[int, str], num_shards: int
+    ) -> List[RangeShard]:
+        """
+        Splits a range into `num_shards` shards.
+        Currently supports splitting ranges of integers and strings.
+
+        Note: If global_min == global_max or num_shards <= 1, a single shard is returned,
+              num_shards is ignored.
+
+        :param global_min: The minimum key for the entire range (int or str).
+        :param global_max: The maximum key for the entire range (int or str).
+        :param num_shards: The number of shards to create.
+        :return: A list of RangeShard objects.
+        """
+        if global_min == global_max or num_shards <= 1:
+            return [RangeShard(global_min, global_max)]
+
+        # Determine which interpolation function to use based on the type of min/max
+        if isinstance(global_min, int) and isinstance(global_max, int):
+            interpolate = RangeShard._interpolate_numeric
+        elif isinstance(global_min, str) and isinstance(global_max, str):
+            interpolate = RangeShard._interpolate_str
+        else:
+            raise ValueError(
+                "Unsupported combination of types for global_min and global_max."
+            )
+
+        shards: List[RangeShard] = []
+        for i in range(num_shards):
+            start = interpolate(global_min, global_max, i, num_shards)
+            end = interpolate(global_min, global_max, i + 1, num_shards)
+
+            if i > 0:
+                if isinstance(start, int):
+                    start = shards[-1].max_key + 1
+                elif isinstance(start, int):
+                    char_list = list(start)
+                    char_list[-1] = chr(ord(char_list[-1]) + 1)
+                    start = "".join(char_list)
+
+            shards.append(RangeShard(start, end))
+
+        return shards
+
+    @staticmethod
+    def _interpolate_numeric(start: int, end: int, step: int, total_steps: int) -> int:
+        """
+        Integer interpolation using integer (floor) division.
+
+        param: start (int): The starting number.
+        param: end (int): The ending number.
+        param: step (int): The current step in the interpolation (0-based).
+        param: total_steps (int): The total number of interpolation steps.
+
+        returns: int: The interpolated integer.
+        """
+        return start + (end - start) * step // total_steps
+
+    @staticmethod
+    def _interpolate_str(start: str, end: str, step: int, total_steps: int) -> str:
+        """
+        Interpolates between two strings lexicographically.
+
+        param: start (str): The starting string.
+        param: end (str): The ending string.
+        param: step (int): The current step in the interpolation (0-based).
+        param: total_steps (int): The total number of interpolation steps.
+
+        returns: str: The interpolated string.
+        """
+        max_len = max(len(start), len(end))
+
+        # Pad strings to the same length with spaces (smallest lexicographical character).
+        start = start.ljust(max_len, " ")
+        end = end.ljust(max_len, " ")
+
+        # Interpolate character by character based on ordinal values.
+        interpolated_chars = [
+            chr(round(ord(s) + (ord(e) - ord(s)) * step / total_steps))
+            for s, e in zip(start, end)
+        ]
+
+        return "".join(interpolated_chars).rstrip()
+
+
+class RangeShardingStrategy(ShardingStrategy, Generic[T]):
+    """
+    Implements a sharding strategy to divide a range of keys into shards.
+
+    method: shards: Generates a list of RangeShard objects based on the global range.
+    """
+
+    def shards(
+        self, num_shards: int, metastore: DatasetMetastore
+    ) -> Iterable[RangeShard[T]]:
+        """
+        Divides the global range of keys into evenly sized shards.
+
+        param: num_shards: The number of shards to divide the range into.
+        param: metastore: The dataset metastore providing access to manifests.
+        returns: A list of RangeShard objects representing the divided range.
+        """
+        min, max = metastore.get_min_max_keys()
+        return RangeShard.split(min, max, num_shards)