pycall 1.5.1 → 1.5.3

data/ext/pycall/pycall.c

@@ -29,7 +29,6 @@ static int python_major_version;
 static int python_has_stackless_extension;
 static PyObject *python_builtins_module;
 static VALUE python_type_mapping;
-static VALUE python_type_mapping;
 static ID id_python_type_mapping;
 
 int
@@ -122,6 +121,58 @@ pycall_m_without_gvl(VALUE mod)
 
 /* ==== PyCall::PyPtr ==== */
 
+struct pending_decref_list {
+  rb_nativethread_lock_t lock;
+  PyObject **pyptrs;
+  size_t count;
+  size_t capacity;
+};
+
+static struct pending_decref_list pending_decrefs;
+
+static void
+pycall_pending_decref_add(PyObject *pyobj)
+{
+  rb_nativethread_lock_lock(&pending_decrefs.lock);
+  if (pending_decrefs.count == pending_decrefs.capacity) {
+    size_t new_capacity = pending_decrefs.capacity ? 2 * pending_decrefs.capacity : 64;
+    /* Not ruby_xrealloc: this function runs during GC, where xmalloc/xrealloc
+     * are prohibited (rb_bug "Cannot realloc during GC" since Ruby 3.3). */
+    PyObject **new_pyptrs = realloc(pending_decrefs.pyptrs, new_capacity * sizeof(PyObject *));
+    if (new_pyptrs == NULL) {
+      /* Leaking the object is preferable to blocking or crashing inside GC */
+      rb_nativethread_lock_unlock(&pending_decrefs.lock);
+      return;
+    }
+    pending_decrefs.pyptrs = new_pyptrs;
+    pending_decrefs.capacity = new_capacity;
+  }
+  pending_decrefs.pyptrs[pending_decrefs.count++] = pyobj;
+  rb_nativethread_lock_unlock(&pending_decrefs.lock);
+}
+
+static void
+pycall_drain_pending_decrefs(void)
+{
+  PyObject **pyptrs;
+  size_t i, count;
+
+  if (pending_decrefs.count == 0) return;
+
+  rb_nativethread_lock_lock(&pending_decrefs.lock);
+  pyptrs = pending_decrefs.pyptrs;
+  count = pending_decrefs.count;
+  pending_decrefs.pyptrs = NULL;
+  pending_decrefs.count = 0;
+  pending_decrefs.capacity = 0;
+  rb_nativethread_lock_unlock(&pending_decrefs.lock);
+
+  for (i = 0; i < count; ++i) {
+    pycall_Py_DecRef(pyptrs[i]);
+  }
+  free(pyptrs);
+}
+
 const rb_data_type_t pycall_pyptr_data_type = {
   "PyCall::PyPtr",
   { 0, pycall_pyptr_free, pycall_pyptr_memsize, },
@@ -130,6 +181,11 @@ const rb_data_type_t pycall_pyptr_data_type = {
 #endif
 };
 
+/* pycall_pyptr_free may be called by the GC sweeper on a thread that does
+ * not hold the GIL.  PyCall keeps the GIL held by the thread that
+ * initialized Python for the entire lifetime of the process, so waiting
+ * for the GIL there (PyGILState_Ensure) blocks forever while the sweeper
+ * holds the GVL, freezing every Ruby thread in the process. */
 void
 pycall_pyptr_free(void *ptr)
 {
@@ -139,7 +195,15 @@ pycall_pyptr_free(void *ptr)
     fprintf(stderr, "zero refcnt object %p of type %s\n", pyobj, Py_TYPE(pyobj)->tp_name);
   }
 #endif /* PYCALL_DEBUG_DUMP_REFCNT */
-  pycall_Py_DecRef(pyobj);
+
+  if (Py_API(PyGILState_Check())) {
+    pycall_Py_DecRef(pyobj);
+  }
+  else {
+    /* Instead of taking the GIL here, enqueue the pointer; the list is
+     * drained on the next Python call. */
+    pycall_pending_decref_add(pyobj);
+  }
 }
 
 static size_t _PySys_GetSizeOf(PyObject *);
