Refactor schema module

src/dependency_injector/schema.py

@@ -9,19 +9,25 @@ from . import containers, providers
 Schema = Dict[Any, Any]
 
 
-def build_schema(schema: Schema) -> Dict[str, providers.Provider]:
+class SchemaProcessorV1:
-    """Build provider schema."""
-    container = containers.DynamicContainer()
-    _create_providers(container, schema['providers'])
-    _setup_injections(container, schema['providers'])
-    return container.providers
 
+    def __init__(self, schema: Schema) -> None:
+        self._schema = schema
+        self._container = containers.DynamicContainer()
 
-def _create_providers(
+    def process(self):
-        container: containers.Container,
+        """Process schema."""
-        providers_data: Dict[str, Any],
+        self._create_providers(self._schema)
-):
+        self._setup_injections(self._schema)
-    for provider_name, data in providers_data.items():
+
+    def get_providers(self):
+        """Return providers."""
+        return self._container.providers
+
+    def _create_providers(self, schema: Schema, container: Optional[containers.Container] = None) -> None:
+        if container is None:
+            container = self._container
+        for provider_name, data in schema['providers'].items():
             provider_type = _get_provider_cls(data['provider'])
             args = []
 
@@ -39,20 +45,14 @@ def _create_providers(
             container.set_provider(provider_name, provider)
 
             if isinstance(provider, providers.Container):
-            _create_providers(provider, data['providers'])
+                self._create_providers(schema=data, container=provider)
 
+    def _setup_injections(self, schema: Schema, container: Optional[containers.Container] = None) -> None:
+        if container is None:
+            container = self._container
 
-def _setup_injections(
+        for provider_name, data in schema['providers'].items():
-        container: containers.Container,
+            provider = getattr(container, provider_name)
-        providers_data: Dict[str, Any],
-        *,
-        current_container: Optional[containers.Container] = None,
-):
-    if not current_container:
-        current_container = container
-
-    for provider_name, data in providers_data.items():
-        provider = getattr(current_container, provider_name)
             args = []
             kwargs = {}
 
@@ -62,7 +62,7 @@ def _setup_injections(
                     injection = None
 
                     if isinstance(arg, str):
-                    injection = _resolve_provider(container, arg)
+                        injection = self._resolve_provider(arg)
 
                     # TODO: add inline injections
 
@@ -79,7 +79,7 @@ def _setup_injections(
                     injection = None
 
                     if isinstance(arg, str):
-                    injection = _resolve_provider(container, arg)
+                        injection = self._resolve_provider(arg)
 
                     # TODO: refactoring
                     if isinstance(arg, dict):
@@ -91,7 +91,7 @@ def _setup_injections(
                             if provides:
                                 provider_args.append(provides)
                         for provider_arg in arg.get('args', []):
-                        provider_args.append(_resolve_provider(container, provider_arg))
+                            provider_args.append(self._resolve_provider(provider_arg))
                         injection = provider_type(*provider_args)
 
                     if not injection:
@@ -102,13 +102,12 @@ def _setup_injections(
                 provider.add_kwargs(**kwargs)
 
             if isinstance(provider, providers.Container):
-            _setup_injections(container, data['providers'], current_container=provider)
+                self._setup_injections(schema=data, container=provider)
 
-
+    def _resolve_provider(self, name: str) -> Optional[providers.Provider]:
-def _resolve_provider(container: containers.Container, name: str) -> Optional[providers.Provider]:
         segments = name.split('.')
         try:
-        provider = getattr(container, segments[0])
+            provider = getattr(self._container, segments[0])
         except AttributeError:
             return None
 
@@ -128,6 +127,13 @@ def _resolve_provider(container: containers.Container, name: str) -> Optional[pr
         return provider
 
 
+def build_schema(schema: Schema) -> Dict[str, providers.Provider]:
+    """Build provider schema."""
+    schema_processor = SchemaProcessorV1(schema)
+    schema_processor.process()
+    return schema_processor.get_providers()
+
+
 def _get_provider_cls(provider_cls_name: str) -> Type[providers.Provider]:
     std_provider_type = _fetch_provider_cls_from_std(provider_cls_name)
     if std_provider_type: