sqlspec 0.21.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

sqlspec/storage/backends/fsspec.py

@@ -1,18 +1,14 @@
 import logging
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
-from sqlspec.exceptions import MissingDependencyError, StorageOperationFailedError
-from sqlspec.storage.backends.base import ObjectStoreBase
-from sqlspec.storage.capabilities import StorageCapabilities
+from sqlspec.exceptions import MissingDependencyError
 from sqlspec.typing import FSSPEC_INSTALLED, PYARROW_INSTALLED
 from sqlspec.utils.sync_tools import async_
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterator
 
-    from fsspec import AbstractFileSystem
-
     from sqlspec.typing import ArrowRecordBatch, ArrowTable
 
 __all__ = ("FSSpecBackend",)
@@ -56,40 +52,30 @@ class _ArrowStreamer:
         raise StopAsyncIteration
 
 
-class FSSpecBackend(ObjectStoreBase):
+class FSSpecBackend:
     """Storage backend using fsspec.
 
-    Implements the ObjectStoreProtocol using fsspec for various protocols
+    Implements ObjectStoreProtocol using fsspec for various protocols
     including HTTP, HTTPS, FTP, and cloud storage services.
     """
 
-    _default_capabilities: ClassVar[StorageCapabilities] = StorageCapabilities(
-        supports_arrow=PYARROW_INSTALLED,
-        supports_streaming=PYARROW_INSTALLED,
-        supports_async=True,
-        supports_compression=True,
-        is_remote=True,
-        is_cloud_native=False,
-    )
-
-    def __init__(self, fs: "Union[str, AbstractFileSystem]", base_path: str = "") -> None:
-        if not FSSPEC_INSTALLED:
-            raise MissingDependencyError(package="fsspec", install_package="fsspec")
+    def __init__(self, uri: str, **kwargs: Any) -> None:
+        self._ensure_fsspec()
 
+        base_path = kwargs.pop("base_path", "")
         self.base_path = base_path.rstrip("/") if base_path else ""
 
-        if isinstance(fs, str):
-            import fsspec
-
-            self.fs = fsspec.filesystem(fs.split("://")[0])
-            self.protocol = fs.split("://")[0]
-            self._fs_uri = fs
+        if "://" in uri:
+            self.protocol = uri.split("://", maxsplit=1)[0]
+            self._fs_uri = uri
         else:
-            self.fs = fs
-            self.protocol = getattr(fs, "protocol", "unknown")
-            self._fs_uri = f"{self.protocol}://"
+            self.protocol = uri
+            self._fs_uri = f"{uri}://"
+
+        import fsspec
 
-        self._instance_capabilities = self._detect_capabilities()
+        self.fs = fsspec.filesystem(self.protocol, **kwargs)
+        self.backend_type = "fsspec"
 
         super().__init__()
 
@@ -99,11 +85,22 @@ class FSSpecBackend(ObjectStoreBase):
         fs_config = config.get("fs_config", {})
         base_path = config.get("base_path", "")
 
-        import fsspec
+        uri = f"{protocol}://"
+        kwargs = dict(fs_config)
+        if base_path:
+            kwargs["base_path"] = base_path
 
-        fs_instance = fsspec.filesystem(protocol, **fs_config)
+        return cls(uri=uri, **kwargs)
 
-        return cls(fs=fs_instance, base_path=base_path)
+    def _ensure_fsspec(self) -> None:
+        """Ensure fsspec is available for operations."""
+        if not FSSPEC_INSTALLED:
+            raise MissingDependencyError(package="fsspec", install_package="fsspec")
+
+    def _ensure_pyarrow(self) -> None:
+        """Ensure PyArrow is available for Arrow operations."""
+        if not PYARROW_INSTALLED:
+            raise MissingDependencyError(package="pyarrow", install_package="pyarrow")
 
     def _resolve_path(self, path: Union[str, Path]) -> str:
         """Resolve path relative to base_path."""
@@ -112,70 +109,38 @@ class FSSpecBackend(ObjectStoreBase):
             clean_base = self.base_path.rstrip("/")
             clean_path = path_str.lstrip("/")
             return f"{clean_base}/{clean_path}"