@@ -620,6 +684,8 @@ pycall_libpython_api_PyObject_Dir(VALUE mod, VALUE pyptr)
   PyObject *dir;
   PyObject *pyobj;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -639,6 +705,8 @@ pycall_libpython_api_PyList_Size(VALUE mod, VALUE pyptr)
   PyObject *pyobj;
   Py_ssize_t size;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -659,6 +727,8 @@ pycall_libpython_api_PyList_GetItem(VALUE mod, VALUE pyptr, VALUE idx)
   PyObject *pyobj_item;
   Py_ssize_t i;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -724,6 +794,8 @@ pycall_libpython_helpers_m_import_module(int argc, VALUE *argv, VALUE mod)
   VALUE name, globals, locals, fromlist, level;
   char const *name_cstr;
 
+  pycall_drain_pending_decrefs();
+
   rb_scan_args(argc, argv, "14", &name, &globals, &locals, &fromlist, &level);
 
   if (RB_TYPE_P(name, T_SYMBOL)) {
@@ -776,6 +848,8 @@ pycall_libpython_helpers_m_compare(VALUE mod, VALUE op, VALUE pyptr_a, VALUE pyp
   PyObject *pyobj_a, *pyobj_b, *res;
   int opid;
 
+  pycall_drain_pending_decrefs();
+
   opid = pycall_rich_compare_opid(op);
 
   if (!is_pycall_pyptr(pyptr_a)) {
@@ -830,6 +904,8 @@ pycall_libpython_helpers_m_getattr(int argc, VALUE *argv, VALUE mod)
 {
   VALUE pyptr, name, default_value;
 
+  pycall_drain_pending_decrefs();
+
   if (rb_scan_args(argc, argv, "21", &pyptr, &name, &default_value) == 2) {
     default_value = Qundef;
   }
@@ -851,6 +927,8 @@ pycall_libpython_helpers_m_hasattr_p(VALUE mod, VALUE pyptr, VALUE name)
   PyObject *pyobj;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -870,6 +948,8 @@ pycall_libpython_helpers_m_setattr(VALUE mod, VALUE pyptr, VALUE name, VALUE val
 {
   PyObject *pyobj, *pyval;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -893,6 +973,8 @@ pycall_libpython_helpers_m_delattr(VALUE mod, VALUE pyptr, VALUE name)
 {
   PyObject *pyobj;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -916,6 +998,8 @@ pycall_libpython_helpers_m_callable_p(VALUE mod, VALUE pyptr)
   PyObject *pyobj;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -932,6 +1016,8 @@ pycall_libpython_helpers_m_call_object(int argc, VALUE *argv, VALUE mod)
   VALUE pyptr;
   PyObject *pyobj;
 
+  pycall_drain_pending_decrefs();
+
   if (argc < 1) {
     rb_raise(rb_eArgError, "too few arguments (%d for >=1)", argc);
   }
@@ -1081,6 +1167,8 @@ pycall_pyobject_wrapper_wrapper_method(int argc, VALUE *argv, VALUE wrapper)
   char *name_cstr;
   PyObject *pyobj, *attr;
 
+  pycall_drain_pending_decrefs();
+
   pyptr = rb_attr_get(wrapper, rb_intern("@__pyptr__"));
   if (NIL_P(pyptr) || !is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "Wrong wrapper object is given");
@@ -1136,6 +1224,8 @@ pycall_libpython_helpers_m_define_wrapper_method(VALUE mod, VALUE wrapper, VALUE
   PyObject *pyobj, *attr;
   char *name_cstr;
 
+  pycall_drain_pending_decrefs();
+
   pyptr = rb_attr_get(wrapper, rb_intern("@__pyptr__"));
   if (NIL_P(pyptr) || !is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "Wrong wrapper object is given");
@@ -1183,10 +1273,10 @@ pycall_convert_index(VALUE index)
     }
   }
   else if (rb_obj_is_kind_of(index, rb_cRange)) {
-    pyobj = pycall_pyslice_from_ruby(index); /* New refrence */
+    pyobj = pycall_pyslice_from_ruby(index); /* New reference */
   }
   else if (pycall_obj_is_step_range(index)) {
-    pyobj = pycall_pyslice_from_ruby(index); /* New refrence */
+    pyobj = pycall_pyslice_from_ruby(index); /* New reference */
   }
   else {
     pyobj = pycall_pyobject_from_ruby(index); /* New reference */
@@ -1201,6 +1291,8 @@ pycall_libpython_helpers_m_getitem(VALUE mod, VALUE pyptr, VALUE key)
   PyObject *pyobj, *pyobj_key, *pyobj_v;
   VALUE obj;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -1226,6 +1318,8 @@ pycall_libpython_helpers_m_setitem(VALUE mod, VALUE pyptr, VALUE key, VALUE v)
   PyObject *pyobj, *pyobj_key, *pyobj_value;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, NULL);
   pyobj_key = pycall_convert_index(key);
   pyobj_value = pycall_pyobject_from_ruby(v);
@@ -1246,6 +1340,8 @@ pycall_libpython_helpers_m_delitem(VALUE mod, VALUE pyptr, VALUE key)
   PyObject *pyobj, *pyobj_key;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, NULL);
   pyobj_key = pycall_convert_index(key);
 
@@ -1263,6 +1359,8 @@ pycall_libpython_helpers_m_str(VALUE mod, VALUE pyptr)
 {
   PyObject *pyobj, *pyobj_str;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, NULL);
 
   pyobj_str = Py_API(PyObject_Str)(pyobj);
@@ -1270,7 +1368,9 @@ pycall_libpython_helpers_m_str(VALUE mod, VALUE pyptr)
     pycall_pyerror_fetch_and_raise("PyObject_Str");
   }
 
-  return pycall_pyobject_to_ruby(pyobj_str);
+  VALUE v = pycall_pyobject_to_ruby(pyobj_str);
+  pycall_Py_DecRef(pyobj_str);
+  return v;
 }
 
 static VALUE
@@ -1279,6 +1379,8 @@ pycall_libpython_helpers_m_dict_contains(VALUE mod, VALUE pyptr, VALUE key)
   PyObject *pyobj, *pyobj_key;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, Py_API(PyDict_Type));
   pyobj_key = pycall_pyobject_from_ruby(key);
   res = Py_API(PyDict_Contains)(pyobj, pyobj_key);
@@ -1296,6 +1398,8 @@ pycall_libpython_helpers_m_dict_each(VALUE mod, VALUE pyptr)
   PyObject *pyobj, *pyobj_key, *pyobj_value;
   Py_ssize_t pos;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, Py_API(PyDict_Type));
 
   pos = 0;
@@ -1315,6 +1419,8 @@ pycall_libpython_helpers_m_sequence_contains(VALUE mod, VALUE pyptr, VALUE key)
   PyObject *pyobj, *pyobj_key;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, NULL);
   if (!Py_API(PySequence_Check)(pyobj))
     rb_raise(rb_eTypeError, "unexpected Python type %s (expected a Python sequence object)", Py_TYPE(pyobj)->tp_name);
