wrapt 2.3.0rc1__tar.gz → 2.4.0.dev1__tar.gz

{wrapt-2.3.0rc1/src/wrapt.egg-info → wrapt-2.4.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wrapt
-Version: 2.3.0rc1
+Version: 2.4.0.dev1
 Summary: Module for decorators, wrappers and monkey patching.
 Author-email: Graham Dumpleton <Graham.Dumpleton@gmail.com>
 License-Expression: BSD-2-Clause

{wrapt-2.3.0rc1 → wrapt-2.4.0.dev1}/src/wrapt/__init__.py

@@ -13,7 +13,7 @@ def _format_version(parts):
     )
 
 
-__version_info__ = ("2", "3", "0", "rc1")
+__version_info__ = ("2", "4", "0", "dev1")
 __version__ = _format_version(__version_info__)
 
 from .__wrapt__ import (

{wrapt-2.3.0rc1 → wrapt-2.4.0.dev1}/src/wrapt/_wrappers.c

@@ -153,6 +153,15 @@ static PyObject *PyType_GetModuleByDef(PyTypeObject *type,
 }
 #endif
 
+/* Polyfill the critical section API for Python < 3.13. Free-threaded
+ * builds only exist on 3.13+, where the real macros are provided (and are
+ * no-ops on GIL builds), so expanding to plain blocks here is safe. */
+
+#if PY_VERSION_HEX < 0x030D0000
+#define Py_BEGIN_CRITICAL_SECTION(op) {
+#define Py_END_CRITICAL_SECTION() }
+#endif
+
 /* Polyfill PyObject_GetOptionalAttrString for Python < 3.13. Matches the
  * 3.13+ semantics: returns 1 if found, 0 if not found (AttributeError
  * only), -1 on other errors with exception set. */
@@ -446,8 +455,16 @@ static int WraptObjectProxy_raw_init(WraptObjectProxyObject *self,
     }
   }
 
+  /* Serialise the swap for the same reason as in the __wrapped__ setter.
+   * Normally __init__ runs before the proxy is shared, but it can be
+   * re-invoked on an already published proxy, in which case concurrent
+   * callers on a free-threaded build could otherwise decref the same old
+   * wrapped object twice. */
+
   Py_INCREF(wrapped);
+  Py_BEGIN_CRITICAL_SECTION(self);
   Py_XSETREF(self->wrapped, wrapped);
+  Py_END_CRITICAL_SECTION();
 
   self->init_called = 1;
 
