refactor(*): Remove mutable arguments from ContainerBuilder

Author: Denis Navarro

aiodi/resolver/__init__.py

@@ -43,7 +43,7 @@ def times(self) -> int:
 
 class Resolver(ABC, Generic[Metadata, Value]):
     @abstractmethod
-    def extract_metadata(self, data: Dict[str, Any], extra: Dict[str, Any] = {}) -> Metadata:
+    def extract_metadata(self, data: Dict[str, Any], extra: Dict[str, Any]) -> Metadata:
         """
         Extract metadata from data
 
@@ -53,7 +53,7 @@ def extract_metadata(self, data: Dict[str, Any], extra: Dict[str, Any] = {}) ->
         """
 
     @abstractmethod
-    def parse_value(self, metadata: Metadata, retries: int = -1, extra: Dict[str, Any] = {}) -> Value:
+    def parse_value(self, metadata: Metadata, retries: int, extra: Dict[str, Any]) -> Value:
         """
         Parse value from metadata
 

aiodi/resolver/loader.py

@@ -62,9 +62,7 @@ def from_metadata(cls, metadata: LoaderMetadata, data: OutputData) -> 'LoadData'
 
 
 class LoaderResolver(Resolver[LoaderMetadata, LoadData]):
-    def extract_metadata(
-        self, data: Dict[str, Any], extra: Dict[str, Any] = {}  # pylint: disable=W0613
-    ) -> LoaderMetadata:
+    def extract_metadata(self, data: Dict[str, Any], extra: Dict[str, Any]) -> LoaderMetadata:  # pylint: disable=W0613
         return LoaderMetadata(
             path_data=data['path_data'],
             decoders=data['decoders'],
@@ -73,8 +71,8 @@ def extract_metadata(
     def parse_value(
         self,
         metadata: LoaderMetadata,
-        retries: int = -1,  # pylint: disable=W0613
-        extra: Dict[str, Any] = {},  # pylint: disable=W0613
+        retries: int,  # pylint: disable=W0613
+        extra: Dict[str, Any],  # pylint: disable=W0613
     ) -> LoadData:
         return LoadData.from_metadata(metadata=metadata, data=metadata.decode())
 
@@ -83,5 +81,5 @@ def prepare_loader_to_parse(
     resolver: Resolver[Any, Any], items: Dict[str, Any], extra: Dict[str, Any]  # pylint: disable=W0613
 ) -> Dict[str, Tuple[LoaderMetadata, int]]:
     return {
-        'value': (resolver.extract_metadata(data=items), 0),
+        'value': (resolver.extract_metadata(data=items, extra=extra), 0),
     }

aiodi/resolver/path.py

@@ -47,16 +47,14 @@ def from_metadata(cls, metadata: PathMetadata) -> 'PathData':
 
 
 class PathResolver(Resolver[PathMetadata, PathData]):
-    def extract_metadata(
-        self, data: Dict[str, Any], extra: Dict[str, Any] = {}  # pylint: disable=W0613
-    ) -> PathMetadata:
+    def extract_metadata(self, data: Dict[str, Any], extra: Dict[str, Any]) -> PathMetadata:  # pylint: disable=W0613
         return PathMetadata(cwd=data.get('cwd', None), filenames=data.get('filenames', []))
 
     def parse_value(
         self,
         metadata: PathMetadata,
-        retries: int = -1,  # pylint: disable=W0613
-        extra: Dict[str, Any] = {},  # pylint: disable=W0613
+        retries: int,  # pylint: disable=W0613
+        extra: Dict[str, Any],  # pylint: disable=W0613
     ) -> PathData:
         return PathData.from_metadata(metadata)
 
@@ -65,5 +63,5 @@ def prepare_path_to_parse(
     resolver: Resolver[Any, Any], items: Dict[str, Any], extra: Dict[str, Any]  # pylint: disable=W0613
 ) -> Dict[str, Tuple[PathMetadata, int]]:
     return {
-        'value': (resolver.extract_metadata(data=items), 0),
+        'value': (resolver.extract_metadata(data=items, extra=extra), 0),
     }

aiodi/resolver/service.py

@@ -73,7 +73,7 @@ def compute_excludes(self) -> List[str]:
         return [left] if len(rights) == 0 else rights
 
     def compute_services(
-        self, resolver: Resolver[Any, Any], resources: List[str], excludes: List[str]
+        self, resolver: Resolver[Any, Any], resources: List[str], excludes: List[str], extra: Dict[str, Any]
     ) -> Dict[str, Tuple['ServiceMetadata', int]]:
         names: List[str] = []
         for include in resources:
@@ -100,7 +100,8 @@ def compute_services(
                             autowire=self.autowire,
                             autoconfigure=self.autoconfigure,
                         ),
-                    }
+                    },
+                    extra=extra,
                 ),
                 0,
             )
@@ -208,9 +209,7 @@ def _define_service_type(name: str, typ: str, cls: str) -> Tuple[Type[Any], Type
 
         return typ, cls  # type: ignore
 
-    def extract_metadata(
-        self, data: Dict[str, Any], extra: Dict[str, Any] = {}  # pylint: disable=W0613
-    ) -> ServiceMetadata:
+    def extract_metadata(self, data: Dict[str, Any], extra: Dict[str, Any]) -> ServiceMetadata:  # pylint: disable=W0613
         key = cast(str, data.get('key'))
         val = data.get('val')
         defaults = cast(ServiceDefaults, data.get('defaults'))
@@ -233,7 +232,7 @@ def extract_metadata(
             defaults=defaults,
         )
 
-    def parse_value(self, metadata: ServiceMetadata, retries: int = -1, extra: Dict[str, Any] = {}) -> Any:
+    def parse_value(self, metadata: ServiceMetadata, retries: int, extra: Dict[str, Any]) -> Any:
         _variables = cast(Dict[str, Any], extra.get('variables'))
         _services = cast(Dict[str, Any], extra.get('services'))
         variable_resolver = cast(Resolver, extra.get('resolvers', {}).get('variable'))
@@ -248,8 +247,10 @@ def parse_value(self, metadata: ServiceMetadata, retries: int = -1, extra: Dict[
                         data={
                             'key': '@{0}:{1}'.format(metadata.name, param.name),
                             'val': metadata.arguments[param.name],
-                        }
+                        },
+                        extra=extra,
                     ),
+                    retries=-1,
                     extra={'variables': _variables},
                 )
             elif param.source_kind == 'svc':
@@ -287,11 +288,14 @@ def prepare_services_to_parse(
         if defaults.has_resources():
             services.update(
                 defaults.compute_services(
-                    resolver=resolver, resources=defaults.compute_resources(), excludes=defaults.compute_excludes()
+                    resolver=resolver,
+                    resources=defaults.compute_resources(),
+                    excludes=defaults.compute_excludes(),
+                    extra=extra,
                 )
             )
         else:
-            metadata = resolver.extract_metadata(data={'key': key, 'val': val, 'defaults': defaults})
+            metadata = resolver.extract_metadata(data={'key': key, 'val': val, 'defaults': defaults}, extra=extra)
             if is_abstract(metadata.type):
                 raise TypeError('Can not instantiate abstract class <{0}>!'.format(metadata.name))
             services[key] = (metadata, 0)

aiodi/resolver/variable.py

@@ -11,7 +11,7 @@
 class VariableMetadata(NamedTuple):
     name: str
     value: Any
-    matches: List['VariableMetadata.MatchMetadata'] = []  # type: ignore
+    matches: List['VariableMetadata.MatchMetadata']  # type: ignore
 
     class MatchMetadata(NamedTuple):  # type: ignore
         source_kind: str
@@ -49,7 +49,7 @@ def __call__(string: Any) -> List[Match]:
         return __call__(string=val) or __call__(string=STATIC_TEMPLATE.format(type(val).__name__, key, val))
 
     def extract_metadata(
-        self, data: Dict[str, Any], extra: Dict[str, Any] = {}  # pylint: disable=W0613
+        self, data: Dict[str, Any], extra: Dict[str, Any]  # pylint: disable=W0613
     ) -> VariableMetadata:
         key: str = data.get('key') or raise_(KeyError('Missing key "key" to extract variable metadata'))  # type: ignore
         val: Any = data.get('val') or raise_(KeyError('Missing key "val" to extract variable metadata'))
@@ -64,8 +64,9 @@ def extract_metadata(
         )
 
     def parse_value(
-        self, metadata: VariableMetadata, retries: int = -1, extra: Dict[str, Any] = {}  # pylint: disable=W0613
+        self, metadata: VariableMetadata, retries: int, extra: Dict[str, Any]  # pylint: disable=W0613
     ) -> Any:
+        extra = {} if extra is None or not isinstance(extra, dict) else extra
         _variables: Dict[str, Any] = extra.get('variables')  # type: ignore
         if _variables is None:
             raise KeyError('Missing key "variables" to parse variable value')
@@ -100,4 +101,9 @@ def parse_value(
 def prepare_variables_to_parse(
     resolver: Resolver[Any, Any], items: Dict[str, Any], extra: Dict[str, Any]  # pylint: disable=W0613
 ) -> Dict[str, Tuple[VariableMetadata, int]]:
-    return dict([(key, (resolver.extract_metadata(data={'key': key, 'val': val}), 0)) for key, val in items.items()])
+    return dict(
+        [
+            (key, (resolver.extract_metadata(data={'key': key, 'val': val}, extra=extra), 0))
+            for key, val in items.items()
+        ]
+    )