pyspiral 0.3.1__cp310-abi3-macosx_11_0_arm64.whl → 0.4.1__cp310-abi3-macosx_11_0_arm64.whl

spiral/tables/snapshot.py

@@ -0,0 +1,78 @@
+from typing import TYPE_CHECKING
+
+from spiral.core.table import TableSnapshot
+from spiral.expressions import ExprLike
+from spiral.tables.scan import Scan
+from spiral.types_ import Timestamp
+
+if TYPE_CHECKING:
+    import duckdb
+    import polars as pl
+    import pyarrow.dataset
+
+    from spiral.tables import Tables
+    from spiral.tables.table import Table
+
+
+class Snapshot:
+    """Spiral table snapshot.
+
+    A snapshot represents a point-in-time view of a table.
+    """
+
+    def __init__(self, tables: "Tables", snapshot: TableSnapshot):
+        self._tables = tables
+        self._snapshot = snapshot
+
+    @property
+    def asof(self) -> Timestamp:
+        """Returns the asof timestamp of the snapshot."""
+        return self._snapshot.asof
+
+    @property
+    def client(self) -> "Tables":
+        """Returns the client used by the snapshot."""
+        return self._tables
+
+    @property
+    def table(self) -> "Table":
+        """Returns the table associated with the snapshot."""
+        from spiral.tables.table import Table
+
+        return Table(self._tables, self._snapshot.table)
+
+    def to_dataset(self) -> "pyarrow.dataset.Dataset":
+        """Returns a PyArrow Dataset representing the table."""
+        from .dataset import TableDataset
+
+        return TableDataset(self)
+
+    def to_polars(self) -> "pl.LazyFrame":
+        """Returns a Polars LazyFrame for the Spiral table."""
+        import polars as pl
+
+        return pl.scan_pyarrow_dataset(self.to_dataset())
+
+    def to_duckdb(self) -> "duckdb.DuckDBPyRelation":
+        """Returns a DuckDB relation for the Spiral table."""
+        import duckdb
+
+        return duckdb.from_arrow(self.to_dataset())
+
+    def scan(
+        self,
+        *projections: ExprLike,
+        where: ExprLike | None = None,
+        exclude_keys: bool = False,
+    ) -> Scan:
+        """Reads the snapshot. If projections are not provided, the entire table is read."""
+        if not projections:
+            # Use table as the default projection.
+            projections = [self._snapshot.table.__expr__]
+
+        return self._tables.scan(
+            *projections,
+            where=where,
+            asof=self._snapshot.asof,
+            exclude_keys=exclude_keys,
+        )

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

@@ -1,22 +1,17 @@
 from datetime import datetime
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING
 
-import pyarrow as pa
-
-from spiral.core.core import Table as CoreTable
-from spiral.core.core import TableMaintenance, TableTransaction
-from spiral.core.spec import Schema
+from spiral.core.table import Table as CoreTable
+from spiral.core.table.spec import Schema
 from spiral.expressions.base import Expr, ExprLike
-from spiral.maintenance import Maintenance
-from spiral.settings import FILE_FORMAT
-from spiral.txn import Transaction
+from spiral.settings import settings
+from spiral.tables.maintenance import Maintenance
+from spiral.tables.scan import Scan
+from spiral.tables.snapshot import Snapshot
+from spiral.tables.transaction import Transaction
 
 if TYPE_CHECKING:
-    import duckdb
-    import polars as pl
-    import pyarrow.dataset
-
-    from spiral.scan_ import Scan
+    from spiral.tables import Tables
 
 
 class Table(Expr):
