refactor(bindings/python): return bytes directly and add type stub fi…

…le (#1514)

* refactor(bindings/python): raise RuntimeError instead of BaseException

* refactor(bindings/python): return bytes from `read`

* feat(bindings/python): add type stub file

bindings/python/opendal.pyi

@@ -0,0 +1,14 @@
+class Operator:
+    def __init__(scheme: str, **kwargs): ...
+    def read(self, path: str) -> bytes: ...
+    def write(self, path: str, bs: bytes): ...
+    def stat(self, path: str) -> Metadata: ...
+
+class AsyncOperator:
+    def __init__(scheme: str, **kwargs): ...
+    async def read(self, path: str) -> bytes: ...
+    async def write(self, path: str, bs: bytes): ...
+    async def stat(self, path: str) -> Metadata: ...
+
+class Metadata:
+    def content_length(self) -> int: ...

bindings/python/src/lib.rs

@@ -16,10 +16,9 @@ use std::collections::HashMap;
 use std::str::FromStr;
 
 use ::opendal as od;
-use pyo3::exceptions::PyBaseException;
-use pyo3::exceptions::PyFileNotFoundError;
+use pyo3::exceptions::{PyFileNotFoundError, PyRuntimeError};
 use pyo3::prelude::*;
-use pyo3::types::PyDict;
+use pyo3::types::{PyBytes, PyDict};
 use pyo3_asyncio::tokio::future_into_py;
 
 fn build_operator(scheme: od::Scheme, map: HashMap<String, String>) -> PyResult<od::Operator> {
@@ -65,8 +64,9 @@ impl AsyncOperator {
         let this = self.0.clone();
         let path = path.to_string();
         future_into_py(py, async move {
-            let res: Vec<u8> = this.read(&path).await.map_err(format_pyerr)?;
-            Ok(res)
+            let res = this.read(&path).await.map_err(format_pyerr)?;
+            let bytes = Python::with_gil(|py| PyBytes::new(py, &res).to_object(py));
+            Ok(bytes)
         })
     }
 
@@ -112,8 +112,10 @@ impl Operator {
         Ok(Operator(build_operator(scheme, map)?.blocking()))
     }
 
-    pub fn read(&self, path: &str) -> PyResult<Vec<u8>> {
-        self.0.read(path).map_err(format_pyerr)
+    pub fn read<'p>(&'p self, py: Python<'p>, path: &str) -> PyResult<&'p PyBytes> {
+        let res = self.0.read(path).map_err(format_pyerr)?;
+        let bytes = PyBytes::new(py, &res);
+        Ok(bytes)
     }
 
     pub fn write(&self, path: &str, bs: Vec<u8>) -> PyResult<()> {
@@ -139,7 +141,7 @@ fn format_pyerr(err: od::Error) -> PyErr {
     use od::ErrorKind::*;
     match err.kind() {
         NotFound => PyFileNotFoundError::new_err(err.to_string()),
-        _ => PyBaseException::new_err(err.to_string()),
+        _ => PyRuntimeError::new_err(err.to_string()),
     }
 }
 

bindings/python/tests/main.py

@@ -21,7 +21,7 @@ def test_blocking():
     op = opendal.Operator("memory")
     op.write("test", b"Hello, World!")
     bs = op.read("test")
-    print(bytes(bs).decode("utf-8"))
+    print(bs.decode("utf-8"))
     meta = op.stat("test")
     print(f"content_length: {meta.content_length()}")
 
@@ -31,7 +31,7 @@ async def test_async():
     op = opendal.AsyncOperator("memory")
     await op.write("test", b"Hello, World!")
     bs = await op.read("test")
-    print(bytes(bs).decode("utf-8"))
+    print(bs.decode("utf-8"))
     meta = await op.stat("test")
     print(f"content_length: {meta.content_length()}")