@@ -1334,6 +1440,8 @@ pycall_libpython_helpers_m_sequence_each(VALUE mod, VALUE pyptr)
 {
   PyObject *pyobj, *pyobj_iter, *pyobj_item;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, NULL);
   if (!Py_API(PySequence_Check)(pyobj))
     rb_raise(rb_eTypeError, "unexpected Python type %s (expected a Python sequence object)", Py_TYPE(pyobj)->tp_name);
@@ -1518,7 +1626,7 @@ pycall_pyobject_to_ruby(PyObject *pyobj)
   Py_API(Py_IncRef)((PyObject *)pyobj->ob_type);
   cls = pycall_python_type_mapping_get_mapped_class(pycall_pytypeptr_new((PyObject *)pyobj->ob_type));
   if (NIL_P(cls)) {
-    rb_warning("Currentry do not support to convert %s to Ruby object", Py_TYPE(pyobj)->tp_name);
+    rb_warning("Currently do not support to convert %s to Ruby object", Py_TYPE(pyobj)->tp_name);
     return pycall_pyobject_wrapper_object_new(rb_cObject, pyobj);
   }
 
@@ -1653,7 +1761,7 @@ pycall_pylong_to_ruby(PyObject *pyobj)
   }
 #endif
 
-  rb_warning("Currentry do not support to convert multi-precision PyLong number to Ruby object");
+  rb_warning("Currently do not support to convert multi-precision PyLong number to Ruby object");
 
   return Qnil;
 }