+        if self.protocol == "s3" and "://" in self._fs_uri:
+            # For S3, we need to include the bucket from the URI
+            # Extract bucket and path from URI like s3://bucket/path
+            uri_parts = self._fs_uri.split("://", 1)[1]  # Remove s3://
+            if "/" in uri_parts:
+                # URI has bucket and base path
+                return f"{uri_parts.rstrip('/')}/{path_str.lstrip('/')}"
+            # URI has only bucket
+            return f"{uri_parts}/{path_str.lstrip('/')}"
         return path_str
 
-    def _detect_capabilities(self) -> StorageCapabilities:
-        """Detect capabilities based on filesystem protocol."""
-        protocol = self.protocol.lower()
-
-        if protocol in {"s3", "s3a", "s3n"}:
-            return StorageCapabilities.s3_compatible()
-        if protocol in {"gcs", "gs"}:
-            return StorageCapabilities.gcs()
-        if protocol in {"abfs", "az", "azure"}:
-            return StorageCapabilities.azure_blob()
-        if protocol in {"file", "local"}:
-            return StorageCapabilities.local_filesystem()
-        return StorageCapabilities(
-            supports_arrow=PYARROW_INSTALLED,
-            supports_streaming=PYARROW_INSTALLED,
-            supports_async=True,
-            supports_compression=True,
-            is_remote=True,
-            is_cloud_native=False,
-        )
-
-    @property
-    def capabilities(self) -> StorageCapabilities:
-        """Return capabilities based on detected protocol."""
-        return getattr(self, "_instance_capabilities", self.__class__._default_capabilities)
-
-    @classmethod
-    def has_capability(cls, capability: str) -> bool:
-        """Check if backend has a specific capability."""
-        return getattr(cls._default_capabilities, capability, False)
-
-    @classmethod
-    def get_capabilities(cls) -> StorageCapabilities:
-        """Get all capabilities for this backend."""
-        return cls._default_capabilities
-
-    @property
-    def backend_type(self) -> str:
-        return "fsspec"
-
     @property
     def base_uri(self) -> str:
         return self._fs_uri
 
     def read_bytes(self, path: Union[str, Path], **kwargs: Any) -> bytes:
         """Read bytes from an object."""
-        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
+        resolved_path = self._resolve_path(path)
+        return self.fs.cat(resolved_path, **kwargs)  # type: ignore[no-any-return]  # pyright: ignore
 
     def write_bytes(self, path: Union[str, Path], data: bytes, **kwargs: Any) -> None:
         """Write bytes to an object."""
-        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
+        resolved_path = self._resolve_path(path)
+
+        # Only create directories for local file systems, not for cloud storage
+        if self.protocol == "file":
+            parent_dir = str(Path(resolved_path).parent)
+            if parent_dir and not self.fs.exists(parent_dir):
+                self.fs.makedirs(parent_dir, exist_ok=True)
+
+        with self.fs.open(resolved_path, mode="wb", **kwargs) as f:
+            f.write(data)  # pyright: ignore
 
     def read_text(self, path: Union[str, Path], encoding: str = "utf-8", **kwargs: Any) -> str:
         """Read text from an object."""
@@ -193,87 +158,59 @@ class FSSpecBackend(ObjectStoreBase):
 
     def delete(self, path: Union[str, Path], **kwargs: Any) -> None:
         """Delete an object."""
-        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
+        resolved_path = self._resolve_path(path)
+        self.fs.rm(resolved_path, **kwargs)
 
     def copy(self, source: Union[str, Path], destination: Union[str, Path], **kwargs: Any) -> None:
         """Copy an object."""
-        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
+        source_path = self._resolve_path(source)
+        dest_path = self._resolve_path(destination)
+        self.fs.copy(source_path, dest_path, **kwargs)
 
     def move(self, source: Union[str, Path], destination: Union[str, Path], **kwargs: Any) -> None:
         """Move an object."""
-        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
+        source_path = self._resolve_path(source)
+        dest_path = self._resolve_path(destination)
+        self.fs.mv(source_path, dest_path, **kwargs)
 
     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)
