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

spiral/cli/iceberg/namespaces.py

@@ -1,47 +0,0 @@
-import sys
-from typing import Annotated
-
-import pyiceberg.exceptions
-import rich
-import typer
-from typer import Argument
-
-from spiral.cli import AsyncTyper, state
-from spiral.cli.types import ProjectArg
-
-app = AsyncTyper(short_help="Apache Iceberg Namespaces.")
-
-
-@app.command(help="List namespaces.")
-def ls(
-    project: ProjectArg,
-    namespace: Annotated[str | None, Argument(help="List only namespaces under this namespace.")] = None,
-):
-    """List Iceberg namespaces."""
-    catalog = state.spiral.iceberg.catalog()
-
-    if namespace is None:
-        try:
-            namespaces = catalog.list_namespaces(project)
-        except pyiceberg.exceptions.ForbiddenError:
-            print(
-                f"The project, {repr(project)}, does not exist or you lack the "
-                f"`iceberg:view` permission to list namespaces in it.",
-                file=sys.stderr,
-            )
-            raise typer.Exit(code=1)
-    else:
-        try:
-            namespaces = catalog.list_namespaces((project, namespace))
-        except pyiceberg.exceptions.ForbiddenError:
-            print(
-                f"The namespace, {repr(project)}.{repr(namespace)}, does not exist or you lack the "
-                f"`iceberg:view` permission to list namespaces in it.",
-                file=sys.stderr,
-            )
-            raise typer.Exit(code=1)
-
-    table = rich.table.Table("Namespace ID", title="Iceberg namespaces")
-    for ns in namespaces:
-        table.add_row(".".join(ns))
-    rich.print(table)

spiral/cli/iceberg/tables.py

@@ -1,60 +0,0 @@
-import sys
-from typing import Annotated
-
-import pyiceberg.exceptions
-import rich
-import typer
-from typer import Argument
-
-from spiral.cli import AsyncTyper, state
-from spiral.cli.types import ProjectArg
-
-app = AsyncTyper(short_help="Apache Iceberg Tables.")
-
-
-@app.command(help="List tables.")
-def ls(
-    project: ProjectArg,
-    namespace: Annotated[str | None, Argument(help="Show only tables in the given namespace.")] = None,
-):
-    catalog = state.spiral.iceberg.catalog()
-
-    try:
-        if namespace is None:
-            tables = catalog.list_tables(project)
-        else:
-            tables = catalog.list_tables((project, namespace))
-    except pyiceberg.exceptions.ForbiddenError:
-        print(
-            f"The namespace, {repr(project)}.{repr(namespace)}, does not exist or you lack the "
-            f"`iceberg:view` permission to list tables in it.",
-            file=sys.stderr,
-        )
-        raise typer.Exit(code=1)
-
-    rich_table = rich.table.Table("table id", title="Iceberg tables")
-    for table in tables:
-        rich_table.add_row(".".join(table))
-    rich.print(rich_table)
-
-
-@app.command(help="Show the table schema.")
-def schema(
-    project: ProjectArg,
-    namespace: Annotated[str, Argument(help="Table namespace.")],
-    table: Annotated[str, Argument(help="Table name.")],
-):
-    catalog = state.spiral.iceberg.catalog()
-
-    try:
-        tbl = catalog.load_table((project, namespace, table))
-    except pyiceberg.exceptions.NoSuchTableError:
-        print(f"No table {repr(table)} found in {repr(project)}.{repr(namespace)}", file=sys.stderr)
-        raise typer.Exit(code=1)
-
-    rich_table = rich.table.Table(
-        "Field ID", "Field name", "Type", "Required", "Doc", title=f"{project}.{namespace}.{table}"
-    )
-    for col in tbl.schema().columns:
-        rich_table.add_row(str(col.field_id), col.name, str(col.field_type), str(col.required), col.doc)
-    rich.print(rich_table)

spiral/cli/indexes/__init__.py

@@ -1,19 +0,0 @@
-import rich
-
-from spiral.cli import AsyncTyper, state
-from spiral.cli.types import ProjectArg
-
-app = AsyncTyper(short_help="Indexes.")
-
-
-@app.command(help="List indexes.")
-def ls(
-    project: ProjectArg,
-):
-    """List indexes."""
-    indexes = state.spiral.project(project).indexes.list_indexes()
-
-    rich_table = rich.table.Table("id", "name", title="Indexes")
-    for index in indexes:
-        rich_table.add_row(index.id, index.name)
-    rich.print(rich_table)

