wrapt 2.2.2rc3__tar.gz → 2.3.0.dev1__tar.gz

{wrapt-2.2.2rc3/src/wrapt.egg-info → wrapt-2.3.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wrapt
-Version: 2.2.2rc3
+Version: 2.3.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.2.2rc3 → wrapt-2.3.0.dev1}/src/wrapt/__init__.py

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

{wrapt-2.2.2rc3 → wrapt-2.3.0.dev1}/src/wrapt/_wrappers.c

@@ -2537,6 +2537,67 @@ static PyObject *WraptObjectProxy_round(WraptObjectProxyObject *self,
 
 /* ------------------------------------------------------------------------- */
 
+static PyObject *wrapt_call_math_unary(WraptObjectProxyObject *self,
+                                       const char *name)
+{
+  PyObject *module = NULL;
+  PyObject *function = NULL;
+  PyObject *result = NULL;
+
+  if (!self->wrapped)
+  {
+    if (raise_uninitialized_wrapper_error(self) == -1)
+      return NULL;
+  }
+
+  module = PyImport_ImportModule("math");
+
+  if (!module)
+    return NULL;
+
+  function = PyObject_GetAttrString(module, name);
+
+  if (!function)
+  {
+    Py_DECREF(module);
+    return NULL;
+  }
+
+  Py_DECREF(module);
+
+  result = PyObject_CallFunctionObjArgs(function, self->wrapped, NULL);
+
+  Py_DECREF(function);
+
+  return result;
+}
+
+/* ------------------------------------------------------------------------- */
+
+static PyObject *WraptObjectProxy_trunc(WraptObjectProxyObject *self,
+                                        PyObject *Py_UNUSED(ignored))
+{
+  return wrapt_call_math_unary(self, "trunc");
+}
+
+/* ------------------------------------------------------------------------- */
+
+static PyObject *WraptObjectProxy_floor(WraptObjectProxyObject *self,
+                                        PyObject *Py_UNUSED(ignored))
+{
+  return wrapt_call_math_unary(self, "floor");
+}
+
+/* ------------------------------------------------------------------------- */
+
+static PyObject *WraptObjectProxy_ceil(WraptObjectProxyObject *self,
+                                       PyObject *Py_UNUSED(ignored))
+{
+  return wrapt_call_math_unary(self, "ceil");
+}
+
+/* ------------------------------------------------------------------------- */
+
 static PyObject *WraptObjectProxy_complex(WraptObjectProxyObject *self,
                                           PyObject *args)
 {
@@ -3148,6 +3209,9 @@ static PyMethodDef WraptObjectProxy_methods[] = {
     {"__reversed__", (PyCFunction)WraptObjectProxy_reversed, METH_NOARGS, 0},
     {"__round__", (PyCFunction)WraptObjectProxy_round,
      METH_VARARGS | METH_KEYWORDS, 0},
+    {"__trunc__", (PyCFunction)WraptObjectProxy_trunc, METH_NOARGS, 0},
+    {"__floor__", (PyCFunction)WraptObjectProxy_floor, METH_NOARGS, 0},
+    {"__ceil__", (PyCFunction)WraptObjectProxy_ceil, METH_NOARGS, 0},
     {"__complex__", (PyCFunction)WraptObjectProxy_complex, METH_NOARGS, 0},
     {"__mro_entries__", (PyCFunction)WraptObjectProxy_mro_entries,
      METH_VARARGS | METH_KEYWORDS, 0},

{wrapt-2.2.2rc3 → wrapt-2.3.0.dev1}/src/wrapt/proxies.py

@@ -62,6 +62,10 @@ def __wrapper_length_hint__(self):
     return self.__wrapped__.__length_hint__()
 
 
+def __wrapper_fspath__(self):
+    return self.__wrapped__.__fspath__()
+
+
 def __wrapper_await__(self):
     return (yield from self.__wrapped__.__await__())
 
@@ -120,6 +124,9 @@ class AutoObjectProxy(BaseObjectProxy):
         if "__length_hint__" in wrapped_attrs and "__length_hint__" not in class_attrs:
             namespace["__length_hint__"] = __wrapper_length_hint__
 
+        if "__fspath__" in wrapped_attrs and "__fspath__" not in class_attrs:
+            namespace["__fspath__"] = __wrapper_fspath__
+
         # Note that not providing compatibility with generator-based coroutines
         # (PEP 342) here as they are removed in Python 3.11+ and were deprecated
         # in 3.8.
@@ -193,6 +200,12 @@ class AutoObjectProxy(BaseObjectProxy):
         elif getattr(cls, "__length_hint__", None) is __wrapper_length_hint__:
             delattr(cls, "__length_hint__")
 
+        if hasattr(self.__wrapped__, "__fspath__"):
+            if "__fspath__" not in class_attrs:
+                cls.__fspath__ = __wrapper_fspath__
+        elif getattr(cls, "__fspath__", None) is __wrapper_fspath__:
+            delattr(cls, "__fspath__")
+
         if hasattr(self.__wrapped__, "__await__"):
             if "__await__" not in class_attrs:
                 cls.__await__ = __wrapper_await__

{wrapt-2.2.2rc3 → wrapt-2.3.0.dev1}/src/wrapt/wrappers.py

@@ -1,6 +1,7 @@
 """Core object proxy and function wrapper implementations."""
 
 import inspect
+import math
 import operator
 import sys
 import types
@@ -164,7 +165,9 @@ class ObjectProxy(_ObjectProxyDictBase, metaclass=_ObjectProxyMetaType):
     """A transparent object proxy that delegates attribute access to a
     wrapped object."""
 
-    __class_getitem__ = classmethod(types.GenericAlias)
+    @classmethod
+    def __class_getitem__(cls, item, /):
+        return types.GenericAlias(cls, item)
 
     def __init__(self, wrapped):
         """Create an object proxy around the given object."""
@@ -261,6 +264,15 @@ class ObjectProxy(_ObjectProxyDictBase, metaclass=_ObjectProxyMetaType):
     def __round__(self, ndigits=None):
         return round(self.__wrapped__, ndigits)
 
+    def __trunc__(self):
+        return math.trunc(self.__wrapped__)
+
+    def __floor__(self):
+        return math.floor(self.__wrapped__)
+
+    def __ceil__(self):
+        return math.ceil(self.__wrapped__)
+
     def __mro_entries__(self, bases):
         if not isinstance(self.__wrapped__, type) and hasattr(
             self.__wrapped__, "__mro_entries__"
@@ -749,7 +761,7 @@ class _FunctionWrapperBase(ObjectProxy):
         object.__setattr__(self, "_self_parent", parent)
         object.__setattr__(self, "_self_owner", owner)
 
-    def __get__(self, instance, owner):
+    def __get__(self, instance, owner=None):
         # This method handles both unbound and bound derived wrapper classes.
         # It is kept in the base class as the amount of common code makes it
         # impractical to split into the derived classes.

{wrapt-2.2.2rc3 → wrapt-2.3.0.dev1}/src/wrapt-stubs/__init__.pyi

@@ -2,7 +2,7 @@ import sys
 
 if sys.version_info >= (3, 10):
     from inspect import FullArgSpec, Signature
-    from types import ModuleType, TracebackType
+    from types import GenericAlias, ModuleType, TracebackType
     from typing import (
         Any,
         AsyncIterator,
@@ -109,6 +109,7 @@ if sys.version_info >= (3, 10):
 
         def __init__(self, wrapped: _T) -> None: ...
         def __getattr__(self, name: str) -> Any: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
         def __mro_entries__(self, bases: tuple[type, ...]) -> tuple[type, ...]: ...
 
         # Context managers.
@@ -149,6 +150,9 @@ if sys.version_info >= (3, 10):
         def __bytes__(self) -> bytes: ...
         def __index__(self) -> int: ...
         def __round__(self, ndigits: int | None = ..., /) -> Any: ...
+        def __trunc__(self) -> Any: ...
+        def __floor__(self) -> Any: ...
+        def __ceil__(self) -> Any: ...
 
         # Unary arithmetic.
         def __neg__(self) -> Any: ...
@@ -224,7 +228,8 @@ if sys.version_info >= (3, 10):
         # and bitwise operations (e.g. __add__ returns
         # ``self.__object_proxy__(self.__wrapped__ + other)``). Subclasses
         # override it to control the type of proxy produced from operations.
-        __self_dict__: dict[str, Any]
+        @property
+        def __self_dict__(self) -> dict[str, Any]: ...
         @property
         def __object_proxy__(self) -> type[BaseObjectProxy[Any]]: ...
         def __self_setattr__(self, name: str, value: Any) -> None: ...
@@ -260,6 +265,7 @@ if sys.version_info >= (3, 10):
         def __aiter__(self) -> AsyncIterator[Any]: ...
         async def __anext__(self) -> Any: ...
         def __length_hint__(self) -> int: ...
+        def __fspath__(self) -> str | bytes: ...
         def __await__(self) -> Generator[Any, Any, Any]: ...
 
     # LazyObjectProxy
@@ -292,7 +298,7 @@ if sys.version_info >= (3, 10):
 
     # PartialCallableObjectProxy
 
-    class PartialCallableObjectProxy:
+    class PartialCallableObjectProxy(BaseObjectProxy[Callable[..., Any]]):
         def __init__(
             self, func: Callable[..., Any], *args: Any, **kwargs: Any
         ) -> None: ...
@@ -304,7 +310,7 @@ if sys.version_info >= (3, 10):
 
     # WeakFunctionProxy
 
-    class WeakFunctionProxy:
+    class WeakFunctionProxy(BaseObjectProxy[Callable[..., Any]]):
         def __init__(
             self,
             wrapped: Callable[..., Any],
@@ -378,6 +384,12 @@ if sys.version_info >= (3, 10):
         ) -> BoundFunctionWrapper[_P1, _R1]: ...
 
     class FunctionWrapper(_FunctionWrapperBase[_P1, _R1]):
+        # The class used to construct the bound wrapper when the function
+        # wrapper is bound to an instance via the descriptor protocol.
+        # Subclasses override it to control the type of bound wrapper
+        # produced.
+        __bound_function_wrapper__: type[BoundFunctionWrapper[_P1, _R1]]
+
         def __init__(
             self,
             wrapped: _WrappedFunction[_P1, _R1],
@@ -644,7 +656,7 @@ if sys.version_info >= (3, 10):
 
     # bind_state_to_wrapper()
 
-    class _StateBindingWrapper:
+    class _StateBindingWrapper(BaseObjectProxy[Any]):
         name: str
         wrapper_factory: _Descriptor | None
         def __init__(self, *, name: str = "state") -> None: ...

{wrapt-2.2.2rc3 → wrapt-2.3.0.dev1/src/wrapt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wrapt
-Version: 2.2.2rc3
+Version: 2.3.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.2.2rc3 → wrapt-2.3.0.dev1}/src/wrapt.egg-info/SOURCES.txt

@@ -30,28 +30,27 @@ tests/core/compat.py
 tests/core/module1.py
 tests/core/module2.py
 tests/core/test_adapter.py
-tests/core/test_adapter_py3.py
-tests/core/test_adapter_py33.py
+tests/core/test_adapter_annotations.py
+tests/core/test_adapter_kwonly.py
 tests/core/test_annotations.py
 tests/core/test_attribute_wrapper.py
 tests/core/test_auto_object_proxy.py
 tests/core/test_callable_binding_no_args.py
 tests/core/test_callable_object_proxy.py
 tests/core/test_class.py
-tests/core/test_class_py37.py
+tests/core/test_class_mro_entries.py
 tests/core/test_copy.py
 tests/core/test_decorator_state.py
 tests/core/test_decorators.py
 tests/core/test_deferred_patching.py
 tests/core/test_descriptor_get_class_access.py
-tests/core/test_descriptors_py36.py
+tests/core/test_descriptors.py
 tests/core/test_enabled_bool_error.py
 tests/core/test_entry_points.py
-tests/core/test_formatargspec_py35.py
-tests/core/test_formatargspec_py38.py
+tests/core/test_formatargspec.py
 tests/core/test_function.py
 tests/core/test_function_wrapper.py
-tests/core/test_inheritance_py37.py
+tests/core/test_inheritance.py
 tests/core/test_inner_classmethod.py
 tests/core/test_inner_staticmethod.py
 tests/core/test_inplace_operators.py

{wrapt-2.2.2rc3 → wrapt-2.3.0.dev1}/tests/conftest.py

@@ -37,14 +37,8 @@ def construct_dummy(path, parent):
 def pytest_pycollect_makemodule(module_path, parent):
     basename = module_path.name
 
-    # Handle Python 2/3 general cases
-    if "_py2" in basename and version >= (3, 0):
-        return construct_dummy(module_path, parent)
-    if "_py3" in basename and version < (3, 0):
-        return construct_dummy(module_path, parent)
-
     # Handle specific Python version cases using regex
-    # Match patterns like "_py33", "_py34", "_py310", etc.
+    # Match patterns like "_py310", "_py312", etc.
     version_match = re.search(r"_py(\d)(\d*)", basename)
     if version_match:
         major = int(version_match.group(1))

{wrapt-2.2.2rc3 → wrapt-2.3.0.dev1}/tests/core/test_auto_object_proxy.py

@@ -134,6 +134,41 @@ class TestAutoObjectProxy(unittest.TestCase):
 
         self.assertEqual(asyncio.run(await_proxy()), 42)
 
+    def test_fspath(self):
+        import os
+
+        class PathLike:
+            def __fspath__(self):
+                return "/path/to/file"
+
+        base = wrapt.BaseObjectProxy(PathLike())
+
+        self.assertRaises(TypeError, os.fspath, base)
+
+        proxy = wrapt.AutoObjectProxy(PathLike())
+
+        self.assertEqual(os.fspath(proxy), "/path/to/file")
+        self.assertTrue(isinstance(proxy, os.PathLike))
+
+    def test_fspath_pathlib(self):
+        import os
+        import pathlib
+
+        instance = pathlib.PurePath("/path/to/file")
+        proxy = wrapt.AutoObjectProxy(instance)
+
+        self.assertEqual(os.fspath(proxy), os.fspath(instance))
+        self.assertTrue(isinstance(proxy, os.PathLike))
+
+    def test_fspath_not_pathlike(self):
+        import os
+
+        proxy = wrapt.AutoObjectProxy(42)
+
+        self.assertFalse(hasattr(type(proxy), "__fspath__"))
+        self.assertRaises(TypeError, os.fspath, proxy)
+        self.assertFalse(isinstance(proxy, os.PathLike))
+
     def test_descriptor(self):
         class Descriptor:
             def __init__(self, value):
@@ -212,6 +247,24 @@ class TestAutoObjectProxyReassignment(unittest.TestCase):
         proxy.__wrapped__ = object()
         self.assertFalse(hasattr(proxy, "__iter__"))
 
+    def test_fspath_added_on_reassignment(self):
+        import os
+        import pathlib
+
+        proxy = wrapt.AutoObjectProxy(object())
+        self.assertRaises(TypeError, os.fspath, proxy)
+        proxy.__wrapped__ = pathlib.PurePath("/path/to/file")
+        self.assertEqual(os.fspath(proxy), os.fspath(proxy.__wrapped__))
+
+    def test_fspath_removed_on_reassignment(self):
+        import os
+        import pathlib
+
+        proxy = wrapt.AutoObjectProxy(pathlib.PurePath("/path/to/file"))
+        self.assertEqual(os.fspath(proxy), os.fspath(proxy.__wrapped__))
+        proxy.__wrapped__ = object()
+        self.assertRaises(TypeError, os.fspath, proxy)
+
     def test_next_added_on_reassignment(self):
         class Iterator:
             def __iter__(self):

wrapt-2.2.2rc3/tests/core/test_formatargspec_py38.py → wrapt-2.3.0.dev1/tests/core/test_formatargspec.py

@@ -1,11 +1,50 @@
-import sys
 import unittest
 from inspect import getfullargspec
 
 from wrapt.arguments import formatargspec
 
 
-class TestFormatargspec38(unittest.TestCase):
+class TestFormatargspec(unittest.TestCase):
+
+    def assertFormatEqual(self, func, ref):
+        formatted = formatargspec(*getfullargspec(func))
+        self.assertEqual(formatted, ref)
+
+    def test_formatargspec(self):
+        def foo1():
+            pass
+
+        self.assertFormatEqual(foo1, "()")
+
+        def foo2(a, b="c"):
+            pass
+
+        self.assertFormatEqual(foo2, ("(a, b='c')"))
+
+        def foo3(a, b, *args, **kwargs):
+            pass
+
+        self.assertFormatEqual(foo3, "(a, b, *args, **kwargs)")
+
+        def foo4(a: int, b) -> list:
+            return []
+
+        formatted4 = "(a: int, b) -> list"
+        self.assertFormatEqual(foo4, formatted4)
+
+        # examples from https://www.python.org/dev/peps/pep-3102/
+        def sortwords(*wordlist, case_sensitive=False):
+            pass
+
+        self.assertFormatEqual(sortwords, "(*wordlist, case_sensitive=False)")
+
+        def compare(a, b, *, key=None):
+            pass
+
+        self.assertFormatEqual(compare, "(a, b, *, key=None)")
+
+
+class TestFormatargspecPositionalOnly(unittest.TestCase):
 
     def assertFormatEqual(self, func, ref):
         formatted = formatargspec(*getfullargspec(func))

{wrapt-2.2.2rc3 → wrapt-2.3.0.dev1}/tests/core/test_object_proxy.py

@@ -1973,6 +1973,157 @@ class SpecialMethods(unittest.TestCase):
         self.assertEqual(round(instance, 3), round(proxy, 3))
         self.assertEqual(round(instance, ndigits=3), round(proxy, ndigits=3))
 
+    def test_math_integral_protocol_methods(self):
+        import math
+
+        class Instance:
+            def __trunc__(self):
+                return "truncated"
+
+            def __floor__(self):
+                return "floored"
+
+            def __ceil__(self):
+                return "ceiled"
+
+        instance = Instance()
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.trunc(proxy), "truncated")
+        self.assertEqual(math.floor(proxy), "floored")
+        self.assertEqual(math.ceil(proxy), "ceiled")
+
+    def test_float_trunc(self):
+        import math
+
+        instance = 1.7
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.trunc(instance), math.trunc(proxy))
+        self.assertEqual(math.trunc(instance), 1)
+
+    def test_negative_float_trunc(self):
+        import math
+
+        instance = -1.7
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.trunc(instance), math.trunc(proxy))
+        self.assertEqual(math.trunc(instance), -1)
+
+    def test_fractions_trunc(self):
+        import fractions
+        import math
+
+        instance = fractions.Fraction("7/3")
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.trunc(instance), math.trunc(proxy))
+        self.assertEqual(math.trunc(instance), 2)
+
+    def test_float_floor(self):
+        import math
+
+        instance = 1.7
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.floor(instance), math.floor(proxy))
+        self.assertEqual(math.floor(instance), 1)
+
+    def test_negative_float_floor(self):
+        import math
+
+        instance = -1.7
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.floor(instance), math.floor(proxy))
+        self.assertEqual(math.floor(instance), -2)
+
+    def test_fractions_floor(self):
+        import fractions
+        import math
+
+        instance = fractions.Fraction("7/3")
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.floor(instance), math.floor(proxy))
+        self.assertEqual(math.floor(instance), 2)
+
+    def test_float_ceil(self):
+        import math
+
+        instance = 1.7
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.ceil(instance), math.ceil(proxy))
+        self.assertEqual(math.ceil(instance), 2)
+
+    def test_negative_float_ceil(self):
+        import math
+
+        instance = -1.7
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.ceil(instance), math.ceil(proxy))
+        self.assertEqual(math.ceil(instance), -1)
+
+    def test_fractions_ceil(self):
+        import fractions
+        import math
+
+        instance = fractions.Fraction("7/3")
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.ceil(instance), math.ceil(proxy))
+        self.assertEqual(math.ceil(instance), 3)
+
+    def test_math_integral_protocol_methods_override_float(self):
+        # The __floor__() and __ceil__() methods of the wrapped object must
+        # take precedence over any __float__() fallback in math.floor() and
+        # math.ceil(), the same as if the wrapped object was used directly.
+
+        import math
+
+        class Instance:
+            def __float__(self):
+                return 3.5
+
+            def __trunc__(self):
+                return "truncated"
+
+            def __floor__(self):
+                return "floored"
+
+            def __ceil__(self):
+                return "ceiled"
+
+        instance = Instance()
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.trunc(proxy), math.trunc(instance))
+        self.assertEqual(math.floor(proxy), math.floor(instance))
+        self.assertEqual(math.ceil(proxy), math.ceil(instance))
+
+    def test_math_float_fallback(self):
+        # An object which only provides __float__() still works with
+        # math.floor() and math.ceil() via the proxy, the same as it does
+        # when used directly, and math.trunc() fails the same way for both.
+
+        import math
+
+        class Instance:
+            def __float__(self):
+                return 3.5
+
+        instance = Instance()
+        proxy = wrapt.ObjectProxy(instance)
+
+        self.assertEqual(math.floor(proxy), math.floor(instance))
+        self.assertEqual(math.ceil(proxy), math.ceil(instance))
+
+        self.assertRaises(TypeError, math.trunc, instance)
+        self.assertRaises(TypeError, math.trunc, proxy)
+
 
 class TestArgumentUnpacking(unittest.TestCase):