@@ -1690,19 +1798,21 @@ pycall_pyunicode_to_ruby(PyObject *pyobj)
     return Qnil;
   }
 
-  pyobj = Py_API(PyUnicode_AsUTF8String)(pyobj);
-  if (!pyobj) {
+  PyObject *pyobj_uni = Py_API(PyUnicode_AsUTF8String)(pyobj);
+  if (!pyobj_uni) {
     Py_API(PyErr_Clear)();
     return Qnil;
   }
 
-  res = Py_API(PyString_AsStringAndSize)(pyobj, &str, &len);
+  res = Py_API(PyString_AsStringAndSize)(pyobj_uni, &str, &len);
   if (res < 0) {
-    pycall_Py_DecRef(pyobj);
+    pycall_Py_DecRef(pyobj_uni);
     return Qnil;
   }
 
-  return rb_enc_str_new(str, len, rb_enc_from_index(rb_utf8_encindex()));
+  VALUE v = rb_enc_str_new(str, len, rb_enc_from_index(rb_utf8_encindex()));
+  pycall_Py_DecRef(pyobj_uni);
+  return v;
 }
 
 static VALUE
@@ -1775,7 +1885,11 @@ pycall_conv_m_unregister_python_type_mapping(VALUE mod, VALUE pytypeptr)
 static VALUE
 pycall_conv_m_from_ruby(VALUE mod, VALUE obj)
 {
-  PyObject *pyobj = pycall_pyobject_from_ruby(obj);
+  PyObject *pyobj;
+
+  pycall_drain_pending_decrefs();
+
+  pyobj = pycall_pyobject_from_ruby(obj);
   if (PyType_Check(pyobj) || PyClass_Check(pyobj))
     return pycall_pytypeptr_new(pyobj);
   if (PyRuby_Check(pyobj))
@@ -1787,7 +1901,11 @@ static VALUE
 pycall_conv_m_to_ruby(VALUE mod, VALUE pyptr)
 {
   VALUE obj, obj_pyptr;
-  PyObject *pyobj = check_get_pyobj_ptr(pyptr, NULL);
+  PyObject *pyobj;
+
+  pycall_drain_pending_decrefs();
+
+  pyobj = check_get_pyobj_ptr(pyptr, NULL);
   obj = obj_pyptr = pycall_pyobject_to_ruby(pyobj);
   if (is_pyobject_wrapper(obj)) {
     obj_pyptr = pycall_pyobject_wrapper_get_pyptr(obj);
@@ -2309,6 +2427,8 @@ Init_pycall(void)
   pycall_tls_create((pycall_tls_key *)&without_gvl_key);
   rb_define_module_function(mPyCall, "without_gvl", pycall_m_without_gvl, 0);
 
+  rb_nativethread_lock_initialize(&pending_decrefs.lock);
+
   /* PyCall::PyPtr */
 
   cPyPtr = rb_define_class_under(mPyCall, "PyPtr", rb_cBasicObject);

data/ext/pycall/pycall_internal.h

@@ -11,6 +11,7 @@ extern "C" {
 #include <ruby.h>
 #include <ruby/encoding.h>
 #include <ruby/thread.h>
+#include <ruby/thread_native.h>
 
 #include <assert.h>
 #include <inttypes.h>
@@ -71,7 +72,7 @@ typedef intptr_t Py_intptr_t;
 #ifdef HAVE_SSIZE_T
 typedef ssize_t Py_ssize_t;
 #elif SIZEOF_SIZE_T == SIZEOF_VOIDP
-typedef Py_intptr_tr Py_ssize_t;
+typedef Py_intptr_t Py_ssize_t;
 #elif SIZEOF_SIZE_T == SIZEOF_INT
 typedef int Py_ssize_t;
 #elif SIZEOF_SIZE_T == SIZEOF_LONG
@@ -519,6 +520,11 @@ PyObject * PyRuby_New(VALUE ruby_object);
 
 /* ==== thread support ==== */
 
+typedef enum {
+  PyGILState_LOCKED,
+  PyGILState_UNLOCKED
+} PyGILState_STATE;
+
 #if   defined(PYCALL_THREAD_WIN32)
 typedef DWORD pycall_tls_key;
 #elif defined(PYCALL_THREAD_PTHREAD)
@@ -669,6 +675,10 @@ typedef struct {
   PyObject * (* PyUnicode_AsUTF8String)(PyObject *);
   PyObject * (* PyUnicode_DecodeUTF8)(char const*, Py_ssize_t, char const *);
   PyObject * (* PyUnicode_FromFormatV)(char const*, ...);
+
+  int (* PyGILState_Check)(void);
+  PyGILState_STATE (* PyGILState_Ensure)(void);
+  void (* PyGILState_Release)(PyGILState_STATE);
 } pycall_libpython_api_table_t;
 
 pycall_libpython_api_table_t *pycall_libpython_api_table(void);

data/ext/pycall/range.c

@@ -6,6 +6,12 @@ struct enumerator_head {
     VALUE args;
 };
 
+#ifdef HAVE_RTYPEDDATA_GET_DATA
+# define GET_ENUMERATOR_DATA(obj) ((struct enumerator_head *)RTYPEDDATA_GET_DATA(obj))
+#else
+# define GET_ENUMERATOR_DATA(obj) ((struct enumerator_head *)DATA_PTR(obj))
+#endif
+
 int
 pycall_obj_is_step_range(VALUE obj)
 {
@@ -19,7 +25,7 @@ pycall_obj_is_step_range(VALUE obj)
     return 0;
   }
 
-  eh = (struct enumerator_head *)DATA_PTR(obj);
+  eh = GET_ENUMERATOR_DATA(obj);
 
   if (!rb_obj_is_kind_of(eh->obj, rb_cRange)) {
     return 0;
@@ -50,7 +56,7 @@ pycall_extract_range(VALUE obj, VALUE *pbegin, VALUE *pend, int *pexclude_end, V
     exclude_end = rb_funcallv(obj, id_exclude_end, 0, 0);
   }
   else if (pycall_obj_is_step_range(obj)) {
-    struct enumerator_head *eh = (struct enumerator_head *)DATA_PTR(obj);
+    struct enumerator_head *eh = GET_ENUMERATOR_DATA(obj);
     begin = rb_funcallv(eh->obj, id_begin, 0, 0);
     end   = rb_funcallv(eh->obj, id_end,   0, 0);
     exclude_end = rb_funcallv(eh->obj, id_exclude_end, 0, 0);

data/ext/pycall/ruby_wrapper.c

@@ -6,7 +6,6 @@ static PyMemberDef PyRuby_members[] = {
   {NULL} /* sentinel */
 };
 
-static VALUE PyRuby_get_ruby_object_and_set_pyerr(PyObject *pyobj);
 static void PyRuby_dealloc_with_gvl(PyRubyObject *);
 static PyObject * PyRuby_repr_with_gvl(PyRubyObject *);
 static PyObject * PyRuby_call_with_gvl(PyRubyObject *, PyObject *, PyObject *);
@@ -59,10 +58,11 @@ PyObject *
 PyRuby_New(VALUE ruby_object)
 {
   if (!ruby_thread_has_gvl_p()) {
-    CALL_WITH_GVL(PyRuby_New_impl, ruby_object);
+    return CALL_WITH_GVL(PyRuby_New_impl, ruby_object);
+  }
+  else {
+    return PyRuby_New_impl(ruby_object);
   }
-
-  return PyRuby_New_impl(ruby_object);
 }
 
 static void *
@@ -90,7 +90,9 @@ PyRuby_dealloc_with_gvl(PyRubyObject *pyro)
   if (!ruby_thread_has_gvl_p()) {
     CALL_WITH_GVL(PyRuby_dealloc, pyro);
   }
-  PyRuby_dealloc(pyro);
+  else {
+    PyRuby_dealloc(pyro);
+  }
 }
 
 static PyObject *
@@ -99,9 +101,7 @@ PyRuby_repr(PyRubyObject *pyro)
   VALUE obj, str;
   PyObject *res;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)pyro);
-  if (obj == Qundef)
-    return NULL;
+  obj = PyRuby_get_ruby_object((PyObject *)pyro);
 
   str = rb_inspect(obj);
   res = pycall_pystring_from_format("<PyCall.ruby_object %s>", StringValueCStr(str));
@@ -114,7 +114,9 @@ PyRuby_repr_with_gvl(PyRubyObject *pyro)
   if (!ruby_thread_has_gvl_p()) {
     return CALL_WITH_GVL(PyRuby_repr, pyro);
   }
-  return PyRuby_repr(pyro);
+  else {
+    return PyRuby_repr(pyro);
+  }
 }
 
 #if SIZEOF_SSIZE_T < 8
@@ -138,9 +140,7 @@ PyRuby_hash_long(PyRubyObject *pyro)
   VALUE obj, rbhash;
   intptr_t h;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)pyro);