spiral/cli/tables/__init__.py

@@ -1,121 +0,0 @@
-from typing import Annotated
-
-import questionary
-import rich
-import typer
-from questionary import Choice
-from typer import Argument, Option
-
-from spiral import Spiral
-from spiral.cli import AsyncTyper, state
-from spiral.cli.types import ProjectArg
-from spiral.tables import Table
-
-app = AsyncTyper(short_help="Spiral Tables.")
-
-
-def ask_table(project_id, title="Select a table"):
-    tables = list(state.spiral.project(project_id).tables.list_tables())
-
-    if not tables:
-        rich.print("[red]No tables found[/red]")
-        raise typer.Exit(1)
-
-    return questionary.select(
-        title,
-        choices=[
-            Choice(title=f"{table.dataset}.{table.table}", value=f"{table.project_id}.{table.dataset}.{table.table}")
-            for table in tables
-        ],
-    ).ask()
-
-
-@app.command(help="List tables.")
-def ls(
-    project: ProjectArg,
-):
-    tables = Spiral().project(project).tables.list_tables()
-
-    rich_table = rich.table.Table("id", "dataset", "name", title="Spiral tables")
-    for table in tables:
-        rich_table.add_row(table.id, table.dataset, table.table)
-    rich.print(rich_table)
-
-
-@app.command(help="Show the table key schema.")
-def key_schema(
-    project: ProjectArg,
-    table: Annotated[str | None, Option(help="Table name.")] = None,
-    dataset: Annotated[str | None, Option(help="Dataset name.")] = None,
-):
-    _, table = _get_table(project, table, dataset)
-    rich.print(table.key_schema)
-
-
-@app.command(help="Compute the full table schema.")
-def schema(
-    project: ProjectArg,
-    table: Annotated[str | None, Option(help="Table name.")] = None,
-    dataset: Annotated[str | None, Option(help="Dataset name.")] = None,
-):
-    _, table = _get_table(project, table, dataset)
-    rich.print(table.schema)
-
-
-@app.command(help="Flush Write-Ahead-Log.")
-def flush(
-    project: ProjectArg,
-    table: Annotated[str | None, Option(help="Table name.")] = None,
-    dataset: Annotated[str | None, Option(help="Dataset name.")] = None,
-):
-    identifier, table = _get_table(project, table, dataset)
-    table.maintenance().flush_wal()
-    print(f"Flushed WAL for table {identifier} in project {project}.")
-
-
-@app.command(help="Display scan.")
-def debug(
-    project: ProjectArg,
-    table: Annotated[str | None, Option(help="Table name.")] = None,
-    dataset: Annotated[str | None, Option(help="Dataset name.")] = None,
-    column_group: Annotated[str, Argument(help="Dot-separated column group path.")] = ".",
-):
-    _, table = _get_table(project, table, dataset)
-    if column_group != ".":
-        projection = table[column_group]
-    else:
-        projection = table
-    scan = table.scan(projection)
-
-    scan._debug()
-
-
-@app.command(help="Display manifests.")
-def manifests(
-    project: ProjectArg,
-    table: Annotated[str | None, Option(help="Table name.")] = None,
-    dataset: Annotated[str | None, Option(help="Dataset name.")] = None,
-    column_group: Annotated[str, Argument(help="Dot-separated column group path.")] = ".",
-):
-    _, table = _get_table(project, table, dataset)
-    if column_group != ".":
-        projection = table[column_group]
-    else:
-        projection = table
-    scan = projection.scan()
-
-    scan._dump_manifests()
-
-
-def _get_table(
-    project: ProjectArg,
-    table: Annotated[str | None, Option(help="Table name.")] = None,
-    dataset: Annotated[str | None, Option(help="Dataset name.")] = None,
-) -> (str, Table):
-    if table is None:
-        identifier = ask_table(project)
-    else:
-        identifier = table
-        if dataset is not None:
-            identifier = f"{dataset}.{table}"
-    return identifier, state.spiral.project(project).tables.table(identifier)

