rubyx-py 0.2.0 → 0.2.1

data/ext/rubyx/src/rubyx_object.rs

@@ -4,10 +4,11 @@ use crate::python_ffi::PyObject;
 use crate::python_guard::PyGuard;
 use crate::ruby_helpers;
 use crate::stream::SendableValue;
+use magnus::encoding::EncodingCapable;
 use magnus::r_hash::ForEach;
 use magnus::typed_data::Obj;
 use magnus::value::ReprValue;
-use magnus::{Class, IntoValue, RHash, Ruby, Symbol, TryConvert, Value};
+use magnus::{Class, IntoValue, RHash, RString, Ruby, Symbol, TryConvert, Value};
 use std::ffi::CString;
 
 const RUBY_IMPLICIT_CONVERSIONS: &[&str] = &[
@@ -51,6 +52,24 @@ pub(crate) fn python_to_sendable(
         };
         return Ok(SendableValue::Str(val));
     }
+    if api.bytes_check(py_val) {
+        let Some(val) = api.bytes_to_vec(py_val) else {
+            if api.has_error() {
+                api.clear_error();
+            }
+            return Err("Cannot decode Python bytes".to_string());
+        };
+        return Ok(SendableValue::Bytes(val));
+    }
+    if api.bytearray_check(py_val) {
+        let Some(val) = api.bytearray_to_vec(py_val) else {
+            if api.has_error() {
+                api.clear_error();
+            }
+            return Err("Cannot read Python bytearray".to_string());
+        };
+        return Ok(SendableValue::Bytes(val));
+    }
     if api.tuple_check(py_val) {
         let len = api.tuple_size(py_val);
         let mut items = Vec::with_capacity(len as usize);
@@ -61,6 +80,32 @@ pub(crate) fn python_to_sendable(
         return Ok(SendableValue::List(items));
     }
 
+    if api.is_set(py_val) || api.is_frozen_set(py_val) {
+        let len = api.set_size(py_val);
+        let mut items = Vec::with_capacity(len as usize);
+        let iter = api.object_get_iter(py_val);
+        loop {
+            let item = api.iter_next(iter);
+            if item.is_null() {
+                break;
+            }
+            let result = python_to_sendable(item, api);
+            api.decref(item);
+            match result {
+                Ok(val) => items.push(val),
+                Err(e) => {
+                    api.decref(iter);
+                    return Err(e);
+                }
+            }
+        }
+        if api.has_error() {
+            api.clear_error();
+        }
+        api.decref(iter);
+        return Ok(SendableValue::Set(items));
+    }
+
     if api.list_check(py_val) {
         let len = api.list_size(py_val);
         let mut items = Vec::with_capacity(len as usize);
@@ -95,7 +140,7 @@ pub(crate) fn python_to_sendable(
         let name = std::ffi::CString::new("__dict__").unwrap();
         api.object_has_attr_string(py_val, name.as_ptr()) != 0
     };
-    if api.callable_check(py_val) == 0 && has_dict {
+    if has_dict || api.callable_check(py_val) != 0 {
         api.incref(py_val);
         return Ok(SendableValue::PyObjectRef(py_val as usize));
     }
@@ -153,6 +198,24 @@ pub(crate) fn ruby_to_python(
         return Ok(py_str);
     }
     if value.is_kind_of(ruby.class_string()) {
+        let rstr = RString::try_convert(value)?;
+        // ASCII-8BIT means bytes/bytearray
+        let enc = rstr.enc_get();
+        let ascii_8_bit = ruby
+            .find_encindex("ASCII-8BIT")
+            .map_err(|_| magnus::Error::new(ruby_helpers::runtime_error(), "No ASCII-8BIT"))?;
+        if enc == ascii_8_bit {
+            let bytes = unsafe { rstr.as_slice() };
+            let py_bytes = api.bytes_from_slice(bytes);
+            if py_bytes.is_null() {
+                return Err(magnus::Error::new(
+                    ruby_helpers::runtime_error(),
+                    "Failed to create Python bytes from String",
+                ));
+            }
+            return Ok(py_bytes);
+        }
+        // UTF-8 string conversion
         let val = String::try_convert(value)?;
         return val
             .to_python(api)
@@ -762,6 +825,134 @@ impl RubyxObject {
         result
     }
 
+    pub fn call(&self, args: &[magnus::Value]) -> Result<Value, magnus::Error> {
+        let api = self.api;
+        let gil = api.ensure_gil();
+        let result = (|| -> Result<Value, magnus::Error> {
+            if api.callable_check(self.py_obj) == 0 {
+                return Err(magnus::Error::new(
+                    ruby_helpers::type_error(),
+                    "Python object is not callable",
+                ));
+            }
+            let ruby = Ruby::get().map_err(|e| {
+                magnus::Error::new(
+                    ruby_helpers::runtime_error(),
+                    format!("Ruby VM handle unavailable: {e}"),
+                )
+            })?;
+
+            // Extract positional and keyword arguments
+            let (positional, kwargs) = if let Some(last) = args.last() {
+                if last.is_kind_of(ruby.class_hash()) {
+                    (&args[..args.len() - 1], Some(RHash::try_convert(*last)?))
+                } else {
+                    (args, None)
+                }
+            } else {
+                (args, None)
+            };
+
+            // Args Tuple for args
+            let py_args = api.tuple_new(positional.len() as isize);
+            if py_args.is_null() {
+                return Err(magnus::Error::new(
+                    ruby_helpers::runtime_error(),
+                    "Failed to allocate Python args tuple",
+                ));
+            }
+            let py_args_guard = PyGuard::new(py_args, api).ok_or_else(|| {
+                magnus::Error::new(ruby_helpers::runtime_error(), "Null Python args tuple")
+            })?;
+            for (i, arg) in positional.iter().enumerate() {
+                let py_arg = ruby_to_python(*arg, api)?;
+                if api.tuple_set_item(py_args_guard.ptr(), i as isize, py_arg) != 0 {
+                    api.decref(py_arg);
+                    if let Some(py_err) = PythonApi::extract_exception(api) {
+                        return Err(magnus::Error::from(py_err));
+                    }
+                    return Err(magnus::Error::new(
+                        ruby_helpers::runtime_error(),
+                        "Failed to set tuple argument",
+                    ));
+                }
+            }
+
+            // kwargs dict
+            let py_kwargs_guard = if let Some(hash) = kwargs {
+                let dict = api.dict_new();
+                if dict.is_null() {
+                    return Err(magnus::Error::new(
+                        ruby_helpers::runtime_error(),
+                        "Failed to allocate kwargs dict",
+                    ));
+                }
+                let guard = PyGuard::new(dict, api).ok_or_else(|| {
+                    magnus::Error::new(ruby_helpers::runtime_error(), "Null kwargs dict")
+                })?;
+                hash.foreach(|k: Value, v: Value| {
+                    let key = if let Ok(s) = String::try_convert(k) {
+                        s
+                    } else if let Ok(sym) = Symbol::try_convert(k) {
+                        sym.name()?.to_string()
+                    } else {
+                        return Err(magnus::Error::new(
+                            ruby_helpers::type_error(),
+                            "kwargs keys must be String or Symbol",
+                        ));
+                    };
+                    let py_key = key.to_python(api).map_err(|e| {
+                        magnus::Error::new(ruby_helpers::runtime_error(), format!("{e:?}"))
+                    })?;
+                    let py_val = ruby_to_python(v, api)?;
+                    let rc = api.dict_set_item(guard.ptr(), py_key, py_val);
+                    api.decref(py_key);
+                    api.decref(py_val);
+                    if rc != 0 {
+                        if let Some(py_err) = PythonApi::extract_exception(api) {
+                            return Err(magnus::Error::from(py_err));
+                        }
+                        return Err(magnus::Error::new(
+                            ruby_helpers::runtime_error(),
+                            "Failed to set kwargs item",
+                        ));
+                    }
+                    Ok(ForEach::Continue)
+                })?;
+                Some(guard)
+            } else {
+                None
+            };
+
+            let py_kwargs_ptr = py_kwargs_guard
+                .as_ref()
+                .map_or(std::ptr::null_mut(), |g| g.ptr());
+            // call the python callable with args and kwargs
+            let py_result = api.object_call(self.py_obj, py_args_guard.ptr(), py_kwargs_ptr);
+            if py_result.is_null() {
+                if let Some(py_err) = PythonApi::extract_exception(api) {
+                    return Err(magnus::Error::from(py_err));
+                }
+                return Err(magnus::Error::new(
+                    ruby_helpers::runtime_error(),
+                    "Python call failed",
+                ));
+            }
+            let py_result_guard = PyGuard::new(py_result, api).ok_or_else(|| {
+                magnus::Error::new(ruby_helpers::runtime_error(), "Null Python result")
+            })?;
+            let wrapper = RubyxObject::new(py_result_guard.ptr(), api).ok_or_else(|| {
+                magnus::Error::new(
+                    ruby_helpers::runtime_error(),
+                    "Failed to wrap Python result",
+                )
+            })?;
+            Ok(wrapper.into_value_with(&ruby))
+        })();
+        api.release_gil(gil);
+        result
+    }
+
     pub fn py_type(&self) -> Result<String, magnus::Error> {
         let gil = self.api.ensure_gil();
         let result = self.api.type_name(self.py_obj);
@@ -1668,6 +1859,206 @@ mod tests {
         });
     }
 
+    // ========== call tests ==========
+
+    #[test]
+    #[serial]
+    fn test_call_lambda_no_args() {
+        with_ruby_python(|_ruby, api| {
+            let globals = crate::eval::make_globals(api);
+            let py_func = api
+                .run_string("lambda: 42", 258, globals.ptr(), globals.ptr())
+                .expect("lambda eval should succeed");
+            let wrapper = RubyxObject::new(py_func, api).unwrap();
+
+            let result = wrapper.call(&[]).expect("call should succeed");
+            let obj = Obj::<RubyxObject>::try_convert(result).expect("should be RubyxObject");
+            assert_eq!(api.long_to_i64(obj.as_ptr()), 42);
+
+            drop(wrapper);
+            api.decref(py_func);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_call_lambda_with_args() {
+        with_ruby_python(|ruby, api| {
+            let globals = crate::eval::make_globals(api);
+            let py_func = api
+                .run_string("lambda x, y: x + y", 258, globals.ptr(), globals.ptr())
+                .expect("lambda eval should succeed");
+            let wrapper = RubyxObject::new(py_func, api).unwrap();
+
+            let args = vec![3_i64.into_value_with(ruby), 4_i64.into_value_with(ruby)];
+            let result = wrapper.call(&args).expect("call should succeed");
+            let obj = Obj::<RubyxObject>::try_convert(result).expect("should be RubyxObject");
+            assert_eq!(api.long_to_i64(obj.as_ptr()), 7);
+
+            drop(wrapper);
+            api.decref(py_func);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_call_builtin_function() {
+        with_ruby_python(|ruby, api| {
+            let builtins = api
+                .import_module("builtins")
+                .expect("builtins should import");
+            let len_func = api.object_get_attr_string(builtins, "len");
+            let wrapper = RubyxObject::new(len_func, api).unwrap();
+
+            let globals = crate::eval::make_globals(api);
+            let py_list = api
+                .run_string("[1, 2, 3]", 258, globals.ptr(), globals.ptr())
+                .expect("list eval should succeed");
+            let list_wrapper = RubyxObject::new(py_list, api).unwrap();
+
+            let args = vec![list_wrapper.into_value_with(ruby)];
+            let result = wrapper.call(&args).expect("call should succeed");
+            let obj = Obj::<RubyxObject>::try_convert(result).expect("should be RubyxObject");
+            assert_eq!(api.long_to_i64(obj.as_ptr()), 3);
+
+            drop(wrapper);
+            api.decref(len_func);
+            api.decref(builtins);
+            api.decref(py_list);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_call_with_kwargs() {
+        with_ruby_python(|ruby, api| {
+            let globals = crate::eval::make_globals(api);
+            let _ = api.run_string(
+                "def greet(name, greeting='Hello'): return f'{greeting}, {name}!'",
+                257,
+                globals.ptr(),
+                globals.ptr(),
+            );
+            let key = api.string_from_str("greet");
+            let func = api.dict_get_item(globals.ptr(), key);
+            api.decref(key);
+            let wrapper = RubyxObject::new(func, api).unwrap();
+
+            let kwargs = ruby.hash_new();
+            kwargs
+                .aset(ruby.sym_new("greeting"), "Hi".into_value_with(ruby))
+                .unwrap();
+            let args = vec!["Alice".into_value_with(ruby), kwargs.into_value_with(ruby)];
+            let result = wrapper
+                .call(&args)
+                .expect("call with kwargs should succeed");
+            let obj = Obj::<RubyxObject>::try_convert(result).expect("should be RubyxObject");
+            assert_eq!(
+                api.string_to_string(obj.as_ptr()),
+                Some("Hi, Alice!".to_string())
+            );
+
+            drop(wrapper);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_call_class_as_constructor() {
+        with_ruby_python(|ruby, api| {
+            let globals = crate::eval::make_globals(api);
+            let _ = api.run_string(
+                "class Pt:\n    def __init__(self, x):\n        self.x = x",
+                257,
+                globals.ptr(),
+                globals.ptr(),
+            );
+            let key = api.string_from_str("Pt");
+            let cls = api.dict_get_item(globals.ptr(), key);
+            api.decref(key);
+            let wrapper = RubyxObject::new(cls, api).unwrap();
+
+            let args = vec![10_i64.into_value_with(ruby)];
+            let result = wrapper.call(&args).expect("class call should succeed");
+            let obj = Obj::<RubyxObject>::try_convert(result).expect("should be RubyxObject");
+
+            let x_attr = api.object_get_attr_string(obj.as_ptr(), "x");
+            assert!(!x_attr.is_null());
+            assert_eq!(api.long_to_i64(x_attr), 10);
+            api.decref(x_attr);
+
+            drop(wrapper);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_call_non_callable_raises_error() {
+        with_ruby_python(|_ruby, api| {
+            let py_int = api.long_from_i64(42);
+            let wrapper = RubyxObject::new(py_int, api).unwrap();
+
+            let result = wrapper.call(&[]);
+            assert!(result.is_err(), "calling non-callable should error");
+            let err_msg = result.unwrap_err().to_string();
+            assert!(
+                err_msg.contains("not callable"),
+                "error should mention not callable, got: {err_msg}"
+            );
+
+            drop(wrapper);
+            api.decref(py_int);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_call_propagates_python_error() {
+        with_ruby_python(|_ruby, api| {
+            let globals = crate::eval::make_globals(api);
+            let _ = api.run_string(
+                "def explode(): raise ValueError('boom')",
+                257,
+                globals.ptr(),
+                globals.ptr(),
+            );
+            let key = api.string_from_str("explode");
+            let func = api.dict_get_item(globals.ptr(), key);
+            api.decref(key);
+            let wrapper = RubyxObject::new(func, api).unwrap();
+
+            let result = wrapper.call(&[]);
+            assert!(result.is_err(), "call that raises should return error");
+            let err_msg = result.unwrap_err().to_string();
+            assert!(
+                err_msg.contains("boom"),
+                "error should contain Python message, got: {err_msg}"
+            );
+
+            drop(wrapper);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_call_returns_rubyx_object() {
+        with_ruby_python(|_ruby, api| {
+            let globals = crate::eval::make_globals(api);
+            let py_func = api
+                .run_string("lambda: [1, 2, 3]", 258, globals.ptr(), globals.ptr())
+                .expect("lambda eval should succeed");
+            let wrapper = RubyxObject::new(py_func, api).unwrap();
+
+            let result = wrapper.call(&[]).expect("call should succeed");
+            let obj = Obj::<RubyxObject>::try_convert(result).expect("should be RubyxObject");
+            assert!(api.list_check(obj.as_ptr()));
+            assert_eq!(api.list_size(obj.as_ptr()), 3);
+
+            drop(wrapper);
+            api.decref(py_func);
+        });
+    }
+
     // ========== is_truthy / is_falsy tests ==========
 
     #[test]
@@ -1960,15 +2351,16 @@ mod tests {
         api.decref(os);
     }
 
+    // ========== python_to_sendable: set / frozenset ==========
+
     #[test]
     #[serial]
-    fn test_python_to_sendable_set_returns_err() {
+    fn test_python_to_sendable_set_returns_set() {
         use crate::test_helpers::skip_if_no_python;
         let Some(guard) = skip_if_no_python() else {
             return;
         };
         let api = guard.api();
-        // Sets don't have __dict__, so they return Err (not PyObjectRef)
         let globals = api.dict_new();
         let builtins = api
             .import_module("builtins")
@@ -1980,8 +2372,22 @@ mod tests {
         let py_set = result.expect("set eval should succeed");
         assert!(!py_set.is_null());
 
-        let sendable = python_to_sendable(py_set, api);
-        assert!(sendable.is_err(), "set should return Err (no __dict__)");
+        let sendable = python_to_sendable(py_set, api).expect("set should convert to Set");
+        match &sendable {
+            SendableValue::Set(items) => {
+                assert_eq!(items.len(), 3);
+                let mut vals: Vec<i64> = items
+                    .iter()
+                    .map(|item| match item {
+                        SendableValue::Integer(n) => *n,
+                        other => panic!("expected Integer, got {other:?}"),
+                    })
+                    .collect();
+                vals.sort();
+                assert_eq!(vals, vec![1, 2, 3]);
+            }
+            other => panic!("expected Set, got {other:?}"),
+        }
         api.decref(py_set);
         api.decref(builtins);
         api.decref(globals);
@@ -1989,13 +2395,387 @@ mod tests {
 
     #[test]
     #[serial]
-    fn test_python_to_sendable_primitives_not_py_object_ref() {
+    fn test_python_to_sendable_frozenset_returns_set() {
         use crate::test_helpers::skip_if_no_python;
         let Some(guard) = skip_if_no_python() else {
             return;
         };
         let api = guard.api();
-
+        let globals = api.dict_new();
+        let builtins = api
+            .import_module("builtins")
+            .expect("builtins should import");
+        let key = api.string_from_str("__builtins__");
+        api.dict_set_item(globals, key, builtins);
+        api.decref(key);
+        let result = api.run_string("frozenset({10, 20})", 258, globals, globals);
+        let py_fset = result.expect("frozenset eval should succeed");
+        assert!(!py_fset.is_null());
+
+        let sendable = python_to_sendable(py_fset, api).expect("frozenset should convert to Set");
+        match &sendable {
+            SendableValue::Set(items) => {
+                assert_eq!(items.len(), 2);
+                let mut vals: Vec<i64> = items
+                    .iter()
+                    .map(|item| match item {
+                        SendableValue::Integer(n) => *n,
+                        other => panic!("expected Integer, got {other:?}"),
+                    })
+                    .collect();
+                vals.sort();
+                assert_eq!(vals, vec![10, 20]);
+            }
+            other => panic!("expected Set, got {other:?}"),
+        }
+        api.decref(py_fset);
+        api.decref(builtins);
+        api.decref(globals);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_empty_set() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        let globals = api.dict_new();
+        let builtins = api
+            .import_module("builtins")
+            .expect("builtins should import");
+        let key = api.string_from_str("__builtins__");
+        api.dict_set_item(globals, key, builtins);
+        api.decref(key);
+        let result = api.run_string("set()", 258, globals, globals);
+        let py_set = result.expect("empty set eval should succeed");
+        assert!(!py_set.is_null());
+
+        let sendable = python_to_sendable(py_set, api).expect("empty set should convert");
+        match &sendable {
+            SendableValue::Set(items) => assert!(items.is_empty()),
+            other => panic!("expected empty Set, got {other:?}"),
+        }
+        api.decref(py_set);
+        api.decref(builtins);
+        api.decref(globals);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_set_with_mixed_types() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        let globals = api.dict_new();
+        let builtins = api
+            .import_module("builtins")
+            .expect("builtins should import");
+        let key = api.string_from_str("__builtins__");
+        api.dict_set_item(globals, key, builtins);
+        api.decref(key);
+        let result = api.run_string("{42, 'hello', 3.14, True}", 258, globals, globals);
+        let py_set = result.expect("mixed set eval should succeed");
+        assert!(!py_set.is_null());
+
+        let sendable = python_to_sendable(py_set, api).expect("mixed set should convert");
+        match &sendable {
+            SendableValue::Set(items) => {
+                assert_eq!(items.len(), 4);
+                let has_int = items
+                    .iter()
+                    .any(|i| matches!(i, SendableValue::Integer(42)));
+                let has_str = items
+                    .iter()
+                    .any(|i| matches!(i, SendableValue::Str(s) if s == "hello"));
+                let has_float = items.iter().any(|i| matches!(i, SendableValue::Float(_)));
+                let has_bool = items.iter().any(|i| matches!(i, SendableValue::Bool(true)));
+                assert!(has_int, "set should contain integer 42");
+                assert!(has_str, "set should contain string 'hello'");
+                assert!(has_float, "set should contain float 3.14");
+                assert!(has_bool, "set should contain bool True");
+            }
+            other => panic!("expected Set, got {other:?}"),
+        }
+        api.decref(py_set);
+        api.decref(builtins);
+        api.decref(globals);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_set_with_strings() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        let globals = api.dict_new();
+        let builtins = api
+            .import_module("builtins")
+            .expect("builtins should import");
+        let key = api.string_from_str("__builtins__");
+        api.dict_set_item(globals, key, builtins);
+        api.decref(key);
+        let result = api.run_string("{'apple', 'banana', 'cherry'}", 258, globals, globals);
+        let py_set = result.expect("string set eval should succeed");
+        assert!(!py_set.is_null());
+
+        let sendable = python_to_sendable(py_set, api).expect("string set should convert");
+        match &sendable {
+            SendableValue::Set(items) => {
+                assert_eq!(items.len(), 3);
+                let mut vals: Vec<&str> = items
+                    .iter()
+                    .map(|item| match item {
+                        SendableValue::Str(s) => s.as_str(),
+                        other => panic!("expected Str, got {other:?}"),
+                    })
+                    .collect();
+                vals.sort();
+                assert_eq!(vals, vec!["apple", "banana", "cherry"]);
+            }
+            other => panic!("expected Set, got {other:?}"),
+        }
+        api.decref(py_set);
+        api.decref(builtins);
+        api.decref(globals);
+    }
+
+    // ========== python_to_sendable: callable ==========
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_user_defined_function() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        let globals = crate::eval::make_globals(api);
+        let py_func = api.run_string(
+            "def greet(name): return f'Hello {name}'\ngreet",
+            257, // Py_file_input for statements
+            globals.ptr(),
+            globals.ptr(),
+        );
+        // file_input returns None; retrieve the function from globals
+        drop(py_func);
+        let key = api.string_from_str("greet");
+        let func = api.dict_get_item(globals.ptr(), key);
+        api.decref(key);
+        assert!(!func.is_null(), "greet function should exist in globals");
+        assert!(api.callable_check(func) != 0, "greet should be callable");
+
+        let sendable = python_to_sendable(func, api)
+            .expect("user-defined function should convert via PyObjectRef");
+        match &sendable {
+            SendableValue::PyObjectRef(addr) => {
+                assert_eq!(*addr, func as usize);
+            }
+            other => panic!("expected PyObjectRef for function, got {other:?}"),
+        }
+        // Clean up: decref the incref from python_to_sendable
+        // dict_get_item returns a borrowed ref, so only the sendable's incref needs cleanup
+        api.decref(func);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_lambda() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        let globals = crate::eval::make_globals(api);
+        let py_lambda = api
+            .run_string("lambda x: x * 2", 258, globals.ptr(), globals.ptr())
+            .expect("lambda eval should succeed");
+        assert!(!py_lambda.is_null());
+        assert!(
+            api.callable_check(py_lambda) != 0,
+            "lambda should be callable"
+        );
+
+        let sendable =
+            python_to_sendable(py_lambda, api).expect("lambda should convert via PyObjectRef");
+        match &sendable {
+            SendableValue::PyObjectRef(addr) => {
+                assert_eq!(*addr, py_lambda as usize);
+            }
+            other => panic!("expected PyObjectRef for lambda, got {other:?}"),
+        }
+        api.decref(py_lambda); // sendable's incref
+        api.decref(py_lambda); // run_string's ref
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_builtin_function() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        let builtins = api
+            .import_module("builtins")
+            .expect("builtins should import");
+        let len_func = api.object_get_attr_string(builtins, "len");
+        assert!(!len_func.is_null(), "len should be accessible");
+        assert!(api.callable_check(len_func) != 0, "len should be callable");
+
+        let sendable = python_to_sendable(len_func, api)
+            .expect("builtin function should convert via PyObjectRef");
+        match &sendable {
+            SendableValue::PyObjectRef(addr) => {
+                assert_eq!(*addr, len_func as usize);
+            }
+            other => panic!("expected PyObjectRef for builtin function, got {other:?}"),
+        }
+        api.decref(len_func); // sendable's incref
+        api.decref(len_func); // get_attr_string ref
+        api.decref(builtins);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_class() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        let globals = crate::eval::make_globals(api);
+        // Define a class (classes are callable — calling them constructs instances)
+        let _ = api.run_string(
+            "class Greeter:\n    def __init__(self, name):\n        self.name = name",
+            257,
+            globals.ptr(),
+            globals.ptr(),
+        );
+        let key = api.string_from_str("Greeter");
+        let cls = api.dict_get_item(globals.ptr(), key);
+        api.decref(key);
+        assert!(!cls.is_null(), "Greeter class should exist in globals");
+        assert!(api.callable_check(cls) != 0, "classes should be callable");
+
+        let sendable = python_to_sendable(cls, api).expect("class should convert via PyObjectRef");
+        match &sendable {
+            SendableValue::PyObjectRef(addr) => {
+                assert_eq!(*addr, cls as usize);
+            }
+            other => panic!("expected PyObjectRef for class, got {other:?}"),
+        }
+        api.decref(cls); // sendable's incref
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_instance_with_call() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        let globals = crate::eval::make_globals(api);
+        // Create an instance with __call__
+        let py_obj = api
+            .run_string(
+                "type('Adder', (), {'__call__': lambda self, x, y: x + y})()",
+                258,
+                globals.ptr(),
+                globals.ptr(),
+            )
+            .expect("callable instance eval should succeed");
+        assert!(!py_obj.is_null());
+        assert!(
+            api.callable_check(py_obj) != 0,
+            "instance with __call__ should be callable"
+        );
+
+        let sendable = python_to_sendable(py_obj, api)
+            .expect("callable instance should convert via PyObjectRef");
+        match &sendable {
+            SendableValue::PyObjectRef(addr) => {
+                assert_eq!(*addr, py_obj as usize);
+            }
+            other => panic!("expected PyObjectRef for callable instance, got {other:?}"),
+        }
+        api.decref(py_obj); // sendable's incref
+        api.decref(py_obj); // run_string ref
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_callable_is_callable_check() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        let globals = crate::eval::make_globals(api);
+        let py_lambda = api
+            .run_string("lambda: 42", 258, globals.ptr(), globals.ptr())
+            .expect("lambda eval should succeed");
+
+        let sendable = python_to_sendable(py_lambda, api).expect("lambda should convert");
+        match &sendable {
+            SendableValue::PyObjectRef(addr) => {
+                // Verify the wrapped object is still callable
+                let ptr = *addr as *mut PyObject;
+                assert!(
+                    api.callable_check(ptr) != 0,
+                    "wrapped callable should still report callable"
+                );
+            }
+            other => panic!("expected PyObjectRef, got {other:?}"),
+        }
+        api.decref(py_lambda);
+        api.decref(py_lambda);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_callable_method() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+        // Get a bound method: "hello".upper
+        let globals = crate::eval::make_globals(api);
+        let py_method = api
+            .run_string("'hello'.upper", 258, globals.ptr(), globals.ptr())
+            .expect("bound method eval should succeed");
+        assert!(!py_method.is_null());
+        assert!(
+            api.callable_check(py_method) != 0,
+            "bound method should be callable"
+        );
+
+        let sendable = python_to_sendable(py_method, api)
+            .expect("bound method should convert via PyObjectRef");
+        assert!(
+            matches!(sendable, SendableValue::PyObjectRef(_)),
+            "bound method should be PyObjectRef"
+        );
+        api.decref(py_method); // sendable's incref
+        api.decref(py_method); // run_string ref
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_primitives_not_py_object_ref() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+
         // int → Integer, not PyObjectRef
         let py_int = api.long_from_i64(42);
         assert!(matches!(
@@ -2016,4 +2796,291 @@ mod tests {
             Ok(SendableValue::Nil)
         ));
     }
+
+    // ========== python_to_sendable: bytes/bytearray ==========
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_bytes() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+
+        let py_bytes = api.bytes_from_slice(b"hello");
+        let result = python_to_sendable(py_bytes, api);
+        assert!(
+            matches!(&result, Ok(SendableValue::Bytes(v)) if v == b"hello"),
+            "Python bytes should convert to SendableValue::Bytes, got: {:?}",
+            result
+        );
+        api.decref(py_bytes);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_bytes_empty() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+
+        let py_bytes = api.bytes_from_slice(b"");
+        let result = python_to_sendable(py_bytes, api);
+        assert!(
+            matches!(&result, Ok(SendableValue::Bytes(v)) if v.is_empty()),
+            "Empty Python bytes should convert to empty Bytes, got: {:?}",
+            result
+        );
+        api.decref(py_bytes);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_bytes_with_nulls() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+
+        let data: &[u8] = b"\x00\x01\xff\x00\xfe";
+        let py_bytes = api.bytes_from_slice(data);
+        let result = python_to_sendable(py_bytes, api);
+        assert!(
+            matches!(&result, Ok(SendableValue::Bytes(v)) if v.as_slice() == data),
+            "Bytes with NULs should roundtrip, got: {:?}",
+            result
+        );
+        api.decref(py_bytes);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_bytearray() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+
+        let py_ba = api.bytearray_from_slice(b"world");
+        let result = python_to_sendable(py_ba, api);
+        assert!(
+            matches!(&result, Ok(SendableValue::Bytes(v)) if v == b"world"),
+            "Python bytearray should convert to SendableValue::Bytes, got: {:?}",
+            result
+        );
+        api.decref(py_ba);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_bytearray_empty() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+
+        let py_ba = api.bytearray_from_slice(b"");
+        let result = python_to_sendable(py_ba, api);
+        assert!(
+            matches!(&result, Ok(SendableValue::Bytes(v)) if v.is_empty()),
+            "Empty bytearray should convert to empty Bytes, got: {:?}",
+            result
+        );
+        api.decref(py_ba);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_bytes_not_string() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+
+        // Python bytes must not produce SendableValue::Str
+        let py_bytes = api.bytes_from_slice(b"hello");
+        let result = python_to_sendable(py_bytes, api);
+        assert!(
+            !matches!(&result, Ok(SendableValue::Str(_))),
+            "Python bytes must not become Str"
+        );
+        assert!(
+            !matches!(&result, Ok(SendableValue::PyObjectRef(_))),
+            "Python bytes must not fall through to PyObjectRef"
+        );
+        api.decref(py_bytes);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_bytes_in_list() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+
+        // [b"hello", 42, b"\x00\xff"]
+        let py_list = api.list_new(3);
+        api.list_set_item(py_list, 0, api.bytes_from_slice(b"hello"));
+        api.list_set_item(py_list, 1, api.long_from_i64(42));
+        api.list_set_item(py_list, 2, api.bytes_from_slice(b"\x00\xff"));
+
+        let result = python_to_sendable(py_list, api).expect("list with bytes should convert");
+        if let SendableValue::List(items) = result {
+            assert_eq!(items.len(), 3);
+            assert!(matches!(&items[0], SendableValue::Bytes(v) if v == b"hello"));
+            assert!(matches!(&items[1], SendableValue::Integer(42)));
+            assert!(matches!(&items[2], SendableValue::Bytes(v) if v == b"\x00\xff"));
+        } else {
+            panic!("Expected List, got: {:?}", result);
+        }
+        api.decref(py_list);
+    }
+
+    #[test]
+    #[serial]
+    fn test_python_to_sendable_bytes_as_dict_value() {
+        use crate::test_helpers::skip_if_no_python;
+        let Some(guard) = skip_if_no_python() else {
+            return;
+        };
+        let api = guard.api();
+
+        let py_dict = api.dict_new();
+        let key = api.string_from_str("data");
+        let val = api.bytes_from_slice(b"\xde\xad\xbe\xef");
+        api.dict_set_item(py_dict, key, val);
+        api.decref(key);
+        api.decref(val);
+
+        let result =
+            python_to_sendable(py_dict, api).expect("dict with bytes value should convert");
+        if let SendableValue::Dict(entries) = result {
+            assert_eq!(entries.len(), 1);
+            assert!(matches!(&entries[0].0, SendableValue::Str(s) if s == "data"));
+            assert!(matches!(&entries[0].1, SendableValue::Bytes(v) if v == b"\xde\xad\xbe\xef"));
+        } else {
+            panic!("Expected Dict, got: {:?}", result);
+        }
+        api.decref(py_dict);
+    }
+
+    // ========== ruby_to_python: ASCII-8BIT String → Python bytes ==========
+
+    #[test]
+    #[serial]
+    fn test_ruby_to_python_ascii_8bit_string_becomes_bytes() {
+        with_ruby_python(|ruby, api| {
+            let s = ruby.str_from_slice(b"hello");
+            s.enc_associate(
+                ruby.find_encoding("ASCII-8BIT")
+                    .expect("ASCII-8BIT must exist"),
+            )
+            .unwrap();
+
+            let py_obj = ruby_to_python(s.as_value(), api)
+                .expect("ASCII-8BIT string conversion should succeed");
+
+            assert!(api.bytes_check(py_obj), "Should produce Python bytes");
+            assert!(!api.is_string(py_obj), "Should NOT produce Python str");
+
+            let back = api.bytes_to_vec(py_obj).unwrap();
+            assert_eq!(back, b"hello");
+            api.decref(py_obj);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_ruby_to_python_ascii_8bit_empty() {
+        with_ruby_python(|ruby, api| {
+            let s = ruby.str_from_slice(b"");
+            s.enc_associate(
+                ruby.find_encoding("ASCII-8BIT")
+                    .expect("ASCII-8BIT must exist"),
+            )
+            .unwrap();
+
+            let py_obj =
+                ruby_to_python(s.as_value(), api).expect("empty ASCII-8BIT should convert");
+
+            assert!(api.bytes_check(py_obj));
+            let back = api.bytes_to_vec(py_obj).unwrap();
+            assert!(back.is_empty());
+            api.decref(py_obj);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_ruby_to_python_ascii_8bit_with_nulls() {
+        with_ruby_python(|ruby, api| {
+            let data: &[u8] = b"\x00\x01\x02\xff\xfe\x00";
+            let s = ruby.str_from_slice(data);
+            s.enc_associate(
+                ruby.find_encoding("ASCII-8BIT")
+                    .expect("ASCII-8BIT must exist"),
+            )
+            .unwrap();
+
+            let py_obj =
+                ruby_to_python(s.as_value(), api).expect("binary data with NULs should convert");
+
+            assert!(api.bytes_check(py_obj));
+            let back = api.bytes_to_vec(py_obj).unwrap();
+            assert_eq!(back, data);
+            api.decref(py_obj);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_ruby_to_python_utf8_string_stays_str() {
+        with_ruby_python(|ruby, api| {
+            // Regular UTF-8 string must still become Python str, not bytes
+            let py_str = ruby_to_python("hello".into_value_with(ruby), api)
+                .expect("UTF-8 string should convert");
+
+            assert!(api.is_string(py_str), "UTF-8 should produce Python str");
+            assert!(!api.bytes_check(py_str), "UTF-8 should NOT produce bytes");
+            assert_eq!(api.string_to_string(py_str), Some("hello".to_string()));
+            api.decref(py_str);
+        });
+    }
+
+    #[test]
+    #[serial]
+    fn test_ruby_to_python_ascii_8bit_roundtrip_via_sendable() {
+        with_ruby_python(|ruby, api| {
+            // Ruby ASCII-8BIT String → Python bytes → SendableValue::Bytes
+            let data: &[u8] = b"\xca\xfe\xba\xbe";
+            let s = ruby.str_from_slice(data);
+            s.enc_associate(
+                ruby.find_encoding("ASCII-8BIT")
+                    .expect("ASCII-8BIT must exist"),
+            )
+            .unwrap();
+
+            // Ruby → Python
+            let py_obj = ruby_to_python(s.as_value(), api).expect("should convert to Python");
+            assert!(api.bytes_check(py_obj));
+
+            // Python → SendableValue
+            let sendable = python_to_sendable(py_obj, api).expect("should convert to sendable");
+            assert!(
+                matches!(&sendable, SendableValue::Bytes(v) if v == data),
+                "Full roundtrip should preserve bytes, got: {:?}",
+                sendable
+            );
+            api.decref(py_obj);
+        });
+    }
 }