Fix lazy import for callable attributes of a module.

Author: GrahamDumpleton

docs/changes.rst

@@ -11,6 +11,25 @@ Version 2.0.1
   accessible when using ``from wrapt import *`` and type checkers such as
   ``mypy`` or ``pylance`` may not see it as part of the public API.
 
+* When using ``wrapt.lazy_import()`` to lazily import a function of a module,
+  the resulting proxy object wasn't marked as callable until something triggered
+  the import of the module via the proxy. This meant a ``callable()`` check
+  on the proxy would return ``False`` until the module was actually imported.
+  Further, calling the proxy before the module was imported would raise
+  ``TypeError: 'LazyObjectProxy' object is not callable`` rather than
+  importing the module and calling the function as expected. In order to
+  address this issue, an additional keyword argument ``interface`` has been
+  added to ``wrapt.lazy_import()`` which can be used to specify the expected
+  interface type of the wrapped object. This will default to ``Callable``
+  when an attribute name is supplied, and to ``ModuleType`` when no attribute
+  name is supplied. If using ``wrapt.lazy_import()`` and supplying an
+  ``attribute`` argument, and you expect the wrapped object to be something
+  other than a callable, you should now also supply ``interface=...`` with the
+  appropriate type from ``collections.abc`` to ensure the proxy behaves correctly
+  prior to the module being imported. This should only be necessary where the
+  wrapped object has special dunder methods on its type which need to exist on
+  the proxy prior to the module being imported.
+
 Version 2.0.0
 -------------
 

docs/wrappers.rst

@@ -667,14 +667,21 @@ and used as the wrapped object instead of the module itself.
 
 ::
 
-    def lazy_import(name, attribute=None):
+    def lazy_import(name, attribute=None, *, interface=...):
         """Lazily imports the module `name`, returning a `LazyObjectProxy` which
         will import the module when it is first needed. When `name is a dotted name,
         then the full dotted name is imported and the last module is taken as the
         target. If `attribute` is provided then it is used to retrieve an attribute
         from the module.
         """
 
+        if attribute is not None:
+            if interface is ...:
+                interface = Callable
+        else:
+            if interface is ...:
+                interface = ModuleType
+
         def _import():
             module = __import__(name, fromlist=[""])
 
@@ -683,7 +690,18 @@ and used as the wrapped object instead of the module itself.
 
             return module
 
-        return LazyObjectProxy(_import)
+        return LazyObjectProxy(_import, interface=interface)
+
+The ``interface`` argument is a hint as to the type of object being wrapped.
+This is used to help ``LazyObjectProxy`` determine what special methods need to
+be added to the proxy in order to properly stand in for the wrapped object
+prior to the module being imported, at which point the required special methods
+can be determined from the actual wrapped object. This is important for cases
+such as where the wrapped object is a callable, as the proxy will need to
+implement ``__call__()`` so that calling it will trigger the import of the module
+and then call the wrapped callable. If dealing with attribute of a module which
+have a different interface type, such as an iterable, then the appropriate type
+from ``collections.abc`` should be used.
 
 Since such a lazy import feature is generally useful, a convenience function
 ``wrapt.lazy_import()`` is provided which implements the above example.

src/wrapt/__init__.pyi

@@ -37,12 +37,16 @@ if sys.version_info >= (3, 10):
     # LazyObjectProxy
 
     class LazyObjectProxy(AutoObjectProxy[T]):
-        def __init__(self, callback: Callable[[], T] | None) -> None: ...
+        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) -> LazyObjectProxy[Any]: ...
+    def lazy_import(
+        name: str, attribute: str, *, interface: Any = ...
+    ) -> LazyObjectProxy[Any]: ...
 
     # CallableObjectProxy
 

src/wrapt/proxies.py

@@ -1,5 +1,8 @@
 """Variants of ObjectProxy for different use cases."""
 
+from collections.abc import Callable
+from types import ModuleType
+
 from .__wrapt__ import BaseObjectProxy
 from .decorators import synchronized
 
@@ -30,7 +33,12 @@ def __iter__(self):
 # object and add special dunder methods.
 
 
-def __wrapper_call__(self, *args, **kwargs):
+def __wrapper_call__(*args, **kwargs):
+    def _unpack_self(self, *args):
+        return self, args
+
+    self, args = _unpack_self(*args)
+
     return self.__wrapped__(*args, **kwargs)
 
 
@@ -136,7 +144,7 @@ def __new__(cls, wrapped):
         if cls is AutoObjectProxy:
             name = BaseObjectProxy.__name__
 
-        return super().__new__(type(name, (cls,), namespace))
+        return super(AutoObjectProxy, cls).__new__(type(name, (cls,), namespace))
 
     def __wrapped_setattr_fixups__(self):
         """Adjusts special dunder methods on the class as needed based on the
@@ -218,10 +226,64 @@ class LazyObjectProxy(AutoObjectProxy):
     when it is first needed.
     """
 
