Resolving TypeError With Generic Decorators And Multiple Args In Dishka

July 14, 2025 by StackCamp Team 72 views

Generic Decorator with Multiple Args is Broken

Introduction

This article addresses an issue encountered while using a generic decorator with multiple arguments in the dishka dependency injection library. The problem arises when attempting to decorate a function that takes a generic type variable and a list of a related type as arguments. This article will explore the error, provide a detailed explanation of the code, and discuss the root cause of the TypeError. We will also delve into potential solutions and workarounds for this issue. Understanding the intricacies of generic decorators and type hints is crucial for developers aiming to leverage the full power of dependency injection in Python.

Problem Description

The core issue revolves around a TypeError that occurs when dishka attempts to process a generic decorator function. Specifically, the error message "TypeError: list[__main__.A] is not a generic class" indicates a problem with how type hints are being interpreted within the decorator's logic. This typically happens when the decorator tries to access or manipulate the type hint of a list containing a generic type. This can be a significant obstacle in building modular and maintainable applications, as generic decorators are a powerful tool for adding cross-cutting concerns to different parts of the codebase. Effective resolution of this issue is crucial for maintaining the flexibility and robustness of applications using dependency injection.

Code Snippet

To illustrate the problem, consider the following code snippet:

from typing import TypeVar, list

from dishka import Provider, Scope, decorate, make_container, provide, provide_all


class A:
    pass


class A1(A):
    pass


class A2(A):
    pass


TA = TypeVar("TA", bound=A)


class P(Provider):
    scope = Scope.APP

    @provide
    def alist(self) -> list[A]:
        return []

    @decorate
    def adda(self, x: TA, many: list[A]) -> TA:
        many.append(x)
        return x

    a = provide_all(A1, A2)


c = make_container(P())

Error Traceback

When executing this code, the following traceback is generated:

Traceback (most recent call last):
  File "/home/tishka17/src/dishka/tmp/collect_list.py", line 30, in <module>
    c = make_container(P())
        ^^^^^^^^^^^^^^^^^^^
  File "/home/tishka17/src/dishka/src/dishka/container.py", line 272, in make_container
    ).build()
      ^^^^^^^
  File "/home/tishka17/src/dishka/src/dishka/registry_builder.py", line 455, in build
    self._process_generic_decorator(provider, decorator)
  File "/home/tishka17/src/dishka/src/dishka/registry_builder.py", line 302, in _process_generic_decorator
    self._decorate_factory(
  File "/home/tishka17/src/dishka/src/dishka/registry_builder.py", line 387, in _decorate_factory
    new_factory = decorator.as_factory(
                  ^^^^^^^^^^^^^^^^^^^^^
  File "/home/tishka17/src/dishka/src/dishka/dependency_source/decorator.py", line 52, in as_factory
    self._replace_dep(
  File "/home/tishka17/src/dishka/src/dishka/dependency_source/decorator.py", line 82, in _replace_dep
    old_key.type_hint[args],
    ~~~~~~~~~~~~~~~~~^^^^^^
TypeError: list[__main__.A] is not a generic class

Detailed Explanation

Code Breakdown

Let's break down the code to understand the context of the error.

Class Definitions:
- A: A base class.
- A1, A2: Subclasses of A.
Type Variable:
- TA = TypeVar("TA", bound=A): Defines a generic type variable TA that is bound to class A.
Provider Class P:
- scope = Scope.APP: Sets the scope of the provider to APP.
- alist: A provider method that returns an empty list of type list[A]. This list is intended to hold instances of class A or its subclasses.
- adda: A decorator method that takes an instance x of type TA and a list many of type list[A]. It appends x to many and returns x. This is where the problem lies, as the dishka library struggles to handle the type hint list[A] within the decorator.
- a: Provides instances of A1 and A2 using provide_all.
Container Creation:
- c = make_container(P()): Creates a dependency injection container using the provider P. This is the line that triggers the error.

Root Cause of the Error

The error "TypeError: list[__main__.A] is not a generic class" arises because dishka's decorator implementation attempts to treat list[A] as a generic type that can be indexed, similar to how you would index a TypeVar. However, list[A] is a concrete type hint representing a list of A instances, not a generic type that can be further parameterized. The decorator logic in dishka expects to be able to extract type information from the type_hint using indexing (type_hint[args]), which is valid for generic types like TypeVar but not for concrete types like list[A]. This limitation in handling concrete type hints within generic decorators leads to the observed TypeError. Understanding this type system nuance is crucial for effectively debugging and resolving similar issues in the future.

Potential Solutions and Workarounds

While the direct use of list[A] in the decorator causes an error, there are several potential solutions and workarounds to achieve the desired functionality.

1. Using `typing.List`

One approach is to use typing.List instead of the built-in list. typing.List is a generic type and can be indexed. However, this might not directly solve the issue as dishka might still have trouble resolving the type hint within the decorator.

from typing import TypeVar, List

from dishka import Provider, Scope, decorate, make_container, provide, provide_all


class A:
    pass


class A1(A):
    pass


class A2(A):
    pass


TA = TypeVar("TA", bound=A)


class P(Provider):
    scope = Scope.APP

    @provide
    def alist(self) -> List[A]:
        return []

    @decorate
    def adda(self, x: TA, many: List[A]) -> TA:
        many.append(x)
        return x

    a = provide_all(A1, A2)


c = make_container(P())

2. Custom Type Hint

Another workaround is to introduce a custom type hint that represents the list of A instances. This can provide a more specific type that dishka might be able to handle better.

from typing import TypeVar, NewType

from dishka import Provider, Scope, decorate, make_container, provide, provide_all


class A:
    pass


class A1(A):
    pass


class A2(A):
    pass


TA = TypeVar("TA", bound=A)
AList = NewType("AList", list[A])


class P(Provider):
    scope = Scope.APP

    @provide
    def alist(self) -> list[A]:
        return []

    @decorate
    def adda(self, x: TA, many: list[A]) -> TA:
        many.append(x)
        return x

    a = provide_all(A1, A2)


c = make_container(P())

3. Refactoring the Decorator

A more robust solution might involve refactoring the decorator to avoid direct manipulation of type hints for concrete types. This could involve passing the list as a separate dependency or using a different mechanism to achieve the desired behavior. By decoupling the type hint manipulation from the core decorator logic, you can create more resilient and maintainable code. Effective refactoring requires careful consideration of the underlying design principles and the specific needs of the application.

4. Conditional Logic Inside the Decorator

You can also add conditional logic inside the decorator to handle different type hints. This approach involves checking the type hint and applying different logic based on whether it is a generic type or a concrete type. While this can be a viable workaround, it can also make the decorator more complex and harder to maintain. Careful implementation is key to avoiding potential pitfalls and ensuring the long-term maintainability of the code.

from typing import TypeVar, List, get_origin

from dishka import Provider, Scope, decorate, make_container, provide, provide_all


class A:
    pass


class A1(A):
    pass


class A2(A):
    pass


TA = TypeVar("TA", bound=A)


class P(Provider):
    scope = Scope.APP

    @provide
    def alist(self) -> List[A]:
        return []

    @decorate
    def adda(self, x: TA, many: List[A]) -> TA:
        if get_origin(many) is list:
            many.append(x)
        return x

    a = provide_all(A1, A2)


c = make_container(P())

Conclusion

In summary, the TypeError encountered when using a generic decorator with multiple arguments in dishka highlights the challenges of working with type hints and generic types in dependency injection. The error "TypeError: list[__main__.A] is not a generic class" specifically points to the library's inability to handle concrete type hints like list[A] within the decorator's logic. While this issue presents a hurdle, various solutions and workarounds, such as using typing.List, custom type hints, refactoring the decorator, or adding conditional logic, can be employed to achieve the desired functionality. Understanding the nuances of type hints and generic types is crucial for developers aiming to leverage the full power of dependency injection in Python. This article provides a comprehensive overview of the problem, its causes, and potential solutions, equipping developers with the knowledge to tackle similar issues effectively. Mastering these concepts is essential for building robust and maintainable applications using modern Python practices.