-  if (obj == Qundef)
-    return (void *)-1;
+  obj = PyRuby_get_ruby_object((PyObject *)pyro);
 
   rbhash = rb_hash(obj);
   h = FIX2LONG(rbhash); /* Ruby's hash value is a Fixnum */
@@ -154,7 +154,9 @@ PyRuby_hash_long_with_gvl(PyRubyObject *pyro)
   if (!ruby_thread_has_gvl_p()) {
     return (long)(intptr_t)CALL_WITH_GVL(PyRuby_hash_long, pyro);
   }
-  return (long)(intptr_t)PyRuby_hash_long(pyro);
+  else {
+    return (long)(intptr_t)PyRuby_hash_long(pyro);
+  }
 }
 
 static void *
@@ -163,9 +165,7 @@ PyRuby_hash_hash_t(PyRubyObject *pyro)
   VALUE obj, rbhash;
   Py_hash_t h;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)pyro);
-  if (obj == Qundef)
-    return (void *)-1;
+  obj = PyRuby_get_ruby_object((PyObject *)pyro);
 
   rbhash = rb_hash(obj);
 #if SIZEOF_PY_HASH_T == SIZEOF_LONG
@@ -185,7 +185,9 @@ PyRuby_hash_hash_t_with_gvl(PyRubyObject *pyro)
   if (!ruby_thread_has_gvl_p()) {
     return (Py_hash_t)CALL_WITH_GVL(PyRuby_hash_hash_t, pyro);
   }