-    def __new__(cls, callback=None):
-        return super().__new__(cls, None)
+    def __new__(cls, callback=None, *, interface=...):
+        """Injects special dunder methods into a dynamically created subclass
+        as needed based on the wrapped object.
+        """
+
+        if interface is ...:
+            interface = type(None)
+
+        namespace = {}
+
+        interface_attrs = dir(interface)
+        class_attrs = set(dir(cls))
+
+        if "__call__" in interface_attrs and "__call__" not in class_attrs:
+            namespace["__call__"] = __wrapper_call__
+
+        if "__iter__" in interface_attrs and "__iter__" not in class_attrs:
+            namespace["__iter__"] = __wrapper_iter__
+
+        if "__next__" in interface_attrs and "__next__" not in class_attrs:
+            namespace["__next__"] = __wrapper_next__
+
+        if "__aiter__" in interface_attrs and "__aiter__" not in class_attrs:
+            namespace["__aiter__"] = __wrapper_aiter__
+
+        if "__anext__" in interface_attrs and "__anext__" not in class_attrs:
+            namespace["__anext__"] = __wrapper_anext__
 
-    def __init__(self, callback=None):
+        if (
+            "__length_hint__" in interface_attrs
+            and "__length_hint__" not in class_attrs
+        ):
+            namespace["__length_hint__"] = __wrapper_length_hint__
+
+        # 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.
+
+        if "__await__" in interface_attrs and "__await__" not in class_attrs:
+            namespace["__await__"] = __wrapper_await__
+
+        if "__get__" in interface_attrs and "__get__" not in class_attrs:
+            namespace["__get__"] = __wrapper_get__
+
+        if "__set__" in interface_attrs and "__set__" not in class_attrs:
+            namespace["__set__"] = __wrapper_set__
+
+        if "__delete__" in interface_attrs and "__delete__" not in class_attrs:
+            namespace["__delete__"] = __wrapper_delete__
+
+        if "__set_name__" in interface_attrs and "__set_name__" not in class_attrs:
+            namespace["__set_name__"] = __wrapper_set_name__
+
+        name = cls.__name__
+
+        return super(AutoObjectProxy, cls).__new__(type(name, (cls,), namespace))
+
+    def __init__(self, callback=None, *, interface=...):
         """Initialize the object proxy with wrapped object as `None` but due
         to presence of special `__wrapped_factory__` attribute addded first,
         this will actually trigger the deferred creation of the wrapped object
@@ -263,14 +325,21 @@ def __wrapped_get__(self):
             return self.__wrapped__
 
 
-def lazy_import(name, attribute=None):
+def lazy_import(name, attribute=None, *, interface=...):
     """Lazily imports the module `name`, returning a `LazyObjectProxy` which
     will import the module when it is first needed. When `name is a dotted name,
     then the full dotted name is imported and the last module is taken as the
     target. If `attribute` is provided then it is used to retrieve an attribute
     from the module.
     """
 
+    if attribute is not None:
+        if interface is ...:
+            interface = Callable
+    else:
+        if interface is ...:
+            interface = ModuleType
+
     def _import():
         module = __import__(name, fromlist=[""])
 
@@ -279,4 +348,4 @@ def _import():
 
         return module
 
-    return LazyObjectProxy(_import)
+    return LazyObjectProxy(_import, interface=interface)

tests/core/test_lazy_object_proxy.py

@@ -60,3 +60,52 @@ def test_lazy_import_dotted(self):
         self.assertIsNotNone(client_mod.HTTPConnection)
 
         self.assertTrue("http.client" in sys.modules)
+
+    def test_lazy_import_callable(self):
+        dumps = wrapt.lazy_import("json", "dumps")
+
+        self.assertTrue(callable(dumps))
+
+        result = dumps({"key": "value"})
+
+        self.assertEqual(result, '{"key": "value"}')
+
+    def test_lazy_import_iterable(self):
+        from collections.abc import Iterable
+
+        if "string" in sys.modules:
+            del sys.modules["string"]
+
+        digits0 = wrapt.lazy_import("string", "digits")
+
+        self.assertFalse(hasattr(type(digits0), "__iter__"))
+
+        self.assertTrue(callable(digits0))
+
+        # XXX Iteration does not seem to test for __iter__ being a method
+        # on the type, so this test is not sufficient to raise the TypeError.
+        # I was at some point seeing expected failures here, but not now and
+        # I don't know why.
+
+        # if "string" in sys.modules:
+        #     del sys.modules["string"]
+
+        # digits1 = wrapt.lazy_import("string", "digits")
+
+        # with self.assertRaises(TypeError):
+        #     for char in digits1:
+        #         pass
+
+        if "string" in sys.modules:
+            del sys.modules["string"]
+
+        digits2 = wrapt.lazy_import("string", "digits", interface=Iterable)
+
+        self.assertTrue(hasattr(type(digits2), "__iter__"))
+
+        self.assertFalse(callable(digits2))
+
+        for char in digits2:
+            self.assertIn(char, "0123456789")
+
+        self.assertEqual("".join(digits2), "0123456789")