spiral/core/index/__init__.pyi

@@ -1,15 +0,0 @@
-import pyarrow as pa
-
-class IndexStatus:
-    status: str
-    staleness_s: int | None
-    # An extent of keys that are indexed.
-    # key_extent: KeyExtent | None
-
-class TextIndex:
-    id: str
-
-    def status(self) -> IndexStatus: ...
-
-class SearchScan:
-    def to_record_batches(self) -> pa.RecordBatchReader: ...

spiral/iceberg/__init__.py

@@ -1,3 +0,0 @@
-from spiral.iceberg.client import Iceberg
-
-__all__ = ["Iceberg"]

spiral/indexes/__init__.py

@@ -1,5 +0,0 @@
-from spiral.indexes.client import Indexes
-from spiral.indexes.index import TextIndex
-from spiral.indexes.scan import SearchScan
-
-__all__ = ["Indexes", "SearchScan", "TextIndex"]

spiral/indexes/client.py

@@ -1,137 +0,0 @@
-import datetime
-
-from spiral.api import SpiralAPI
-from spiral.api.projects import TextIndexResource
-from spiral.core.client import Spiral as CoreSpiral
-from spiral.expressions.base import ExprLike
-from spiral.indexes.index import TextIndex
-from spiral.indexes.scan import SearchScan
-from spiral.types_ import Uri
-
-
-class Indexes:
-    def __init__(self, api: SpiralAPI, spiral: CoreSpiral, *, project_id: str | None = None):
-        self._api = api
-        self._spiral = spiral
-        self._project_id = project_id
-
-    def index(self, identifier: str) -> TextIndex:
-        """Returns the index with the given identifier."""
-        project_id, index_name = self._parse_identifier(identifier)
-        if project_id is None:
-            raise ValueError("Must provide a fully qualified index identifier.")
-
-        res = list(self._api.project.list_text_indexes(project_id, name=index_name))
-        if len(res) == 0:
-            raise ValueError(f"Index not found: {project_id}.{index_name}")
-        res = res[0]
-
-        return TextIndex(self, self._spiral.get_text_index(res.id), index_name)
-
-    def list_indexes(self) -> list[TextIndexResource]:
-        project_id = self._project_id
-        if project_id is None:
-            raise ValueError("Must provide a project ID to list indexes.")
-        return list(self._api.project.list_text_indexes(project_id))
-
-    def create_text_index(
-        self,
-        identifier: str,
-        # At least one projection is required. All projections must reference the same table!
-        # NOTE(marko): Indexes are currently independent of tables.
-        #   That will likely change with the new root resource such as documents.
-        *projections: ExprLike,
-        where: ExprLike | None = None,
-        root_uri: Uri | None = None,
-        exist_ok: bool = False,
-    ) -> TextIndex:
-        """Creates a text index over the table projection.
-
-        See `se.text.field` for how to create and configure indexable fields.
-
-        Args:
-            identifier: The index identifier, in the form `project.index` or `index`.
-            projections: At least one projection expression is required.
-                All projections must reference the same table.
-            where: An optional filter expression to apply to the index.
-            root_uri: The root URI for the index.
-            exist_ok: If True, do not raise an error if the index already exists.
-        """
-        from spiral import expressions as se
-
-        project_id, index_name = self._parse_identifier(identifier)
-        if project_id is None:
-            raise ValueError("Must provide a fully qualified index identifier.")
-
-        if not projections:
-            raise ValueError("At least one projection is required.")
-        projection = se.merge(*projections)
-        if where is not None:
-            where = se.lift(where)
-
-        core_index = self._spiral.create_text_index(
-            project_id,
-            index_name,
-            projection.__expr__,
-            where.__expr__ if where else None,
-            root_uri=root_uri,
-            # TODO(marko): Validate that if an index exists, it's the same?
-            exist_ok=exist_ok,
-        )
-
-        return TextIndex(self, core_index, index_name)
-
-    def _parse_identifier(self, identifier: str) -> tuple[str | None, str]:
-        parts = identifier.split(".")
-        if len(parts) == 1:
-            return self._project_id, parts[0]
-        elif len(parts) == 2:
-            return parts[0], parts[1]
-        else:
-            raise ValueError(f"Invalid index identifier: {identifier}")
-
-    def search(
-        self,
-        *rank_by: ExprLike,
-        where: ExprLike | None = None,
-        top_k: int = 10,
-        # Do not refresh the index if freshness does not exceed the freshness window.
-        # NOTE(marko): The current implementation fails the query if the index is stale.
-        freshness_window: datetime.timedelta | None = None,
-    ) -> SearchScan:
-        """Queries the index with the given rank by and where clauses.
-
-        Rank by expressions are combined for scoring.
-            See `se.text.find` and `se.text.boost` for scoring expressions.
-        The `where` expression is used to filter the results.
-            It must return a boolean value and use only conjunctions (ANDs). Expressions in where statement
-            are considered either a `must` or `must_not` clause in search terminology.
-
-        Args:
-            rank_by: At least one rank by expression is required.
-                These expressions are used to score the results.
-            where: An optional filter expression to apply to the index.
-                It must return a boolean value and use only conjunctions (ANDs).
-            top_k: The number of top results to return.
-            freshness_window: If provided, the index will not be refreshed if its freshness does not exceed this window.
-        """
-        from spiral import expressions as se
-
-        if not rank_by:
-            raise ValueError("At least one rank by expression is required.")
-        rank_by = se.or_(*rank_by)
-        if where is not None:
-            where = se.lift(where)
-
-        if freshness_window is None:
-            freshness_window = datetime.timedelta(seconds=0)
-        freshness_window_s = int(freshness_window.total_seconds())
-
-        return SearchScan(
-            self._spiral.open_search_scan(
-                rank_by.__expr__,
-                top_k=top_k,
-                freshness_window_s=freshness_window_s,
-                filter=where.__expr__ if where else None,
-            )
-        )

