pyspiral 0.5.0__cp310-abi3-macosx_11_0_arm64.whl → 0.6.0__cp310-abi3-macosx_11_0_arm64.whl

spiral/streaming_/stream.py

@@ -0,0 +1,146 @@
+import os
+import tempfile
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from spiral.core.client import Shard
+from spiral.core.table import Scan as CoreScan
+from spiral.streaming_.reader import SpiralReader
+
+if TYPE_CHECKING:
+    from streaming.base.array import NDArray
+    from streaming.base.format import Reader
+    from streaming.base.world import World
+
+
+class SpiralStream:
+    """
+    An MDS (streaming) compatible Stream.
+
+    The stream does not extend the default Stream class, but it is compactible with its API.
+
+    The stream is not registered with MDS, as the only way to construct the stream is through Spiral client.
+    Stream can be passed to MDS's StreamingDataset in `streams` argument.
+    """
+
+    def __init__(self, scan: CoreScan, shards: list[Shard], cache_dir: str | None = None):
+        self._scan = scan
+        # TODO(marko): Read shards only on world.is_local_leader in `get_shards` and materialize on disk.
+        self._shards = shards
+
+        if cache_dir is not None:
+            if not os.path.exists(cache_dir):
+                os.makedirs(cache_dir, exist_ok=True)
+            if not os.path.isdir(cache_dir):
+                raise ValueError(f"Cache dir {cache_dir} is not a directory.")
+        else:
+            cache_dir = tempfile.gettempdir()
+        self._cache_dir = cache_dir
+
+        # Enure split directory exists.
+        os.makedirs(os.path.join(self._cache_dir, self.split), exist_ok=True)
+
+    @property
+    def local(self) -> str:
+        # Dataset: Register/lookup our shared memory prefix and filelock root directory.
+        return self._cache_dir
+
+    @property
+    def remote(self) -> str | None:
+        # Dataset: Register/lookup our shared memory prefix and filelock root directory.
+        return None
+
+    @property
+    def split(self) -> str:
+        # Dataset: Register/lookup our shared memory prefix and filelock root directory.
+        return "default"
+
+    @classmethod
+    def validate_weights(cls, streams) -> tuple[bool, bool]:
+        from streaming.base.stream import Stream
+
+        return Stream.validate_weights(streams)
+
+    @classmethod
+    def apply_weights(cls, streams, samples_per_stream, choose_per_epoch, seed) -> int:
+        from streaming.base.stream import Stream
+
+        return Stream.apply_weights(streams, samples_per_stream, choose_per_epoch, seed)
+
+    def apply_default(self, default: dict):
+        # Applies defaults from the StreamingDataset.
+        # 'remote', 'local', 'split', 'download_retry', 'download_timeout', 'validate_hash', 'keep_zip'
+        if default["split"] is not None:
+            raise ValueError("SpiralStream does not support split, as the split is defined in the Scan.")
+
+    def prepare_shard(self, shard: "Reader") -> int:
+        """Ensure (download, validate, extract, etc.) that we have the given shard.
+
+        Args:
+            shard (Reader): Which shard.
+
+        Returns:
+            int: Change in cache usage.
+        """
+        if not isinstance(shard, SpiralReader):
+            raise ValueError("Only SpiralReader is supported in SpiralStream")
+
+        shard_path = os.path.join(self._cache_dir, self.split, shard.filename)
+        if os.path.exists(shard_path):
+            # Already exists.
+            return 0
+
+        # This method exists but it's hidden.
+        self._scan._prepare_shard(shard_path, shard.shard.key_range, expected_cardinality=shard.shard.cardinality)
+
+        # Get the size of the file on disk.
+        stat = os.stat(shard_path)
+        return stat.st_size
+
+    def get_shards(self, world: "World", allow_unsafe_types: bool) -> list["Reader"]:
+        """Load this Stream's index, retrieving its shard readers.
+
+        Args:
+            world (World): Distributed context.
+            allow_unsafe_types (bool): If a shard contains Pickle, which allows arbitrary code
+                execution during deserialization, whether to keep going if ``True`` or raise an error.
+                This argument is ignored as SpiralStream does not support Pickle.
+
+        Returns:
+            `List[Reader]: Shard readers.
+        """
+        basepath = os.path.join(self._cache_dir, self.split)
+        return [SpiralReader(shard, basepath) for shard in self._shards]  # type: ignore[return-value]
+
+    def set_up_local(self, shards: list["Reader"], cache_usage_per_shard: "NDArray[np.int64]") -> None:
+        """Bring a local directory into a consistent state, getting which shards are present.
+
+        Args:
+            shards (List[Reader]): List of this stream's shards.
+            cache_usage_per_shard (NDArray[np.int64]): Cache usage per shard of this stream.
+        """
+        listing = set()
+        for file in os.listdir(os.path.join(self._cache_dir, self.split)):
+            if os.path.isfile(os.path.join(self._cache_dir, self.split, file)) and file.endswith(".vortex"):
+                listing.add(file)
+
+        # Determine which shards are present, making local dir consistent.
+        for i, shard in enumerate(shards):
+            if not isinstance(shard, SpiralReader):
+                raise ValueError("Only SpiralReader is supported in SpiralStream")
+            if shard.filename in listing:
+                # Get the size of the file on disk.
+                stat = os.stat(os.path.join(self._cache_dir, self.split, shard.filename))
+                cache_usage_per_shard[i] = stat.st_size
+            else:
+                cache_usage_per_shard[i] = 0
+
+    def get_index_size(self) -> int:
+        """Get the size of the index file in bytes.
+
+        Returns:
+            int: Size in bytes.
+        """
+        # There is no index file stored on disk.
+        return 0

