lance-namespace 0.0.5__py3-none-any.whl

lance_namespace/__init__.py

@@ -0,0 +1,104 @@
+"""
+Lance Namespace Python Client
+
+A Python client for the Lance Namespace API that provides a unified interface
+for managing namespaces and tables across different backend implementations.
+"""
+
+from .namespace import LanceNamespace, connect
+
+# Re-export all models from the urllib3 client
+from lance_namespace_urllib3_client.models import (
+    ListNamespacesRequest,
+    ListNamespacesResponse,
+    DescribeNamespaceRequest,
+    DescribeNamespaceResponse,
+    CreateNamespaceRequest,
+    CreateNamespaceResponse,
+    DropNamespaceRequest,
+    DropNamespaceResponse,
+    NamespaceExistsRequest,
+    ListTablesRequest,
+    ListTablesResponse,
+    DescribeTableRequest,
+    DescribeTableResponse,
+    RegisterTableRequest,
+    RegisterTableResponse,
+    TableExistsRequest,
+    DropTableRequest,
+    DropTableResponse,
+    DeregisterTableRequest,
+    DeregisterTableResponse,
+    CountTableRowsRequest,
+    CreateTableRequest,
+    CreateTableResponse,
+    InsertIntoTableRequest,
+    InsertIntoTableResponse,
+    MergeInsertIntoTableRequest,
+    MergeInsertIntoTableResponse,
+    UpdateTableRequest,
+    UpdateTableResponse,
+    DeleteFromTableRequest,
+    DeleteFromTableResponse,
+    QueryTableRequest,
+    CreateTableIndexRequest,
+    CreateTableIndexResponse,
+    ListTableIndicesRequest,
+    ListTableIndicesResponse,
+    DescribeTableIndexStatsRequest,
+    DescribeTableIndexStatsResponse,
+    DescribeTransactionRequest,
+    DescribeTransactionResponse,
+    AlterTransactionRequest,
+    AlterTransactionResponse,
+)
+
+__all__ = [
+    # Main interface and connect function
+    "LanceNamespace",
+    "connect",
+    
+    # Request/Response models
+    "ListNamespacesRequest",
+    "ListNamespacesResponse",
+    "DescribeNamespaceRequest", 
+    "DescribeNamespaceResponse",
+    "CreateNamespaceRequest",
+    "CreateNamespaceResponse",
+    "DropNamespaceRequest",
+    "DropNamespaceResponse",
+    "NamespaceExistsRequest",
+    "ListTablesRequest",
+    "ListTablesResponse",
+    "DescribeTableRequest",
+    "DescribeTableResponse",
+    "RegisterTableRequest",
+    "RegisterTableResponse",
+    "TableExistsRequest",
+    "DropTableRequest",
+    "DropTableResponse",
+    "DeregisterTableRequest",
+    "DeregisterTableResponse",
+    "CountTableRowsRequest",
+    "CreateTableRequest",
+    "CreateTableResponse",
+    "InsertIntoTableRequest",
+    "InsertIntoTableResponse",
+    "MergeInsertIntoTableRequest",
+    "MergeInsertIntoTableResponse",
+    "UpdateTableRequest",
+    "UpdateTableResponse",
+    "DeleteFromTableRequest",
+    "DeleteFromTableResponse",
+    "QueryTableRequest",
+    "CreateTableIndexRequest",
+    "CreateTableIndexResponse",
+    "ListTableIndicesRequest",
+    "ListTableIndicesResponse",
+    "DescribeTableIndexStatsRequest",
+    "DescribeTableIndexStatsResponse",
+    "DescribeTransactionRequest",
+    "DescribeTransactionResponse",
+    "AlterTransactionRequest",
+    "AlterTransactionResponse",
+]

lance_namespace/dir.py

