Add overriding functionality on declarative container initialization

src/dependency_injector/containers.pyx

@@ -88,6 +88,18 @@ class DynamicContainer(object):
             del self.providers[name]
         super(DynamicContainer, self).__delattr__(name)
 
+    def set_providers(self, **providers):
+        """Set container providers.
+
+        :param providers: Dictionary of providers
+        :type providers:
+            dict[str, :py:class:`dependency_injector.providers.Provider`]
+
+        :rtype: None
+        """
+        for name, provider in six.iteritems(providers):
+            setattr(self, name, provider)
+
     def override(self, object overriding):
         """Override current container by overriding container.
 
@@ -111,6 +123,19 @@ class DynamicContainer(object):
             except AttributeError:
                 pass
 
+    def override_providers(self, **overriding_providers):
+        """Override container providers.
+
+        :param overriding_providers: Dictionary of providers
+        :type overriding_providers:
+            dict[str, :py:class:`dependency_injector.providers.Provider`]
+
+        :rtype: None
+        """
+        for name, overriding_provider in six.iteritems(overriding_providers):
+            container_provider = getattr(self, name)
+            container_provider.override(overriding_provider)
+
     def reset_last_overriding(self):
         """Reset last overriding provider for each container providers.
 
@@ -265,18 +290,16 @@ class DeclarativeContainer(object):
     :type: tuple[:py:class:`DeclarativeContainer`]
     """
 
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, **overriding_providers):
         """Constructor.
 
         :return: Dynamic container with copy of all providers.
         :rtype: :py:class:`DynamicContainer`
         """
-        container = cls.instance_type(*args, **kwargs)
+        container = cls.instance_type()
         container.provider_type = cls.provider_type
-
-        for name, provider in six.iteritems(deepcopy(cls.providers)):
-            setattr(container, name, provider)
-
+        container.set_providers(**deepcopy(cls.providers))
+        container.override_providers(**overriding_providers)
         return container
 
     @classmethod

tests/unit/containers/test_declarative.py

@@ -265,3 +265,12 @@ class DeclarativeContainerTests(unittest.TestCase):
                          dict(Container1=Container.Container1,
                               Container2=Container.Container2,
                               Container3=Container.Container3))
+
+    def test_init_with_overriding_providers(self):
+        p1 = providers.Provider()
+        p2 = providers.Provider()
+
+        container = ContainerA(p11=p1, p12=p2)
+
+        self.assertIs(container.p11.last_overriding, p1)
+        self.assertIs(container.p12.last_overriding, p2)

tests/unit/containers/test_dynamic.py

@@ -75,6 +75,16 @@ class DeclarativeContainerInstanceTests(unittest.TestCase):
         self.assertIs(ContainerA.provider_type,
                       containers.DeclarativeContainer.provider_type)
 
+    def test_set_providers(self):
+        p13 = providers.Provider()
+        p14 = providers.Provider()
+        container_a = ContainerA()
+
+        container_a.set_providers(p13=p13, p14=p14)
+
+        self.assertIs(container_a.p13, p13)
+        self.assertIs(container_a.p14, p14)
+
     def test_override(self):
         class _Container(containers.DeclarativeContainer):
             p11 = providers.Provider()
@@ -108,6 +118,22 @@ class DeclarativeContainerInstanceTests(unittest.TestCase):
         with self.assertRaises(errors.Error):
             container.override(container)
 
+    def test_override_providers(self):
+        p1 = providers.Provider()
+        p2 = providers.Provider()
+        container_a = ContainerA()
+
+        container_a.override_providers(p11=p1, p12=p2)
+
+        self.assertIs(container_a.p11.last_overriding, p1)
+        self.assertIs(container_a.p12.last_overriding, p2)
+
+    def test_override_providers_with_unknown_provider(self):
+        container_a = ContainerA()
+
+        with self.assertRaises(AttributeError):
+            container_a.override_providers(unknown=providers.Provider())
+
     def test_reset_last_overridding(self):
         class _Container(containers.DeclarativeContainer):
             p11 = providers.Provider()