wrapt 2.0.0rc2__cp314-cp314t-win_arm64.whl → 2.0.1__cp314-cp314t-win_arm64.whl

wrapt/__init__.py

@@ -2,14 +2,14 @@
 Wrapt is a library for decorators, wrappers and monkey patching.
 """
 
-__version_info__ = ("2", "0", "0", "rc2")
+__version_info__ = ("2", "0", "1")
 __version__ = ".".join(__version_info__)
 
 from .__wrapt__ import (
+    BaseObjectProxy,
     BoundFunctionWrapper,
     CallableObjectProxy,
     FunctionWrapper,
-    ObjectProxy,
     PartialCallableObjectProxy,
     partial,
 )
@@ -30,12 +30,16 @@ from .patches import (
     wrap_object,
     wrap_object_attribute,
 )
+from .proxies import AutoObjectProxy, LazyObjectProxy, ObjectProxy, lazy_import
 from .weakrefs import WeakFunctionProxy
 
 __all__ = (
+    "AutoObjectProxy",
+    "BaseObjectProxy",
     "BoundFunctionWrapper",
     "CallableObjectProxy",
     "FunctionWrapper",
+    "LazyObjectProxy",
     "ObjectProxy",
     "PartialCallableObjectProxy",
     "partial",
@@ -49,6 +53,7 @@ __all__ = (
     "when_imported",
     "apply_patch",
     "function_wrapper",
+    "lazy_import",
     "patch_function_wrapper",
     "resolve_path",
     "transient_function_wrapper",

wrapt/__init__.pyi

@@ -24,13 +24,33 @@ if sys.version_info >= (3, 10):
 
     # ObjectProxy
 
-    class ObjectProxy(Generic[T]):
+    class BaseObjectProxy(Generic[T]):
         __wrapped__: T
         def __init__(self, wrapped: T) -> None: ...
 
+    class ObjectProxy(BaseObjectProxy[T]):
+        def __init__(self, wrapped: T) -> None: ...
+
+    class AutoObjectProxy(BaseObjectProxy[T]):
+        def __init__(self, wrapped: T) -> None: ...
+
+    # LazyObjectProxy
+
+    class LazyObjectProxy(AutoObjectProxy[T]):
+        def __init__(
+            self, callback: Callable[[], T] | None, *, interface: Any = ...
+        ) -> None: ...
+
+    @overload
+    def lazy_import(name: str) -> LazyObjectProxy[ModuleType]: ...
+    @overload
+    def lazy_import(
+        name: str, attribute: str, *, interface: Any = ...
+    ) -> LazyObjectProxy[Any]: ...
+
     # CallableObjectProxy
 
-    class CallableObjectProxy(ObjectProxy[T]):
+    class CallableObjectProxy(BaseObjectProxy[T]):
         def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
 
     # PartialCallableObjectProxy
@@ -123,7 +143,7 @@ if sys.version_info >= (3, 10):
             callable: (
                 Callable[P, R]
                 | Callable[Concatenate[type[T], P], R]
-                # | Callable[Concatenate[Any, P], R] # Don't use, breaks stuff.
+                | Callable[Concatenate[Any, P], R]
                 | Callable[[type[T]], R]
                 | Descriptor
             ),

wrapt/__wrapt__.py

@@ -4,20 +4,14 @@ wrappers.
 
 import os
 
-from .wrappers import (
-    BoundFunctionWrapper,
-    CallableObjectProxy,
-    FunctionWrapper,
-    ObjectProxy,
-    PartialCallableObjectProxy,
-    _FunctionWrapperBase,
-)
-
-# Import Python fallbacks.
-
+from .wrappers import BoundFunctionWrapper, CallableObjectProxy, FunctionWrapper
+from .wrappers import ObjectProxy as BaseObjectProxy
+from .wrappers import PartialCallableObjectProxy, _FunctionWrapperBase
 
 # Try to use C extensions if not disabled.
 
+_using_c_extension = False
+
 _use_extensions = not os.environ.get("WRAPT_DISABLE_EXTENSIONS")
 
 if _use_extensions:
@@ -26,16 +20,20 @@ if _use_extensions:
             BoundFunctionWrapper,
             CallableObjectProxy,
             FunctionWrapper,
-            ObjectProxy,
+        )
+        from ._wrappers import (
+            ObjectProxy as BaseObjectProxy,  # type: ignore[no-redef,import-not-found]
+        )
+        from ._wrappers import (  # type: ignore[no-redef,import-not-found]
             PartialCallableObjectProxy,
             _FunctionWrapperBase,
         )
+
+        _using_c_extension = True
     except ImportError:
         # C extensions not available, using Python implementations
         pass
 
-# Provide an alias for partial().
-
 
 def partial(*args, **kwargs):
     """Create a callable object proxy with partial application of the given