@@ -0,0 +1,348 @@
+"""
+Lance Directory Namespace implementation using OpenDAL.
+"""
+from typing import Dict, List, Optional
+from urllib.parse import urlparse
+import os
+
+import opendal
+
+import lance
+import pyarrow as pa
+
+from lance_namespace.namespace import LanceNamespace
+from lance_namespace_urllib3_client.models import (
+    ListNamespacesRequest,
+    ListNamespacesResponse,
+    DescribeNamespaceRequest,
+    DescribeNamespaceResponse,
+    CreateNamespaceRequest,
+    CreateNamespaceResponse,
+    DropNamespaceRequest,
+    DropNamespaceResponse,
+    NamespaceExistsRequest,
+    ListTablesRequest,
+    ListTablesResponse,
+    CreateTableRequest,
+    CreateTableResponse,
+    DropTableRequest,
+    DropTableResponse,
+    DescribeTableRequest,
+    DescribeTableResponse,
+    JsonArrowSchema,
+    JsonArrowField,
+    JsonArrowDataType,
+)
+
+
+class DirectoryNamespace(LanceNamespace):
+    """Lance Directory Namespace implementation using OpenDAL."""
+    
+    def __init__(self, **properties):
+        """Initialize the directory namespace.
+        
+        Args:
+            root: The root directory of the namespace (optional, defaults to current directory)
+            **properties: Additional configuration properties for specific storage backends
+        """
+        
+        self.config = DirectoryNamespaceConfig(properties)
+        root = self.config.root
+        
+        # Use current directory if root is not specified
+        if not root:
+            root = os.getcwd()
+        
+        self.namespace_path = self._parse_path(root)
+        self.operator = self._initialize_operator(root)
+    
+    def create_namespace(self, request: CreateNamespaceRequest) -> CreateNamespaceResponse:
+        """Create a namespace - not supported for directory namespace."""
+        raise NotImplementedError(
+            "Directory namespace only contains a flat list of tables and does not support creating namespaces"
+        )
+    
+    def list_namespaces(self, request: ListNamespacesRequest) -> ListNamespacesResponse:
+        """List namespaces - not supported for directory namespace."""
+        raise NotImplementedError(
+            "Directory namespace only contains a flat list of tables and does not support listing namespaces"
+        )
+    
+    def describe_namespace(self, request: DescribeNamespaceRequest) -> DescribeNamespaceResponse:
+        """Describe namespace - not supported for directory namespace."""
+        raise NotImplementedError(
+            "Directory namespace only contains a flat list of tables and does not support describing namespaces"
+        )
+    
+    def drop_namespace(self, request: DropNamespaceRequest) -> DropNamespaceResponse:
+        """Drop namespace - not supported for directory namespace."""
+        raise NotImplementedError(
+            "Directory namespace only contains a flat list of tables and does not support dropping namespaces"
+        )
+    
+    def namespace_exists(self, request: NamespaceExistsRequest) -> None:
+        """Check namespace exists - not supported for directory namespace."""
+        raise NotImplementedError(
+            "Directory namespace only contains a flat list of tables and does not support namespace existence checks"
+        )
+    
+    def list_tables(self, request: ListTablesRequest) -> ListTablesResponse:
+        """List all tables in the namespace."""
+        self._validate_root_namespace_id(request.id)
+        
+        try:
+            tables = []
+            entries = self.operator.list("", recursive=False)
+            
+            for entry in entries:
+                path = entry.path.rstrip('/')
+                
+                # Only process paths that contain ".lance"
+                if ".lance" not in path:
+                    continue
+                
+                # Strip .lance suffix to get clean table name
+                table_name = path[:-6]  # Remove '.lance' (6 characters)
+                
+                # Check if it's a valid Lance dataset
+                try:
+                    versions_path = f"{table_name}.lance/_versions/"
+                    version_entries = list(self.operator.list(versions_path, limit=1))
+                    if version_entries:
+                        tables.append(table_name)  # Add clean name without .lance
+                except:
+                    # If _versions doesn't exist, it's not a Lance dataset
+                    pass
+            
+            response = ListTablesResponse(tables=tables)
+            return response
+        except Exception as e:
+            raise RuntimeError(f"Failed to list tables: {e}")
+    
+    
+    def create_table(self, request: CreateTableRequest, request_data: bytes) -> CreateTableResponse:
+        """Create a table using Lance dataset."""
+        if not request.id:
+            raise ValueError("table ID cannot be empty")
+        
+        if not request.var_schema:
+            raise ValueError("Schema is required in CreateTableRequest")
+        
+        table_name = self._normalize_table_id(request.id)
+        table_path = self._get_table_path(table_name)
+        
+        if request.location and request.location != table_path:
+            raise ValueError(f"Cannot create table {table_name} at location {request.location}, must be at location {table_path}")
+        
+        # Convert JsonArrowSchema to PyArrow Schema
+        schema = self._convert_json_arrow_schema_to_pyarrow(request.var_schema)
+        
+        # Create empty table with schema
+        arrays = []
+        for field in schema:
+            # Create empty array for each field
+            empty_array = pa.array([], type=field.type)
+            arrays.append(empty_array)
+        
+        empty_table = pa.Table.from_arrays(arrays, schema=schema)
+        
+        # Create Lance dataset
+        lance.write_dataset(empty_table, table_path, storage_options=self.config.storage_options)
+        
+        response = CreateTableResponse(location=table_path, version=1)
+        return response
+    
+    def drop_table(self, request: DropTableRequest) -> DropTableResponse:
+        """Drop a table by removing its Lance dataset."""
+        if not request.id:
+            raise ValueError("table ID cannot be empty")
+        
+        table_name = self._normalize_table_id(request.id)
+        table_path = self._get_table_path(table_name)
+        
+        try:
+            # Remove the entire table directory
+            self.operator.remove_all(f"{table_name}.lance/")
+            response = DropTableResponse()
+            return response
+        except Exception as e:
+            raise RuntimeError(f"Failed to drop table {table_name}: {e}")
+
+    def describe_table(self, request: DescribeTableRequest) -> DescribeTableResponse:
+        """Describe a table by checking its existence and returning location."""
+        if not request.id:
+            raise ValueError("table ID cannot be empty")
+        
+        table_name = self._normalize_table_id(request.id)
+        table_path = self._get_table_path(table_name)
+        
+        try:
+            # Check if it's a Lance dataset by looking for objects with _versions/ prefix
+            versions_path = f"{table_name}.lance/_versions/"
+            version_entries = list(self.operator.list(versions_path, limit=1))
+            if not version_entries:
+                raise RuntimeError(f"Table does not exist: {table_name}")
+        except Exception as e:
+            raise RuntimeError(f"Table does not exist: {table_name}: {e}")
+        
+        response = DescribeTableResponse(location=table_path)
+        return response
+    
+    def _normalize_table_id(self, id: List[str]) -> str:
+        """Normalize table ID - only single-level IDs are supported."""
+        if not id:
+            raise ValueError("Directory namespace table ID cannot be empty")
+        
+        if len(id) != 1:
+            raise ValueError(
+                f"Directory namespace only supports single-level table IDs, but got: {id}"
+            )
+        
+        return id[0]
+    
+    def _validate_root_namespace_id(self, id: Optional[List[str]]) -> None:
+        """Validate that the namespace ID represents a root namespace."""
+        if id:
+            raise ValueError(
+                f"Directory namespace only supports root namespace operations, "
+                f"but got namespace ID: {id}. Expected empty ID."
+            )
+    
+    def _get_table_path(self, table_name: str) -> str:
+        """Get the full path for a table."""
+        root = self.config.root if self.config.root else os.getcwd()
+        return f"{root}/{table_name}.lance"
+    
+    def _convert_json_arrow_schema_to_pyarrow(self, json_schema: JsonArrowSchema) -> pa.Schema:
+        """Convert JsonArrowSchema to PyArrow Schema."""
+        fields = []
+        for json_field in json_schema.fields:
+            arrow_type = self._convert_json_arrow_type_to_pyarrow(json_field.type)
+            field = pa.field(json_field.name, arrow_type, nullable=json_field.nullable)
+            fields.append(field)
+        
+        return pa.schema(fields, metadata=json_schema.metadata)
+    
+    def _convert_json_arrow_type_to_pyarrow(self, json_type: JsonArrowDataType) -> pa.DataType:
+        """Convert JsonArrowDataType to PyArrow DataType."""
+        type_name = json_type.type.lower()
+        
+        if type_name == "null":
+            return pa.null()
+        elif type_name in ["bool", "boolean"]:
+            return pa.bool_()
+        elif type_name == "int8":
+            return pa.int8()
+        elif type_name == "uint8":
+            return pa.uint8()
+        elif type_name == "int16":
+            return pa.int16()
+        elif type_name == "uint16":
+            return pa.uint16()
+        elif type_name == "int32":
+            return pa.int32()
+        elif type_name == "uint32":
+            return pa.uint32()
+        elif type_name == "int64":
+            return pa.int64()
+        elif type_name == "uint64":
+            return pa.uint64()
+        elif type_name == "float32":
+            return pa.float32()
+        elif type_name == "float64":
+            return pa.float64()
+        elif type_name == "utf8":
+            return pa.utf8()
+        elif type_name == "binary":
+            return pa.binary()
+        else:
+            raise ValueError(f"Unsupported Arrow type: {type_name}")
+    
+    def _parse_path(self, path: str) -> str:
+        """Parse the path and convert to a proper URI if needed."""
+        parsed = urlparse(path)
+        if parsed.scheme:
+            return path
+        
+        # Handle absolute and relative POSIX paths
+        if path.startswith('/'):
+            return f"file://{path}"
+        else:
+            current_dir = os.getcwd()
+            absolute_path = os.path.abspath(os.path.join(current_dir, path))
+            return f"file://{absolute_path}"
+    
+    def _normalize_scheme(self, scheme: Optional[str]) -> str:
+        """Normalize scheme with aliases."""
+        if scheme is None:
+            return 'fs'
+        
+        # Handle scheme aliases
+        scheme_lower = scheme.lower()
+        if scheme_lower in ['s3a', 's3n']:
+            return 's3'
+        elif scheme_lower == 'abfs':
+            return 'azblob'
+        elif scheme_lower == 'file':
+            return 'fs'
+        else:
+            return scheme_lower
+    
+    def _initialize_operator(self, root: str) -> opendal.Operator:
+        """Initialize the OpenDAL operator based on the root path."""
+        scheme_split = root.split("://", 1)
+        
+        # Local file system path
+        if len(scheme_split) < 2:
+            return opendal.Operator("fs", root=root)
+        
+        scheme = self._normalize_scheme(scheme_split[0])
+        authority_split = scheme_split[1].split("/", 1)
+        authority = authority_split[0]
+        path = authority_split[1] if len(authority_split) > 1 else ""
+        
+        if scheme in ["s3", "gcs"]:
+            return opendal.Operator(scheme, root=path, bucket=authority)
+        elif scheme == "azblob":
+            return opendal.Operator(scheme, root=path, container=authority)
+        else:
+            return opendal.Operator(scheme, root=scheme_split[1])
+    
+
+
+class DirectoryNamespaceConfig:
+    """Configuration for DirectoryNamespace."""
+    
+    ROOT = "root"
+    STORAGE_OPTIONS_PREFIX = "storage."
+    
+    def __init__(self, properties: Optional[Dict[str, str]] = None):
+        """Initialize configuration from properties.
+        
+        Args:
+            properties: Dictionary of configuration properties
+        """
+        if properties is None:
+            properties = {}
+            
+        self._root = properties.get(self.ROOT)
+        self._storage_options = self._extract_storage_options(properties)
+    
+    def _extract_storage_options(self, properties: Dict[str, str]) -> Dict[str, str]:
+        """Extract storage configuration properties by removing the prefix."""
+        storage_options = {}
+        for key, value in properties.items():
+            if key.startswith(self.STORAGE_OPTIONS_PREFIX):
+                storage_key = key[len(self.STORAGE_OPTIONS_PREFIX):]
+                storage_options[storage_key] = value
+        return storage_options
+    
+    @property
+    def root(self) -> Optional[str]:
+        """Get the namespace root directory."""
+        return self._root
+    
+    @property
+    def storage_options(self) -> Dict[str, str]:
+        """Get the storage configuration properties."""
+        return self._storage_options.copy()