@@ -25,31 +20,55 @@ class Table(Expr):
     Different catalog implementations should ultimately construct a Table object.
     """
 
-    def __init__(
-        self,
-        table: CoreTable,
-        name: str | None = None,
-    ):
+    # TODO(marko): Make identifier required.
+    def __init__(self, tables: "Tables", table: CoreTable, *, identifier: str | None = None):
         super().__init__(table.__expr__)
 
+        self._tables = tables
         self._table = table
-        self._name = name or self._table.id
-        self._key_schema = self._table.key_schema.to_arrow()
+        self._identifier = identifier
+        self._key_schema = self._table.key_schema
         self._key_columns = set(self._key_schema.names)
 
+    @property
+    def client(self) -> "Tables":
+        """Returns the client used by the table."""
+        return self._tables
+
     @property
     def table_id(self) -> str:
         return self._table.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
+
     @property
     def last_modified_at(self) -> int:
         return self._table.get_wal(asof=None).last_modified_at
 
     def __str__(self):
-        return self._name
+        return self.identifier
 
     def __repr__(self):
-        return f'Table("{self._name}")'
+        return f'Table("{self.identifier}")'
 
     def __getitem__(self, item: str) -> Expr:
         from spiral import expressions as se
@@ -77,7 +96,7 @@ class Table(Expr):
         return se.merge(se.pack({key: se.key(key) for key in key_paths}), super().select(*other_paths, exclude=exclude))
 
     @property
-    def key_schema(self) -> pa.Schema:
+    def key_schema(self) -> Schema:
         """Returns the key schema of the table."""
         return self._key_schema
 
@@ -89,83 +108,50 @@ class Table(Expr):
         """
         return self._table.get_schema(asof=None)
 
-    def to_dataset(self) -> "pyarrow.dataset.Dataset":
-        """Returns a PyArrow Dataset representing the table."""
-        from .dataset import TableDataset
-
-        return TableDataset(self)
-
-    def to_polars(self) -> "pl.LazyFrame":
-        """Returns a Polars LazyFrame for the Spiral table."""
-        import polars as pl
-
-        return pl.scan_pyarrow_dataset(self.to_dataset())
-
-    def to_duckdb(self) -> "duckdb.DuckDBPyRelation":
-        """Returns a DuckDB relation for the Spiral table."""
-        import duckdb
-
-        return duckdb.from_arrow(self.to_dataset())
-
     def scan(
         self,
         *projections: ExprLike,
         where: ExprLike | None = None,
-        asof: datetime | int | str = None,
+        asof: datetime | int | None = None,
         exclude_keys: bool = False,
-    ) -> "Scan":
-        """Reads the table. If projections are not provided, the entire table is read.
-
-        See `spiral.scan` for more information.
-        """
-        from spiral.scan_ import scan
-
+    ) -> Scan:
+        """Reads the table. If projections are not provided, the entire table is read."""
         if not projections:
             projections = [self]
 
-        return scan(
-            *projections,
-            where=where,
-            asof=asof,
-            exclude_keys=exclude_keys,
-        )
+        return self._tables.scan(*projections, where=where, asof=asof, exclude_keys=exclude_keys)
 
