Added support config providers with strings

Author: eadwinCode

ellar/di/service_config.py

@@ -34,6 +34,54 @@
 
 
 class ProviderConfig(t.Generic[T]):
+    """
+    ProviderConfig is a class that configures a provider for a service.
+
+    Example:
+
+    >>> class SomeClass:
+    ...     def __init__(self, a: InjectByTag('A'), b: AnotherType):
+    ...         self.a = a
+    ...         self.b = b
+
+    >>> provider_config = ProviderConfig(SomeClass)
+    >>> provider_config.register(container)
+
+    Example with string:
+
+    >>> provider_config = ProviderConfig('path.to:SomeClass')
+    >>> provider_config.register(container)
+
+    Example with value:
+
+    >>> provider_config = ProviderConfig(SomeClass, use_value=SomeValue)
+    >>> provider_config.register(container)
+
+    Example with class:
+
+    >>> provider_config = ProviderConfig(SomeClass, use_class=AnotherType)
+    >>> provider_config.register(container)
+
+    Example with use_class as string:
+
+    >>> provider_config = ProviderConfig(SomeClass, use_class='path.to:AnotherType')
+    >>> provider_config.register(container)
+
+    Example with scope:
+
+    >>> provider_config = ProviderConfig(SomeClass, scope=request_scope)
+    >>> provider_config.register(container)
+
+    Example with tag:
+
+    >>> provider_config = ProviderConfig(SomeClass, tag='some_tag')
+    >>> provider_config.register(container)
+    >>> instance = container.get(InjectByTag('some_tag'))
+    >>> assert isinstance(instance, SomeClass)
+
+
+    """
+
     __slots__ = (
         "base_type",
         "use_value",
@@ -46,7 +94,7 @@ class ProviderConfig(t.Generic[T]):
 
     def __init__(
         self,
-        base_type: t.Union[t.Type[T], t.Type],
+        base_type: t.Union[t.Type[T], t.Type, str],
         *,
         use_value: t.Optional[T] = None,
         use_class: t.Union[t.Type[T], t.Any] = None,
@@ -69,33 +117,46 @@ def __init__(
         self.core = core
 
     def get_type(self) -> t.Type:
-        return self.base_type
+        return self._resolve_type(self.base_type)
+
+    def get_use_class(self) -> t.Type:
+        return self._resolve_type(self.use_class)
+
+    def _resolve_type(self, type_or_str: t.Union[t.Type, str]) -> t.Type:
+        from ellar.utils.importer import import_from_string
+
+        if isinstance(type_or_str, str):
+            return t.cast(t.Type, import_from_string(type_or_str))
+        return type_or_str
 
     def register(self, container: "Container") -> None:
-        scope = get_scope(self.base_type) or self.scope
-        if self.use_class:
-            scope = get_scope(self.use_class) or scope
+        base_type = self.get_type()
+        scope = get_scope(base_type) or self.scope
+        use_class = self.get_use_class()
+
+        if use_class:
+            scope = get_scope(use_class) or scope
             container.register(
-                base_type=self.base_type,
-                concrete_type=self.use_class,
+                base_type=base_type,
+                concrete_type=use_class,
                 scope=scope,
                 tag=self.tag,
             )
         elif self.use_value:
             container.register(
-                base_type=self.base_type,
+                base_type=base_type,
                 concrete_type=self.use_value,
                 scope=scope,
                 tag=self.tag,
             )
-        elif not isinstance(self.base_type, type):
+        elif not isinstance(base_type, type):
             raise DIImproperConfiguration(
-                f"couldn't determine provider setup for {self.base_type}. "
+                f"couldn't determine provider setup for {base_type}. "
                 f"Please use `ProviderConfig` or `register_services` function in a "
                 f"Module to configure the provider"
             )
         else:
-            container.register(base_type=self.base_type, scope=scope, tag=self.tag)
+            container.register(base_type=base_type, scope=scope, tag=self.tag)
 
 
 @t.overload

tests/test_di/test_provider_scopes.py

@@ -4,6 +4,7 @@
 from ellar.di import EllarInjector, ProviderConfig, has_binding
 from ellar.di.exceptions import DIImproperConfiguration
 from ellar.di.scopes import RequestScope, SingletonScope, TransientScope
+from ellar.utils.importer import get_class_import
 from injector import UnsatisfiedRequirement, inject
 
 from .examples import AnyContext, Foo, IContext, TransientRequestContext
@@ -12,6 +13,7 @@
 @pytest.mark.parametrize(
     "provider, ref_type, expected_scope",
     [
+        (ProviderConfig(get_class_import(Foo)), Foo, SingletonScope),
         (ProviderConfig(Foo, use_value=Foo()), Foo, SingletonScope),
         (ProviderConfig(Foo), Foo, SingletonScope),
         (ProviderConfig(Foo, scope=TransientScope), Foo, TransientScope),

tests/test_di/test_providers.py

@@ -8,6 +8,7 @@
 )
 from ellar.di.providers import ClassProvider, ModuleProvider
 from ellar.di.scopes import SingletonScope, TransientScope
+from ellar.utils.importer import get_class_import
 from injector import (
     CircularDependency,
     UnsatisfiedRequirement,
@@ -20,10 +21,12 @@
     Foo1,
     Foo2,
     FooDBCatsRepository,
+    IContext,
     IDBContext,
     InjectType,
     InjectType2,
     IRepository,
+    TransientRequestContext,
 )
 
 
@@ -83,6 +86,9 @@ def test_provider_advance_use_case():
         ProviderConfig(
             IRepository, use_class=FooDBCatsRepository
         ),  # register base type against a concrete_type
+        ProviderConfig(
+            IContext, use_class=get_class_import(TransientRequestContext)
+        ),  # register base type against a concrete_type
         ProviderConfig(
             IDBContext, use_class=AnyDBContext
         ),  # register base type against a concrete_type
@@ -93,8 +99,10 @@ def test_provider_advance_use_case():
         provider.register(injector.container)
 
     repository = injector.get(IRepository)
+    ictx = injector.get(IContext)
     db_context = injector.get(IDBContext)
     assert isinstance(repository, FooDBCatsRepository)
+    assert isinstance(ictx, TransientRequestContext)
     assert isinstance(db_context, AnyDBContext)
     assert repository.context == db_context  # service registered as singleton