etcd-client-py 0.2.4__tar.gz → 0.3.0__tar.gz

etcd_client_py-0.3.0/.github/workflows/test.yml

@@ -0,0 +1,41 @@
+name: Test
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Install etcd
+      run: |
+        wget https://github.com/etcd-io/etcd/releases/download/v3.4.10/etcd-v3.4.10-linux-amd64.tar.gz
+        tar -xzf etcd-v3.4.10-linux-amd64.tar.gz
+        mv etcd-v3.4.10-linux-amd64/etcd* /usr/local/bin/
+
+    - name: Set up Python as Runtime
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.12"
+
+    - name: Set up Rust toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        override: true
+
+    - name: Install protobuf compiler
+      run: |
+        sudo apt install -y protobuf-compiler
+
+    - name: Install dependencies and build the package
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install -r requirements.txt
+        python -m maturin build
+        python -m pip install .
+
+    - name: Test
+      run: |
+        python -m pytest

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/Cargo.lock

@@ -210,7 +210,7 @@ dependencies = [
 
 [[package]]
 name = "etcd-client-py"
-version = "0.2.4"
+version = "0.3.0"
 dependencies = [
  "etcd-client",
  "pyo3",

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "etcd-client-py"
-version = "0.2.4"
+version = "0.3.0"
 edition = "2021"
 authors = ["Lablup Inc."]
 readme = "./README.md"

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/Makefile

@@ -12,4 +12,4 @@ fmt:
 	cargo fmt
 
 lint:
-	cargo clippy 
+	cargo clippy

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: etcd-client-py
-Version: 0.2.4
+Version: 0.3.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 License-File: LICENSE

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/etcd_client.pyi

@@ -8,7 +8,7 @@ from typing import Any, AsyncIterator, Final, Optional
 
 @dataclass
 class EtcdLockOption:
-    lock_name: str
+    lock_name: bytes
     timeout: Optional[float]
     ttl: Optional[int]
 
@@ -30,31 +30,31 @@ class CompareOp:
 
 class Compare:
     @staticmethod
-    def version(key: str, cmp: "CompareOp", version: int) -> "Compare": ...
+    def version(key: bytes, cmp: "CompareOp", version: int) -> "Compare": ...
     """
     Compares the version of the given key.
     """
     @staticmethod
-    def create_revision(key: str, cmp: "CompareOp", revision: int) -> "Compare": ...
+    def create_revision(key: bytes, cmp: "CompareOp", revision: int) -> "Compare": ...
     """
     Compares the creation revision of the given key.
     """
     @staticmethod
-    def mod_revision(key: str, cmp: "CompareOp", revision: int) -> "Compare": ...
+    def mod_revision(key: bytes, cmp: "CompareOp", revision: int) -> "Compare": ...
     """
     Compares the last modified revision of the given key.
     """
     @staticmethod
-    def value(key: str, cmp: "CompareOp", value: str) -> "Compare": ...
+    def value(key: bytes, cmp: "CompareOp", value: bytes) -> "Compare": ...
     """
     Compares the value of the given key.
     """
     @staticmethod
-    def lease(key: str, cmp: "CompareOp", lease: int) -> "Compare": ...
+    def lease(key: bytes, cmp: "CompareOp", lease: int) -> "Compare": ...
     """
     Compares the lease id of the given key.
     """
-    def with_range(self, end: list[int]) -> "Compare": ...
+    def with_range(self, end: bytes) -> "Compare": ...
     """
     Sets the comparison to scan the range [key, end).
     """
@@ -95,11 +95,11 @@ class TxnOp:
     """
 
     @staticmethod
-    def get(key: str) -> "TxnOp": ...
+    def get(key: bytes) -> "TxnOp": ...
     @staticmethod
-    def put(key: str, value: str) -> "TxnOp": ...
+    def put(key: bytes, value: bytes) -> "TxnOp": ...
     @staticmethod
-    def delete(key: str) -> "TxnOp": ...
+    def delete(key: bytes) -> "TxnOp": ...
     @staticmethod
     def txn(txn: "Txn") -> "TxnOp": ...
 
@@ -154,21 +154,15 @@ class CondVar:
         """ """
 
 class Communicator:
-    async def get(self, key: str) -> str:
+    async def get(self, key: bytes) -> list[int]:
         """
         Gets the key from the key-value store.
         """
-    async def get_prefix(self, key: str) -> dict[str, Any]:
+    async def get_prefix(self, key: bytes) -> list[tuple[list[int], list[int]]]:
         """
         Gets the key from the key-value store.
         """
-    async def put(self, key: str, value: str) -> None:
-        """
-        Put the given key into the key-value store.
-        A put request increments the revision of the key-value store
-        and generates one event in the event history.
-        """
-    async def put_prefix(self, key: str, value: dict[str, Any]) -> None:
+    async def put(self, key: bytes, value: bytes) -> None:
         """
         Put the given key into the key-value store.
         A put request increments the revision of the key-value store
@@ -181,19 +175,17 @@ class Communicator:
         and generates events with the same revision for every completed operation.
         It is not allowed to modify the same key several times within one txn.
         """
-    async def delete(self, key: str) -> None:
+    async def delete(self, key: bytes) -> None:
         """
         Deletes the given key from the key-value store.
         """
-    async def delete_prefix(self, key: str) -> None:
+    async def delete_prefix(self, key: bytes) -> None:
         """
         Deletes the given key from the key-value store.
         """
-    async def keys_prefix(self, key: str) -> list[str]:
-        """ """
-    async def replace(self, key: str, initial_value: str, new_value: str) -> bool:
+    async def keys_prefix(self, key: bytes) -> list[list[int]]:
         """ """
-    async def lock(self, name: str) -> None:
+    async def lock(self, name: bytes) -> None:
         """
         Lock acquires a distributed shared lock on a given named lock.
         On success, it will return a unique key that exists so long as the
@@ -202,7 +194,7 @@ class Communicator:
         lock ownership. The lock is held until Unlock is called on the key or the
         lease associate with the owner expires.
         """
-    async def unlock(self, key: str) -> None:
+    async def unlock(self, name: bytes) -> None:
         """
         Unlock takes a key returned by Lock and releases the hold on lock. The
         next Lock caller waiting for the lock will then be woken up and given
@@ -225,7 +217,7 @@ class Communicator:
         """
     def watch(
         self,
-        key: str,
+        key: bytes,
         *,
         once: Optional[bool] = False,
         ready_event: Optional["CondVar"] = None,
@@ -238,7 +230,7 @@ class Communicator:
         """
     def watch_prefix(
         self,
-        key: str,
+        key: bytes,
         *,
         once: Optional[bool] = False,
         ready_event: Optional["CondVar"] = None,
@@ -261,16 +253,16 @@ class Watch:
 class WatchEvent:
     """ """
 
-    key: str
-    value: str
+    key: bytes
+    value: bytes
     event: "WatchEventType"
-    prev_value: Optional[str]
+    prev_value: Optional[bytes]
 
     def __init__(
-        key: str,
-        value: str,
+        key: bytes,
+        value: bytes,
         event: "WatchEventType",
-        prev_value: Optional[str] = None,
+        prev_value: Optional[bytes] = None,
     ) -> None: ...
 
 class WatchEventType:
@@ -296,7 +288,7 @@ class CondVar:
 class ClientError(Exception):
     """ """
 
-class GRpcStatusError(ClientError):
+class GRPCStatusError(ClientError):
     """ """
 
 class InvalidArgsError(ClientError):
@@ -332,7 +324,7 @@ class EndpointError(ClientError):
 class LockError(ClientError):
     """ """
 
-class GRpcStatusCode(Enum):
+class GRPCStatusCode(Enum):
     Ok = 0
     """The operation completed successfully."""
 

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/src/communicator.rs

@@ -1,9 +1,8 @@
-use etcd_client::{Client as EtcdClient, PutOptions};
+use etcd_client::Client as EtcdClient;
 use etcd_client::{DeleteOptions, GetOptions, WatchOptions};
-use pyo3::exceptions::PyException;
 use pyo3::prelude::*;
+use pyo3::types::PyBytes;
 use pyo3_asyncio::tokio::future_into_py;
-use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
@@ -19,8 +18,9 @@ pub struct PyCommunicator(pub Arc<Mutex<EtcdClient>>);
 #[pymethods]
 impl PyCommunicator {
     // TODO: Implement and use the CRUD response types
-    fn get<'a>(&'a self, py: Python<'a>, key: String) -> PyResult<&'a PyAny> {
+    fn get<'a>(&'a self, py: Python<'a>, key: &PyBytes) -> PyResult<&'a PyAny> {
         let client = self.0.clone();
+        let key = key.as_bytes().to_vec();
         future_into_py(py, async move {
             let mut client = client.lock().await;
             let result = client.get(key, None).await;
@@ -28,7 +28,7 @@ impl PyCommunicator {
                 .map(|response| {
                     let kvs = response.kvs();
                     if !kvs.is_empty() {
-                        Some(String::from_utf8(kvs[0].value().to_owned()).unwrap())
+                        Some(kvs[0].value().to_owned())
                     } else {
                         None
                     }
@@ -37,29 +37,32 @@ impl PyCommunicator {
         })
     }
 
-    fn get_prefix<'a>(&'a self, py: Python<'a>, prefix: String) -> PyResult<&'a PyAny> {
+    fn get_prefix<'a>(&'a self, py: Python<'a>, prefix: &PyBytes) -> PyResult<&'a PyAny> {
         let client = self.0.clone();
+        let prefix = prefix.as_bytes().to_vec();
+
         future_into_py(py, async move {
             let mut client = client.lock().await;
             let options = GetOptions::new().with_prefix();
             let result = client.get(prefix, Some(options)).await;
             result
                 .map(|response| {
-                    let mut result = HashMap::new();
+                    let mut list = vec![];
                     let kvs = response.kvs();
                     for kv in kvs {
-                        let key = String::from_utf8(kv.key().to_owned()).unwrap();
-                        let value = String::from_utf8(kv.value().to_owned()).unwrap();
-                        result.insert(key, value);
+                        list.push((kv.key().to_owned(), kv.value().to_owned()));
                     }
-                    result
+                    list
                 })
                 .map_err(|e| PyClientError(e).into())
         })
     }
 
-    fn put<'a>(&'a self, py: Python<'a>, key: String, value: String) -> PyResult<&'a PyAny> {
+    fn put<'a>(&'a self, py: Python<'a>, key: &PyBytes, value: &PyBytes) -> PyResult<&'a PyAny> {
         let client = self.0.clone();
+        let key = key.as_bytes().to_vec();
+        let value = value.as_bytes().to_vec();
+
         future_into_py(py, async move {
             let mut client = client.lock().await;
             let result = client.put(key, value, None).await;
@@ -67,23 +70,10 @@ impl PyCommunicator {
         })
     }
 
-    fn put_prefix<'a>(
-        &'a self,
-        py: Python<'a>,
-        prefix: String,
-        value: String,
-    ) -> PyResult<&'a PyAny> {
+    fn delete<'a>(&'a self, py: Python<'a>, key: &PyBytes) -> PyResult<&'a PyAny> {
         let client = self.0.clone();
-        future_into_py(py, async move {
-            let mut client = client.lock().await;
-            let options = PutOptions::new().with_prev_key();
-            let result = client.put(prefix, value, Some(options)).await;
-            result.map(|_| ()).map_err(|e| PyClientError(e).into())
-        })
-    }
+        let key = key.as_bytes().to_vec();
 
-    fn delete<'a>(&'a self, py: Python<'a>, key: String) -> PyResult<&'a PyAny> {
-        let client = self.0.clone();
         future_into_py(py, async move {
             let mut client = client.lock().await;
 
@@ -92,8 +82,10 @@ impl PyCommunicator {
         })
     }
 
-    fn delete_prefix<'a>(&'a self, py: Python<'a>, key: String) -> PyResult<&'a PyAny> {
+    fn delete_prefix<'a>(&'a self, py: Python<'a>, key: &PyBytes) -> PyResult<&'a PyAny> {
         let client = self.0.clone();
+        let key = key.as_bytes().to_vec();
+
         future_into_py(py, async move {
             let mut client = client.lock().await;
             let options = DeleteOptions::new().with_prefix();
@@ -114,39 +106,10 @@ impl PyCommunicator {
         })
     }
 
-    fn replace<'a>(
-        &'a self,
-        py: Python<'a>,
-        key: String,
-        initial_val: String,
-        new_val: String,
-    ) -> PyResult<&'a PyAny> {
+    fn keys_prefix<'a>(&'a self, py: Python<'a>, key: &PyBytes) -> PyResult<&'a PyAny> {
         let client = self.0.clone();
-        future_into_py(py, async move {
-            let mut client = client.lock().await;
-            match client.get(key.clone(), None).await {
-                Ok(response) => {
-                    if let Some(key_value) = response.kvs().get(0) {
-                        if *key_value.value_str().unwrap() == initial_val {
-                            match client.put(key, new_val, None).await {
-                                Ok(_) => Ok(true), // replace successful
-                                Err(e) => Err(PyClientError(e)),
-                            }
-                        } else {
-                            Ok(false) // initial_val not equal to current value
-                        }
-                    } else {
-                        Ok(false) // Key does not exist
-                    }
-                }
-                Err(e) => Err(PyClientError(e)),
-            }
-            .map_err(|e| PyErr::new::<PyException, _>(format!("{}", e.0)))
-        })
-    }
+        let key = key.as_bytes().to_vec();
 
-    fn keys_prefix<'a>(&'a self, py: Python<'a>, key: String) -> PyResult<&'a PyAny> {
-        let client = self.0.clone();
         future_into_py(py, async move {
             let mut client = client.lock().await;
             let options = GetOptions::new().with_prefix();
@@ -156,8 +119,7 @@ impl PyCommunicator {
                     let mut result = Vec::new();
                     let kvs = response.kvs();
                     for kv in kvs {
-                        let key = String::from_utf8(kv.key().to_owned()).unwrap();
-                        result.push(key);
+                        result.push(kv.key().to_owned());
                     }
                     result
                 })
@@ -165,8 +127,10 @@ impl PyCommunicator {
         })
     }
 
-    fn lock<'a>(&'a self, py: Python<'a>, name: String) -> PyResult<&'a PyAny> {
+    fn lock<'a>(&'a self, py: Python<'a>, name: &PyBytes) -> PyResult<&'a PyAny> {
         let client = self.0.clone();
+        let name = name.as_bytes().to_vec();
+
         future_into_py(py, async move {
             let mut client = client.lock().await;
             let result = client.lock(name, None).await;
@@ -174,11 +138,13 @@ impl PyCommunicator {
         })
     }
 
-    fn unlock<'a>(&'a self, py: Python<'a>, key: String) -> PyResult<&'a PyAny> {
+    fn unlock<'a>(&'a self, py: Python<'a>, name: &PyBytes) -> PyResult<&'a PyAny> {
         let client = self.0.clone();
+        let name = name.as_bytes().to_vec();
+
         future_into_py(py, async move {
             let mut client = client.lock().await;
-            let result = client.unlock(key).await;
+            let result = client.unlock(name).await;
             result.map(|_| ()).map_err(|e| PyClientError(e).into())
         })
     }
@@ -222,24 +188,26 @@ impl PyCommunicator {
 
     fn watch(
         &self,
-        key: String,
+        key: &PyBytes,
         once: Option<bool>,
         ready_event: Option<PyCondVar>,
         cleanup_event: Option<PyCondVar>,
     ) -> PyWatch {
         let client = self.0.clone();
+        let key = key.as_bytes().to_vec();
         let once = once.unwrap_or(false);
         PyWatch::new(client, key, once, None, ready_event, cleanup_event)
     }
 
     fn watch_prefix(
         &self,
-        key: String,
+        key: &PyBytes,
         once: Option<bool>,
         ready_event: Option<PyCondVar>,
         cleanup_event: Option<PyCondVar>,
     ) -> PyWatch {
         let client = self.0.clone();
+        let key = key.as_bytes().to_vec();
         let once = once.unwrap_or(false);
         let options = WatchOptions::new().with_prefix();
         PyWatch::new(client, key, once, Some(options), ready_event, cleanup_event)

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/src/compare.rs

@@ -1,6 +1,7 @@
 use etcd_client::{Compare, CompareOp};
 use pyo3::prelude::*;
 use pyo3::pyclass::CompareOp as PyO3CompareOp;
+use pyo3::types::PyBytes;
 
 #[derive(Clone)]
 #[pyclass(name = "CompareOp")]
@@ -42,31 +43,38 @@ pub struct PyCompare(pub Compare);
 #[pymethods]
 impl PyCompare {
     #[staticmethod]
-    fn version(key: String, cmp: PyCompareOp, version: i64) -> PyResult<Self> {
+    fn version(key: &PyBytes, cmp: PyCompareOp, version: i64) -> PyResult<Self> {
+        let key = key.as_bytes().to_vec();
         Ok(PyCompare(Compare::version(key, cmp.0, version)))
     }
 
     #[staticmethod]
-    fn create_revision(key: String, cmp: PyCompareOp, revision: i64) -> PyResult<Self> {
+    fn create_revision(key: &PyBytes, cmp: PyCompareOp, revision: i64) -> PyResult<Self> {
+        let key = key.as_bytes().to_vec();
         Ok(PyCompare(Compare::create_revision(key, cmp.0, revision)))
     }
 
     #[staticmethod]
-    fn mod_revision(key: String, cmp: PyCompareOp, revision: i64) -> PyResult<Self> {
+    fn mod_revision(key: &PyBytes, cmp: PyCompareOp, revision: i64) -> PyResult<Self> {
+        let key = key.as_bytes().to_vec();
         Ok(PyCompare(Compare::mod_revision(key, cmp.0, revision)))
     }
 
     #[staticmethod]
-    fn value(key: String, cmp: PyCompareOp, value: String) -> PyResult<Self> {
+    fn value(key: &PyBytes, cmp: PyCompareOp, value: &PyBytes) -> PyResult<Self> {
+        let key = key.as_bytes().to_vec();
+        let value = value.as_bytes().to_vec();
         Ok(PyCompare(Compare::value(key, cmp.0, value)))
     }
 
     #[staticmethod]
-    fn lease(key: String, cmp: PyCompareOp, lease: i64) -> PyResult<Self> {
+    fn lease(key: &PyBytes, cmp: PyCompareOp, lease: i64) -> PyResult<Self> {
+        let key = key.as_bytes().to_vec();
         Ok(PyCompare(Compare::lease(key, cmp.0, lease)))
     }
 
-    fn with_range(&self, end: String) -> PyResult<Self> {
+    fn with_range(&self, end: &PyBytes) -> PyResult<Self> {
+        let end = end.as_bytes().to_vec();
         Ok(PyCompare(self.0.clone().with_range(end)))
     }
 

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/src/error.rs

@@ -2,7 +2,7 @@ use pyo3::{create_exception, exceptions::PyException, types::PyDict, PyErr, Pyth
 use std::fmt::Debug;
 
 create_exception!(etcd_client, ClientError, PyException);
-create_exception!(etcd_client, GRpcStatusError, ClientError);
+create_exception!(etcd_client, GRPCStatusError, ClientError);
 create_exception!(etcd_client, InvalidArgsError, ClientError);
 create_exception!(etcd_client, InvalidUriError, ClientError);
 create_exception!(etcd_client, IoError, ClientError);
@@ -15,8 +15,8 @@ create_exception!(etcd_client, InvalidHeaderValueError, ClientError);
 create_exception!(etcd_client, EndpointError, ClientError);
 create_exception!(etcd_client, LockError, ClientError);
 
-#[pyclass(name = "GRpcStatusCode")]
-pub enum PyGRpcStatusCode {
+#[pyclass(name = "GRPCStatusCode")]
+pub enum PyGRPCStatusCode {
     Ok = 0,
     Cancelled = 1,
     Unknown = 2,
@@ -54,7 +54,7 @@ impl From<PyClientError> for PyErr {
                     .unwrap();
 
                 let kv_args: PyObject = error_details.into_py(py);
-                GRpcStatusError::new_err(kv_args)
+                GRPCStatusError::new_err(kv_args)
             }),
             etcd_client::Error::InvalidArgs(e) => {
                 InvalidArgsError::new_err(format!("InvalidArgsError(err={})", e))

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/src/lib.rs

@@ -15,8 +15,8 @@ use communicator::PyCommunicator;
 use compare::{PyCompare, PyCompareOp};
 use condvar::PyCondVar;
 use error::{
-    ClientError, ElectError, EndpointError, GRpcStatusError, InvalidArgsError,
-    InvalidHeaderValueError, InvalidUriError, IoError, LeaseKeepAliveError, PyGRpcStatusCode,
+    ClientError, ElectError, EndpointError, GRPCStatusError, InvalidArgsError,
+    InvalidHeaderValueError, InvalidUriError, IoError, LeaseKeepAliveError, PyGRPCStatusCode,
     TransportError, Utf8Error, WatchError,
 };
 use lock_manager::PyEtcdLockOption;
@@ -45,10 +45,10 @@ fn etcd_client(py: Python, module: &PyModule) -> PyResult<()> {
     module.add_class::<PyTxnResponse>()?;
     module.add_class::<PyEtcdLockOption>()?;
 
-    module.add_class::<PyGRpcStatusCode>()?;
+    module.add_class::<PyGRPCStatusCode>()?;
 
     module.add("ClientError", py.get_type::<ClientError>())?;
-    module.add("GRpcStatusError", py.get_type::<GRpcStatusError>())?;
+    module.add("GRPCStatusError", py.get_type::<GRPCStatusError>())?;
     module.add("InvalidArgsError", py.get_type::<InvalidArgsError>())?;
     module.add("IoError", py.get_type::<IoError>())?;
     module.add("InvalidUriError", py.get_type::<InvalidUriError>())?;

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/src/lock_manager.rs

@@ -1,18 +1,18 @@
 use crate::{
     client::PyClient,
     communicator::PyCommunicator,
-    error::{GRpcStatusError, LockError, PyClientError},
+    error::{GRPCStatusError, LockError, PyClientError},
 };
 use etcd_client::{Client as EtcdClient, LockOptions};
 
-use pyo3::prelude::*;
+use pyo3::{prelude::*, types::PyBytes};
 use std::time::Duration;
 use tokio::time::{sleep, timeout};
 
 #[derive(Debug, Clone)]
 #[pyclass(get_all, set_all, name = "EtcdLockOption")]
 pub struct PyEtcdLockOption {
-    pub lock_name: String,
+    pub lock_name: Vec<u8>,
     pub timeout: Option<f64>,
     pub ttl: Option<i64>,
 }
@@ -20,7 +20,8 @@ pub struct PyEtcdLockOption {
 #[pymethods]
 impl PyEtcdLockOption {
     #[new]
-    fn new(lock_name: String, timeout: Option<f64>, ttl: Option<i64>) -> Self {
+    fn new(lock_name: &PyBytes, timeout: Option<f64>, ttl: Option<i64>) -> Self {
+        let lock_name = lock_name.as_bytes().to_vec();
         Self {
             lock_name,
             timeout,
@@ -30,7 +31,7 @@ impl PyEtcdLockOption {
 
     fn __repr__(&self) -> PyResult<String> {
         Ok(format!(
-            "EtcdLockOption(lock_name={}, timeout={:?}, ttl={:?})",
+            "EtcdLockOption(lock_name={:?}, timeout={:?}, ttl={:?})",
             self.lock_name, self.timeout, self.ttl
         ))
     }
@@ -38,10 +39,10 @@ impl PyEtcdLockOption {
 
 pub struct EtcdLockManager {
     pub client: PyClient,
-    pub lock_name: String,
+    pub lock_name: Vec<u8>,
     pub ttl: Option<i64>,
     pub timeout_seconds: Option<f64>,
-    pub lock_id: Option<String>,
+    pub lock_id: Option<Vec<u8>>,
     pub lease_id: Option<i64>,
     pub lease_keepalive_task: Option<tokio::task::JoinHandle<Result<(), PyClientError>>>,
 }
@@ -98,15 +99,11 @@ impl EtcdLockManager {
                         .map(|lease_id| LockOptions::new().with_lease(lease_id));
 
                     let lock_res = client
-                        .lock(self.lock_name.clone().as_bytes(), lock_req_options)
+                        .lock(self.lock_name.clone(), lock_req_options)
                         .await
                         .map_err(PyClientError)?;
 
-                    self.lock_id = Some(
-                        std::str::from_utf8(lock_res.key())
-                            .expect("Invalid utf8 chars includeded in lock request!")
-                            .to_owned(),
-                    );
+                    self.lock_id = Some(lock_res.key().to_vec());
                     Ok(())
                 },
             )
@@ -123,7 +120,7 @@ impl EtcdLockManager {
                             etcd_client::Error::GRpcStatus(status)
                                 if status.code() != tonic::Code::NotFound =>
                             {
-                                return Err(GRpcStatusError::new_err(status.to_string()))
+                                return Err(GRPCStatusError::new_err(status.to_string()))
                             }
                             _ => return Err(PyClientError(e).into()),
                         },
@@ -160,7 +157,11 @@ impl EtcdLockManager {
             client.lease_revoke(lease_id).await.map_err(PyClientError)?;
         } else {
             client
-                .unlock(self.lock_id.as_ref().unwrap().as_bytes())
+                .unlock(
+                    self.lock_id
+                        .to_owned()
+                        .expect("Failed to unlock due to lock_id is None"),
+                )
                 .await
                 .map_err(PyClientError)?;
         }

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/src/txn.rs

@@ -1,5 +1,5 @@
 use etcd_client::{DeleteOptions, GetOptions, PutOptions, Txn, TxnOp};
-use pyo3::prelude::*;
+use pyo3::{prelude::*, types::PyBytes};
 
 use crate::compare::PyCompare;
 
@@ -10,18 +10,23 @@ pub struct PyTxnOp(pub TxnOp);
 #[pymethods]
 impl PyTxnOp {
     #[staticmethod]
-    fn get(key: String) -> PyResult<Self> {
+    fn get(key: &PyBytes) -> PyResult<Self> {
+        let key = key.as_bytes().to_vec();
         let options = GetOptions::new();
         Ok(PyTxnOp(TxnOp::get(key, Some(options))))
     }
+
     #[staticmethod]
-    fn put(key: String, value: String) -> PyResult<Self> {
+    fn put(key: &PyBytes, value: &PyBytes) -> PyResult<Self> {
+        let key = key.as_bytes().to_vec();
+        let value = value.as_bytes().to_vec();
         let options = PutOptions::new();
         Ok(PyTxnOp(TxnOp::put(key, value, Some(options))))
     }
 
     #[staticmethod]
-    fn delete(key: String) -> PyResult<Self> {
+    fn delete(key: &PyBytes) -> PyResult<Self> {
+        let key = key.as_bytes().to_vec();
         let options = DeleteOptions::new();
         Ok(PyTxnOp(TxnOp::delete(key, Some(options))))
     }

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/src/watch.rs

@@ -16,7 +16,7 @@ use crate::watch_event_stream::PyWatchEventStream;
 #[derive(Clone)]
 pub struct PyWatch {
     client: Arc<Mutex<EtcdClient>>,
-    key: String,
+    key: Vec<u8>,
     once: bool,
     options: Option<WatchOptions>,
     watcher: Arc<Mutex<Option<Watcher>>>,
@@ -30,7 +30,7 @@ pub struct PyWatch {
 impl PyWatch {
     pub fn new(
         client: Arc<Mutex<EtcdClient>>,
-        key: String,
+        key: Vec<u8>,
         once: bool,
         options: Option<WatchOptions>,
         ready_event: Option<PyCondVar>,

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/src/watch_event.rs

@@ -7,10 +7,10 @@ use pyo3::pyclass::CompareOp;
 #[pyclass(get_all, name = "WatchEvent")]
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct PyWatchEvent {
-    key: String,
-    value: String,
+    key: Vec<u8>,
+    value: Vec<u8>,
     event: PyWatchEventType,
-    prev_value: Option<String>,
+    prev_value: Option<Vec<u8>>,
 }
 
 #[pymethods]
@@ -18,10 +18,10 @@ impl PyWatchEvent {
     #[new]
     #[pyo3(signature = (key, value, event, prev_value))]
     fn new(
-        key: String,
-        value: String,
+        key: Vec<u8>,
+        value: Vec<u8>,
         event: PyWatchEventType,
-        prev_value: Option<String>,
+        prev_value: Option<Vec<u8>>,
     ) -> Self {
         Self {
             key,
@@ -33,7 +33,7 @@ impl PyWatchEvent {
 
     pub fn __repr__(&self) -> String {
         format!(
-            "Event(event={:?}, key={}, value={}, prev_value={:?})",
+            "Event(event={:?}, key={:?}, value={:?}, prev_value={:?})",
             self.event, self.key, self.value, self.prev_value
         )
     }
@@ -50,8 +50,8 @@ impl PyWatchEvent {
 impl From<EtcdClientEvent> for PyWatchEvent {
     fn from(event: EtcdClientEvent) -> Self {
         let kv = event.kv().unwrap();
-        let key = String::from_utf8(kv.key().to_owned()).unwrap();
-        let value = String::from_utf8(kv.value().to_owned()).unwrap();
+        let key = kv.key().to_owned();
+        let value = kv.value().to_owned();
         let prev_value = None;
         let event = PyWatchEventType(event.event_type());
         Self {

{etcd_client_py-0.2.4 → etcd_client_py-0.3.0}/tests/harness.py

@@ -1,3 +1,9 @@
+"""
+Backend.AI AsyncEtcd Client Copy
+Ref: https://github.com/lablup/backend.ai/blob/main/src/ai/backend/common/etcd.py
+=================================================================================
+"""
+
 """
 An asynchronous client wrapper for etcd v3 API.
 
@@ -7,8 +13,6 @@ Fortunately, etcd3's watchers are not blocking because they are implemented
 using callbacks in separate threads.
 """
 
-from __future__ import annotations
-
 import asyncio
 from dataclasses import dataclass
 import enum
@@ -44,8 +48,8 @@ from etcd_client import (
     CompareOp,
     CondVar,
     ConnectOptions,
-    GRpcStatusCode,
-    GRpcStatusError,
+    GRPCStatusCode,
+    GRPCStatusError,
     WatchEvent,
 )
 
@@ -64,7 +68,7 @@ class HostPortPair:
         return f"{self.host}:{self.port}"
 
     @classmethod
-    def parse(cls, s: str) -> HostPortPair:
+    def parse(cls, s: str) -> "HostPortPair":
         if ":" in s:
             host, port_str = s.rsplit(":")
             port = int(port_str)
@@ -220,7 +224,7 @@ class AsyncEtcd:
         scope_prefix = self._merge_scope_prefix_map(scope_prefix_map)[scope]
         mangled_key = self._mangle_key(f"{_slash(scope_prefix)}{key}")
         async with self.etcd.connect() as communicator:
-            await communicator.put(mangled_key, str(val))
+            await communicator.put(mangled_key.encode(self.encoding), str(val).encode(self.encoding))
 
     async def put_prefix(
         self,
@@ -260,7 +264,7 @@ class AsyncEtcd:
             actions = []
             for k, v in flattened_dict.items():
                 actions.append(
-                    TxnOp.put(self._mangle_key(f"{_slash(scope_prefix)}{k}"), str(v))
+                    TxnOp.put(self._mangle_key(f"{_slash(scope_prefix)}{k}").encode(self.encoding), str(v).encode(self.encoding))
                 )
 
             await communicator.txn(
@@ -289,7 +293,7 @@ class AsyncEtcd:
         actions = []
         for k, v in flattened_dict_obj.items():
             actions.append(
-                TxnOp.put(self._mangle_key(f"{_slash(scope_prefix)}{k}"), str(v))
+                TxnOp.put(self._mangle_key(f"{_slash(scope_prefix)}{k}").encode(self.encoding), str(v).encode(self.encoding))
             )
 
         async with self.etcd.connect() as communicator:
@@ -337,10 +341,10 @@ class AsyncEtcd:
         async with self.etcd.connect() as communicator:
             for scope_prefix in scope_prefixes:
                 value = await communicator.get(
-                    self._mangle_key(f"{_slash(scope_prefix)}{key}")
+                    self._mangle_key(f"{_slash(scope_prefix)}{key}").encode(self.encoding)
                 )
                 if value is not None:
-                    return value
+                    return bytes(value).decode(self.encoding)
         return None
 
     async def get_prefix(
@@ -409,9 +413,9 @@ class AsyncEtcd:
                 mangled_key_prefix = self._mangle_key(
                     f"{_slash(scope_prefix)}{key_prefix}"
                 )
-                values = await communicator.get_prefix(mangled_key_prefix)
+                values = await communicator.get_prefix(mangled_key_prefix.encode(self.encoding))
                 pair_sets.append(
-                    [(self._demangle_key(k), v) for k, v in values.items()]
+                    [(self._demangle_key(bytes(k).decode(self.encoding)), bytes(v).decode(self.encoding)) for k, v in values]
                 )
 
         configs = [
@@ -440,10 +444,10 @@ class AsyncEtcd:
                 EtcdTransactionAction()
                 .when(
                     [
-                        Compare.value(mangled_key, CompareOp.EQUAL, initial_val),
+                        Compare.value(mangled_key.encode(self.encoding), CompareOp.EQUAL, initial_val.encode(self.encoding)),
                     ]
                 )
-                .and_then([TxnOp.put(mangled_key, new_val)])
+                .and_then([TxnOp.put(mangled_key.encode(self.encoding), new_val.encode(self.encoding))])
                 .or_else([])
             )
 
@@ -459,7 +463,7 @@ class AsyncEtcd:
         scope_prefix = self._merge_scope_prefix_map(scope_prefix_map)[scope]
         mangled_key = self._mangle_key(f"{_slash(scope_prefix)}{key}")
         async with self.etcd.connect() as communicator:
-            await communicator.delete(mangled_key)
+            await communicator.delete(mangled_key.encode(self.encoding))
 
     async def delete_multi(
         self,
@@ -473,7 +477,7 @@ class AsyncEtcd:
             actions = []
             for k in keys:
                 actions.append(
-                    TxnOp.delete(self._mangle_key(f"{_slash(scope_prefix)}{k}"))
+                    TxnOp.delete(self._mangle_key(f"{_slash(scope_prefix)}{k}").encode(self.encoding))
                 )
             communicator.txn(EtcdTransactionAction().and_then(actions).or_else([]))
 
@@ -487,7 +491,7 @@ class AsyncEtcd:
         scope_prefix = self._merge_scope_prefix_map(scope_prefix_map)[scope]
         mangled_key_prefix = self._mangle_key(f"{_slash(scope_prefix)}{key_prefix}")
         async with self.etcd.connect() as communicator:
-            await communicator.delete_prefix(mangled_key_prefix)
+            await communicator.delete_prefix(mangled_key_prefix.encode(self.encoding))
 
     async def _watch_impl(
         self,
@@ -508,7 +512,7 @@ class AsyncEtcd:
                             )
                         except asyncio.TimeoutError:
                             pass
-                    yield Event(ev.key[scope_prefix_len:], ev.event, ev.value)
+                    yield Event(bytes(ev.key).decode(self.encoding)[scope_prefix_len:], ev.event, bytes(ev.value).decode(self.encoding))
                     if once:
                         return
         finally:
@@ -535,7 +539,7 @@ class AsyncEtcd:
             try:
                 async for ev in self._watch_impl(
                     lambda communicator: communicator.watch(
-                        mangled_key,
+                        mangled_key.encode(self.encoding),
                         ready_event=ready_event,
                     ),
                     scope_prefix_len,
@@ -545,10 +549,10 @@ class AsyncEtcd:
                 ):
                     yield ev
                 ended_without_error = True
-            except GRpcStatusError as e:
+            except GRPCStatusError as e:
                 err_detail = e.args[0]
 
-                if err_detail["code"] == GRpcStatusCode.Unavailable:
+                if err_detail["code"] == GRPCStatusCode.Unavailable:
                     log.warn(
                         "watch(): error while connecting to Etcd server, retrying..."
                     )
@@ -577,7 +581,7 @@ class AsyncEtcd:
             try:
                 async for ev in self._watch_impl(
                     lambda communicator: communicator.watch_prefix(
-                        mangled_key_prefix,
+                        mangled_key_prefix.encode(self.encoding),
                         ready_event=ready_event,
                     ),
                     scope_prefix_len,
@@ -587,10 +591,10 @@ class AsyncEtcd:
                 ):
                     yield ev
                 ended_without_error = True
-            except GRpcStatusError as e:
+            except GRPCStatusError as e:
                 err_detail = e.args[0]
 
-                if err_detail["code"] == GRpcStatusCode.Unavailable:
+                if err_detail["code"] == GRPCStatusCode.Unavailable:
                     log.warn(
                         "watch_prefix(): error while connecting to Etcd server, retrying..."
                     )