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

sqlspec/statement/sql.py

@@ -191,7 +191,7 @@ class SQL:
         if _existing_state:
             self._load_from_existing_state(_existing_state)
 
-        if not isinstance(statement, SQL):
+        if not isinstance(statement, SQL) and not _existing_state:
             self._set_original_parameters(*parameters)
 
         self._process_parameters(*parameters, **kwargs)
@@ -235,6 +235,7 @@ class SQL:
         self._is_many = existing_state.get("is_many", self._is_many)
         self._is_script = existing_state.get("is_script", self._is_script)
         self._raw_sql = existing_state.get("raw_sql", self._raw_sql)
+        self._original_parameters = existing_state.get("original_parameters", self._original_parameters)
 
     def _set_original_parameters(self, *parameters: Any) -> None:
         """Store the original parameters for compatibility."""
@@ -493,6 +494,8 @@ class SQL:
             "is_script": self._is_script,
             "raw_sql": self._raw_sql,
         }
+        # Always include original_parameters in existing_state
+        existing_state["original_parameters"] = self._original_parameters
 
         # Create new instance
         new_statement = statement if statement is not None else self._statement
@@ -595,10 +598,9 @@ class SQL:
         new_obj = self.copy()
         new_obj._is_many = True
         if parameters is not None:
-            # Replace parameters for executemany
             new_obj._positional_params = []
             new_obj._named_params = {}
-            new_obj._positional_params = parameters
+            new_obj._original_parameters = parameters
         return new_obj
 
     def as_script(self) -> "SQL":
@@ -677,6 +679,10 @@ class SQL:
     @property
     def parameters(self) -> Any:
         """Get merged parameters."""
+        # For executemany operations, return the original parameters list
+        if self._is_many and self._original_parameters is not None:
+            return self._original_parameters
+
         self._ensure_processed()
         assert self._processed_state is not None
         return self._processed_state.merged_parameters
@@ -710,6 +716,18 @@ class SQL:
         if self._is_script:
             return self.sql, None
 
+        # For executemany operations with original parameters, handle specially
+        if self._is_many and self._original_parameters is not None:
+            # Get the SQL, but use the original parameters list
+            sql = self.sql  # This will ensure processing if needed
+            params = self._original_parameters
+
+            # Convert placeholder style if requested
+            if placeholder_style:
+                sql, params = self._convert_placeholder_style(sql, params, placeholder_style)
+
+            return sql, params
+
         # If parsing is disabled, return raw SQL without transformation
         if not self._config.enable_parsing and self._raw_sql:
             return self._raw_sql, self._raw_parameters
@@ -737,8 +755,6 @@ class SQL:
         if placeholder_style:
             sql, params = self._convert_placeholder_style(sql, params, placeholder_style)
 
-        # Debug log the final SQL
-        logger.debug("Final compiled SQL: '%s'", sql)
         return sql, params
 
     @staticmethod
@@ -803,6 +819,24 @@ class SQL:
         Returns:
             Tuple of (converted_sql, converted_params)
         """
+        # Handle execute_many case where params is a list of parameter sets
+        if self._is_many and isinstance(params, list) and params and isinstance(params[0], (list, tuple)):
+            # For execute_many, we only need to convert the SQL once
+            # The parameters remain as a list of tuples
+            converter = self._config.parameter_converter
+            param_info = converter.validator.extract_parameters(sql)
+
+            if param_info:
+                from sqlspec.statement.parameters import ParameterStyle
+
+                target_style = (
+                    ParameterStyle(placeholder_style) if isinstance(placeholder_style, str) else placeholder_style
+                )
+                sql = self._replace_placeholders_in_sql(sql, param_info, target_style)
+
+            # Parameters remain as list of tuples for execute_many
+            return sql, params
+
         # Extract parameter info from current SQL
         converter = self._config.parameter_converter
         param_info = converter.validator.extract_parameters(sql)
@@ -969,7 +1003,7 @@ class SQL:
                 result_dict["1"] = params
             return result_dict
 
-        if isinstance(params, dict):
+        if is_dict(params):
             # Check if already in correct format (keys are "1", "2", etc.)
             if all(key.isdigit() for key in params):
                 return params

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