add scope support to dicts

Author: eirikur-nc

injector/__init__.py

@@ -28,6 +28,7 @@
     Any,
     Callable,
     Dict,
+    Generator,
     Generic,
     Iterable,
     List,
@@ -340,7 +341,7 @@ def __repr__(self) -> str:
 
 
 @private
-class ListOfProviders(Provider, Generic[T]):
+class Multibinder(Provider, Generic[T]):
     """Provide a list of instances via other Providers."""
 
     _multi_bindings: List['Binding']
@@ -354,16 +355,7 @@ def append(self, provider: Provider[T], scope: Type['Scope']) -> None:
         pseudo_type = type(f"pseudo-type-{id(provider)}", (provider.__class__,), {})
         self._multi_bindings.append(Binding(pseudo_type, provider, scope))
 
-    def __repr__(self) -> str:
-        return '%s(%r)' % (type(self).__name__, self._multi_bindings)
-
-
-class MultiBindProvider(ListOfProviders[List[T]]):
-    """Used by :meth:`Binder.multibind` to flatten results of providers that
-    return sequences."""
-
-    def get(self, injector: 'Injector') -> List[T]:
-        result: List[T] = []
+    def get_scoped_providers(self, injector: 'Injector') -> Generator[Provider[T], None, None]:
         for binding in self._multi_bindings:
             if (
                 isinstance(binding.provider, ClassProvider)
@@ -377,19 +369,31 @@ def get(self, injector: 'Injector') -> List[T]:
                 scope_binding, _ = self._binder.get_binding(binding.scope)
             scope_instance: Scope = scope_binding.provider.get(injector)
             provider_instance = scope_instance.get(binding.interface, binding.provider)
-            instances = _ensure_iterable(provider_instance.get(injector))
+            yield provider_instance
+
+    def __repr__(self) -> str:
+        return '%s(%r)' % (type(self).__name__, self._multi_bindings)
+
+
+class MultiBindProvider(Multibinder[List[T]]):
+    """Used by :meth:`Binder.multibind` to flatten results of providers that
+    return sequences."""
+
+    def get(self, injector: 'Injector') -> List[T]:
+        result: List[T] = []
+        for provider in self.get_scoped_providers(injector):
+            instances: List[T] = _ensure_iterable(provider.get(injector))
             result.extend(instances)
         return result
 
 
-class MapBindProvider(ListOfProviders[Dict[str, T]]):
+class MapBindProvider(Multibinder[Dict[str, T]]):
     """A provider for map bindings."""
 
     def get(self, injector: 'Injector') -> Dict[str, T]:
         map: Dict[str, T] = {}
-        for binding in self._multi_bindings:
-            # TODO: support scope
-            map.update(binding.provider.get(injector))
+        for provider in self.get_scoped_providers(injector):
+            map.update(provider.get(injector))
         return map
 
 
@@ -552,7 +556,7 @@ def multibind(
         :param scope: Optional Scope in which to bind.
         """
         if interface not in self._bindings:
-            provider: ListOfProviders
+            provider: Multibinder
             if (
                 isinstance(interface, dict)
                 or isinstance(interface, type)
@@ -566,7 +570,7 @@ def multibind(
             self._bindings[interface] = binding
         else:
             binding = self._bindings[interface]
-            assert isinstance(binding.provider, ListOfProviders)
+            assert isinstance(binding.provider, Multibinder)
             provider = binding.provider
 
         if isinstance(provider, MultiBindProvider) and isinstance(to, list):

injector_test.py

@@ -754,6 +754,22 @@ def configure(binder: Binder) -> None:
     assert first_list[2] is second_list[2]
 
 
+def test_multibind_dict_scopes_applies_to_the_bound_items() -> None:
+    def configure(binder: Binder) -> None:
+        binder.multibind(Dict[str, Plugin], to={'a': PluginA}, scope=singleton)
+        binder.multibind(Dict[str, Plugin], to={'b': PluginB})
+        binder.multibind(Dict[str, Plugin], to={'c': PluginC}, scope=singleton)
+
+    injector = Injector([configure])
+    first_dict = injector.get(Dict[str, Plugin])
+    second_dict = injector.get(Dict[str, Plugin])
+
+    assert first_dict is not second_dict
+    assert first_dict['a'] is second_dict['a']
+    assert first_dict['b'] is not second_dict['b']
+    assert first_dict['c'] is second_dict['c']
+
+
 def test_multibind_scopes_does_not_apply_to_the_type_globally() -> None:
     def configure(binder: Binder) -> None:
         binder.multibind(List[Plugin], to=PluginA, scope=singleton)