-        except Exception as exc:
-            msg = f"Failed to read Arrow table from {path}"
-            raise StorageOperationFailedError(msg) from exc
+        resolved_path = self._resolve_path(path)
+        with self.fs.open(resolved_path, mode="rb", **kwargs) as f:
+            return pq.read_table(f)
 
     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
-        except Exception as exc:
-            msg = f"Failed to write Arrow table to {path}"
-            raise StorageOperationFailedError(msg) from exc
+        resolved_path = self._resolve_path(path)
+        with self.fs.open(resolved_path, mode="wb") as f:
+            pq.write_table(table, f, **kwargs)  # pyright: ignore
 
     def list_objects(self, prefix: str = "", recursive: bool = True, **kwargs: Any) -> list[str]:
         """List objects with optional prefix."""
-        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
+        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))
 
     def glob(self, pattern: str, **kwargs: Any) -> list[str]:
         """Find objects matching a glob pattern."""
-        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
+        resolved_pattern = self._resolve_path(pattern)
+        return sorted(self.fs.glob(resolved_pattern, **kwargs))  # pyright: ignore
 
-    def is_object(self, path: str) -> bool:
+    def is_object(self, path: Union[str, Path]) -> bool:
         """Check if path points to an object."""
         resolved_path = self._resolve_path(path)
         return self.fs.exists(resolved_path) and not self.fs.isdir(resolved_path)
 
-    def is_path(self, path: str) -> bool:
+    def is_path(self, path: Union[str, Path]) -> bool:
         """Check if path points to a prefix (directory-like)."""
         resolved_path = self._resolve_path(path)
         return self.fs.isdir(resolved_path)  # type: ignore[no-any-return]
@@ -294,9 +231,6 @@ class FSSpecBackend(ObjectStoreBase):
 
         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": True,
@@ -305,6 +239,11 @@ class FSSpecBackend(ObjectStoreBase):
             "type": info.type,
         }
 
+    def sign(self, path: str, expires_in: int = 3600, for_upload: bool = False) -> str:
+        """Generate a signed URL for the file."""
+        resolved_path = self._resolve_path(path)
+        return f"{self._fs_uri}{resolved_path}"
+
     def _stream_file_batches(self, obj_path: Union[str, Path]) -> "Iterator[ArrowRecordBatch]":
         import pyarrow.parquet as pq
 
@@ -313,10 +252,8 @@ class FSSpecBackend(ObjectStoreBase):
             yield from parquet_file.iter_batches()
 
     def stream_arrow(self, pattern: str, **kwargs: Any) -> "Iterator[ArrowRecordBatch]":
-        if not FSSPEC_INSTALLED:
-            raise MissingDependencyError(package="fsspec", install_package="fsspec")
-        if not PYARROW_INSTALLED:
-            raise MissingDependencyError(package="pyarrow", install_package="pyarrow")
+        self._ensure_fsspec()
+        self._ensure_pyarrow()
 
         for obj_path in self.glob(pattern, **kwargs):
             yield from self._stream_file_batches(obj_path)