lance_namespace/namespace.py

@@ -0,0 +1,183 @@
+"""
+Lance Namespace base interface and implementations.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional, List, Union
+import importlib
+import inspect
+
+from lance_namespace_urllib3_client.models import (
+    ListNamespacesRequest,
+    ListNamespacesResponse,
+    DescribeNamespaceRequest,
+    DescribeNamespaceResponse,
+    CreateNamespaceRequest,
+    CreateNamespaceResponse,
+    DropNamespaceRequest,
+    DropNamespaceResponse,
+    NamespaceExistsRequest,
+    ListTablesRequest,
+    ListTablesResponse,
+    DescribeTableRequest,
+    DescribeTableResponse,
+    RegisterTableRequest,
+    RegisterTableResponse,
+    TableExistsRequest,
+    DropTableRequest,
+    DropTableResponse,
+    DeregisterTableRequest,
+    DeregisterTableResponse,
+    CountTableRowsRequest,
+    CreateTableRequest,
+    CreateTableResponse,
+    InsertIntoTableRequest,
+    InsertIntoTableResponse,
+    MergeInsertIntoTableRequest,
+    MergeInsertIntoTableResponse,
+    UpdateTableRequest,
+    UpdateTableResponse,
+    DeleteFromTableRequest,
+    DeleteFromTableResponse,
+    QueryTableRequest,
+    CreateTableIndexRequest,
+    CreateTableIndexResponse,
+    ListTableIndicesRequest,
+    ListTableIndicesResponse,
+    DescribeTableIndexStatsRequest,
+    DescribeTableIndexStatsResponse,
+    DescribeTransactionRequest,
+    DescribeTransactionResponse,
+    AlterTransactionRequest,
+    AlterTransactionResponse,
+)
+
+
+class LanceNamespace(ABC):
+    """Base interface for Lance Namespace implementations."""
+
+    def list_namespaces(self, request: ListNamespacesRequest) -> ListNamespacesResponse:
+        """List namespaces."""
+        raise NotImplementedError("Not supported: list_namespaces")
+    
+    def describe_namespace(self, request: DescribeNamespaceRequest) -> DescribeNamespaceResponse:
+        """Describe a namespace."""
+        raise NotImplementedError("Not supported: describe_namespace")
+    
+    def create_namespace(self, request: CreateNamespaceRequest) -> CreateNamespaceResponse:
+        """Create a new namespace."""
+        raise NotImplementedError("Not supported: create_namespace")
+    
+    def drop_namespace(self, request: DropNamespaceRequest) -> DropNamespaceResponse:
+        """Drop a namespace."""
+        raise NotImplementedError("Not supported: drop_namespace")
+    
+    def namespace_exists(self, request: NamespaceExistsRequest) -> None:
+        """Check if a namespace exists."""
+        raise NotImplementedError("Not supported: namespace_exists")
+    
+    def list_tables(self, request: ListTablesRequest) -> ListTablesResponse:
+        """List tables in a namespace."""
+        raise NotImplementedError("Not supported: list_tables")
+    
+    def describe_table(self, request: DescribeTableRequest) -> DescribeTableResponse:
+        """Describe a table."""
+        raise NotImplementedError("Not supported: describe_table")
+    
+    def register_table(self, request: RegisterTableRequest) -> RegisterTableResponse:
+        """Register a table."""
+        raise NotImplementedError("Not supported: register_table")
+    
+    def table_exists(self, request: TableExistsRequest) -> None:
+        """Check if a table exists."""
+        raise NotImplementedError("Not supported: table_exists")
+    
+    def drop_table(self, request: DropTableRequest) -> DropTableResponse:
+        """Drop a table."""
+        raise NotImplementedError("Not supported: drop_table")
+    
+    def deregister_table(self, request: DeregisterTableRequest) -> DeregisterTableResponse:
+        """Deregister a table."""
+        raise NotImplementedError("Not supported: deregister_table")
+    
+    def count_table_rows(self, request: CountTableRowsRequest) -> int:
+        """Count rows in a table."""
+        raise NotImplementedError("Not supported: count_table_rows")
+    
+    def create_table(self, request: CreateTableRequest, request_data: bytes) -> CreateTableResponse:
+        """Create a new table."""
+        raise NotImplementedError("Not supported: create_table")
+    
+    def insert_into_table(self, request: InsertIntoTableRequest, request_data: bytes) -> InsertIntoTableResponse:
+        """Insert data into a table."""
+        raise NotImplementedError("Not supported: insert_into_table")
+    
+    def merge_insert_into_table(
+        self, request: MergeInsertIntoTableRequest, request_data: bytes
+    ) -> MergeInsertIntoTableResponse:
+        """Merge insert data into a table."""
+        raise NotImplementedError("Not supported: merge_insert_into_table")
+    
+    def update_table(self, request: UpdateTableRequest) -> UpdateTableResponse:
+        """Update a table."""
+        raise NotImplementedError("Not supported: update_table")
+    
+    def delete_from_table(self, request: DeleteFromTableRequest) -> DeleteFromTableResponse:
+        """Delete from a table."""
+        raise NotImplementedError("Not supported: delete_from_table")
+    
+    def query_table(self, request: QueryTableRequest) -> bytes:
+        """Query a table."""
+        raise NotImplementedError("Not supported: query_table")
+    
+    def create_table_index(self, request: CreateTableIndexRequest) -> CreateTableIndexResponse:
+        """Create a table index."""
+        raise NotImplementedError("Not supported: create_table_index")
+    
+    def list_table_indices(self, request: ListTableIndicesRequest) -> ListTableIndicesResponse:
+        """List table indices."""
+        raise NotImplementedError("Not supported: list_table_indices")
+    
+    def describe_table_index_stats(
+        self, request: DescribeTableIndexStatsRequest
+    ) -> DescribeTableIndexStatsResponse:
+        """Describe table index statistics."""
+        raise NotImplementedError("Not supported: describe_table_index_stats")
+    
+    def describe_transaction(self, request: DescribeTransactionRequest) -> DescribeTransactionResponse:
+        """Describe a transaction."""
+        raise NotImplementedError("Not supported: describe_transaction")
+    
+    def alter_transaction(self, request: AlterTransactionRequest) -> AlterTransactionResponse:
+        """Alter a transaction."""
+        raise NotImplementedError("Not supported: alter_transaction")
+
+
+NATIVE_IMPLS = {
+    "rest": "lance_namespace.rest.LanceRestNamespace",
+    "dir": "lance_namespace.dir.DirectoryNamespace",
+}
+
+def connect(impl: str, properties: Dict[str, str]) -> LanceNamespace:
+    """
+    Connect to a Lance namespace implementation.
+    
+    Args:
+        impl: Implementation alias or full class path
+        properties: Configuration properties
+        conf: Optional configuration object
+        
+    Returns:
+        LanceNamespace instance
+    """
+    impl_class = NATIVE_IMPLS.get(impl, impl)
+    try:
+        module_name, class_name = impl_class.rsplit(".", 1)
+        module = importlib.import_module(module_name)
+        namespace_class = getattr(module, class_name)
+
+        if not issubclass(namespace_class, LanceNamespace):
+            raise ValueError(f"Class {impl_class} does not implement LanceNamespace interface")
+
+        return namespace_class(**properties)
+    except Exception as e:
+        raise ValueError(f"Failed to construct namespace impl {impl_class}: {e}")

lance_namespace/rest.py

@@ -0,0 +1,322 @@
+"""
+Lance REST Namespace implementation.
+"""
+from typing import Dict, Any, Optional
+import json
+
+from lance_namespace_urllib3_client import (
+    ApiClient,
+    Configuration,
+    NamespaceApi,
+    TableApi,
+    TransactionApi,
+)
+from lance_namespace_urllib3_client.models import (
+    ListNamespacesRequest,
+    ListNamespacesResponse,
+    DescribeNamespaceRequest,
+    DescribeNamespaceResponse,
+    CreateNamespaceRequest,
+    CreateNamespaceResponse,
+    DropNamespaceRequest,
+    DropNamespaceResponse,
+    NamespaceExistsRequest,
+    ListTablesRequest,
+    ListTablesResponse,
+    DescribeTableRequest,
+    DescribeTableResponse,
+    RegisterTableRequest,
+    RegisterTableResponse,
+    TableExistsRequest,
+    DropTableRequest,
+    DropTableResponse,
+    DeregisterTableRequest,
+    DeregisterTableResponse,
+    CountTableRowsRequest,
+    CreateTableRequest,
+    CreateTableResponse,
+    InsertIntoTableRequest,
+    InsertIntoTableResponse,
+    MergeInsertIntoTableRequest,
+    MergeInsertIntoTableResponse,
+    UpdateTableRequest,
+    UpdateTableResponse,
+    DeleteFromTableRequest,
+    DeleteFromTableResponse,
+    QueryTableRequest,
+    CreateTableIndexRequest,
+    CreateTableIndexResponse,
+    ListTableIndicesRequest,
+    ListTableIndicesResponse,
+    DescribeTableIndexStatsRequest,
+    DescribeTableIndexStatsResponse,
+    DescribeTransactionRequest,
+    DescribeTransactionResponse,
+    AlterTransactionRequest,
+    AlterTransactionResponse,
+)
+
+from .namespace import LanceNamespace
+
+
+class RestNamespaceConfig:
+    """Configuration for REST namespace."""
+
+    DELIMITER = "delimiter"
+    HEADER_PREFIX = "header."
+    
+    def __init__(self, properties: Dict[str, str]):
+        self._delimiter = properties.get(self.DELIMITER, ".")
+        self._headers = {}
+
+        for key, value in properties.items():
+            if key.startswith(self.HEADER_PREFIX):
+                header_name = key[len(self.HEADER_PREFIX):]
+                self._headers[header_name] = value
+    
+    def delimiter(self) -> str:
+        return self._delimiter
+    
+    def additional_headers(self) -> Dict[str, str]:
+        return self._headers
+
+
+def object_id_str(id_list: list[str], delimiter: str = ".", obj: Any = None) -> str:
+    """Convert a list of strings to a string identifier using the specified delimiter.
+    If the list is empty, returns the delimiter itself.
+    
+    Args:
+        id_list: List of strings representing the identifier
+        delimiter: Delimiter to join the strings
+        obj: The object containing the id (for error messages)
+        
+    Returns:
+        String identifier
+        
+    Raises:
+        ValueError: If id_list is None
+    """
+    if id_list is None:
+        object_type = type(obj).__name__ if obj is not None else "Unknown"
+        raise ValueError(f"Object of type '{object_type}' must have an 'id' field")
+    if len(id_list) == 0:
+        return delimiter
+    return delimiter.join(id_list)
+
+
+class LanceRestNamespace(LanceNamespace):
+    """REST implementation of Lance Namespace."""
+    
+    def __init__(self, **kwargs):
+        configuration = Configuration()
+        if "uri" in kwargs:
+            configuration.host = kwargs["uri"]
+
+        self.api_client = ApiClient(configuration)
+        self.namespace_api = NamespaceApi(self.api_client)
+        self.table_api = TableApi(self.api_client)
+        self.transaction_api = TransactionApi(self.api_client)
+        self.config = RestNamespaceConfig(kwargs)
+    
+    def list_namespaces(self, request: ListNamespacesRequest) -> ListNamespacesResponse:
+        return self.namespace_api.list_namespaces(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            delimiter=self.config.delimiter(),
+            page_token=request.page_token,
+            limit=request.limit,
+            _headers=self.config.additional_headers(),
+        )
+    
+    def describe_namespace(self, request: DescribeNamespaceRequest) -> DescribeNamespaceResponse:
+        return self.namespace_api.describe_namespace(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            describe_namespace_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def create_namespace(self, request: CreateNamespaceRequest) -> CreateNamespaceResponse:
+        return self.namespace_api.create_namespace(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            create_namespace_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def drop_namespace(self, request: DropNamespaceRequest) -> DropNamespaceResponse:
+        return self.namespace_api.drop_namespace(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            drop_namespace_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def namespace_exists(self, request: NamespaceExistsRequest) -> None:
+        self.namespace_api.namespace_exists(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            namespace_exists_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def list_tables(self, request: ListTablesRequest) -> ListTablesResponse:
+        return self.table_api.list_tables(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            delimiter=self.config.delimiter(),
+            page_token=request.page_token,
+            limit=request.limit,
+            _headers=self.config.additional_headers(),
+        )
+    
+    def describe_table(self, request: DescribeTableRequest) -> DescribeTableResponse:
+        return self.table_api.describe_table(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            describe_table_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def register_table(self, request: RegisterTableRequest) -> RegisterTableResponse:
+        return self.table_api.register_table(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            register_table_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def table_exists(self, request: TableExistsRequest) -> None:
+        self.table_api.table_exists(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            table_exists_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def drop_table(self, request: DropTableRequest) -> DropTableResponse:
+        return self.table_api.drop_table(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            drop_table_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def deregister_table(self, request: DeregisterTableRequest) -> DeregisterTableResponse:
+        return self.table_api.deregister_table(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            deregister_table_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+
+    def count_table_rows(self, request: CountTableRowsRequest) -> int:
+        return self.table_api.count_table_rows(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            count_table_rows_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def create_table(self, request: CreateTableRequest, request_data: bytes) -> CreateTableResponse:
+        table_properties = json.dumps(request.properties) if request.properties else None
+        return self.table_api.create_table(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            x_lance_table_location=request.location,
+            body=request_data,
+            delimiter=self.config.delimiter(),
+            x_lance_table_properties=table_properties,
+            _headers=self.config.additional_headers(),
+        )
+    
+    def insert_into_table(self, request: InsertIntoTableRequest, request_data: bytes) -> InsertIntoTableResponse:
+        mode = request.mode if request.mode else None
+        
+        return self.table_api.insert_into_table(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            body=request_data,
+            delimiter=self.config.delimiter(),
+            mode=mode,
+            _headers=self.config.additional_headers(),
+        )
+    
+    def merge_insert_into_table(
+        self, request: MergeInsertIntoTableRequest, request_data: bytes
+    ) -> MergeInsertIntoTableResponse:
+        return self.table_api.merge_insert_into_table(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            on=request.on,
+            body=request_data,
+            delimiter=self.config.delimiter(),
+            when_matched_update_all=request.when_matched_update_all,
+            when_matched_update_all_filt=request.when_matched_update_all_filt,
+            when_not_matched_insert_all=request.when_not_matched_insert_all,
+            when_not_matched_by_source_delete=request.when_not_matched_by_source_delete,
+            when_not_matched_by_source_delete_filt=request.when_not_matched_by_source_delete_filt,
+            _headers=self.config.additional_headers(),
+        )
+    
+    def update_table(self, request: UpdateTableRequest) -> UpdateTableResponse:
+        return self.table_api.update_table(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            update_table_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def delete_from_table(self, request: DeleteFromTableRequest) -> DeleteFromTableResponse:
+        return self.table_api.delete_from_table(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            delete_from_table_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def query_table(self, request: QueryTableRequest) -> bytes:
+        return self.table_api.query_table(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            query_table_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def create_table_index(self, request: CreateTableIndexRequest) -> CreateTableIndexResponse:
+        return self.table_api.create_table_index(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            create_table_index_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def list_table_indices(self, request: ListTableIndicesRequest) -> ListTableIndicesResponse:
+        return self.table_api.list_table_indices(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            list_table_indices_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def describe_table_index_stats(
+        self, request: DescribeTableIndexStatsRequest, index_name: str
+    ) -> DescribeTableIndexStatsResponse:
+        return self.table_api.describe_table_index_stats(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            index_name=index_name,
+            describe_table_index_stats_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def describe_transaction(self, request: DescribeTransactionRequest) -> DescribeTransactionResponse:
+        return self.transaction_api.describe_transaction(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            describe_transaction_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )
+    
+    def alter_transaction(self, request: AlterTransactionRequest) -> AlterTransactionResponse:
+        return self.transaction_api.alter_transaction(
+            id=object_id_str(request.id, self.config.delimiter(), request),
+            alter_transaction_request=request,
+            delimiter=self.config.delimiter(),
+            _headers=self.config.additional_headers(),
+        )

lance_namespace-0.0.5.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: lance-namespace
+Version: 0.0.5
+Summary: Python client for Lance Namespace API
+Author-email: Jack Ye <yezhaoqin@gmail.com>
+Requires-Python: >=3.10
+Requires-Dist: lance-namespace-urllib3-client
+Requires-Dist: opendal>=0.46.0
+Requires-Dist: pyarrow>=14.0.0
+Requires-Dist: pylance>=0.18.0
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: test
+Requires-Dist: pytest-cov>=4.0.0; extra == 'test'
+Requires-Dist: pytest>=7.0.0; extra == 'test'

lance_namespace-0.0.5.dist-info/RECORD

@@ -0,0 +1,8 @@
+lance_namespace/__init__.py,sha256=_ciyt9wISTrNx_mMht6mqTJYv3D9UW2pZo40dVaggFI,2911
+lance_namespace/dir.py,sha256=GGOeDYM6Mv1SoLP6ejSXKgUF-W1NlN_MuuytP94siL8,13434
+lance_namespace/namespace.py,sha256=ChAt5oG6fejdzCboPU7g4sGB884CXzkrDhDYuZcqNWE,7143
+lance_namespace/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lance_namespace/rest.py,sha256=_6N7DN6cYgsTwxOrb0R1Tr76KZ4Q-paPaI_BHANfcmQ,12972
+lance_namespace-0.0.5.dist-info/METADATA,sha256=ZbeD6IkWIJ9Q2vpark4-g7xUjNmieEEzZcWU3RYnTLA,470
+lance_namespace-0.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lance_namespace-0.0.5.dist-info/RECORD,,

lance_namespace-0.0.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any