-    # NOTE: "vortex" is valid format. We don't want that visible in the API docs.
     def write(
         self,
         expr: ExprLike,
         *,
-        format: Literal["parquet"] | None = None,
         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 format: the format to write the data in. Defaults to "parquet".
         :param partition_size_bytes: The maximum partition size in bytes.
         """
-        format = format or FILE_FORMAT
-
-        with self.txn(format=format) as txn:
+        with self.txn() as txn:
             txn.write(
                 expr,
                 partition_size_bytes=partition_size_bytes,
             )
 
-    # NOTE: "vortex" is valid format. We don't want that visible in the API docs.
-    def txn(self, format: Literal["parquet"] | None = None) -> Transaction:
+    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._tables, self._table.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.
-
-        :param format: The format to use for the transaction. Defaults to "parquet".
         """
-        return Transaction(TableTransaction(self._table.metastore, format or FILE_FORMAT))
-
-    def maintenance(self, format: Literal["parquet"] | None = None) -> Maintenance:
-        """Maintenance tasks for the table.
+        return Transaction(self._tables._spiral.open_transaction(self._table, settings().file_format))
 
-        :param format: The format to use. Defaults to "parquet".
-        """
-        return Maintenance(TableMaintenance(self._table.metastore, format or FILE_FORMAT))
+    def maintenance(self) -> Maintenance:
+        """Access maintenance operations for a table."""
+        return Maintenance(self._tables._spiral.open_maintenance(self._table, settings().file_format))

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

@@ -1,5 +1,9 @@
-from spiral.core.core import TableTransaction
-from spiral.expressions import ExprLike
+from typing import TYPE_CHECKING
+
+from spiral.core.table import TableTransaction
+
+if TYPE_CHECKING:
+    from spiral.expressions.base import ExprLike
 
 
 class Transaction:
@@ -26,7 +30,7 @@ class Transaction:
         else:
             self._transaction.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.

pyspiral-0.3.1.dist-info/RECORD

@@ -1,85 +0,0 @@
-pyspiral-0.3.1.dist-info/METADATA,sha256=QWHcYqfg46JUluQy_NZ3TKilWdvRFwOCqcJPYMo4g3c,1782
-pyspiral-0.3.1.dist-info/WHEEL,sha256=WcVLymwUFXZZBOS7GhUoID5qvQcDPxnkUAYBKypRBtM,103
-pyspiral-0.3.1.dist-info/entry_points.txt,sha256=uft7u-a6g40NLt4Q6BleWbK4NY0M8nZuYPpP8DV0EOk,45
-spiral/catalog.py,sha256=o6b8yhVzHmk_CPNZMKyJU0H8xpjJKKcf2rjcopTSBKc,2912
-spiral/scan_.py,sha256=TNAR_ELKRMJec6fIxhOwpW12WTwZc4sDLtfGdiok-lw,8239
-spiral/substrait_.py,sha256=LmdRhyTX7vhgEbpxV6FUssyL-BiBEIPBeUZApeaKDM4,12671
-spiral/core/core/__init__.pyi,sha256=zQhEB9X0B4EJGZf6AJYZdRt1tDQelF5tCsUaVdH7p4I,2706
-spiral/core/spec/__init__.pyi,sha256=RAnvJjuQPxbcyPtjldvOU8zjVlHhnTKHAFa77sqxBdw,6714
-spiral/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/core/manifests/__init__.pyi,sha256=DXr4Ab_Xo11AzrJlSj7FTSJc8qoO-SkL-_ik4kB855U,1516
-spiral/core/metastore/__init__.pyi,sha256=pdKED91GVJ9XWxTWc9gwkHvVHV_RKxvL43Ofs5ndmew,3145
-spiral/types_.py,sha256=W_jyO7F6rpPiH69jhgSgV7OxQZbOlb1Ho3InpKUP6Eo,155
-spiral/proto/scandal/__init__.py,sha256=wAAEkPN4S4XDpGQtw1MV5zFUeHM01XSAa5tgUgcALvg,777
-spiral/proto/util.py,sha256=smnvVo6nYH3FfDm9jqhNLaXz4bbTBaQezHQDCTvZyiQ,1486
-spiral/proto/spiral/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/proto/spiral/table/__init__.py,sha256=_F1f52RMkZsXofPXpJb2KE8KR5l6zxCtrGrabR1uDxo,2816
-spiral/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/proto/_/scandal/__init__.py,sha256=4UV2TipI1dJWCM2gFNmZM1qbM1_C_pilO3DTI1Kqq8M,8655
-spiral/proto/_/arrow/flight/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/proto/_/arrow/flight/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/proto/_/arrow/flight/protocol/sql/__init__.py,sha256=_xhj9QkWEW1qZ-iVxcQ8k4EjYr7KJ5ofitJGqVUGQi4,79921
-spiral/proto/_/arrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/proto/_/spiral/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/proto/_/spiral/table/__init__.py,sha256=WnBvPPGHphSIa5K6ct6G3S3pK5BJtcC0EIce7r4Jam4,8818
-spiral/proto/_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/proto/_/spiraldb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/proto/_/spiraldb/metastore/__init__.py,sha256=40Egtg8MRYTaTTYRKOHkwuiyXEkw3Yg7ETCQskIzpIg,16873
-spiral/proto/_/spfs/__init__.py,sha256=9WtIXr7HGslKWRHHieFDo8N_qnGL4QQyLOCWEkOKRvk,1017
-spiral/proto/substrait/__init__.py,sha256=pV4-T-lwAHKkfFrNYSUGY4IkbIvuKjSo_imzF7BLj_s,126526
-spiral/proto/substrait/extensions/__init__.py,sha256=yD7dg0TBqn-GK_L0qeVof1GKnwSLg_kPyQSV3kcSljs,3655
-spiral/maintenance.py,sha256=UFvWBLf9L0qDxJa2VdyBzxQxN4W3D9F3QHFKWp1yWZU,304
-spiral/arrow.py,sha256=LBPwZcGkP4kXb42_kl5IUwWW3DO84CV3QJDwCHjG5Dg,7225
-spiral/__init__.py,sha256=Dlaha3kfmzIri8A3-d69tOC2iQrK5fXlYVSI6uU4Fus,394
-spiral/cli/console.py,sha256=-OP0bB_efxhWh4lZ95KRdu-SRgSUMJ47Rbi9FHv1TlY,2577
-spiral/cli/org.py,sha256=ezWhoGUkJQQAwI1jKvDP8uZPNlnou_hXtRDa1us5cSE,2935
-spiral/cli/token.py,sha256=dv30aa745bbS-c3tyzQUTSxGG_N0kCt8G4bip9fP_EM,968
-spiral/cli/__init__.py,sha256=CoiAJ7FDgqjG_TrU-6SpP1hyZloIlEP4wcwnrF8flHM,2237
-spiral/cli/types.py,sha256=4cphJs-i0vfq_CcnHxT9FpHiZdGwxME5GnOmIGB6Thw,1436
-spiral/cli/workload.py,sha256=-XreFPJcX7kZvcYE3oQMeGkkYoXi25R5nuktJPg-PuY,2000
-spiral/cli/admin.py,sha256=3pIs6PxDugMtdgzfRpn_HfBDv-cwAYtF0cJP2INB01A,579
-spiral/cli/fs.py,sha256=rgI3QNKg0_B-3T2d0KgjcLYQNc2M6sRK95cJ_J0nth0,1523
-spiral/cli/app.py,sha256=2oZfDTgj_gZ-lFMMzzJJTnvVzQhp_iedvH-FJnaaMW0,1487
-spiral/cli/table.py,sha256=eh2NAk0GlfvthwRNeIbcZTsRWU3ypFx_uu9OaOLHPUo,628
-spiral/cli/login.py,sha256=C7VpqVyYO2daUeIWHoelWnSGN7cju8YEuqOy12ImH4c,381
-spiral/cli/printer.py,sha256=5HD3UcszFfPk-dK8U5akuvtXqMB7PMgOB1DFYMqspG8,1625
-spiral/cli/__main__.py,sha256=kNaKM2xgJo7GRogf83nYldLM-RGUR6vymdGwZxywQu0,71
-spiral/cli/project.py,sha256=N9ocPRtjLT5lfrPMGbX_-bUXP6o5gq3RpoGYQR3CJ74,4524
-spiral/cli/state.py,sha256=1quvei8TnDTT6mDRo58P8FUfy4w16Z9sggBz7cFgllY,70
-spiral/dataset.py,sha256=53s1JGM9lQkzbZes9nXnax6XtMtCUDR0TBOeTA8wC38,14019
-spiral/grpc_.py,sha256=f3czdP1Mxme42Y5--a5ogYq1TTiWn-J_MlGjwJ2mWwM,1015
-spiral/debug.py,sha256=t590eAUtNWwMTsSdkjVNN7J1iMqY2p4PRJ3BWR_ozho,8999
-spiral/expressions/tiff.py,sha256=fQwIn0kLFBM2Y3YYIHmTgb_EIRHKT2fNc77nioDQQw4,8044
-spiral/expressions/io.py,sha256=gJ2a0FKMmdxarWKENulPRwH7KDvSJTIh_OUxX306xAM,3045
-spiral/expressions/__init__.py,sha256=LqvssKQTvoyX4s5UIG_HtYZbt5i5EkghkEpsE_37MWg,6118
-spiral/expressions/png.py,sha256=3SjreqYcnDL4_EWMENcaGpZVoXR49KAfJiERkFSdT-w,511
-spiral/expressions/list_.py,sha256=nbo4xQAuqBsQGajq_JgORaJl8_CDvOAv14zMbqmtZh4,1814
-spiral/expressions/http.py,sha256=begUydWoFHEqjeLkATvI_v66Ez6_rR-OQBWO5cHbb9c,2742
-spiral/expressions/refs.py,sha256=EndnGTLSA-s3hD6QOkxfUSWpw2IUm1hnKyyiPIlhZ7I,2370
-spiral/expressions/udf.py,sha256=vOlrdxiVpt7vdSgiTKX_XR86YKyu02Fdwb9xlINCby4,1363
-spiral/expressions/mp4.py,sha256=0qhTP4HGI0WL-nVhke-ykqEnOYcb64Aqryplgelv-BA,2437
-spiral/expressions/str_.py,sha256=tY8RXW3JWvr1-bEfCZtk5FAf11wKJnXPuA9EoeJ9tA4,1265
-spiral/expressions/qoi.py,sha256=FCAsoF-3ur7CMIk2Oz5Hm4qDdb901E_7_-aKT8yss6E,511
-spiral/expressions/base.py,sha256=mTBwS6CwdDaV8uotjZUiKi7GHQzX2TRPpnseJJUDrR0,4776
-spiral/expressions/struct.py,sha256=MuxoBP6ESpwmjzusG-_HxHGYKvQQz6AZWzvw7vNUHJM,2007
-spiral/settings.py,sha256=H0ELgA1k_YENufIWscXV7gzdU8t7JOCw0AdUDVvCFH0,4704
-spiral/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/api/filesystems.py,sha256=_JWFbggORWOAg0yKASsEXbu8Vk-hIMOiiVrwcEcm_RA,3424
-spiral/api/workloads.py,sha256=4MWs2pp9AWvx6cZhgyW-ehyCRxpHc_NAQgHaoYOEBfg,1266
-spiral/api/__init__.py,sha256=Wy2ZEL0balniPP7LuYLhazxI9p3ZcgZ9g_MAZLWF3Hg,6828
-spiral/api/tokens.py,sha256=WaSRr_l3i81t5u2qi3kWW-fySbyKFm-PQK1ZlmoSByc,1464
-spiral/api/admin.py,sha256=HJBrRJScbcdDuFhF_06E0EyE-_Y0osfYPxVoRAyEoTc,837
-spiral/api/organizations.py,sha256=-PO93HTX02IxhXM6SJpAhnAXpVW1WjthFO4-AOzZAC4,2670
-spiral/api/tables.py,sha256=3Kt0tPfu3jQGIIAMUSNAMRtDRGK-STRYoHHgzZ4qFNU,2532
-spiral/api/projects.py,sha256=-VGlu5V3TJ3XLCGu85bPHRFiktIADnAxfLWIH8Rmxug,4986
-spiral/txn.py,sha256=SIww2vAazE1nPxyAkeiN7NMvXmBK6jHhFM_uMkEUW0o,1508
-spiral/table.py,sha256=HzSRNQAI9YscdfmeHlwZcIdrK2SJ9wWq-GRRCmint_M,5541
-spiral/authn/modal_.py,sha256=agcnR3dYTslkH2K_a2Eis_2JWn9Ps11FVrGG_jkOdGk,472
-spiral/authn/device.py,sha256=ohHSVLW3a-qLNYQGN-3kXxV_836xOe0UYBN8i63cqAQ,6796
-spiral/authn/authn.py,sha256=OCGJAUfoKLiXw9xAcAnX6i6mBRlvsl6qEFcimqQOu7g,2555
-spiral/authn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spiral/authn/github_.py,sha256=K-0RUHDreINjnCDHyT9aeVDRk6WtNP7noBYEcwdz2W4,1313
-spiral/adbc.py,sha256=H_bzevPy5teyZKzjczh1gQ_zPcfk5sNASiJKQvyab9E,13830
-spiral/project.py,sha256=q9jHql7hz5OQzPfDfvE_hN3K9cZotD0cxkdug9EUTwM,4889
-spiral/_lib.abi3.so,sha256=p285aXvfZS7XzjXERyb5tsrH0fwq9rVdZ0hX4rvbkrA,64644032
-pyspiral-0.3.1.dist-info/RECORD,,

spiral/api/tables.py

@@ -1,91 +0,0 @@
-from typing import Annotated
-
-from pydantic import AfterValidator, BaseModel, StringConstraints
-
-from . import ArrowSchema, Paged, PagedRequest, PagedResponse, ProjectId, ServiceBase
-
-
-def _validate_root_uri(uri: str) -> str:
-    if uri.endswith("/"):
-        raise ValueError("Root URI must not end with a slash.")
-    return uri
-
-
-RootUri = Annotated[str, AfterValidator(_validate_root_uri)]
-DatasetName = Annotated[str, StringConstraints(max_length=128, pattern=r"^[a-zA-Z_][a-zA-Z0-9_-]+$")]
-TableName = Annotated[str, StringConstraints(max_length=128, pattern=r"^[a-zA-Z_][a-zA-Z0-9_-]+$")]
-
-
-class TableMetadata(BaseModel):
-    root_uri: RootUri
-    spfs_mount_id: str | None = None
-
-    key_schema: ArrowSchema
-
-    # TODO(marko): Randomize this on creation of metadata.
-    # Column group salt is used to compute column group IDs.
-    # It's used to ensure that column group IDs are unique
-    # across different tables, even if paths are the same.
-    # It's never modified.
-    column_group_salt: int = 0
-
-
-class Table(BaseModel):
-    id: str
-    project_id: ProjectId
-    dataset: DatasetName
-    table: TableName
-    metadata: TableMetadata
-
-
-class CreateTable:
-    class Request(BaseModel):
-        project_id: ProjectId
-        dataset: DatasetName
-        table: TableName
-        key_schema: ArrowSchema
-        root_uri: RootUri | None = None
-        exist_ok: bool = False
-
-    class Response(BaseModel):
-        table: Table
-
-
-class FindTable:
-    class Request(BaseModel):
-        project_id: ProjectId
-        dataset: DatasetName = None
-        table: TableName = None
-
-    class Response(BaseModel):
-        table: Table | None
-
-
-class GetTable:
-    class Request(BaseModel):
-        id: str
-
-    class Response(BaseModel):
-        table: Table
-
-
-class ListTables:
-    class Request(PagedRequest):
-        project_id: ProjectId
-        dataset: DatasetName | None = None
-
-    class Response(PagedResponse[Table]): ...
-
-
-class TableService(ServiceBase):
-    def create(self, req: CreateTable.Request) -> CreateTable.Response:
-        return self.client.post("/table/create", req, CreateTable.Response)
-
-    def find(self, req: FindTable.Request) -> FindTable.Response:
-        return self.client.put("/table/find", req, FindTable.Response)
-
-    def get(self, req: GetTable.Request) -> GetTable.Response:
-        return self.client.put(f"/table/{req.id}", GetTable.Response)
-
-    def list(self, req: ListTables.Request) -> Paged[Table]:
-        return self.client.paged("/table/list", req, ListTables.Response)

spiral/api/tokens.py

@@ -1,56 +0,0 @@
-from pydantic import BaseModel
-
-from . import Paged, PagedRequest, PagedResponse, ServiceBase
-
-
-class Token(BaseModel):
-    id: str
-    project_id: str
-    on_behalf_of: str
-
-
-class ExchangeToken:
-    class Request(BaseModel): ...
-
-    class Response(BaseModel):
-        token: str
-
-
-class IssueToken:
-    class Request(BaseModel): ...
-
-    class Response(BaseModel):
-        token: Token
-        token_secret: str
-
-
-class RevokeToken:
-    class Request(BaseModel):
-        token_id: str
-
-    class Response(BaseModel):
-        token: Token
-
-
-class ListTokens:
-    class Request(PagedRequest):
-        project_id: str
-        on_behalf_of: str | None = None
-
-    class Response(PagedResponse[Token]): ...
-
-
-class TokenService(ServiceBase):
-    def exchange(self) -> ExchangeToken.Response:
-        """Exchange a basic / identity token to a short-lived Spiral token."""
-        return self.client.post("/token/exchange", ExchangeToken.Request(), ExchangeToken.Response)
-
-    def issue(self) -> IssueToken.Response:
-        """Issue an API token on behalf of a principal."""
-        return self.client.post("/token/issue", IssueToken.Request(), IssueToken.Response)
-
-    def revoke(self, request: RevokeToken.Request) -> RevokeToken.Response:
-        return self.client.put("/token/revoke", request, RevokeToken.Response)
-
-    def list(self, request: ListTokens.Request) -> Paged[Token]:
-        return self.client.paged("/token/list", request, ListTokens.Response)

spiral/authn/authn.py

@@ -1,89 +0,0 @@
-import base64
-import logging
-import os
-
-from spiral.api import Authn, SpiralAPI
-
-ENV_TOKEN_ID = "SPIRAL_TOKEN_ID"
-ENV_TOKEN_SECRET = "SPIRAL_TOKEN_SECRET"
-
-log = logging.getLogger(__name__)
-
-
-class FallbackAuthn(Authn):
-    """Credential provider that tries multiple providers in order."""
-
-    def __init__(self, providers: list[Authn]):
-        self._providers = providers
-
-    def token(self) -> str | None:
-        for provider in self._providers:
-            token = provider.token()
-            if token is not None:
-                return token
-        return None
-
-
-class TokenAuthn(Authn):
-    """Credential provider that returns a fixed token."""
-
-    def __init__(self, token: str):
-        self._token = token
-
-    def token(self) -> str:
-        return self._token
-
-
-class EnvironmentAuthn(Authn):
-    """Credential provider that returns a basic token from the environment.
-
-    NOTE: Returns basic token. Must be exchanged.
-    """
-
-    def token(self) -> str | None:
-        if ENV_TOKEN_ID not in os.environ:
-            return None
-        if ENV_TOKEN_SECRET not in os.environ:
-            raise ValueError(f"{ENV_TOKEN_SECRET} is missing.")
-
-        token_id = os.environ[ENV_TOKEN_ID]
-        token_secret = os.environ[ENV_TOKEN_SECRET]
-        basic_token = base64.b64encode(f"{token_id}:{token_secret}".encode()).decode("utf-8")
-
-        return basic_token
-
-
-class DeviceAuthProvider(Authn):
-    """Auth provider that uses the device flow to authenticate a Spiral user."""
-
-    def __init__(self, device_auth):
-        # NOTE(ngates): device_auth: spiral.auth.device_code.DeviceAuth
-        #  We don't type it to satisfy our import linter
-        self._device_auth = device_auth
-
-    def token(self) -> str | None:
-        # TODO(ngates): only run this if we're in a notebook, CLI, or otherwise on the user's machine.
-        return self._device_auth.authenticate().access_token
-
-
-class TokenExchangeProvider(Authn):
-    """Auth provider that exchanges a basic token for a Spiral token."""
-
-    def __init__(self, authn: Authn, base_url: str):
-        self._authn = authn
-        self._token_service = SpiralAPI(authn, base_url).token
-
-        self._sp_token = None
-
-    def token(self) -> str | None:
-        if self._sp_token is not None:
-            return self._sp_token
-
-        # Don't try to exchange if token is not discovered.
-        if self._authn.token() is None:
-            return None
-
-        log.debug("Exchanging token")
-        self._sp_token = self._token_service.exchange().token
-
-        return self._sp_token