@@ -339,8 +276,7 @@ class FSSpecBackend(ObjectStoreBase):
         Returns:
             AsyncIterator of Arrow record batches
         """
-        if not PYARROW_INSTALLED:
-            raise MissingDependencyError(package="pyarrow", install_package="pyarrow")
+        self._ensure_pyarrow()
 
         return _ArrowStreamer(self, pattern, **kwargs)
 
@@ -376,6 +312,10 @@ class FSSpecBackend(ObjectStoreBase):
         """Get object metadata from storage asynchronously."""
         return await async_(self.get_metadata)(path, **kwargs)
 
+    async def sign_async(self, path: str, expires_in: int = 3600, for_upload: bool = False) -> str:
+        """Generate a signed URL asynchronously."""
+        return await async_(self.sign)(path, expires_in, for_upload)
+
     async def read_arrow_async(self, path: Union[str, Path], **kwargs: Any) -> "ArrowTable":
         """Read Arrow table from storage asynchronously."""
         return await async_(self.read_arrow)(path, **kwargs)

sqlspec/storage/backends/local.py

@@ -0,0 +1,310 @@
+"""Local file system storage backend.
+
+A simple, zero-dependency implementation for local file operations.
+No external dependencies like fsspec or obstore required.
+"""
+
+import shutil
+from collections.abc import AsyncIterator, Iterator
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Optional, Union
+from urllib.parse import unquote, urlparse
+
+from sqlspec.exceptions import MissingDependencyError
+from sqlspec.typing import PYARROW_INSTALLED
+from sqlspec.utils.sync_tools import async_
+
+if TYPE_CHECKING:
+    import asyncio
+
+    from sqlspec.typing import ArrowRecordBatch, ArrowTable
+
+__all__ = ("LocalStore",)
+
+
+class LocalStore:
+    """Simple local file system storage backend.
+
+    Provides file system operations without requiring fsspec or obstore.
+    Supports file:// URIs and regular file paths.
+
+    Implements ObjectStoreProtocol for type safety.
+    """
+
+    __slots__ = ("_loop", "backend_type", "base_path", "protocol")
+
+    def __init__(self, uri: str = "", **kwargs: Any) -> None:
+        """Initialize local storage backend.
+
+        Args:
+            uri: File URI or path (e.g., "file:///path" or "/path")
+            **kwargs: Additional options (base_path for relative operations)
+        """
+        if uri.startswith("file://"):
+            parsed = urlparse(uri)
+            path = unquote(parsed.path)
+            # Handle Windows paths (file:///C:/path)
+            if path and len(path) > 2 and path[2] == ":":  # noqa: PLR2004
+                path = path[1:]  # Remove leading slash for Windows
+            self.base_path = Path(path).resolve()
+        elif uri:
+            self.base_path = Path(uri).resolve()
+        else:
+            self.base_path = Path.cwd()
+
+        # Allow override with explicit base_path
+        if "base_path" in kwargs:
+            self.base_path = Path(kwargs["base_path"]).resolve()
+
+        # Create base directory if it doesn't exist and it's actually a directory
+        if not self.base_path.exists():
+            self.base_path.mkdir(parents=True, exist_ok=True)
+        elif self.base_path.is_file():
+            # If base_path points to a file, use its parent as the base directory
+            self.base_path = self.base_path.parent
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+
+        self.protocol = "file"
+        self.backend_type = "local"
+
+    def _ensure_pyarrow(self) -> None:
+        """Ensure PyArrow is available for Arrow operations."""
+        if not PYARROW_INSTALLED:
+            raise MissingDependencyError(package="pyarrow", install_package="pyarrow")
+
+    def _resolve_path(self, path: "Union[str, Path]") -> Path:
+        """Resolve path relative to base_path."""
+        p = Path(path)
+        if p.is_absolute():
+            return p
+        return self.base_path / p
+
+    def read_bytes(self, path: "Union[str, Path]", **kwargs: Any) -> bytes:
+        """Read bytes from file."""
+        resolved = self._resolve_path(path)
+        return resolved.read_bytes()
+
+    def write_bytes(self, path: "Union[str, Path]", data: bytes, **kwargs: Any) -> None:
+        """Write bytes to file."""
+        resolved = self._resolve_path(path)
+        resolved.parent.mkdir(parents=True, exist_ok=True)
+        resolved.write_bytes(data)
+
+    def read_text(self, path: "Union[str, Path]", encoding: str = "utf-8", **kwargs: Any) -> str:
+        """Read text from file."""
+        return self._resolve_path(path).read_text(encoding=encoding)
+
+    def write_text(self, path: "Union[str, Path]", data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
+        """Write text to file."""
+        resolved = self._resolve_path(path)
+        resolved.parent.mkdir(parents=True, exist_ok=True)
+        resolved.write_text(data, encoding=encoding)
+
+    def list_objects(self, prefix: str = "", recursive: bool = True, **kwargs: Any) -> list[str]:
+        """List objects in directory."""
+        # If prefix looks like a directory path, treat as directory
+        if prefix and (prefix.endswith("/") or "/" in prefix):
+            search_path = self._resolve_path(prefix)
+            if not search_path.exists():
+                return []
+            if search_path.is_file():
+                return [str(search_path.relative_to(self.base_path))]
+        else:
+            # Treat as filename prefix filter
+            search_path = self.base_path
+
+        pattern = "**/*" if recursive else "*"
+        files = []
+        for path in search_path.glob(pattern):
+            if path.is_file():
+                try:
+                    relative = path.relative_to(self.base_path)
+                    relative_str = str(relative)
+                    # Apply prefix filter if provided
+                    if not prefix or relative_str.startswith(prefix):
+                        files.append(relative_str)
+                except ValueError:
+                    # Path is outside base_path, use absolute
+                    path_str = str(path)
+                    if not prefix or path_str.startswith(prefix):
+                        files.append(path_str)
+
+        return sorted(files)
+
+    def exists(self, path: "Union[str, Path]", **kwargs: Any) -> bool:
+        """Check if file exists."""
+        return self._resolve_path(path).exists()
+
+    def delete(self, path: "Union[str, Path]", **kwargs: Any) -> None:
+        """Delete file or directory."""
+        resolved = self._resolve_path(path)
+        if resolved.is_dir():
+            shutil.rmtree(resolved)
+        elif resolved.exists():
+            resolved.unlink()
+
+    def copy(self, source: "Union[str, Path]", destination: "Union[str, Path]", **kwargs: Any) -> None:
+        """Copy file or directory."""
+        src = self._resolve_path(source)
+        dst = self._resolve_path(destination)
+        dst.parent.mkdir(parents=True, exist_ok=True)
+
+        if src.is_dir():
+            shutil.copytree(src, dst, dirs_exist_ok=True)
+        else:
+            shutil.copy2(src, dst)
+
+    def move(self, source: "Union[str, Path]", destination: "Union[str, Path]", **kwargs: Any) -> None:
+        """Move file or directory."""
+        src = self._resolve_path(source)
+        dst = self._resolve_path(destination)
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(src), str(dst))
+
+    def glob(self, pattern: str, **kwargs: Any) -> list[str]:
+        """Find files matching pattern."""
+        # Handle both relative and absolute patterns
+        if Path(pattern).is_absolute():
+            base_path = Path(pattern).parent
+            pattern_name = Path(pattern).name
+            matches = base_path.rglob(pattern_name) if "**" in pattern else base_path.glob(pattern_name)
+        else:
+            matches = self.base_path.rglob(pattern) if "**" in pattern else self.base_path.glob(pattern)
+
+        results = []
+        for match in matches:
+            if match.is_file():
+                try:
+                    relative = match.relative_to(self.base_path)
+                    results.append(str(relative))
+                except ValueError:
+                    results.append(str(match))
+
+        return sorted(results)
+
+    def get_metadata(self, path: "Union[str, Path]", **kwargs: Any) -> dict[str, Any]:
+        """Get file metadata."""
+        resolved = self._resolve_path(path)
+        if not resolved.exists():
+            return {}
+
+        stat = resolved.stat()
+        return {
+            "size": stat.st_size,
+            "modified": stat.st_mtime,
+            "created": stat.st_ctime,
+            "is_file": resolved.is_file(),
+            "is_dir": resolved.is_dir(),
+            "path": str(resolved),
+        }
+
+    def is_object(self, path: "Union[str, Path]") -> bool:
+        """Check if path points to a file."""
+        return self._resolve_path(path).is_file()
+
+    def is_path(self, path: "Union[str, Path]") -> bool:
+        """Check if path points to a directory."""
+        return self._resolve_path(path).is_dir()
+
+    def read_arrow(self, path: "Union[str, Path]", **kwargs: Any) -> "ArrowTable":
+        """Read Arrow table from file."""
+        self._ensure_pyarrow()
+        import pyarrow.parquet as pq
+
+        return pq.read_table(str(self._resolve_path(path)))
+
+    def write_arrow(self, path: "Union[str, Path]", table: "ArrowTable", **kwargs: Any) -> None:
+        """Write Arrow table to file."""
+        self._ensure_pyarrow()
+        import pyarrow.parquet as pq
+
+        resolved = self._resolve_path(path)
+        resolved.parent.mkdir(parents=True, exist_ok=True)
+        pq.write_table(table, str(resolved))
+
+    def stream_arrow(self, pattern: str, **kwargs: Any) -> Iterator["ArrowRecordBatch"]:
+        """Stream Arrow record batches from files matching pattern.
+
+        Yields:
+            Arrow record batches from matching files.
+        """
+        if not PYARROW_INSTALLED:
+            raise MissingDependencyError(package="pyarrow", install_package="pyarrow")
+        import pyarrow.parquet as pq
+
+        files = self.glob(pattern)
+        for file_path in files:
+            resolved = self._resolve_path(file_path)
+            parquet_file = pq.ParquetFile(str(resolved))
+            yield from parquet_file.iter_batches()
+
+    def sign(self, path: "Union[str, Path]", expires_in: int = 3600, for_upload: bool = False) -> str:
+        """Generate a signed URL (returns file:// URI for local files)."""
+        # For local files, just return a file:// URI
+        # No actual signing needed for local files
+        return self._resolve_path(path).as_uri()
+
+    # Async methods using sync_tools.async_
+    async def read_bytes_async(self, path: "Union[str, Path]", **kwargs: Any) -> bytes:
+        """Read bytes from file asynchronously."""
+        return await async_(self.read_bytes)(path, **kwargs)
+
+    async def write_bytes_async(self, path: "Union[str, Path]", data: bytes, **kwargs: Any) -> None:
+        """Write bytes to file asynchronously."""
+        await async_(self.write_bytes)(path, data, **kwargs)
+
+    async def read_text_async(self, path: "Union[str, Path]", encoding: str = "utf-8", **kwargs: Any) -> str:
+        """Read text from file 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:
+        """Write text to file 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]:
+        """List objects asynchronously."""
+        return await async_(self.list_objects)(prefix, recursive, **kwargs)
+
+    async def exists_async(self, path: "Union[str, Path]", **kwargs: Any) -> bool:
+        """Check if file exists asynchronously."""
+        return await async_(self.exists)(path, **kwargs)
+
+    async def delete_async(self, path: "Union[str, Path]", **kwargs: Any) -> None:
+        """Delete file asynchronously."""
+        await async_(self.delete)(path, **kwargs)
+
+    async def copy_async(self, source: "Union[str, Path]", destination: "Union[str, Path]", **kwargs: Any) -> None:
+        """Copy file asynchronously."""
+        await async_(self.copy)(source, destination, **kwargs)
+
+    async def move_async(self, source: "Union[str, Path]", destination: "Union[str, Path]", **kwargs: Any) -> None:
+        """Move file asynchronously."""
+        await async_(self.move)(source, destination, **kwargs)
+
+    async def get_metadata_async(self, path: "Union[str, Path]", **kwargs: Any) -> dict[str, Any]:
+        """Get file metadata asynchronously."""
+        return await async_(self.get_metadata)(path, **kwargs)
+
+    async def read_arrow_async(self, path: "Union[str, Path]", **kwargs: Any) -> "ArrowTable":
+        """Read Arrow table asynchronously."""
+        return await async_(self.read_arrow)(path, **kwargs)
+
+    async def write_arrow_async(self, path: "Union[str, Path]", table: "ArrowTable", **kwargs: Any) -> None:
+        """Write Arrow table asynchronously."""
+        await async_(self.write_arrow)(path, table, **kwargs)
+
+    def stream_arrow_async(self, pattern: str, **kwargs: Any) -> AsyncIterator["ArrowRecordBatch"]:
+        """Stream Arrow record batches asynchronously."""
+
+        # Convert sync iterator to async
+        async def _stream() -> AsyncIterator["ArrowRecordBatch"]:
+            for batch in self.stream_arrow(pattern, **kwargs):
+                yield batch
+
+        return _stream()
+
+    async def sign_async(self, path: "Union[str, Path]", expires_in: int = 3600, for_upload: bool = False) -> str:
+        """Generate a signed URL asynchronously (returns file:// URI for local files)."""
+        return await async_(self.sign)(path, expires_in, for_upload)