Refactored InjectByTag

Author: eadwinCode

docs/basics/testing.md

@@ -305,6 +305,7 @@ When controllers use `InjectByTag` for dependency injection, the resolver automa
 
 ```python
 from ellar.di import InjectByTag, ProviderConfig
+from ellar.common.types import T
 
 # Module with tagged provider
 @Module(
@@ -316,12 +317,14 @@ from ellar.di import InjectByTag, ProviderConfig
 class UserModule:
     pass
 
-# Controller using tagged dependency
+# Controller using tagged dependency (supports both syntaxes)
 @Controller()
 class UserController:
-    def __init__(self, user_repo: InjectByTag('user_repo')):
+    def __init__(self, user_repo: InjectByTag[T("user_repo")]):  # Generic syntax
         self.user_repo = user_repo
 
+# Or use callable syntax: InjectByTag('user_repo')
+
 # Automatic resolution works with tags!
 test_module = Test.create_test_module(
     controllers=[UserController],

docs/overview/providers.md

@@ -221,5 +221,11 @@ class AModule(ModuleBase):
 
 In the above example, we are tagging `Foo` as `first_foo` and `FooB` as `second_foo`. By doing this, we can resolve both services using their tag names, thus providing the possibility of resolving services by tag name or type.
 
-Also, services can be injected as a dependency by using tags. To achieve this, the `InjectByTag` decorator is used as a `**constructor**` argument.
+Also, services can be injected as a dependency by using tags. To achieve this, `InjectByTag` is used as a `**constructor**` argument.
 This allows for more flexibility in managing dependencies and resolving services based on tags.
+
+`InjectByTag` supports two syntaxes:
+- **Callable syntax**: `InjectByTag('tag_name')` 
+- **Generic syntax**: `InjectByTag[T("tag_name")]` where T is from `ellar.common.types.T`
+
+Both syntaxes work identically and can be used interchangeably based on your preference.

ellar/common/__init__.py

@@ -99,7 +99,13 @@
 from .serializer import Serializer, serialize_object
 from .templating import TemplateResponse, render_template, render_template_string
 
+
+def T(tag: str) -> str:
+    return tag
+
+
 __all__ = [
+    "T",
     "AnonymousIdentity",
     "ControllerBase",
     "serialize_object",

ellar/di/service_config.py

@@ -72,11 +72,12 @@ class ProviderConfig(t.Generic[T]):
     >>> provider_config = ProviderConfig(SomeClass, scope=request_scope)
     >>> provider_config.register(container)
 
-    Example with tag:
+    Example with tag (supports both callable and generic syntax):
 
     >>> provider_config = ProviderConfig(SomeClass, tag='some_tag')
     >>> provider_config.register(container)
-    >>> instance = container.get(InjectByTag('some_tag'))
+    >>> instance = container.get(InjectByTag('some_tag'))  # Callable syntax
+    >>> # or: instance = container.get(InjectByTag[T('some_tag')])  # Generic syntax
     >>> assert isinstance(instance, SomeClass)
 
 
@@ -315,10 +316,14 @@ def get_scope(
     )
 
 
-def InjectByTag(tag: str) -> t.Any:
+class _InjectByTagClass:
     """
     Inject a provider/service by tag.
 
+    Supports both callable and generic syntax:
+    - InjectByTag('A')  # callable syntax
+    - InjectByTag['A']  # generic syntax
+
     For example:
 
     class A:
@@ -332,6 +337,12 @@ def __init__(self, a: InjectByTag('A'), b: AnotherType):
             self.a = a
             self.b = b
 
+    # Or using generic syntax:
+    class SomeClass:
+        def __init__(self, a: InjectByTag['A'], b: AnotherType):
+            self.a = a
+            self.b = b
+
     injector = EllarInjector()
     injector.container.register_exact_scoped(A, tag='A')
     injector.container.register_exact_scoped(AnotherType)
@@ -340,8 +351,30 @@ def __init__(self, a: InjectByTag('A'), b: AnotherType):
     instance = injector.get(SomeClass)
     assert instance.a.name == 'A'
     assert instance.b.name == 'AnotherType'
-
-    :param tag: Registered Provider/Service tag name
-    :return: typing.Any
     """
-    return t.NewType(Tag(tag), Tag)
+
+    def __call__(self, tag: str) -> t.Any:
+        """
+        Callable syntax: InjectByTag('tag_name')
+
+        :param tag: Registered Provider/Service tag name
+        :return: A NewType for tagged dependency injection
+        """
+        return t.NewType(Tag(tag), Tag)
+
+    def __getitem__(self, tag: str) -> t.Any:
+        """
+        Generic syntax: InjectByTag['tag_name']
+
+        :param tag: Registered Provider/Service tag name
+        :return: A NewType for tagged dependency injection
+        """
+        return t.NewType(Tag(tag), Tag)
+
+    def __repr__(self) -> str:
+        """Return a string representation for debugging"""
+        return "InjectByTag"
+
+
+# Create singleton instance to support both syntaxes
+InjectByTag = _InjectByTagClass()

tests/test_testing_dependency_resolution.py

@@ -3,7 +3,7 @@
 """
 
 import pytest
-from ellar.common import Controller, Module, get
+from ellar.common import Controller, Module, T, get
 from ellar.core import ForwardRefModule, ModuleBase
 from ellar.di import InjectByTag, ProviderConfig, injectable
 from ellar.di.exceptions import UnsatisfiedRequirement
@@ -519,7 +519,7 @@ class ComplexAppModule(ModuleBase):
 
     @Controller()
     class ComplexController:
-        def __init__(self, user_repo: InjectByTag("user_repo"), auth: IAuthService):
+        def __init__(self, user_repo: InjectByTag[T("user_repo")], auth: IAuthService):
             self.user_repo = user_repo
             self.auth = auth