sqlspec 0.12.1__py3-none-any.whl → 0.12.2__py3-none-any.whl

sqlspec/storage/backends/fsspec.py

@@ -1,6 +1,7 @@
 # pyright: ignore=reportUnknownVariableType
 import logging
 from io import BytesIO
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Union
 
 from sqlspec.exceptions import MissingDependencyError
@@ -77,14 +78,15 @@ class FSSpecBackend(ObjectStoreBase):
 
         return cls(fs=fs_instance, base_path=base_path)
 
-    def _resolve_path(self, path: str) -> str:
+    def _resolve_path(self, path: Union[str, Path]) -> str:
         """Resolve path relative to base_path."""
+        path_str = str(path)
         if self.base_path:
             # Ensure no double slashes
             clean_base = self.base_path.rstrip("/")
-            clean_path = path.lstrip("/")
+            clean_path = path_str.lstrip("/")
             return f"{clean_base}/{clean_path}"
-        return path
+        return path_str
 
     @property
     def backend_type(self) -> str:
@@ -95,51 +97,51 @@ class FSSpecBackend(ObjectStoreBase):
         return self._fs_uri
 
     # Core Operations (sync)
-    def read_bytes(self, path: str, **kwargs: Any) -> bytes:
+    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
 
-    def write_bytes(self, path: str, data: bytes, **kwargs: Any) -> None:
+    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
 
-    def read_text(self, path: str, encoding: str = "utf-8", **kwargs: Any) -> str:
+    def read_text(self, path: Union[str, Path], encoding: str = "utf-8", **kwargs: Any) -> str:
         """Read text from an object."""
         data = self.read_bytes(path, **kwargs)
         return data.decode(encoding)
 
-    def write_text(self, path: str, data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
+    def write_text(self, path: Union[str, Path], data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
         """Write text to an object."""
         self.write_bytes(path, data.encode(encoding), **kwargs)
 
     # Object Operations
-    def exists(self, path: str, **kwargs: Any) -> bool:
+    def exists(self, path: Union[str, Path], **kwargs: Any) -> bool:
         """Check if an object exists."""
         resolved_path = self._resolve_path(path)
         return self.fs.exists(resolved_path, **kwargs)  # type: ignore[no-any-return]
 
-    def delete(self, path: str, **kwargs: Any) -> None:
+    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)
 
-    def copy(self, source: str, destination: str, **kwargs: Any) -> None:
+    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)
 
-    def move(self, source: str, destination: str, **kwargs: Any) -> None:
+    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)
 
     # Arrow Operations
-    def read_arrow(self, path: str, **kwargs: Any) -> "ArrowTable":
+    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")
@@ -150,7 +152,7 @@ class FSSpecBackend(ObjectStoreBase):
         with self.fs.open(resolved_path, mode="rb", **kwargs) as f:
             return pq.read_table(f)
 
-    def write_arrow(self, path: str, table: "ArrowTable", **kwargs: Any) -> None:
+    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")
@@ -194,7 +196,7 @@ class FSSpecBackend(ObjectStoreBase):
         resolved_path = self._resolve_path(path)
         return self.fs.isdir(resolved_path)  # type: ignore[no-any-return]
 
-    def get_metadata(self, path: str, **kwargs: Any) -> dict[str, Any]:
+    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)
 
@@ -217,7 +219,7 @@ class FSSpecBackend(ObjectStoreBase):
             "type": getattr(info, "type", "file"),
         }
 
-    def _stream_file_batches(self, obj_path: str) -> "Iterator[ArrowRecordBatch]":
+    def _stream_file_batches(self, obj_path: Union[str, Path]) -> "Iterator[ArrowRecordBatch]":
         import pyarrow.parquet as pq
 
         with self.fs.open(obj_path, mode="rb") as f:
@@ -234,15 +236,15 @@ class FSSpecBackend(ObjectStoreBase):
         for obj_path in self.glob(pattern, **kwargs):
             yield from self._stream_file_batches(obj_path)
 
