sqlspec 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

sqlspec/storage/backends/base.py

@@ -1,166 +1,163 @@
 """Base class for storage backends."""
 
-from __future__ import annotations
-
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any
+from collections.abc import AsyncIterator, Iterator
+from typing import Any
 
-if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Iterator
+from mypy_extensions import mypyc_attr
 
-    from sqlspec.typing import ArrowRecordBatch, ArrowTable
+from sqlspec.typing import ArrowRecordBatch, ArrowTable
 
 __all__ = ("ObjectStoreBase",)
 
 
+@mypyc_attr(allow_interpreted_subclasses=True)
 class ObjectStoreBase(ABC):
-    """Base class for instrumented storage backends."""
+    """Base class for storage backends."""
+
+    __slots__ = ()
 
-    # Sync Operations
     @abstractmethod
     def read_bytes(self, path: str, **kwargs: Any) -> bytes:
-        """Actual implementation of read_bytes in subclasses."""
+        """Read bytes from storage."""
         raise NotImplementedError
 
     @abstractmethod
     def write_bytes(self, path: str, data: bytes, **kwargs: Any) -> None:
-        """Actual implementation of write_bytes in subclasses."""
+        """Write bytes to storage."""
         raise NotImplementedError
 
     @abstractmethod
     def read_text(self, path: str, encoding: str = "utf-8", **kwargs: Any) -> str:
-        """Actual implementation of read_text in subclasses."""
+        """Read text from storage."""
         raise NotImplementedError
 
     @abstractmethod
     def write_text(self, path: str, data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
-        """Actual implementation of write_text in subclasses."""
+        """Write text to storage."""
         raise NotImplementedError
 
     @abstractmethod
     def list_objects(self, prefix: str = "", recursive: bool = True, **kwargs: Any) -> list[str]:
-        """Actual implementation of list_objects in subclasses."""
+        """List objects in storage."""
         raise NotImplementedError
 
     @abstractmethod
     def exists(self, path: str, **kwargs: Any) -> bool:
-        """Actual implementation of exists in subclasses."""
+        """Check if object exists in storage."""
         raise NotImplementedError
 
     @abstractmethod
     def delete(self, path: str, **kwargs: Any) -> None:
-        """Actual implementation of delete in subclasses."""
+        """Delete object from storage."""
         raise NotImplementedError
 
     @abstractmethod
     def copy(self, source: str, destination: str, **kwargs: Any) -> None:
-        """Actual implementation of copy in subclasses."""
+        """Copy object within storage."""
         raise NotImplementedError
 
     @abstractmethod
     def move(self, source: str, destination: str, **kwargs: Any) -> None:
-        """Actual implementation of move in subclasses."""
+        """Move object within storage."""
         raise NotImplementedError
 
     @abstractmethod
     def glob(self, pattern: str, **kwargs: Any) -> list[str]:
-        """Actual implementation of glob in subclasses."""
+        """Find objects matching pattern."""
         raise NotImplementedError
 
     @abstractmethod
     def get_metadata(self, path: str, **kwargs: Any) -> dict[str, Any]:
-        """Actual implementation of get_metadata in subclasses."""
+        """Get object metadata from storage."""
         raise NotImplementedError
 
     @abstractmethod
     def is_object(self, path: str) -> bool:
-        """Actual implementation of is_object in subclasses."""
+        """Check if path points to an object."""
         raise NotImplementedError
 
     @abstractmethod
     def is_path(self, path: str) -> bool:
-        """Actual implementation of is_path in subclasses."""
+        """Check if path points to a directory."""
         raise NotImplementedError
 
     @abstractmethod
     def read_arrow(self, path: str, **kwargs: Any) -> ArrowTable:
-        """Actual implementation of read_arrow in subclasses."""
+        """Read Arrow table from storage."""
         raise NotImplementedError
 
     @abstractmethod
     def write_arrow(self, path: str, table: ArrowTable, **kwargs: Any) -> None:
-        """Actual implementation of write_arrow in subclasses."""
+        """Write Arrow table to storage."""
         raise NotImplementedError
 
     @abstractmethod
     def stream_arrow(self, pattern: str, **kwargs: Any) -> Iterator[ArrowRecordBatch]:
-        """Actual implementation of stream_arrow in subclasses."""
+        """Stream Arrow record batches from storage."""
         raise NotImplementedError
 
-    # Abstract async methods that subclasses must implement
-    # Backends can either provide native async implementations or wrap sync methods
-
     @abstractmethod
     async def read_bytes_async(self, path: str, **kwargs: Any) -> bytes:
-        """Actual async implementation of read_bytes in subclasses."""
+        """Read bytes from storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def write_bytes_async(self, path: str, data: bytes, **kwargs: Any) -> None:
-        """Actual async implementation of write_bytes in subclasses."""
+        """Write bytes to storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def read_text_async(self, path: str, encoding: str = "utf-8", **kwargs: Any) -> str:
-        """Actual async implementation of read_text in subclasses."""
+        """Read text from storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def write_text_async(self, path: str, data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
-        """Actual async implementation of write_text in subclasses."""
+        """Write text to storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def list_objects_async(self, prefix: str = "", recursive: bool = True, **kwargs: Any) -> list[str]:
-        """Actual async implementation of list_objects in subclasses."""
+        """List objects in storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def exists_async(self, path: str, **kwargs: Any) -> bool:
-        """Actual async implementation of exists in subclasses."""
+        """Check if object exists in storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def delete_async(self, path: str, **kwargs: Any) -> None:
-        """Actual async implementation of delete in subclasses."""
+        """Delete object from storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def copy_async(self, source: str, destination: str, **kwargs: Any) -> None:
-        """Actual async implementation of copy in subclasses."""
+        """Copy object within storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def move_async(self, source: str, destination: str, **kwargs: Any) -> None:
-        """Actual async implementation of move in subclasses."""
+        """Move object within storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def get_metadata_async(self, path: str, **kwargs: Any) -> dict[str, Any]:
-        """Actual async implementation of get_metadata in subclasses."""
+        """Get object metadata from storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def read_arrow_async(self, path: str, **kwargs: Any) -> ArrowTable:
-        """Actual async implementation of read_arrow in subclasses."""
+        """Read Arrow table from storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     async def write_arrow_async(self, path: str, table: ArrowTable, **kwargs: Any) -> None:
-        """Actual async implementation of write_arrow in subclasses."""
+        """Write Arrow table to storage asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
     def stream_arrow_async(self, pattern: str, **kwargs: Any) -> AsyncIterator[ArrowRecordBatch]:
-        """Actual async implementation of stream_arrow in subclasses."""
+        """Stream Arrow record batches from storage asynchronously."""
         raise NotImplementedError

sqlspec/storage/backends/fsspec.py

@@ -1,10 +1,8 @@
-# pyright: ignore=reportUnknownVariableType
 import logging
-from io import BytesIO
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Union
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union
 
-from sqlspec.exceptions import MissingDependencyError
+from sqlspec.exceptions import MissingDependencyError, StorageOperationFailedError
 from sqlspec.storage.backends.base import ObjectStoreBase
 from sqlspec.storage.capabilities import StorageCapabilities
 from sqlspec.typing import FSSPEC_INSTALLED, PYARROW_INSTALLED
@@ -21,34 +19,51 @@ __all__ = ("FSSpecBackend",)
 
 logger = logging.getLogger(__name__)
 
-# Constants for URI validation
-URI_PARTS_MIN_COUNT = 2
-"""Minimum number of parts in a valid cloud storage URI (bucket/path)."""
 
-AZURE_URI_PARTS_MIN_COUNT = 2
-"""Minimum number of parts in an Azure URI (account/container)."""
+class _ArrowStreamer:
+    def __init__(self, backend: "FSSpecBackend", pattern: str, **kwargs: Any) -> None:
+        self.backend = backend
+        self.pattern = pattern
+        self.kwargs = kwargs
+        self.paths_iterator: Optional[Iterator[str]] = None
+        self.batch_iterator: Optional[Iterator[ArrowRecordBatch]] = None
 
-AZURE_URI_BLOB_INDEX = 2
-"""Index of blob name in Azure URI parts."""
+    def __aiter__(self) -> "_ArrowStreamer":
+        return self
 
+    async def _initialize(self) -> None:
+        """Initialize the paths iterator."""
+        if self.paths_iterator is None:
+            paths = await async_(self.backend.glob)(self.pattern, **self.kwargs)
+            self.paths_iterator = iter(paths)
 
-def _join_path(prefix: str, path: str) -> str:
-    if not prefix:
-        return path
-    prefix = prefix.rstrip("/")
-    path = path.lstrip("/")
-    return f"{prefix}/{path}"
+    async def __anext__(self) -> "ArrowRecordBatch":
+        await self._initialize()
+
+        if self.batch_iterator:
+            try:
+                return next(self.batch_iterator)
+            except StopIteration:
+                self.batch_iterator = None
+
+        if self.paths_iterator:
+            try:
+                path = next(self.paths_iterator)
+                self.batch_iterator = await async_(self.backend._stream_file_batches)(path)
+                return await self.__anext__()
+            except StopIteration:
+                raise StopAsyncIteration
+        raise StopAsyncIteration
 
 
 class FSSpecBackend(ObjectStoreBase):
-    """Extended protocol support via fsspec.
+    """Storage backend using fsspec.
 
-    This backend implements the ObjectStoreProtocol using fsspec,
-    providing support for extended protocols not covered by obstore
-    and offering fallback capabilities.
+    Implements the ObjectStoreProtocol using fsspec,
+    providing support for various protocols including HTTP, HTTPS, FTP,
+    and cloud storage services.
     """
 
-    # FSSpec supports most operations but varies by underlying filesystem
     _default_capabilities: ClassVar[StorageCapabilities] = StorageCapabilities(
         supports_arrow=PYARROW_INSTALLED,
         supports_streaming=PYARROW_INSTALLED,
@@ -75,7 +90,6 @@ class FSSpecBackend(ObjectStoreBase):
             self.protocol = getattr(fs, "protocol", "unknown")
             self._fs_uri = f"{self.protocol}://"
 
-        # Set instance-level capabilities based on detected protocol
         self._instance_capabilities = self._detect_capabilities()
 
         super().__init__()
@@ -145,17 +159,24 @@ class FSSpecBackend(ObjectStoreBase):
     def base_uri(self) -> str:
         return self._fs_uri
 
-    # Core Operations (sync)
     def read_bytes(self, path: Union[str, Path], **kwargs: Any) -> bytes:
         """Read bytes from an object."""
-        resolved_path = self._resolve_path(path)
-        return self.fs.cat(resolved_path, **kwargs)  # type: ignore[no-any-return]  # pyright: ignore
+        try:
+            resolved_path = self._resolve_path(path)
+            return self.fs.cat(resolved_path, **kwargs)  # type: ignore[no-any-return]  # pyright: ignore
+        except Exception as exc:
+            msg = f"Failed to read bytes from {path}"
+            raise StorageOperationFailedError(msg) from exc
 
     def write_bytes(self, path: Union[str, Path], data: bytes, **kwargs: Any) -> None:
         """Write bytes to an object."""
-        resolved_path = self._resolve_path(path)
-        with self.fs.open(resolved_path, mode="wb", **kwargs) as f:
-            f.write(data)  # pyright: ignore
+        try:
+            resolved_path = self._resolve_path(path)
+            with self.fs.open(resolved_path, mode="wb", **kwargs) as f:
+                f.write(data)  # pyright: ignore
+        except Exception as exc:
+            msg = f"Failed to write bytes to {path}"
+            raise StorageOperationFailedError(msg) from exc
 
     def read_text(self, path: Union[str, Path], encoding: str = "utf-8", **kwargs: Any) -> str:
         """Read text from an object."""
@@ -166,7 +187,6 @@ class FSSpecBackend(ObjectStoreBase):
         """Write text to an object."""
         self.write_bytes(path, data.encode(encoding), **kwargs)
 
-    # Object Operations
     def exists(self, path: Union[str, Path], **kwargs: Any) -> bool:
         """Check if an object exists."""
         resolved_path = self._resolve_path(path)
@@ -174,66 +194,81 @@ class FSSpecBackend(ObjectStoreBase):
 
     def delete(self, path: Union[str, Path], **kwargs: Any) -> None:
         """Delete an object."""
-        resolved_path = self._resolve_path(path)
-        self.fs.rm(resolved_path, **kwargs)
+        try:
+            resolved_path = self._resolve_path(path)
+            self.fs.rm(resolved_path, **kwargs)
+        except Exception as exc:
+            msg = f"Failed to delete {path}"
+            raise StorageOperationFailedError(msg) from exc
 
     def copy(self, source: Union[str, Path], destination: Union[str, Path], **kwargs: Any) -> None:
         """Copy an object."""
-        source_path = self._resolve_path(source)
-        dest_path = self._resolve_path(destination)
-        self.fs.copy(source_path, dest_path, **kwargs)
+        try:
+            source_path = self._resolve_path(source)
+            dest_path = self._resolve_path(destination)
+            self.fs.copy(source_path, dest_path, **kwargs)
+        except Exception as exc:
+            msg = f"Failed to copy {source} to {destination}"
+            raise StorageOperationFailedError(msg) from exc
 
     def move(self, source: Union[str, Path], destination: Union[str, Path], **kwargs: Any) -> None:
         """Move an object."""
-        source_path = self._resolve_path(source)
-        dest_path = self._resolve_path(destination)
-        self.fs.mv(source_path, dest_path, **kwargs)
+        try:
+            source_path = self._resolve_path(source)
+            dest_path = self._resolve_path(destination)
+            self.fs.mv(source_path, dest_path, **kwargs)
+        except Exception as exc:
+            msg = f"Failed to move {source} to {destination}"
+            raise StorageOperationFailedError(msg) from exc
 
-    # Arrow Operations
     def read_arrow(self, path: Union[str, Path], **kwargs: Any) -> "ArrowTable":
         """Read an Arrow table from storage."""
         if not PYARROW_INSTALLED:
             raise MissingDependencyError(package="pyarrow", install_package="pyarrow")
+        try:
+            import pyarrow.parquet as pq
 
-        import pyarrow.parquet as pq
-
-        resolved_path = self._resolve_path(path)
-        with self.fs.open(resolved_path, mode="rb", **kwargs) as f:
-            return pq.read_table(f)
+            resolved_path = self._resolve_path(path)
+            with self.fs.open(resolved_path, mode="rb", **kwargs) as f:
+                return pq.read_table(f)
+        except Exception as exc:
+            msg = f"Failed to read Arrow table from {path}"
+            raise StorageOperationFailedError(msg) from exc
 
     def write_arrow(self, path: Union[str, Path], table: "ArrowTable", **kwargs: Any) -> None:
         """Write an Arrow table to storage."""
         if not PYARROW_INSTALLED:
             raise MissingDependencyError(package="pyarrow", install_package="pyarrow")
+        try:
+            import pyarrow.parquet as pq
 
-        import pyarrow.parquet as pq
-
-        resolved_path = self._resolve_path(path)
-        with self.fs.open(resolved_path, mode="wb") as f:
-            pq.write_table(table, f, **kwargs)  # pyright: ignore
+            resolved_path = self._resolve_path(path)
+            with self.fs.open(resolved_path, mode="wb") as f:
+                pq.write_table(table, f, **kwargs)  # pyright: ignore
+        except Exception as exc:
+            msg = f"Failed to write Arrow table to {path}"
+            raise StorageOperationFailedError(msg) from exc
 
-    # Listing Operations
     def list_objects(self, prefix: str = "", recursive: bool = True, **kwargs: Any) -> list[str]:
         """List objects with optional prefix."""
-        resolved_prefix = self._resolve_path(prefix) if prefix else self.base_path
-
-        # Use fs.glob for listing files
-        if recursive:
-            pattern = f"{resolved_prefix}/**" if resolved_prefix else "**"
-        else:
-            pattern = f"{resolved_prefix}/*" if resolved_prefix else "*"
-
-        paths = [str(path) for path in self.fs.glob(pattern, **kwargs) if not self.fs.isdir(path)]
-        return sorted(paths)
+        try:
+            resolved_prefix = self._resolve_path(prefix)
+            if recursive:
+                return sorted(self.fs.find(resolved_prefix, **kwargs))
+            return sorted(self.fs.ls(resolved_prefix, detail=False, **kwargs))
+        except Exception as exc:
+            msg = f"Failed to list objects with prefix '{prefix}'"
+            raise StorageOperationFailedError(msg) from exc
 
     def glob(self, pattern: str, **kwargs: Any) -> list[str]:
         """Find objects matching a glob pattern."""
-        resolved_pattern = self._resolve_path(pattern)
-        # Use fsspec's native glob
-        paths = [str(path) for path in self.fs.glob(resolved_pattern, **kwargs) if not self.fs.isdir(path)]
-        return sorted(paths)
+        try:
+            resolved_pattern = self._resolve_path(pattern)
+            return sorted(self.fs.glob(resolved_pattern, **kwargs))  # pyright: ignore
+        except Exception as exc:
+            msg = f"Failed to glob with pattern '{pattern}'"
+            raise StorageOperationFailedError(msg) from exc
 
-    # Path Operations
     def is_object(self, path: str) -> bool:
         """Check if path points to an object."""
         resolved_path = self._resolve_path(path)
@@ -246,23 +281,29 @@ class FSSpecBackend(ObjectStoreBase):
 
     def get_metadata(self, path: Union[str, Path], **kwargs: Any) -> dict[str, Any]:
         """Get object metadata."""
-        info = self.fs.info(self._resolve_path(path), **kwargs)
-
-        if isinstance(info, dict):
-            return info
-
-        # Try to get dict representation
         try:
-            return vars(info)  # type: ignore[no-any-return]
-        except AttributeError:
-            pass
-
-        resolved_path = self._resolve_path(path)
+            resolved_path = self._resolve_path(path)
+            info = self.fs.info(resolved_path, **kwargs)
+            if isinstance(info, dict):
+                return {
+                    "path": resolved_path,
+                    "exists": True,
+                    "size": info.get("size"),
+                    "last_modified": info.get("mtime"),
+                    "type": info.get("type", "file"),
+                }
+
+        except FileNotFoundError:
+            return {"path": self._resolve_path(path), "exists": False}
+        except Exception as exc:
+            msg = f"Failed to get metadata for {path}"
+            raise StorageOperationFailedError(msg) from exc
         return {
             "path": resolved_path,
-            "exists": self.fs.exists(resolved_path),
-            "size": getattr(info, "size", None),
-            "type": getattr(info, "type", "file"),
+            "exists": True,
+            "size": info.size,
+            "last_modified": info.mtime,
+            "type": info.type,
         }
 
     def _stream_file_batches(self, obj_path: Union[str, Path]) -> "Iterator[ArrowRecordBatch]":
@@ -278,85 +319,68 @@ class FSSpecBackend(ObjectStoreBase):
         if not PYARROW_INSTALLED:
             raise MissingDependencyError(package="pyarrow", install_package="pyarrow")
 
-        # Stream each file as record batches
         for obj_path in self.glob(pattern, **kwargs):
             yield from self._stream_file_batches(obj_path)
 
     async def read_bytes_async(self, path: Union[str, Path], **kwargs: Any) -> bytes:
-        """Async read bytes. Wraps the sync implementation."""
+        """Read bytes from storage asynchronously."""
         return await async_(self.read_bytes)(path, **kwargs)
 
     async def write_bytes_async(self, path: Union[str, Path], data: bytes, **kwargs: Any) -> None:
-        """Async write bytes. Wraps the sync implementation."""
+        """Write bytes to storage asynchronously."""
         return await async_(self.write_bytes)(path, data, **kwargs)
 
-    async def _stream_file_batches_async(self, obj_path: Union[str, Path]) -> "AsyncIterator[ArrowRecordBatch]":
-        import pyarrow.parquet as pq
-
-        data = await self.read_bytes_async(obj_path)
-        parquet_file = pq.ParquetFile(BytesIO(data))
-        for batch in parquet_file.iter_batches():
-            yield batch
-
-    async def stream_arrow_async(self, pattern: str, **kwargs: Any) -> "AsyncIterator[ArrowRecordBatch]":
-        """Async stream Arrow record batches.
-
-        This implementation provides file-level async streaming. Each file is
-        read into memory before its batches are processed.
+    def stream_arrow_async(self, pattern: str, **kwargs: Any) -> "AsyncIterator[ArrowRecordBatch]":
+        """Stream Arrow record batches from storage asynchronously.
 
         Args:
             pattern: The glob pattern to match.
             **kwargs: Additional arguments to pass to the glob method.
 
-        Yields:
+        Returns:
             AsyncIterator of Arrow record batches
         """
         if not PYARROW_INSTALLED:
             raise MissingDependencyError(package="pyarrow", install_package="pyarrow")
 
-        paths = await async_(self.glob)(pattern, **kwargs)
-
-        # Stream batches from each path
-        for path in paths:
-            async for batch in self._stream_file_batches_async(path):
-                yield batch
+        return _ArrowStreamer(self, pattern, **kwargs)
 
     async def read_text_async(self, path: Union[str, Path], encoding: str = "utf-8", **kwargs: Any) -> str:
-        """Async read text. Wraps the sync implementation."""
+        """Read text from storage asynchronously."""
         return await async_(self.read_text)(path, encoding, **kwargs)
 
     async def write_text_async(self, path: Union[str, Path], data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
-        """Async write text. Wraps the sync implementation."""
+        """Write text to storage asynchronously."""
         await async_(self.write_text)(path, data, encoding, **kwargs)
 
     async def list_objects_async(self, prefix: str = "", recursive: bool = True, **kwargs: Any) -> list[str]:
-        """Async list objects. Wraps the sync implementation."""
+        """List objects in storage asynchronously."""
         return await async_(self.list_objects)(prefix, recursive, **kwargs)
 
     async def exists_async(self, path: Union[str, Path], **kwargs: Any) -> bool:
-        """Async exists check. Wraps the sync implementation."""
+        """Check if object exists in storage asynchronously."""
         return await async_(self.exists)(path, **kwargs)
 
     async def delete_async(self, path: Union[str, Path], **kwargs: Any) -> None:
-        """Async delete. Wraps the sync implementation."""
+        """Delete object from storage asynchronously."""
         await async_(self.delete)(path, **kwargs)
 
     async def copy_async(self, source: Union[str, Path], destination: Union[str, Path], **kwargs: Any) -> None:
-        """Async copy. Wraps the sync implementation."""
+        """Copy object in storage asynchronously."""
         await async_(self.copy)(source, destination, **kwargs)
 
     async def move_async(self, source: Union[str, Path], destination: Union[str, Path], **kwargs: Any) -> None:
-        """Async move. Wraps the sync implementation."""
+        """Move object in storage asynchronously."""
         await async_(self.move)(source, destination, **kwargs)
 
     async def get_metadata_async(self, path: Union[str, Path], **kwargs: Any) -> dict[str, Any]:
-        """Async get metadata. Wraps the sync implementation."""
+        """Get object metadata from storage asynchronously."""
         return await async_(self.get_metadata)(path, **kwargs)
 
     async def read_arrow_async(self, path: Union[str, Path], **kwargs: Any) -> "ArrowTable":
-        """Async read Arrow. Wraps the sync implementation."""
+        """Read Arrow table from storage asynchronously."""
         return await async_(self.read_arrow)(path, **kwargs)
 
     async def write_arrow_async(self, path: Union[str, Path], table: "ArrowTable", **kwargs: Any) -> None:
-        """Async write Arrow. Wraps the sync implementation."""
+        """Write Arrow table to storage asynchronously."""
         await async_(self.write_arrow)(path, table, **kwargs)