fix mypy errors

aiogram/dispatcher/dispatcher.py

@@ -292,10 +292,13 @@ class Dispatcher(Router):
         event: TelegramObject,
         **kwargs: Any,
     ) -> Any:
-        if self.tracer is None:
+        if (
+            self.tracer is None
+            or (tracer_manager := self.tracer.get_trigger_span_manager(event)) is None
+        ):
             return await super()._propagate_event(observer, update_type, event, **kwargs)
 
-        async with self.tracer.get_trigger_span_manager(event):
+        async with tracer_manager:
             return await super()._propagate_event(observer, update_type, event, **kwargs)
 
     @classmethod

aiogram/dispatcher/event/telegram.py

@@ -136,10 +136,12 @@ class TelegramEventObserver:
                     handler_manager := tracer_instance.get_handler_span_manager(handler)
                 ):
 
-                    @functools.wraps(handler.callback)
+                    @functools.wraps(handler.call)
-                    async def handler_wrapper(event, **kwargs):
+                    async def handler_wrapper(
+                        event: TelegramObject, *args: Any, **kwargs: Any
+                    ) -> Any:
                         async with handler_manager:  # noqa: B023
-                            return await handler.call(event, **kwargs)  # noqa: B023
+                            return await handler.call(event, *args, **kwargs)  # noqa: B023
 
                     handler_call = handler_wrapper
                 wrapped_inner = self.outer_middleware.wrap_middlewares(

aiogram/dispatcher/middlewares/manager.py

@@ -58,15 +58,15 @@ class MiddlewareManager(Sequence[MiddlewareType[TelegramObject]]):
     async def middleware_step(
         tracer_instance: AbstractTracer,
         middleware: MiddlewareType[TelegramObject],
-        handler,
+        handler: CallbackType,
         event: TelegramObject,
-        data,
+        kwargs: dict[str, Any],
     ) -> Any:
         manager = tracer_instance.get_middleware_span_manager(middleware)
         if manager is None:
-            return await middleware(handler, event, data)
+            return await middleware(handler, event, kwargs)
         async with manager:
-            return await middleware(handler, event, data)
+            return await middleware(handler, event, kwargs)
 
     @staticmethod
     def wrap_middlewares(
@@ -80,10 +80,10 @@ class MiddlewareManager(Sequence[MiddlewareType[TelegramObject]]):
         tracer_instance = tracer.get()
         if tracer_instance is None:
             for m in reversed(middlewares):
-                middleware = functools.partial(m, middleware)
+                middleware = functools.partial(m, middleware)  # type: ignore[assignment]
         else:
             for m in reversed(middlewares):
-                middleware = functools.partial(
+                middleware = functools.partial(  # type: ignore[assignment]
                     MiddlewareManager.middleware_step, tracer_instance, m, middleware
                 )
         return middleware

aiogram/tracer.py

@@ -5,35 +5,36 @@ from contextlib import AbstractAsyncContextManager
 from contextvars import ContextVar
 from typing import TYPE_CHECKING
 
+from aiogram.dispatcher.event.bases import MiddlewareEventType, MiddlewareType
+
 if TYPE_CHECKING:
-    from aiogram import BaseMiddleware
+    from aiogram.dispatcher.event.handler import HandlerObject
-    from aiogram.dispatcher.event.handler import CallbackType, HandlerObject
     from aiogram.types import TelegramObject
 
 
 class AbstractTracer(ABC):
     @abstractmethod
     def get_middleware_span_manager(
-        self, middleware: BaseMiddleware
+        self, middleware: MiddlewareType[MiddlewareEventType]
-    ) -> AbstractAsyncContextManager | None:
+    ) -> AbstractAsyncContextManager[None] | None:
         pass
 
     @abstractmethod
     def get_handler_span_manager(
         self, handler: HandlerObject
-    ) -> AbstractAsyncContextManager | None:
+    ) -> AbstractAsyncContextManager[None] | None:
         pass
 
     @abstractmethod
     def get_trigger_span_manager(
         self, event: TelegramObject
-    ) -> AbstractAsyncContextManager | None:
+    ) -> AbstractAsyncContextManager[None] | None:
         pass
 
     @abstractmethod
     def get_filter_span_manager(
         self, handler: HandlerObject
-    ) -> AbstractAsyncContextManager | None:
+    ) -> AbstractAsyncContextManager[None] | None:
         pass