-  return (Py_hash_t)PyRuby_hash_hash_t(pyro);
+  else {
+    return (Py_hash_t)PyRuby_hash_hash_t(pyro);
+  }
 }
 
 struct call_rb_funcallv_params {
@@ -233,9 +235,7 @@ PyRuby_call(struct PyRuby_call_params *params)
   PyObject *pyobj_res;
   int state;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)params->pyro);
-  if (obj == Qundef)
-    return NULL;
+  obj = PyRuby_get_ruby_object((PyObject *)params->pyro);
 
   id_call = rb_intern("call");
   if (!rb_respond_to(obj, id_call)) {
@@ -269,8 +269,9 @@ PyRuby_call_with_gvl(PyRubyObject *pyro, PyObject *pyobj_args, PyObject *pyobj_k
   if (!ruby_thread_has_gvl_p()) {
     return CALL_WITH_GVL(PyRuby_call, &params);
   }
-
-  return PyRuby_call(&params);
+  else {
+    return PyRuby_call(&params);
+  }
 }
 
 struct PyRuby_getattro_params {
@@ -286,9 +287,7 @@ PyRuby_getattro(struct PyRuby_getattro_params *params)
   ID name_id;
   PyObject *pyobj_res;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)params->pyro);
-  if (obj == Qundef)
-    return NULL;
+  obj = PyRuby_get_ruby_object((PyObject *)params->pyro);
 
   name = pycall_pyobject_to_ruby(params->pyobj_name);
   name_cstr = StringValueCStr(name);
@@ -348,8 +347,9 @@ PyRuby_getattro_with_gvl(PyRubyObject *pyro, PyObject *pyobj_name)
   if (!ruby_thread_has_gvl_p()) {
     return CALL_WITH_GVL(PyRuby_getattro, &params);
   }
-
-  return PyRuby_getattro(&params);
+  else {
+    return PyRuby_getattro(&params);
+  }
 }
 
 /* ==== PyCall::PyRubyPtr ==== */
