feat(python): add delete_many API

bindings/python/python/opendal/__init__.pyi

@@ -152,6 +152,18 @@ class Operator(_Base):
         -------
             None
         """
+    def delete_many(self, paths: Iterable[PathBuf]) -> None:
+        """Delete multiple objects in a single request.
+
+        Args:
+            paths (Iterable[str | Path]): Collection of object paths to delete.
+                Each element is treated the same as calling :py:meth:`delete`
+                individually.
+
+        Notes
+        -----
+            Missing objects are ignored by default.
+        """
     def stat(self, path: PathBuf, **kwargs) -> Metadata:
         """Get the metadata of the object at the given path.
 
@@ -381,6 +393,18 @@ class AsyncOperator(_Base):
         -------
             None
         """
+    async def delete_many(self, paths: Iterable[PathBuf]) -> None:
+        """Delete multiple objects in a single request.
+
+        Args:
+            paths (Iterable[str | Path]): Collection of object paths to delete.
+                Each element is treated the same as calling :py:meth:`delete`
+                individually.
+
+        Notes
+        -----
+            Missing objects are ignored by default.
+        """
     async def stat(self, path: PathBuf, **kwargs) -> Metadata:
         """Get the metadata of the object at the given path.
 

bindings/python/src/operator.rs

@@ -232,6 +232,18 @@ impl Operator {
         self.core.delete(&path).map_err(format_pyerr)
     }
 
+    /// Delete multiple paths in a single call.
+    ///
+    /// Accepts any iterable of path-like objects. Paths that do not exist are ignored.
+    pub fn delete_many(&self, paths: Vec<PathBuf>) -> PyResult<()> {
+        let paths: Vec<String> = paths
+            .into_iter()
+            .map(|path| path.to_string_lossy().to_string())
+            .collect();
+
+        self.core.delete_iter(paths).map_err(format_pyerr)
+    }
+
     /// Checks if the given path exists.
     ///
     /// # Notes
@@ -577,6 +589,25 @@ impl AsyncOperator {
         )
     }
 
+    /// Delete multiple paths in a single call.
+    ///
+    /// Accepts any iterable of path-like objects. Paths that do not exist are ignored.
+    pub fn delete_many<'p>(
+        &'p self,
+        py: Python<'p>,
+        paths: Vec<PathBuf>,
+    ) -> PyResult<Bound<'p, PyAny>> {
+        let this = self.core.clone();
+        let paths: Vec<String> = paths
+            .into_iter()
+            .map(|path| path.to_string_lossy().to_string())
+            .collect();
+
+        future_into_py(py, async move {
+            this.delete_iter(paths).await.map_err(format_pyerr)
+        })
+    }
+
     /// Check given path is exists.
     ///
     /// # Notes

bindings/python/tests/test_async_delete.py

@@ -47,3 +47,18 @@ async def test_async_remove_all(service_name, operator, async_operator):
             with pytest.raises(NotFound):
                 await async_operator.read(f"{parent}/{path}")
     await async_operator.remove_all(f"{parent}/")
+
+
+@pytest.mark.asyncio
+@pytest.mark.need_capability("read", "write", "delete")
+async def test_async_delete_many(service_name, operator, async_operator):
+    parent = f"delete_many_{str(uuid4())}"
+    targets = [f"{parent}/file_{idx}.txt" for idx in range(3)]
+
+    for path in targets:
+        await async_operator.write(path, os.urandom(16))
+
+    await async_operator.delete_many(targets)
+
+    for path in targets:
+        assert not await async_operator.exists(path)

bindings/python/tests/test_sync_delete.py

@@ -46,3 +46,17 @@ def test_sync_remove_all(service_name, operator, async_operator):
             with pytest.raises(NotFound):
                 operator.read(f"{parent}/{path}")
     operator.remove_all(f"{parent}/")
+
+
+@pytest.mark.need_capability("read", "write", "delete")
+def test_sync_delete_many(service_name, operator, async_operator):
+    parent = f"delete_many_{str(uuid4())}"
+    targets = [f"{parent}/file_{idx}.txt" for idx in range(3)]
+
+    for path in targets:
+        operator.write(path, os.urandom(16))
+
+    operator.delete_many(targets)
+
+    for path in targets:
+        assert not operator.exists(path)