@@ -1061,7 +1078,16 @@ static PyObject *WraptObjectProxy_inplace_add(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    /* As in the __wrapped__ setter, serialise the swap so that concurrent
+     * in-place operations on the same proxy cannot decref the same old
+     * wrapped object twice on a free-threaded build. The wrapped object
+     * was read before the operation ran, so a concurrent mutation can
+     * still be lost, matching pure Python semantics. The same applies to
+     * all of the in-place operators which follow. */
+
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -1143,7 +1169,9 @@ static PyObject *WraptObjectProxy_inplace_subtract(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -1225,7 +1253,9 @@ static PyObject *WraptObjectProxy_inplace_multiply(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -1308,7 +1338,9 @@ WraptObjectProxy_inplace_remainder(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -1391,7 +1423,9 @@ static PyObject *WraptObjectProxy_inplace_power(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -1473,7 +1507,9 @@ static PyObject *WraptObjectProxy_inplace_lshift(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -1555,7 +1591,9 @@ static PyObject *WraptObjectProxy_inplace_rshift(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -1637,7 +1675,9 @@ static PyObject *WraptObjectProxy_inplace_and(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -1719,7 +1759,9 @@ static PyObject *WraptObjectProxy_inplace_xor(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -1801,7 +1843,9 @@ static PyObject *WraptObjectProxy_inplace_or(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -1942,7 +1986,9 @@ WraptObjectProxy_inplace_floor_divide(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -2025,7 +2071,9 @@ WraptObjectProxy_inplace_true_divide(WraptObjectProxyObject *self,
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -2149,7 +2197,9 @@ static PyObject *WraptObjectProxy_inplace_matrix_multiply(
     if (!object)
       return NULL;
 
+    Py_BEGIN_CRITICAL_SECTION(self);
     Py_SETREF(self->wrapped, object);
+    Py_END_CRITICAL_SECTION();
 
     Py_INCREF(self);
     return (PyObject *)self;
@@ -2450,7 +2500,8 @@ static PyObject *WraptObjectProxy_bytes(WraptObjectProxyObject *self,
       return NULL;
   }
 
-  return PyObject_Bytes(self->wrapped);
+  return PyObject_CallFunctionObjArgs((PyObject *)&PyBytes_Type,
+                                      self->wrapped, NULL);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2919,15 +2970,22 @@ static int WraptObjectProxy_set_dict(WraptObjectProxyObject *self,
 
 static PyObject *WraptObjectProxy_get_self_dict(WraptObjectProxyObject *self)
 {
+  PyObject *result = NULL;
+
+  /* self->dict is only NULL after tp_clear has run. Perform the lazy
+   * recreation and the reference acquisition inside a critical section
+   * so that two threads racing here on a free-threaded build cannot both
+   * create a dict, leaking one of them, or return a dict which the other
+   * thread has already replaced. */
+
+  Py_BEGIN_CRITICAL_SECTION(self);
   if (!self->dict)
-  {
     self->dict = PyDict_New();
-    if (!self->dict)
-      return NULL;
-  }
+  result = self->dict;
+  Py_XINCREF(result);
+  Py_END_CRITICAL_SECTION();
 
-  Py_INCREF(self->dict);
-  return self->dict;
+  return result;
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2972,8 +3030,16 @@ static int WraptObjectProxy_set_wrapped(WraptObjectProxyObject *self,
     return -1;
   }
 
+  /* On free-threaded builds the swap must be serialised, otherwise two
+   * threads assigning __wrapped__ on the same proxy can both read the same
+   * old value and both decref it, releasing it twice. The critical section
+   * covers only the swap; __wrapped_setattr_fixups__ below runs arbitrary
+   * Python code and must stay outside it. */
+
   Py_INCREF(value);
+  Py_BEGIN_CRITICAL_SECTION(self);
   Py_XSETREF(self->wrapped, value);
+  Py_END_CRITICAL_SECTION();
 
   fixups = PyObject_GetAttr((PyObject *)self, state->str_setattr_fixups);
 
@@ -3385,11 +3451,19 @@ static int WraptPartialCallableObjectProxy_raw_init(
 
   if (result == 0)
   {
-    Py_INCREF(args);
-    Py_XSETREF(self->args, args);
+    /* Serialise the swaps for the same reason as in the __wrapped__
+     * setter. Initialisation normally happens before the proxy is shared,
+     * but __init__ can be re-invoked on an already published proxy, in
+     * which case concurrent callers on a free-threaded build could
+     * otherwise decref the same old args or kwargs twice. */
 
+    Py_INCREF(args);
     Py_XINCREF(kwargs);
+
+    Py_BEGIN_CRITICAL_SECTION(self);
+    Py_XSETREF(self->args, args);
     Py_XSETREF(self->kwargs, kwargs);
+    Py_END_CRITICAL_SECTION();
   }
 
   return result;
@@ -3617,23 +3691,27 @@ static int WraptFunctionWrapperBase_raw_init(
 
   if (result == 0)
   {
-    Py_INCREF(instance);
-    Py_XSETREF(self->instance, instance);
+    /* Serialise the swaps for the same reason as in the __wrapped__
+     * setter. These fields have no setters, so re-invocation of __init__
+     * on an already published wrapper is the only path by which
+     * concurrent callers on a free-threaded build could otherwise decref
+     * the same old field values twice. */
 
+    Py_INCREF(instance);
     Py_INCREF(wrapper);
-    Py_XSETREF(self->wrapper, wrapper);
-
     Py_INCREF(enabled);
-    Py_XSETREF(self->enabled, enabled);
-
     Py_INCREF(binding);
-    Py_XSETREF(self->binding, binding);
-
     Py_INCREF(parent);
-    Py_XSETREF(self->parent, parent);
-
     Py_INCREF(owner);
+
+    Py_BEGIN_CRITICAL_SECTION(self);
+    Py_XSETREF(self->instance, instance);
+    Py_XSETREF(self->wrapper, wrapper);
+    Py_XSETREF(self->enabled, enabled);
+    Py_XSETREF(self->binding, binding);
+    Py_XSETREF(self->parent, parent);
     Py_XSETREF(self->owner, owner);
+    Py_END_CRITICAL_SECTION();
   }
 
   return result;

{wrapt-2.3.0rc1 → wrapt-2.4.0.dev1/src/wrapt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wrapt
-Version: 2.3.0rc1
+Version: 2.4.0.dev1
 Summary: Module for decorators, wrappers and monkey patching.
 Author-email: Graham Dumpleton <Graham.Dumpleton@gmail.com>
 License-Expression: BSD-2-Clause

{wrapt-2.3.0rc1 → wrapt-2.4.0.dev1}/tests/core/test_object_proxy.py

@@ -1932,6 +1932,55 @@ class SpecialMethods(unittest.TestCase):
 
         self.assertEqual(bytes(instance), bytes(proxy))
 
+    def test_int_bytes(self):
+        # bytes(proxy) should behave like bytes() on the wrapped object even
+        # when it has no __bytes__ (e.g. an int, where bytes(n) yields a
+        # zero-filled buffer of length n).
+        instance = 3
+
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(bytes(instance), bytes(proxy))
+
+    def test_index_bytes(self):
+        # An object with __index__() but no __bytes__ converts like an int,
+        # yielding a zero-filled buffer.
+        class Class:
+            def __index__(self):
+                return 2
+
+        instance = Class()
+
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(bytes(instance), bytes(proxy))
+
+    def test_buffer_bytes(self):
+        # An object supporting the buffer protocol but no __bytes__.
+        instance = bytearray(b"abcd")
+
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(bytes(instance), bytes(proxy))
+
+    def test_iterable_bytes(self):
+        # An iterable of ints, converted element by element.
+        instance = [1, 2, 3]
+
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(bytes(instance), bytes(proxy))
+
+    def test_str_bytes(self):
+        # bytes() on a str without an encoding raises TypeError, and the
+        # proxy should match rather than fall back to some other conversion.
+        instance = "abcd"
+
+        proxy = wrapt.ObjectProxy(instance)
+
+        with self.assertRaises(TypeError):
+            bytes(proxy)
+
     def test_str_format(self):
         instance = "abcd"