Fix issues where tagged constructor injection didn't work in python 3.7.

Author: runemalm

src/dependency_injection/container.py

@@ -222,45 +222,46 @@ def _inject_dependencies(
  dependencies = {}
  for param_name, param_info in params.items():
  if param_name != "self":
- # Check for *args and **kwargs
  if param_info.kind == inspect.Parameter.VAR_POSITIONAL:
- # *args parameter
  pass
  elif param_info.kind == inspect.Parameter.VAR_KEYWORD:
- # **kwargs parameter
  pass
  else:
- # Priority 1: Check if constructor_args has argument with same name
  if constructor_args and param_name in constructor_args:
  dependencies[param_name] = constructor_args[param_name]
  else:
- # Priority 2: Handle List[Tagged], List[AnyTagged[...]], ...
- tagged_dependencies = []
  if (
  hasattr(param_info.annotation, "__origin__")
  and param_info.annotation.__origin__ is list
  ):
  inner_type = param_info.annotation.__args__[0]
 
- if isinstance(inner_type, Tagged):
+ tagged_dependencies = []
+ if isinstance(inner_type, type) and issubclass(
+ inner_type, Tagged
+ ):
+ tagged_type = inner_type.tag
  tagged_dependencies = self.resolve_all(
- tags={inner_type.tag}
+ tags={tagged_type}
  )
 
- elif isinstance(inner_type, AnyTagged):
+ elif isinstance(inner_type, type) and issubclass(
+ inner_type, AnyTagged
+ ):
  tagged_dependencies = self.resolve_all(
  tags=inner_type.tags, match_all_tags=False
  )
 
- elif isinstance(inner_type, AllTagged):
+ elif isinstance(inner_type, type) and issubclass(
+ inner_type, AllTagged
+ ):
  tagged_dependencies = self.resolve_all(
  tags=inner_type.tags, match_all_tags=True
  )
 
  dependencies[param_name] = tagged_dependencies
 
  else:
- # Priority 3: Regular type resolution
  try:
  dependencies[param_name] = self.resolve(
  param_info.annotation, scope_name=scope_name

src/dependency_injection/tags/all_tagged.py

@@ -1,12 +1,20 @@
-from typing import Type, Tuple, Set, Union
+from typing import Generic, Set, Tuple, Type, TypeVar, Union
 
+T = TypeVar("T")
 
-class AllTagged:
- def __init__(self, tags: Tuple[Type, ...]):
- self.tags: Set[Type] = set(tags)
+
+class AllTagged(Generic[T]):
+ def __init__(self, tags: Tuple[Type[T], ...]):
+ self.tags: Set[Type[T]] = set(tags)
 
  @classmethod
- def __class_getitem__(cls, item: Union[Type, Tuple[Type, ...]]) -> "AllTagged":
+ def __class_getitem__(
+ cls, item: Union[Type[T], Tuple[Type[T], ...]]
+ ) -> Type["AllTagged"]:
  if not isinstance(item, tuple):
  item = (item,)
- return cls(item)
+ return type(
+ f'AllTagged_{"_".join([t.__name__ for t in item])}',
+ (cls,),
+ {"tags": set(item)},
+ )

src/dependency_injection/tags/any_tagged.py

@@ -1,12 +1,22 @@
-from typing import Type, Tuple, Set, Union
+from typing import Type, Generic, TypeVar, Tuple, Union, Set
 
+T = TypeVar("T")
 
-class AnyTagged:
- def __init__(self, tags: Union[Tuple[Type, ...], Type]):
+
+class AnyTagged(Generic[T]):
+ def __init__(self, tags: Union[Tuple[Type[T], ...], Type[T]]):
  if not isinstance(tags, tuple):
  tags = (tags,)
- self.tags: Set[Type] = set(tags)
+ self.tags: Set[Type[T]] = set(tags)
 
  @classmethod
- def __class_getitem__(cls, item: Union[Type, Tuple[Type, ...]]) -> "AnyTagged":
- return cls(item)
+ def __class_getitem__(
+ cls, item: Union[Type[T], Tuple[Type[T], ...]]
+ ) -> Type["AnyTagged"]:
+ if not isinstance(item, tuple):
+ item = (item,)
+ return type(
+ f'AnyTagged_{"_".join([t.__name__ for t in item])}',
+ (cls,),
+ {"tags": set(item)},
+ )

src/dependency_injection/tags/tagged.py

@@ -1,10 +1,12 @@
-from typing import Type
+from typing import Type, Generic, TypeVar
 
+T = TypeVar("T")
 
-class Tagged:
- def __init__(self, tag: Type):
+
+class Tagged(Generic[T]):
+ def __init__(self, tag: Type[T]):
  self.tag = tag
 
  @classmethod
- def __class_getitem__(cls, item: Type) -> "Tagged":
- return cls(item)
+ def __class_getitem__(cls, item: Type[T]) -> Type["Tagged"]:
+ return type(f"Tagged_{item.__name__}", (cls,), {"tag": item})