@@ -478,56 +478,3 @@ pycall_init_ruby_wrapper(void)
   rb_define_module_function(mPyCall, "wrap_ruby_object", pycall_m_wrap_ruby_object, 1);
 }
 
-/* --- File internal utilities --- */
-
-static VALUE
-funcall_id2ref(VALUE object_id)
-{
-  VALUE rb_mObjSpace;
-  object_id = rb_check_to_integer(object_id, "to_int");
-  rb_mObjSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
-  return rb_funcall(rb_mObjSpace, rb_intern("_id2ref"), 1, object_id);
-}
-
-static VALUE
-protect_id2ref(VALUE object_id)
-{
-  VALUE obj;
-  int state;
-
-  obj = rb_protect((VALUE (*)(VALUE))funcall_id2ref, object_id, &state);
-  if (state)
-    return Qundef;
-
-  return obj;
-}
-
-static VALUE
-protect_id2ref_and_set_pyerr(VALUE object_id)
-{
-  VALUE obj = protect_id2ref(object_id);
-  if (obj != Qundef)
-    return obj;
-
-  obj = rb_errinfo();
-  if (RTEST(rb_obj_is_kind_of(obj, rb_eRangeError))) {
-    Py_API(PyErr_SetString)(Py_API(PyExc_RuntimeError), "[BUG] referenced object was garbage-collected");
-  }
-  else {
-    VALUE emesg = rb_check_funcall(obj, rb_intern("message"), 0, 0);
-    Py_API(PyErr_Format)(Py_API(PyExc_RuntimeError),
-        "[BUG] Unable to obtain ruby object from ID: %s (%s)",
-        StringValueCStr(emesg), rb_class2name(CLASS_OF(obj)));
-  }
-  return Qundef;
-}
-
-static VALUE
-PyRuby_get_ruby_object_and_set_pyerr(PyObject *pyobj)
-{
-  VALUE obj_id;
-  if (!PyRuby_Check(pyobj))
-    return Qundef;
-  obj_id = rb_obj_id(PyRuby_get_ruby_object(pyobj));
-  return protect_id2ref_and_set_pyerr(obj_id);
-}

data/lib/pycall/libpython/pytypeobject_struct.rb

@@ -231,7 +231,7 @@ module PyCall
         else
           name, basic_size = *args
           new.tap do |t|
-            # NOTE: Disable autorelease for avoiding SEGV occurrance in Python's GC collect function
+            # NOTE: Disable autorelease for avoiding SEGV occurrence in Python's GC collect function
             #       at which the __new__ method object of this type object is freed.
             t.pointer.autorelease = false
 

data/lib/pycall/pyobject_wrapper.rb

@@ -33,8 +33,6 @@ module PyCall
     }.freeze
 
     def method_missing(name, *args)
-      name_str = name.to_s if name.kind_of?(Symbol)
-      name_str.chop! if name_str.end_with?('=')
       case name
       when *OPERATOR_METHOD_NAMES.keys
         op_name = OPERATOR_METHOD_NAMES[name]
@@ -44,7 +42,8 @@ module PyCall
           return self.__send__(name, *args)
         end
       else
-        if LibPython::Helpers.hasattr?(__pyptr__, name_str)
+        name_without_last_equal = name.to_s.chomp('=')
+        if LibPython::Helpers.hasattr?(__pyptr__, name_without_last_equal)
           LibPython::Helpers.define_wrapper_method(self, name)
           return self.__send__(name, *args)
         end

data/lib/pycall/version.rb

@@ -1,5 +1,5 @@
 module PyCall
-  VERSION = "1.5.1"
+  VERSION = "1.5.3"
 
   module Version
     numbers, TAG = VERSION.split("-")

data/lib/pycall.rb

@@ -116,7 +116,7 @@ module PyCall
     rescue PyError => err
       raise err unless ctx.__exit__(err.type, err.value, err.traceback)
     rescue Exception => err
-      # TODO: support telling what exception has been catched
+      # TODO: support telling what exception has been caught
       raise err unless ctx.__exit__(err.class, err, err.backtrace_locations)
     else
       ctx.__exit__(nil, nil, nil)