spiral/substrait_.py

@@ -1,9 +1,9 @@
-import betterproto
+import betterproto2
 import pyarrow as pa
 
 import spiral.expressions as se
 from spiral.expressions.base import Expr
-from spiral.protogen.substrait import (
+from spiral.protogen._.substrait import (
     Expression,
     ExpressionFieldReference,
     ExpressionLiteral,
@@ -17,7 +17,7 @@ from spiral.protogen.substrait import (
     ExpressionScalarFunction,
     ExtendedExpression,
 )
-from spiral.protogen.substrait.extensions import (
+from spiral.protogen._.substrait.extensions import (
     SimpleExtensionDeclaration,
     SimpleExtensionDeclarationExtensionFunction,
     SimpleExtensionDeclarationExtensionType,
@@ -58,7 +58,7 @@ class SubstraitConverter:
         return self._expr(expr.referred_expr[0].expression)
 
     def _extension_declaration(self, ext: SimpleExtensionDeclaration):
-        match betterproto.which_one_of(ext, "mapping_type"):
+        match betterproto2.which_one_of(ext, "mapping_type"):
             case "extension_function", ext_func:
                 self._extension_function(ext_func)
             case "extension_type", ext_type:
@@ -152,7 +152,7 @@ class SubstraitConverter:
         raise NotImplementedError()
 
     def _expr(self, expr: Expression) -> Expr:
-        match betterproto.which_one_of(expr, "rex_type"):
+        match betterproto2.which_one_of(expr, "rex_type"):
             case "literal", e:
                 return self._expr_literal(e)
             case "selection", e:
@@ -196,7 +196,7 @@ class SubstraitConverter:
             "fixed_binary",
         }
 
-        match betterproto.which_one_of(expr, "literal_type"):
+        match betterproto2.which_one_of(expr, "literal_type"):
             case type_, v if type_ in simple:
                 return se.scalar(pa.scalar(v))
             case "timestamp", v:
@@ -225,7 +225,7 @@ class SubstraitConverter:
                 raise NotImplementedError(f"Literal type not supported: {literal_type}")
 
     def _expr_selection(self, expr: ExpressionFieldReference):
-        match betterproto.which_one_of(expr, "root_type"):
+        match betterproto2.which_one_of(expr, "root_type"):
             case "root_reference", _:
                 # The reference is relative to the root
                 base_expr = self.scope
@@ -233,7 +233,7 @@ class SubstraitConverter:
             case _:
                 raise NotImplementedError("Only root_reference expressions are supported")
 
-        match betterproto.which_one_of(expr, "reference_type"):
+        match betterproto2.which_one_of(expr, "reference_type"):
             case "direct_reference", direct_ref:
                 return self._expr_direct_reference(base_expr, base_type, direct_ref)
             case "masked_reference", masked_ref:
@@ -242,7 +242,7 @@ class SubstraitConverter:
                 raise NotImplementedError()
 
     def _expr_direct_reference(self, scope: Expr, scope_type: pa.StructType, expr: ExpressionReferenceSegment):
-        match betterproto.which_one_of(expr, "reference_type"):
+        match betterproto2.which_one_of(expr, "reference_type"):
             case "map_key", ref:
                 raise NotImplementedError("Map types not yet supported in Spiral")
             case "struct_field", ref:

spiral/table.py

@@ -0,0 +1,257 @@
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from spiral.core.table import Table as CoreTable
+from spiral.core.table.spec import Schema
+from spiral.expressions.base import Expr, ExprLike
+from spiral.settings import settings
+from spiral.snapshot import Snapshot
+from spiral.transaction import Transaction
+
+if TYPE_CHECKING:
+    import duckdb
+    import polars as pl
+    import pyarrow.dataset as ds
+    import streaming
+    import torch.utils.data as torchdata  # noqa
+
+    from spiral.client import Spiral
+    from spiral.key_space_index import KeySpaceIndex
+
+
+class Table(Expr):
+    """API for interacting with a SpiralDB's Table.
+
+    Spiral Table is a powerful and flexible way for storing, analyzing,
+    and querying massive and/or multimodal datasets. The data model will feel familiar
+    to users of SQL- or DataFrame-style systems, yet is designed to be more flexible, more powerful,
+    and more useful in the context of modern data processing.
+
+    Tables are stored and queried directly from object storage.
+    """
+
+    def __init__(self, spiral: "Spiral", core: CoreTable, *, identifier: str | None = None):
+        super().__init__(core.__expr__)
+
+        self.spiral = spiral
+        self.core = core
+
+        self._key_schema = core.key_schema
+        self._key_columns = set(self._key_schema.names)
+        self._identifier = identifier
+
+    @property
+    def table_id(self) -> str:
+        return self.core.id
+
+    @property
+    def identifier(self) -> str:
+        """Returns the fully qualified identifier of the table."""
+        return self._identifier or self.table_id
+
+    @property
+    def dataset(self) -> str | None:
+        """Returns the dataset of the table."""
+        if self._identifier is None:
+            return None
+        _, dataset, _ = self._identifier.split(".")
+        return dataset
+
+    @property
+    def name(self) -> str | None:
+        """Returns the name of the table."""
+        if self._identifier is None:
+            return None
+        _, _, name = self._identifier.split(".")
+        return name
+
+    def last_modified_at(self) -> int:
+        return self.core.get_wal(asof=None).last_modified_at
+
+    def __str__(self):
+        return self.identifier
+
+    def __repr__(self):
+        return f'Table("{self.identifier}")'
+
+    def __getitem__(self, item: str) -> Expr:
+        return super().__getitem__(item)
+
+    def select(self, *paths: str, exclude: list[str] = None) -> "Expr":
+        return super().select(*paths, exclude=exclude)
+
+    @property
+    def key_schema(self) -> Schema:
+        """Returns the key schema of the table."""
+        return self._key_schema
+
+    def schema(self) -> Schema:
+        """Returns the FULL schema of the table.
+
+        NOTE: This can be expensive for large tables.
+        """
+        return self.core.get_schema(asof=None)
+
+    def write(
+        self,
+        expr: ExprLike,
+        *,
+        partition_size_bytes: int | None = None,
+    ) -> None:
+        """Write an item to the table inside a single transaction.
+
+        :param expr: The expression to write. Must evaluate to a struct array.
+        :param partition_size_bytes: The maximum partition size in bytes.
+        """
+        with self.txn() as txn:
+            txn.write(
+                expr,
+                partition_size_bytes=partition_size_bytes,
+            )
+
+    def snapshot(self, asof: datetime | int | None = None) -> Snapshot:
+        """Returns a snapshot of the table at the given timestamp."""
+        if isinstance(asof, datetime):
+            asof = int(asof.timestamp() * 1_000_000)
+        return Snapshot(self, self.core.get_snapshot(asof=asof))
+
+    def txn(self) -> Transaction:
+        """Begins a new transaction. Transaction must be committed for writes to become visible.
+
+        IMPORTANT: While transaction can be used to atomically write data to the table,
+             it is important that the primary key columns are unique within the transaction.
+        """
+        return Transaction(self.spiral._core.transaction(self.core, settings().file_format))
+
+    def to_dataset(self) -> "ds.Dataset":
+        """Returns a PyArrow Dataset representing the table."""
+        return self.snapshot().to_dataset()
+
+    def to_polars(self) -> "pl.LazyFrame":
+        """Returns a Polars LazyFrame for the Spiral table."""
+        return self.snapshot().to_polars()
+
+    def to_duckdb(self) -> "duckdb.DuckDBPyRelation":
+        """Returns a DuckDB relation for the Spiral table."""
+        return self.snapshot().to_duckdb()
+
+    def to_data_loader(self, *, index: "KeySpaceIndex", **kwargs) -> "torchdata.DataLoader":
+        """Returns a PyTorch DataLoader.
+
+        Requires `torch` and `streaming` package to be installed.
+
+        Args:
+            index: See `streaming` method.
+            **kwargs: Additional arguments passed to the PyTorch DataLoader constructor.
+
+        """
+        from streaming import StreamingDataLoader
+
+        dataset_kwargs = {}
+        if "batch_size" in kwargs:
+            # Keep it in kwargs for DataLoader
+            dataset_kwargs["batch_size"] = kwargs["batch_size"]
+        if "cache_limit" in kwargs:
+            dataset_kwargs["cache_limit"] = kwargs.pop("cache_limit")
+        if "sampling_method" in kwargs:
+            dataset_kwargs["sampling_method"] = kwargs.pop("sampling_method")
+        if "sampling_granularity" in kwargs:
+            dataset_kwargs["sampling_granularity"] = kwargs.pop("sampling_granularity")
+        if "partition_algo" in kwargs:
+            dataset_kwargs["partition_algo"] = kwargs.pop("partition_algo")
+        if "num_canonical_nodes" in kwargs:
+            dataset_kwargs["num_canonical_nodes"] = kwargs.pop("num_canonical_nodes")
+        if "shuffle" in kwargs:
+            dataset_kwargs["shuffle"] = kwargs.pop("shuffle")
+        if "shuffle_algo" in kwargs:
+            dataset_kwargs["shuffle_algo"] = kwargs.pop("shuffle_algo")
+        if "shuffle_seed" in kwargs:
+            dataset_kwargs["shuffle_seed"] = kwargs.pop("shuffle_seed")
+        if "shuffle_block_size" in kwargs:
+            dataset_kwargs["shuffle_block_size"] = kwargs.pop("shuffle_block_size")
+        if "batching_method" in kwargs:
+            dataset_kwargs["batching_method"] = kwargs.pop("batching_method")
+        if "replication" in kwargs:
+            dataset_kwargs["replication"] = kwargs.pop("replication")
+
+        dataset = self.to_streaming_dataset(index=index, **dataset_kwargs)
+
+        return StreamingDataLoader(dataset=dataset, **kwargs)
+
+    def to_streaming_dataset(
+        self,
+        *,
+        index: "KeySpaceIndex",
+        batch_size: int | None = None,
+        cache_limit: int | str | None = None,
+        sampling_method: str = "balanced",
+        sampling_granularity: int = 1,
+        partition_algo: str = "relaxed",
+        num_canonical_nodes: int | None = None,
+        shuffle: bool = False,
+        shuffle_algo: str = "py1e",
+        shuffle_seed: int = 9176,
+        shuffle_block_size: int | None = None,
+        batching_method: str = "random",
+        replication: int | None = None,
+    ) -> "streaming.StreamingDataset":
+        """Returns a MosaicML's StreamingDataset that can be used for distributed training.
+
+        Requires `streaming` package to be installed.
+
+        Args:
+            See `streaming` method for `index` arg.
+            See MosaicML's `StreamingDataset` for other args.
+
+        This is a helper method to construct a single stream dataset from the scan. When multiple streams are combined,
+        use `to_stream` to get the SpiralStream and construct the StreamingDataset manually using a `streams` arg.
+        """
+        from streaming import StreamingDataset
+
+        stream = self.to_streaming(index=index)
+
+        return StreamingDataset(
+            streams=[stream],
+            batch_size=batch_size,
+            cache_limit=cache_limit,
+            sampling_method=sampling_method,
+            sampling_granularity=sampling_granularity,
+            partition_algo=partition_algo,
+            num_canonical_nodes=num_canonical_nodes,
+            shuffle=shuffle,
+            shuffle_algo=shuffle_algo,
+            shuffle_seed=shuffle_seed,
+            shuffle_block_size=shuffle_block_size,
+            batching_method=batching_method,
+            replication=replication,
+        )
+
+    def to_streaming(self, index: "KeySpaceIndex") -> "streaming.Stream":
+        """Returns a stream to be used with MosaicML's StreamingDataset.
+
+        Requires `streaming` package to be installed.
+
+        Args:
+            index: Prebuilt KeysIndex to use when creating the stream. The index's `asof` will be used when scanning.
+        """
+        from spiral.streaming_ import SpiralStream
+
+        if index.table_id != self.table_id:
+            raise ValueError("Index must be built on the same table as the scan.")
+        if index.asof == 0:
+            raise ValueError("Index have to be synced before it can be used in a stream.")
+
+        # We know table from projection is in the session cause this method is on it.
+        scan = self.spiral.scan(
+            index.projection,
+            where=index.filter,
+            asof=index.asof,
+            # TODO(marko): This should be configurable?
+            exclude_keys=True,
+        )
+
+        # TODO(marko): This should happen in prepare_shards in Stream?
+        #   We have a world there and can compute shards only on leader.
+        shards = self.spiral._core._ops().compute_shards(index=index.core)
+
+        return SpiralStream(scan=scan.core, shards=shards)  # type: ignore[return-value]

spiral/text_index.py

@@ -0,0 +1,17 @@
+from spiral.core.client import TextIndex as CoreTextIndex
+from spiral.expressions import Expr
+
+
+class TextIndex(Expr):
+    def __init__(self, core: CoreTextIndex, *, name: str | None = None):
+        super().__init__(core.__expr__)
+        self.core = core
+        self._name = name
+
+    @property
+    def index_id(self) -> str:
+        return self.core.id
+
+    @property
+    def name(self) -> str:
+        return self._name or self.index_id

spiral/{tables/transaction.py → transaction.py}

@@ -1,9 +1,5 @@
-from typing import TYPE_CHECKING
-
-from spiral.core.table import TableTransaction
-
-if TYPE_CHECKING:
-    from spiral.expressions.base import ExprLike
+from spiral.core.table import Transaction as CoreTransaction
+from spiral.expressions.base import ExprLike
 
 
 class Transaction:
@@ -13,24 +9,24 @@ class Transaction:
             it is important that the primary key columns are unique within the transaction.
     """
 
-    def __init__(self, transaction: TableTransaction):
-        self._transaction = transaction
+    def __init__(self, core: CoreTransaction):
+        self._core = core
 
     @property
     def status(self) -> str:
         """The status of the transaction."""
-        return self._transaction.status
+        return self._core.status
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
         if exc_type is None:
-            self._transaction.commit()
+            self._core.commit()
         else:
-            self._transaction.abort()
+            self._core.abort()
 
-    def write(self, expr: "ExprLike", *, partition_size_bytes: int | None = None):
+    def write(self, expr: ExprLike, *, partition_size_bytes: int | None = None):
         """Write an item to the table inside a single transaction.
 
         :param expr: The expression to write. Must evaluate to a struct array.
@@ -41,12 +37,12 @@ class Transaction:
 
         expr = se.lift(expr)
 
-        self._transaction.write(expr.__expr__, partition_size_bytes=partition_size_bytes)
+        self._core.write(expr.__expr__, partition_size_bytes=partition_size_bytes)
 
     def commit(self):
         """Commit the transaction."""
-        self._transaction.commit()
+        self._core.commit()
 
     def abort(self):
         """Abort the transaction."""
-        self._transaction.abort()
+        self._core.abort()

pyspiral-0.5.0.dist-info/RECORD

@@ -1,103 +0,0 @@
-pyspiral-0.5.0.dist-info/METADATA,sha256=J_bR2LwG0i6M8wB0-60AXJm8MutIfqs9QUbaINmBeTI,1641
-pyspiral-0.5.0.dist-info/WHEEL,sha256=Mdosfxua6Dx1zYgObRH97e3wyiELqBbLtoRJj4RUSQE,103
-pyspiral-0.5.0.dist-info/entry_points.txt,sha256=uft7u-a6g40NLt4Q6BleWbK4NY0M8nZuYPpP8DV0EOk,45
-spiral/__init__.py,sha256=Jv1vbcnnmcTsBLN5mSNjnX3ae4C_mgojXDSBFaqIhN0,208
-spiral/_lib.abi3.so,sha256=4J6RSb9LxUWqUnRZeyccSneyjqEFfIrJ6lMCnsNUqbc,60398416
-spiral/adbc.py,sha256=RIIWBew7zPoQa_h3I-A-nX9cUMDM3D3Je0mqE9aDX9k,14885
-spiral/api/__init__.py,sha256=nzZK3r1K2GSaqaLoIba4WuyUyG7ApjLZ4fyJovT1unA,2000
-spiral/api/admin.py,sha256=A1iVR1XYJSObZivPAD5UzmPuMgupXc9kaHNYYa_kwfs,585
-spiral/api/client.py,sha256=XQaOd1DgLTDOxW_uZUeTX5UCnUpPV1unjxbzWLlPJaM,4650
-spiral/api/filesystems.py,sha256=EA4iqhTeaIlvObvEUxHmZl0pQ24IOxUVWM3GPhFLw8o,4969
-spiral/api/organizations.py,sha256=B-8zZ7lFJANGK7dUNbo_aU-cgI959JBP9VcWb6wdgi0,1895
-spiral/api/projects.py,sha256=mvyp4tnUhItNnPnyWsj0WrSf2ca3mggL7KjXs5Fllco,5671
-spiral/api/telemetry.py,sha256=tfdA3E_EWJwFVxkQfkm8tiYGRubnx2LuE5nbfsk1oG4,474
-spiral/api/text_indexes.py,sha256=f8AcrYaBKsaka5A4okuExl96A-2rBbsgru98l_xogwo,1826
-spiral/api/types.py,sha256=lGdiKViRgIEJXD2ubwnyEIEwHkfRumlZjVEaHMV3Tm8,682
-spiral/api/workers.py,sha256=0wZNUHMioDT53P1OBJfpjyDfIodHwwT6858z2IlRIM4,636
-spiral/api/workloads.py,sha256=XAyXV7vgZcoyyoPoGvOT4jTpyFKFMvrrAfhL6d1h1kE,1748
-spiral/arrow_.py,sha256=T1LZ7bh9aMDbXfpUsf0dR0E1roTQyAYSgZ2mL4s8J_4,7681
-spiral/cli/__init__.py,sha256=ooAFz_iCpVCKHE0TiVElIynbP2PtTgD9cUw46Vh1lcw,2145
-spiral/cli/__main__.py,sha256=kNaKM2xgJo7GRogf83nYldLM-RGUR6vymdGwZxywQu0,71
-spiral/cli/admin.py,sha256=7WbU_tr05clUjmZ-RkKTlvcf1pbXIElRfHRJlCItFGk,326
-spiral/cli/app.py,sha256=-k0rrLbfJRLay_2_MOCt57PLcx0VnNMCkrnKV7j7nos,1725
-spiral/cli/console.py,sha256=6JHbAQV6MFWz3P-VzqPOjhHpkIQagsCdzTMvmuDKMkU,2580
-spiral/cli/fs.py,sha256=dVPoAoAbuQ9yJlfI-JiFgS9VdnPmeBMygVHgehJRj34,4367
-spiral/cli/iceberg/__init__.py,sha256=IQV_gwCFSj6Ubxs58VM9Pal1ymgG2bxdDgOPuk9E5bs,214
-spiral/cli/iceberg/namespaces.py,sha256=x9pvHlcXtcATYYjqimHa6CtkyL3taQUJ--ni_Bfoemc,1510
-spiral/cli/iceberg/tables.py,sha256=nSR4-t54otJfCmubB6vXnbOkbqPVGV0sHBlc-t9cIVg,1930
-spiral/cli/indexes/__init__.py,sha256=yNMBZh3kAz1NXsridvbY4-4jNIJAgntBhDnu1EfaZTI,1291
-spiral/cli/indexes/args.py,sha256=B4zAFnVZKPHq-_z8qnHYwgs1v4c-w_iypbA5MdXL67s,1139
-spiral/cli/indexes/workers.py,sha256=mu-7-Asz1txNtCkoei6q-m-lE5YhLUjCDwstKJcew40,2169
-spiral/cli/login.py,sha256=InKMnpV8NATW5RPgB3ZL-DSVPzUuUByyK4Fx7pZEgfg,607
-spiral/cli/orgs.py,sha256=V-4ZTT3FwFQLcs1-BenC8uCgvWOJcxkZPSdCPfsexhc,2848
-spiral/cli/printer.py,sha256=W83KAE-7meoDD1yRltLQrZqrA2olGapBGy_2USWkY08,1778
-spiral/cli/projects.py,sha256=TKXu_VzkIUccwXzdlg-wQMkrB-Py33g052NrbuJx-D4,5096
-spiral/cli/state.py,sha256=10wTIVQ0SJkY67Z6-KQ1LFlt3aVIPmZhoHFdTwp4kNA,130
-spiral/cli/tables/__init__.py,sha256=DTxviiflWZkUDmPhuGzXmhW2mNRgPNkJcaP7olFtXpc,2678
-spiral/cli/tables/args.py,sha256=bxKQoJuWhCTHlDYz_WRQ6_Kp9XgRBH1UIMgUMzlxliA,1262
-spiral/cli/telemetry.py,sha256=ABDCyV5QJGOIJp4AxvK0LG5xNPIysP37K5haL38T7P4,586
-spiral/cli/types.py,sha256=YG1eHhRLaqlVU_18DQBuF_YMsabhMZLBY0V9CvbSxjY,1369
-spiral/cli/workloads.py,sha256=SbxgwiBlX1AuqpOLV3gs7DFkH-Tbeend7qJTwq0Je84,1994
-spiral/client.py,sha256=K-OuMOTgYxOA9vef5jSANjmPRBfGrzQ65fg6Fd-rHMY,2683
-spiral/core/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/core/client/__init__.pyi,sha256=Tn1OJmkO1rQUsPE9BtfEyxIjoife6s16qOd8XiyHi2c,3475
-spiral/core/index/__init__.pyi,sha256=MBq-jBuTmBreYMJ4AJFAe4e-ByRMM7JVssuEJMLVfQs,131
-spiral/core/table/__init__.pyi,sha256=XhN9xpDdBnugRhtiP9ThC3DSADoLMDL9lxSjjY7fJ28,3296
-spiral/core/table/manifests/__init__.pyi,sha256=3V59-K1qr1z2dGfgRKXaHSVheK8NNw8Q8PFhfbeQd_4,1065
-spiral/core/table/metastore/__init__.pyi,sha256=dMqySDnsjPUTBuFU2MaQGyocKEoGkWpeTQmUP2iIKbc,1880
-spiral/core/table/spec/__init__.pyi,sha256=D4GQp9RWwyLKTlRW7eDXcQE-xA5rF2iBcXZ8y7b48EE,5595
-spiral/datetime_.py,sha256=1TA1RYIRU22qcUuipIjVhAtGnPDVn2z9WttuhkmfkwY,964
-spiral/expressions/__init__.py,sha256=T8PIb0_UB9kynK0dpWbUD4No5lKRTG-wKnao8xOcXjY,6381
-spiral/expressions/base.py,sha256=q_W9XslcdFQtOIE_d1VkEmLickaXKOAoIcFeMoh-nqQ,4751
-spiral/expressions/http.py,sha256=begUydWoFHEqjeLkATvI_v66Ez6_rR-OQBWO5cHbb9c,2742
-spiral/expressions/io.py,sha256=gJ2a0FKMmdxarWKENulPRwH7KDvSJTIh_OUxX306xAM,3045
-spiral/expressions/list_.py,sha256=MMt5lf5H1M3O-x6N_PvqOLGq9NOk6Ukv0fPWwPC_uy4,1809
-spiral/expressions/mp4.py,sha256=_xGVnkygddzxP9a8OACJ8_KXnejuVbYCVKBCXBQ798Y,2151
-spiral/expressions/png.py,sha256=KO8X0OmMzUFwpg2I_j0JTyldPzVXDWIMzjWMWDV9vIY,506
-spiral/expressions/qoi.py,sha256=gvIbb6fXb_Bb080sn9wkpbGGrPs2UEcTXCfuv4-kcYQ,506
-spiral/expressions/refs.py,sha256=omeHBQ5o6N4xgZ3x5Xz7IRrWwYBBtQY8DYK0NNAxeGo,2109
-spiral/expressions/str_.py,sha256=tY8RXW3JWvr1-bEfCZtk5FAf11wKJnXPuA9EoeJ9tA4,1265
-spiral/expressions/struct.py,sha256=pGAnCDh6AK0BK1XfZ1qG4ce4ranIQEE1HQsgmzBcfwQ,2038
-spiral/expressions/text.py,sha256=-02gBWYoyNQ3qQ1--9HTa8IryUDojYQVIp8C7rgnOWQ,1893
-spiral/expressions/tiff.py,sha256=fQwIn0kLFBM2Y3YYIHmTgb_EIRHKT2fNc77nioDQQw4,8044
-spiral/expressions/udf.py,sha256=r6398z2Aj7KnXtwEvCiGNbgOXa6xsb_bnnG-FEvFxV4,1370
-spiral/grpc_.py,sha256=f3czdP1Mxme42Y5--a5ogYq1TTiWn-J_MlGjwJ2mWwM,1015
-spiral/iceberg/__init__.py,sha256=jSIlTxWauAbJV5gsWglZisFbnfNNzLYN90scoYcdWzc,65
-spiral/iceberg/client.py,sha256=E6FyE_h2HLgDW1cAFg1XgglJr6rbVOCWjRtRmqoMVkM,1003
-spiral/indexes/__init__.py,sha256=TXLQ-_3xso3lFIp2lM58_ip9OPNwPKFv1FdsWiUF-d8,178
-spiral/indexes/client.py,sha256=NsFBILEHMjyCUruFrUEKucRQRrN4OvqgbL4pmzWs07g,5600
-spiral/indexes/index.py,sha256=TJB1-hSiPNrzJ_VYFTZGHvIQ_vmoILPK7tyi_9oS1nA,638
-spiral/indexes/scan.py,sha256=B2m-UgNuawNB90HXK33GTQfMy2WLdNNxiiB6cIjFW2Y,697
-spiral/project.py,sha256=0uJ1Jb88Ie-cCNnSdX3QfFtCUqrjLka4zCm_TxCpVak,1189
-spiral/protogen/_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/protogen/_/arrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/protogen/_/arrow/flight/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/protogen/_/arrow/flight/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/protogen/_/arrow/flight/protocol/sql/__init__.py,sha256=_xhj9QkWEW1qZ-iVxcQ8k4EjYr7KJ5ofitJGqVUGQi4,79921
-spiral/protogen/_/scandal/__init__.py,sha256=X5YJqErZDIXxTESw8fLqJp3P2wZlqAglBzPs3LpTd-w,5145
-spiral/protogen/_/spiral/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/protogen/_/spiral/table/__init__.py,sha256=o_aNyTuJBIRY6MlAWceMsjbfaSUuZphRxiG_IXmC0mU,629
-spiral/protogen/_/substrait/__init__.py,sha256=pV4-T-lwAHKkfFrNYSUGY4IkbIvuKjSo_imzF7BLj_s,126526
-spiral/protogen/_/substrait/extensions/__init__.py,sha256=yD7dg0TBqn-GK_L0qeVof1GKnwSLg_kPyQSV3kcSljs,3655
-spiral/protogen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/protogen/substrait/__init__.py,sha256=pV4-T-lwAHKkfFrNYSUGY4IkbIvuKjSo_imzF7BLj_s,126526
-spiral/protogen/substrait/extensions/__init__.py,sha256=yD7dg0TBqn-GK_L0qeVof1GKnwSLg_kPyQSV3kcSljs,3655
-spiral/protogen/util.py,sha256=smnvVo6nYH3FfDm9jqhNLaXz4bbTBaQezHQDCTvZyiQ,1486
-spiral/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/server.py,sha256=ztBmB5lBnUz-smQxR_tC8AI5SOhz17wH0MI3GuzDUdM,600
-spiral/settings.py,sha256=PIQV2ljtB3pEOWoMRVSRzSGJNrXviO2JBgZ5ZY_Nq2E,2794
-spiral/substrait_.py,sha256=2BYvwFGcCwJ0JXNhXOLdPuhM1PqFyaeSqFpQCtv-M4E,12581
-spiral/tables/__init__.py,sha256=iiP7BkHA117em37_e75jtdvoZC10xCXtld18gRnPbTw,430
-spiral/tables/client.py,sha256=MVgfeVF7P4kXnjOTQExp0VmywyuuRQ2IZVxdwVY3xgk,5015
-spiral/tables/dataset.py,sha256=DuHeKVCJfXLsbxmde9QW6yvesW5uhswG6qAxV5X0ZgA,7890
-spiral/tables/debug/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/tables/debug/manifests.py,sha256=t7E0AchHrzOv9vAQpE77Qp3rLc5VTzRRxlByt5OWnUM,2596
-spiral/tables/debug/metrics.py,sha256=XdRDcjggtsLNGCAjam6IxG9072pz_d2C8iLApNRFUtk,2044
-spiral/tables/debug/scan.py,sha256=EEG2gzbBpUyrtk4jQXh-ENk8aySrKf0CZMym_wHuWm4,8947
-spiral/tables/maintenance.py,sha256=7Xa2Jdu_OY1Qu6iN1sPVdywVZtk_Mv3EaC3G93cmQvI,305
-spiral/tables/scan.py,sha256=3lPf5fSyF1fHGdGJ-pvu5HxPWoonf_XL7neWTqzB-0I,7582
-spiral/tables/snapshot.py,sha256=2NTuVEp2uJ1pV3Q5tLj7FOzPSc9axlfb6uOITwHnj0g,2229
-spiral/tables/table.py,sha256=VM93Rsm67sJFendI1_VhlkFORIdBGfhCMBUBK4dve9I,4910
-spiral/tables/transaction.py,sha256=3a64R-mf_cmR54BNn8U-05jmWonp6Ivxhe6u01Dyjzo,1573
-spiral/types_.py,sha256=W_jyO7F6rpPiH69jhgSgV7OxQZbOlb1Ho3InpKUP6Eo,155
-pyspiral-0.5.0.dist-info/RECORD,,

spiral/cli/iceberg/__init__.py

@@ -1,7 +0,0 @@
-from spiral.cli import AsyncTyper
-
-from . import namespaces, tables
-
-app = AsyncTyper(short_help="Apache Iceberg Catalog.")
-app.add_typer(tables.app, name="tables")
-app.add_typer(namespaces.app, name="namespaces")