-    async def read_bytes_async(self, path: str, **kwargs: Any) -> bytes:
+    async def read_bytes_async(self, path: Union[str, Path], **kwargs: Any) -> bytes:
         """Async read bytes. Wraps the sync implementation."""
         return await async_(self.read_bytes)(path, **kwargs)
 
-    async def write_bytes_async(self, path: str, data: bytes, **kwargs: Any) -> None:
+    async def write_bytes_async(self, path: Union[str, Path], data: bytes, **kwargs: Any) -> None:
         """Async write bytes. Wras the sync implementation."""
         return await async_(self.write_bytes)(path, data, **kwargs)
 
-    async def _stream_file_batches_async(self, obj_path: str) -> "AsyncIterator[ArrowRecordBatch]":
+    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)
@@ -274,11 +276,11 @@ class FSSpecBackend(ObjectStoreBase):
             async for batch in self._stream_file_batches_async(path):
                 yield batch
 
-    async def read_text_async(self, path: str, encoding: str = "utf-8", **kwargs: Any) -> str:
+    async def read_text_async(self, path: Union[str, Path], encoding: str = "utf-8", **kwargs: Any) -> str:
         """Async read text. Wraps the sync implementation."""
         return await async_(self.read_text)(path, encoding, **kwargs)
 
-    async def write_text_async(self, path: str, data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
+    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."""
         await async_(self.write_text)(path, data, encoding, **kwargs)
 
@@ -286,30 +288,30 @@ class FSSpecBackend(ObjectStoreBase):
         """Async list objects. Wraps the sync implementation."""
         return await async_(self.list_objects)(prefix, recursive, **kwargs)
 
-    async def exists_async(self, path: str, **kwargs: Any) -> bool:
+    async def exists_async(self, path: Union[str, Path], **kwargs: Any) -> bool:
         """Async exists check. Wraps the sync implementation."""
         return await async_(self.exists)(path, **kwargs)
 
-    async def delete_async(self, path: str, **kwargs: Any) -> None:
+    async def delete_async(self, path: Union[str, Path], **kwargs: Any) -> None:
         """Async delete. Wraps the sync implementation."""
         await async_(self.delete)(path, **kwargs)
 
-    async def copy_async(self, source: str, destination: str, **kwargs: Any) -> None:
+    async def copy_async(self, source: Union[str, Path], destination: Union[str, Path], **kwargs: Any) -> None:
         """Async copy. Wraps the sync implementation."""
         await async_(self.copy)(source, destination, **kwargs)
 
-    async def move_async(self, source: str, destination: str, **kwargs: Any) -> None:
+    async def move_async(self, source: Union[str, Path], destination: Union[str, Path], **kwargs: Any) -> None:
         """Async move. Wraps the sync implementation."""
         await async_(self.move)(source, destination, **kwargs)
 
-    async def get_metadata_async(self, path: str, **kwargs: Any) -> dict[str, Any]:
+    async def get_metadata_async(self, path: Union[str, Path], **kwargs: Any) -> dict[str, Any]:
         """Async get metadata. Wraps the sync implementation."""
         return await async_(self.get_metadata)(path, **kwargs)
 
-    async def read_arrow_async(self, path: str, **kwargs: Any) -> "ArrowTable":
+    async def read_arrow_async(self, path: Union[str, Path], **kwargs: Any) -> "ArrowTable":
         """Async read Arrow. Wraps the sync implementation."""
         return await async_(self.read_arrow)(path, **kwargs)
 
-    async def write_arrow_async(self, path: str, table: "ArrowTable", **kwargs: Any) -> None:
+    async def write_arrow_async(self, path: Union[str, Path], table: "ArrowTable", **kwargs: Any) -> None:
         """Async write Arrow. Wraps the sync implementation."""
         await async_(self.write_arrow)(path, table, **kwargs)

sqlspec/storage/backends/obstore.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import fnmatch
 import logging
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from sqlspec.exceptions import MissingDependencyError, StorageOperationFailedError
 from sqlspec.storage.backends.base import ObjectStoreBase
@@ -17,6 +17,7 @@ from sqlspec.typing import OBSTORE_INSTALLED
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterator
+    from pathlib import Path
 
     from sqlspec.typing import ArrowRecordBatch, ArrowTable
 
@@ -83,19 +84,21 @@ class ObStoreBackend(ObjectStoreBase):
             msg = f"Failed to initialize obstore backend for {store_uri}"
             raise StorageOperationFailedError(msg) from exc
 
-    def _resolve_path(self, path: str) -> str:
+    def _resolve_path(self, path: str | Path) -> str:
         """Resolve path relative to base_path."""
+        # Convert Path to string
+        path_str = str(path)
         # For file:// URIs, the path passed in is already absolute
-        if self.store_uri.startswith("file://") and path.startswith("/"):
+        if self.store_uri.startswith("file://") and path_str.startswith("/"):
             # Remove leading slash for LocalStore (it's relative to its root)
-            return path.lstrip("/")
+            return path_str.lstrip("/")
 
         if self.base_path:
             # Ensure no double slashes by stripping trailing slash from base_path
             clean_base = self.base_path.rstrip("/")
-            clean_path = path.lstrip("/")
+            clean_path = path_str.lstrip("/")
             return f"{clean_base}/{clean_path}"
-        return path
+        return path_str
 
     @property
     def backend_type(self) -> str:
@@ -104,17 +107,26 @@ class ObStoreBackend(ObjectStoreBase):
 
     # Implementation of abstract methods from ObjectStoreBase
 
-    def read_bytes(self, path: str, **kwargs: Any) -> bytes:  # pyright: ignore[reportUnusedParameter]
+    def read_bytes(self, path: str | Path, **kwargs: Any) -> bytes:  # pyright: ignore[reportUnusedParameter]
         """Read bytes using obstore."""
         try:
             resolved_path = self._resolve_path(path)
             result = self.store.get(resolved_path)
-            return result.bytes()  # type: ignore[no-any-return] # pyright: ignore[reportReturnType]
+            bytes_data = result.bytes()
+            # Handle obstore's Bytes type - it might have a method to get raw bytes
+            if hasattr(bytes_data, "__bytes__"):
+                return bytes(bytes_data)
+            if hasattr(bytes_data, "tobytes"):
+                return bytes_data.tobytes()  # type: ignore[no-any-return]
+            if isinstance(bytes_data, bytes):
+                return bytes_data
+            # Try to convert to bytes
+            return bytes(bytes_data)
         except Exception as exc:
             msg = f"Failed to read bytes from {path}"
             raise StorageOperationFailedError(msg) from exc
 
-    def write_bytes(self, path: str, data: bytes, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
+    def write_bytes(self, path: str | Path, data: bytes, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
         """Write bytes using obstore."""
         try:
             resolved_path = self._resolve_path(path)
@@ -123,12 +135,12 @@ class ObStoreBackend(ObjectStoreBase):
             msg = f"Failed to write bytes to {path}"
             raise StorageOperationFailedError(msg) from exc
 
-    def read_text(self, path: str, encoding: str = "utf-8", **kwargs: Any) -> str:
+    def read_text(self, path: str | Path, encoding: str = "utf-8", **kwargs: Any) -> str:
         """Read text using obstore."""
         data = self.read_bytes(path, **kwargs)
         return data.decode(encoding)
 
-    def write_text(self, path: str, data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
+    def write_text(self, path: str | Path, data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
         """Write text using obstore."""
         encoded_data = data.encode(encoding)
         self.write_bytes(path, encoded_data, **kwargs)
@@ -153,7 +165,7 @@ class ObStoreBackend(ObjectStoreBase):
 
         return sorted(objects)
 
-    def exists(self, path: str, **kwargs: Any) -> bool:  # pyright: ignore[reportUnusedParameter]
+    def exists(self, path: str | Path, **kwargs: Any) -> bool:  # pyright: ignore[reportUnusedParameter]
         """Check if object exists using obstore."""
         try:
             self.store.head(self._resolve_path(path))
@@ -161,7 +173,7 @@ class ObStoreBackend(ObjectStoreBase):
             return False
         return True
 
-    def delete(self, path: str, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
+    def delete(self, path: str | Path, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
         """Delete object using obstore."""
         try:
             self.store.delete(self._resolve_path(path))
@@ -169,7 +181,7 @@ class ObStoreBackend(ObjectStoreBase):
             msg = f"Failed to delete {path}"
             raise StorageOperationFailedError(msg) from exc
 
-    def copy(self, source: str, destination: str, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
+    def copy(self, source: str | Path, destination: str | Path, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
         """Copy object using obstore."""
         try:
             self.store.copy(self._resolve_path(source), self._resolve_path(destination))
@@ -177,7 +189,7 @@ class ObStoreBackend(ObjectStoreBase):
             msg = f"Failed to copy {source} to {destination}"
             raise StorageOperationFailedError(msg) from exc
 
-    def move(self, source: str, destination: str, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
+    def move(self, source: str | Path, destination: str | Path, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
         """Move object using obstore."""
         try:
             self.store.rename(self._resolve_path(source), self._resolve_path(destination))
@@ -224,7 +236,7 @@ class ObStoreBackend(ObjectStoreBase):
         # Use standard fnmatch for simple patterns
         return [obj for obj in all_objects if fnmatch.fnmatch(obj, resolved_pattern)]
 
-    def get_metadata(self, path: str, **kwargs: Any) -> dict[str, Any]:  # pyright: ignore[reportUnusedParameter]
+    def get_metadata(self, path: str | Path, **kwargs: Any) -> dict[str, Any]:  # pyright: ignore[reportUnusedParameter]
         """Get object metadata using obstore."""
         resolved_path = self._resolve_path(path)
         try:
@@ -245,13 +257,13 @@ class ObStoreBackend(ObjectStoreBase):
         else:
             return result
 
-    def is_object(self, path: str) -> bool:
+    def is_object(self, path: str | Path) -> bool:
         """Check if path is an object using obstore."""
         resolved_path = self._resolve_path(path)
         # An object exists and doesn't end with /
         return self.exists(path) and not resolved_path.endswith("/")
 
-    def is_path(self, path: str) -> bool:
+    def is_path(self, path: str | Path) -> bool:
         """Check if path is a prefix/directory using obstore."""
         resolved_path = self._resolve_path(path)
 
@@ -261,12 +273,12 @@ class ObStoreBackend(ObjectStoreBase):
 
         # Check if there are any objects with this prefix
         try:
-            objects = self.list_objects(prefix=path, recursive=False)
+            objects = self.list_objects(prefix=str(path), recursive=False)
             return len(objects) > 0
         except Exception:
             return False
 
-    def read_arrow(self, path: str, **kwargs: Any) -> ArrowTable:
+    def read_arrow(self, path: str | Path, **kwargs: Any) -> ArrowTable:
         """Read Arrow table using obstore."""
         try:
             resolved_path = self._resolve_path(path)
@@ -285,7 +297,7 @@ class ObStoreBackend(ObjectStoreBase):
             msg = f"Failed to read Arrow table from {path}"
             raise StorageOperationFailedError(msg) from exc
 
-    def write_arrow(self, path: str, table: ArrowTable, **kwargs: Any) -> None:
+    def write_arrow(self, path: str | Path, table: ArrowTable, **kwargs: Any) -> None:
         """Write Arrow table using obstore."""
         try:
             resolved_path = self._resolve_path(path)
@@ -350,13 +362,22 @@ class ObStoreBackend(ObjectStoreBase):
     # Private async implementations for instrumentation support
     # These are called by the base class async methods after instrumentation
 
-    async def read_bytes_async(self, path: str, **kwargs: Any) -> bytes:  # pyright: ignore[reportUnusedParameter]
+    async def read_bytes_async(self, path: str | Path, **kwargs: Any) -> bytes:  # pyright: ignore[reportUnusedParameter]
         """Private async read bytes using native obstore async if available."""
         resolved_path = self._resolve_path(path)
         result = await self.store.get_async(resolved_path)
-        return cast("bytes", result.bytes())  # pyright: ignore[reportReturnType]
-
-    async def write_bytes_async(self, path: str, data: bytes, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
+        bytes_data = result.bytes()
+        # Handle obstore's Bytes type - it might have a method to get raw bytes
+        if hasattr(bytes_data, "__bytes__"):
+            return bytes(bytes_data)
+        if hasattr(bytes_data, "tobytes"):
+            return bytes_data.tobytes()  # type: ignore[no-any-return]
+        if isinstance(bytes_data, bytes):
+            return bytes_data
+        # Try to convert to bytes
+        return bytes(bytes_data)
+
+    async def write_bytes_async(self, path: str | Path, data: bytes, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
         """Private async write bytes using native obstore async."""
         resolved_path = self._resolve_path(path)
         await self.store.put_async(resolved_path, data)
@@ -379,17 +400,17 @@ class ObStoreBackend(ObjectStoreBase):
     # Implement all other required abstract async methods
     # ObStore provides native async for most operations
 
-    async def read_text_async(self, path: str, encoding: str = "utf-8", **kwargs: Any) -> str:
+    async def read_text_async(self, path: str | Path, encoding: str = "utf-8", **kwargs: Any) -> str:
         """Async read text using native obstore async."""
         data = await self.read_bytes_async(path, **kwargs)
         return data.decode(encoding)
 
-    async def write_text_async(self, path: str, data: str, encoding: str = "utf-8", **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
+    async def write_text_async(self, path: str | Path, data: str, encoding: str = "utf-8", **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
         """Async write text using native obstore async."""
         encoded_data = data.encode(encoding)
         await self.write_bytes_async(path, encoded_data, **kwargs)
 
-    async def exists_async(self, path: str, **kwargs: Any) -> bool:  # pyright: ignore[reportUnusedParameter]
+    async def exists_async(self, path: str | Path, **kwargs: Any) -> bool:  # pyright: ignore[reportUnusedParameter]
         """Async check if object exists using native obstore async."""
         resolved_path = self._resolve_path(path)
         try:
@@ -398,24 +419,24 @@ class ObStoreBackend(ObjectStoreBase):
             return False
         return True
 
-    async def delete_async(self, path: str, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
+    async def delete_async(self, path: str | Path, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
         """Async delete object using native obstore async."""
         resolved_path = self._resolve_path(path)
         await self.store.delete_async(resolved_path)
 
-    async def copy_async(self, source: str, destination: str, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
+    async def copy_async(self, source: str | Path, destination: str | Path, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
         """Async copy object using native obstore async."""
         source_path = self._resolve_path(source)
         dest_path = self._resolve_path(destination)
         await self.store.copy_async(source_path, dest_path)
 
-    async def move_async(self, source: str, destination: str, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
+    async def move_async(self, source: str | Path, destination: str | Path, **kwargs: Any) -> None:  # pyright: ignore[reportUnusedParameter]
         """Async move object using native obstore async."""
         source_path = self._resolve_path(source)
         dest_path = self._resolve_path(destination)
         await self.store.rename_async(source_path, dest_path)
 
-    async def get_metadata_async(self, path: str, **kwargs: Any) -> dict[str, Any]:  # pyright: ignore[reportUnusedParameter]
+    async def get_metadata_async(self, path: str | Path, **kwargs: Any) -> dict[str, Any]:  # pyright: ignore[reportUnusedParameter]
         """Async get object metadata using native obstore async."""
         resolved_path = self._resolve_path(path)
         metadata = await self.store.head_async(resolved_path)
@@ -436,12 +457,12 @@ class ObStoreBackend(ObjectStoreBase):
 
         return result
 
-    async def read_arrow_async(self, path: str, **kwargs: Any) -> ArrowTable:
+    async def read_arrow_async(self, path: str | Path, **kwargs: Any) -> ArrowTable:
         """Async read Arrow table using native obstore async."""
         resolved_path = self._resolve_path(path)
         return await self.store.read_arrow_async(resolved_path, **kwargs)  # type: ignore[no-any-return]  # pyright: ignore[reportAttributeAccessIssue]
 
-    async def write_arrow_async(self, path: str, table: ArrowTable, **kwargs: Any) -> None:
+    async def write_arrow_async(self, path: str | Path, table: ArrowTable, **kwargs: Any) -> None:
         """Async write Arrow table using native obstore async."""
         resolved_path = self._resolve_path(path)
         # Check if the store has native async Arrow support

sqlspec/storage/protocol.py

@@ -1,7 +1,8 @@
-from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+from typing import TYPE_CHECKING, Any, Protocol, Union, runtime_checkable
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterator
+    from pathlib import Path
 
     from sqlspec.typing import ArrowRecordBatch, ArrowTable
 
@@ -23,36 +24,36 @@ class ObjectStoreProtocol(Protocol):
         return
 
     # Core Operations (sync)
-    def read_bytes(self, path: str, **kwargs: Any) -> bytes:
+    def read_bytes(self, path: "Union[str, Path]", **kwargs: Any) -> bytes:
         """Read bytes from an object."""
         return b""
 
-    def write_bytes(self, path: str, data: bytes, **kwargs: Any) -> None:
+    def write_bytes(self, path: "Union[str, Path]", data: bytes, **kwargs: Any) -> None:
         """Write bytes to an object."""
         return
 
-    def read_text(self, path: str, encoding: str = "utf-8", **kwargs: Any) -> str:
+    def read_text(self, path: "Union[str, Path]", encoding: str = "utf-8", **kwargs: Any) -> str:
         """Read text from an object."""
         return ""
 
-    def write_text(self, path: str, data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
+    def write_text(self, path: "Union[str, Path]", data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
         """Write text to an object."""
         return
 
     # Object Operations
-    def exists(self, path: str, **kwargs: Any) -> bool:
+    def exists(self, path: "Union[str, Path]", **kwargs: Any) -> bool:
         """Check if an object exists."""
         return False
 
-    def delete(self, path: str, **kwargs: Any) -> None:
+    def delete(self, path: "Union[str, Path]", **kwargs: Any) -> None:
         """Delete an object."""
         return
 
-    def copy(self, source: str, destination: str, **kwargs: Any) -> None:
+    def copy(self, source: "Union[str, Path]", destination: "Union[str, Path]", **kwargs: Any) -> None:
         """Copy an object."""
         return
 
-    def move(self, source: str, destination: str, **kwargs: Any) -> None:
+    def move(self, source: "Union[str, Path]", destination: "Union[str, Path]", **kwargs: Any) -> None:
         """Move an object."""
         return
 
@@ -66,20 +67,20 @@ class ObjectStoreProtocol(Protocol):
         return []
 
     # Path Operations
-    def is_object(self, path: str) -> bool:
+    def is_object(self, path: "Union[str, Path]") -> bool:
         """Check if path points to an object."""
         return False
 
-    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)."""
         return False
 
-    def get_metadata(self, path: str, **kwargs: Any) -> dict[str, Any]:
+    def get_metadata(self, path: "Union[str, Path]", **kwargs: Any) -> dict[str, Any]:
         """Get object metadata."""
         return {}
 
     # Arrow Operations
-    def read_arrow(self, path: str, **kwargs: Any) -> "ArrowTable":
+    def read_arrow(self, path: "Union[str, Path]", **kwargs: Any) -> "ArrowTable":
         """Read an Arrow table from storage.
 
         For obstore backend, this should use native arrow operations when available.
@@ -87,7 +88,7 @@ class ObjectStoreProtocol(Protocol):
         msg = "Arrow reading not implemented"
         raise NotImplementedError(msg)
 
-    def write_arrow(self, path: str, table: "ArrowTable", **kwargs: Any) -> None:
+    def write_arrow(self, path: "Union[str, Path]", table: "ArrowTable", **kwargs: Any) -> None:
         """Write an Arrow table to storage.
 
         For obstore backend, this should use native arrow operations when available.
@@ -104,32 +105,34 @@ class ObjectStoreProtocol(Protocol):
         raise NotImplementedError(msg)
 
     # Async versions
-    async def read_bytes_async(self, path: str, **kwargs: Any) -> bytes:
+    async def read_bytes_async(self, path: "Union[str, Path]", **kwargs: Any) -> bytes:
         """Async read bytes from an object."""
         msg = "Async operations not implemented"
         raise NotImplementedError(msg)
 
-    async def write_bytes_async(self, path: str, data: bytes, **kwargs: Any) -> None:
+    async def write_bytes_async(self, path: "Union[str, Path]", data: bytes, **kwargs: Any) -> None:
         """Async write bytes to an object."""
         msg = "Async operations not implemented"
         raise NotImplementedError(msg)
 
-    async def read_text_async(self, path: str, encoding: str = "utf-8", **kwargs: Any) -> str:
+    async def read_text_async(self, path: "Union[str, Path]", encoding: str = "utf-8", **kwargs: Any) -> str:
         """Async read text from an object."""
         msg = "Async operations not implemented"
         raise NotImplementedError(msg)
 
-    async def write_text_async(self, path: str, data: str, encoding: str = "utf-8", **kwargs: Any) -> None:
+    async def write_text_async(
+        self, path: "Union[str, Path]", data: str, encoding: str = "utf-8", **kwargs: Any
+    ) -> None:
         """Async write text to an object."""
         msg = "Async operations not implemented"
         raise NotImplementedError(msg)
 
-    async def exists_async(self, path: str, **kwargs: Any) -> bool:
+    async def exists_async(self, path: "Union[str, Path]", **kwargs: Any) -> bool:
         """Async check if an object exists."""
         msg = "Async operations not implemented"
         raise NotImplementedError(msg)
 
-    async def delete_async(self, path: str, **kwargs: Any) -> None:
+    async def delete_async(self, path: "Union[str, Path]", **kwargs: Any) -> None:
         """Async delete an object."""
         msg = "Async operations not implemented"
         raise NotImplementedError(msg)
@@ -139,27 +142,27 @@ class ObjectStoreProtocol(Protocol):
         msg = "Async operations not implemented"
         raise NotImplementedError(msg)
 
-    async def copy_async(self, source: str, destination: str, **kwargs: Any) -> None:
+    async def copy_async(self, source: "Union[str, Path]", destination: "Union[str, Path]", **kwargs: Any) -> None:
         """Async copy an object."""
         msg = "Async operations not implemented"
         raise NotImplementedError(msg)
 
-    async def move_async(self, source: str, destination: str, **kwargs: Any) -> None:
+    async def move_async(self, source: "Union[str, Path]", destination: "Union[str, Path]", **kwargs: Any) -> None:
         """Async move an object."""
         msg = "Async operations not implemented"
         raise NotImplementedError(msg)
 
-    async def get_metadata_async(self, path: str, **kwargs: Any) -> dict[str, Any]:
+    async def get_metadata_async(self, path: "Union[str, Path]", **kwargs: Any) -> dict[str, Any]:
         """Async get object metadata."""
         msg = "Async operations not implemented"
         raise NotImplementedError(msg)
 
-    async def read_arrow_async(self, path: str, **kwargs: Any) -> "ArrowTable":
+    async def read_arrow_async(self, path: "Union[str, Path]", **kwargs: Any) -> "ArrowTable":
         """Async read an Arrow table from storage."""
         msg = "Async arrow reading not implemented"
         raise NotImplementedError(msg)
 
-    async def write_arrow_async(self, path: str, table: "ArrowTable", **kwargs: Any) -> None:
+    async def write_arrow_async(self, path: "Union[str, Path]", table: "ArrowTable", **kwargs: Any) -> None:
         """Async write an Arrow table to storage."""
         msg = "Async arrow writing not implemented"
         raise NotImplementedError(msg)

{sqlspec-0.12.1.dist-info → sqlspec-0.12.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.12.1
+Version: 0.12.2
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/