Implement lazy initialization and improve copying for Configuration provider

src/dependency_injector/providers.pyi

@@ -215,7 +215,19 @@ class Configuration(Object[Any]):
     def __exit__(self, *exc_info: Any) -> None: ...
     def __getattr__(self, item: str) -> ConfigurationOption: ...
     def __getitem__(self, item: Union[str, Provider]) -> ConfigurationOption: ...
+
     def get_name(self) -> str: ...
+    def set_name(self, name: str) -> Configuration: ...
+
+    def get_default(self) -> _Dict[Any, Any]: ...
+    def set_default(self, default: _Dict[Any, Any]): ...
+
+    def get_strict(self) -> bool: ...
+    def set_strict(self, strict: bool) -> Configuration: ...
+
+    def get_children(self) -> _Dict[str, ConfigurationOption]: ...
+    def set_children(self, children: _Dict[str, ConfigurationOption) -> Configuration: ...
+
     def get(self, selector: str) -> Any: ...
     def set(self, selector: str, value: Any) -> OverridingContext[P]: ...
     def reset_cache(self) -> None: ...

src/dependency_injector/providers.pyx

@@ -1709,29 +1709,23 @@ cdef class Configuration(Object):
     def __init__(self, name=DEFAULT_NAME, default=None, strict=False):
         self.__name = name
         self.__strict = strict
-
-        value = {}
-        if default is not None:
-            assert isinstance(default, dict), default
-            value = default.copy()
-
         self.__children = {}
 
-        super().__init__(value)
+        super().__init__(provides={})
+        self.set_default(default)
 
     def __deepcopy__(self, memo):
-        cdef Configuration copied
-
         copied = memo.get(id(self))
         if copied is not None:
             return copied
 
-        copied = self.__class__(self.__name, self.__provides, self.__strict)
+        copied = _memorized_duplicate(self, memo)
-        memo[id(self)] = copied
+        copied.set_name(self.get_name())
+        copied.set_default(self.get_default())
+        copied.set_strict(self.get_strict())
+        copied.set_children(deepcopy(self.get_children(), memo))
 
-        copied.__children = deepcopy(self.__children, memo)
         self._copy_overridings(copied, memo)
-
         return copied
 
     def __enter__(self):
@@ -1764,8 +1758,45 @@ cdef class Configuration(Object):
         return child
 
     def get_name(self):
+        """Return name."""
         return self.__name
 
+    def set_name(self, name):
+        """Set name."""
+        self.__name = name
+        return self
+
+    def get_default(self):
+        """Return default."""
+        return self.provides
+
+    def set_default(self, default):
+        """Set default."""
+        if not default:
+            return self
+
+        assert isinstance(default, dict), default
+        self.set_provides(default.copy())
+        return self
+
+    def get_strict(self):
+        """Return strict flag."""
+        return self.__strict
+
+    def set_strict(self, strict):
+        """Set strict flag."""
+        self.__strict = strict
+        return self
+
+    def get_children(self):
+        """Return children options."""
+        return self.__children
+
+    def set_children(self, children):
+        """Set children options."""
+        self.__children = children
+        return self
+
     def get(self, selector, required=False):
         """Return configuration option.
 

tests/unit/providers/test_configuration_py2_py3.py

@@ -28,6 +28,28 @@ class ConfigTests(unittest.TestCase):
     def tearDown(self):
         del self.config
 
+    def test_init_optional(self):
+        provider = providers.Configuration()
+        provider.set_name('myconfig')
+        provider.set_default({'foo': 'bar'})
+        provider.set_strict(True)
+
+        self.assertEqual(provider.get_name(), 'myconfig')
+        self.assertEqual(provider.get_default(), {'foo': 'bar'})
+        self.assertTrue(provider.get_strict())
+
+    def test_set_name_returns_self(self):
+        provider = providers.Configuration()
+        self.assertIs(provider.set_name('myconfig'), provider)
+
+    def test_set_default_returns_self(self):
+        provider = providers.Configuration()
+        self.assertIs(provider.set_default({}), provider)
+
+    def test_set_strict_returns_self(self):
+        provider = providers.Configuration()
+        self.assertIs(provider.set_strict(True), provider)
+
     def test_default_name(self):
         config = providers.Configuration()
         self.assertEqual(config.get_name(), 'config')