spiral/indexes/index.py

@@ -1,34 +0,0 @@
-import datetime
-from typing import TYPE_CHECKING
-
-from spiral.core.index import TextIndex as CoreTextIndex
-from spiral.expressions import Expr
-
-if TYPE_CHECKING:
-    from spiral.indexes import Indexes
-
-
-class TextIndex(Expr):
-    def __init__(self, indexes: "Indexes", index: CoreTextIndex, name: str):
-        super().__init__(index.__expr__)
-
-        self._indexes = indexes
-        self._index = index
-        self._name = name
-
-    @property
-    def client(self) -> "Indexes":
-        return self._indexes
-
-    @property
-    def index_id(self) -> str:
-        return self._index.id
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    def status(self) -> (str, datetime.timedelta | None):
-        """Fetch the status of the index. If status is ready, returns the staleness of the index."""
-        status = self._index.status()
-        return status.status, datetime.timedelta(seconds=status.staleness_s) if status.staleness_s is not None else None

spiral/indexes/scan.py

@@ -1,22 +0,0 @@
-import pyarrow as pa
-
-from spiral.core.index import SearchScan as CoreSearchScan
-from spiral.settings import CI, DEV
-
-
-class SearchScan:
-    def __init__(self, scan: CoreSearchScan):
-        self._scan = scan
-
-    def to_record_batches(self) -> pa.RecordBatchReader:
-        """Read all results as a record batch reader."""
-        return self._scan.to_record_batches()
-
-    def to_table(self) -> pa.Table:
-        """Read all results as a table."""
-        # NOTE: Evaluates fully on Rust side which improved debuggability.
-        if DEV and not CI:
-            rb = self._scan.to_record_batch()
-            return pa.Table.from_batches([rb])
-
-        return self.to_record_batches().read_all()

spiral/protogen/_/spiral/table/__init__.py

@@ -1,22 +0,0 @@
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# sources: spiral/table/statistics.proto
-# plugin: python-betterproto
-# This file has been @generated
-
-from dataclasses import dataclass
-
-import betterproto
-
-
-@dataclass(eq=False, repr=False)
-class ApproximateSetMembership(betterproto.Message):
-    bloom_filter: "BloomFilter" = betterproto.message_field(
-        2, group="membership_strategy"
-    )
-
-
-@dataclass(eq=False, repr=False)
-class BloomFilter(betterproto.Message):
-    bit_vec: bytes = betterproto.bytes_field(1)
-    bitmap_bits: int = betterproto.uint64_field(2)
-    k_num: int = betterproto.uint32_field(3)