qena-shared-lib 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

qena_shared_lib/exceptions.py

@@ -73,7 +73,7 @@ class ServiceException(Exception):
         severity: Severity | None = None,
         tags: list[str] | None = None,
         extra: dict[str, str] | None = None,
-        logstash_logging: bool | None = None,
+        remote_logging: bool | None = None,
         extract_exc_info: bool | None = None,
     ):
         self._message = message
@@ -88,10 +88,10 @@ class ServiceException(Exception):
         self._tags = tags
         self._extra = extra
 
-        if logstash_logging is not None:
-            self._logstash_logging = logstash_logging
+        if remote_logging is not None:
+            self._remote_logging = remote_logging
         else:
-            self._logstash_logging = True
+            self._remote_logging = True
 
         if extract_exc_info is not None:
             self._extract_exc_info = extract_exc_info
@@ -117,8 +117,8 @@ class ServiceException(Exception):
         return self._extra
 
     @property
-    def logstash_logging(self) -> bool | None:
-        return self._logstash_logging
+    def remote_logging(self) -> bool | None:
+        return self._remote_logging
 
     @property
     def extract_exc_info(self) -> bool | None:
@@ -145,7 +145,7 @@ class HTTPServiceError(ServiceException):
         severity: Severity | None = None,
         tags: list[str] | None = None,
         extra: dict[str, str] | None = None,
-        logstash_logging: bool = True,
+        remote_logging: bool = True,
         extract_exc_info: bool = True,
     ):
         super().__init__(
@@ -153,7 +153,7 @@ class HTTPServiceError(ServiceException):
             severity=severity,
             tags=tags,
             extra=extra,
-            logstash_logging=logstash_logging,
+            remote_logging=remote_logging,
             extract_exc_info=extract_exc_info,
         )
 
@@ -379,7 +379,7 @@ class RabbitMQServiceException(ServiceException):
         severity: Severity | None = None,
         tags: list[str] | None = None,
         extra: dict[str, str] | None = None,
-        logstash_logging: bool | None = None,
+        remote_logging: bool | None = None,
         extract_exc_info: bool | None = None,
     ):
         super().__init__(
@@ -387,7 +387,7 @@ class RabbitMQServiceException(ServiceException):
             severity=severity,
             tags=tags,
             extra=extra,
-            logstash_logging=logstash_logging,
+            remote_logging=remote_logging,
             extract_exc_info=extract_exc_info,
         )
 

qena_shared_lib/http.py

@@ -168,8 +168,8 @@ def get(
     response_class: type[Response] = Default(JSONResponse),
     name: str | None = None,
     openapi_extra: dict[str, Any] | None = None,
-) -> Callable[[Callable], Callable]:
-    def wrapper(route_handler: Callable) -> Callable:
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def wrapper(route_handler: Callable[..., Any]) -> Callable[..., Any]:
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
@@ -225,8 +225,8 @@ def put(
     response_class: type[Response] = Default(JSONResponse),
     name: str | None = None,
     openapi_extra: dict[str, Any] | None = None,
-) -> Callable[[Callable], Callable]:
-    def wrapper(route_handler: Callable) -> Callable:
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def wrapper(route_handler: Callable[..., Any]) -> Callable[..., Any]:
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
@@ -282,8 +282,8 @@ def post(
     response_class: type[Response] = Default(JSONResponse),
     name: str | None = None,
     openapi_extra: dict[str, Any] | None = None,
-) -> Callable[[Callable], Callable]:
-    def wrapper(route_handler: Callable) -> Callable:
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def wrapper(route_handler: Callable[..., Any]) -> Callable[..., Any]:
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
@@ -339,8 +339,8 @@ def delete(
     response_class: type[Response] = Default(JSONResponse),
     name: str | None = None,
     openapi_extra: dict[str, Any] | None = None,
-) -> Callable[[Callable], Callable]:
-    def wrapper(route_handler: Callable) -> Callable:
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def wrapper(route_handler: Callable[..., Any]) -> Callable[..., Any]:
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
@@ -396,8 +396,8 @@ def options(
     response_class: type[Response] = Default(JSONResponse),
     name: str | None = None,
     openapi_extra: dict[str, Any] | None = None,
-) -> Callable[[Callable], Callable]:
-    def wrapper(route_handler: Callable) -> Callable:
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def wrapper(route_handler: Callable[..., Any]) -> Callable[..., Any]:
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
@@ -453,8 +453,8 @@ def head(
     response_class: type[Response] = Default(JSONResponse),
     name: str | None = None,
     openapi_extra: dict[str, Any] | None = None,
-) -> Callable[[Callable], Callable]:
-    def wrapper(route_handler: Callable) -> Callable:
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def wrapper(route_handler: Callable[..., Any]) -> Callable[..., Any]:
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
@@ -510,8 +510,8 @@ def patch(
     response_class: type[Response] = Default(JSONResponse),
     name: str | None = None,
     openapi_extra: dict[str, Any] | None = None,
-) -> Callable[[Callable], Callable]:
-    def wrapper(route_handler: Callable) -> Callable:
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def wrapper(route_handler: Callable[..., Any]) -> Callable[..., Any]:
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,
@@ -567,8 +567,8 @@ def trace(
     response_class: type[Response] = Default(JSONResponse),
     name: str | None = None,
     openapi_extra: dict[str, Any] | None = None,
-) -> Callable[[Callable], Callable]:
-    def wrapper(route_handler: Callable) -> Callable:
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    def wrapper(route_handler: Callable[..., Any]) -> Callable[..., Any]:
         setattr(
             route_handler,
             ROUTE_HANDLER_ATTRIBUTE,

qena_shared_lib/rabbitmq/__init__.py

@@ -1,9 +1,10 @@
 from ._base import AbstractRabbitMQService, RabbitMqManager
 from ._channel import BaseChannel
 from ._exception_handlers import (
-    handle_general_mq_exception,
-    handle_rabbit_mq_service_exception,
-    handle_validation_error,
+    AbstractRabbitMqExceptionHandler,
+    GeneralMqExceptionHandler,
+    RabbitMqServiceExceptionHandler,
+    ValidationErrorHandler,
 )
 from ._listener import (
     CONSUMER_ATTRIBUTE,
@@ -27,6 +28,7 @@ from ._publisher import Publisher
 from ._rpc_client import RpcClient
 
 __all__ = [
+    "AbstractRabbitMqExceptionHandler",
     "AbstractRabbitMQService",
     "BackoffRetryDelay",
     "BaseChannel",
@@ -37,18 +39,18 @@ __all__ = [
     "Consumer",
     "execute",
     "FixedRetryDelay",
-    "handle_general_mq_exception",
-    "handle_rabbit_mq_service_exception",
-    "handle_validation_error",
+    "GeneralMqExceptionHandler",
     "LISTENER_ATTRIBUTE",
     "ListenerBase",
     "ListenerContext",
     "Publisher",
     "RabbitMqManager",
+    "RabbitMqServiceExceptionHandler",
     "RetryDelayJitter",
     "RetryPolicy",
     "RPC_WORKER_ATTRIBUTE",
     "rpc_worker",
     "RpcClient",
     "RpcWorker",
+    "ValidationErrorHandler",
 ]

qena_shared_lib/rabbitmq/_base.py

@@ -5,17 +5,17 @@ from asyncio import (
     gather,
     iscoroutinefunction,
 )
-from dataclasses import dataclass
 from functools import partial
-from inspect import Parameter, signature
 from random import uniform
 from typing import (
     Any,
     Awaitable,
     Callable,
     Concatenate,
+    Generic,
     ParamSpec,
     TypeVar,
+    cast,
 )
 
 from pika.adapters.asyncio_connection import AsyncioConnection
@@ -25,20 +25,18 @@ from pika.frame import Method
 from prometheus_client import Counter
 from prometheus_client import Enum as PrometheusEnum
 from punq import Container, Scope
-from pydantic import ValidationError
 
-from ..dependencies.miscellaneous import validate_annotation
 from ..exceptions import (
     RabbitMQConnectionUnhealthyError,
-    ServiceException,
 )
 from ..logging import LoggerProvider
-from ..logstash import BaseLogstashSender
+from ..remotelogging import BaseRemoteLogSender
 from ..utils import AsyncEventLoopMixin
 from ._exception_handlers import (
-    handle_general_mq_exception,
-    handle_rabbit_mq_service_exception,
-    handle_validation_error,
+    AbstractRabbitMqExceptionHandler,
+    GeneralMqExceptionHandler,
+    RabbitMqServiceExceptionHandler,
+    ValidationErrorHandler,
 )
 from ._listener import (
     LISTENER_ATTRIBUTE,
@@ -56,29 +54,28 @@ __all__ = [
     "RabbitMqManager",
 ]
 
-E = TypeVar("E")
+
+E = TypeVar("E", bound=BaseException)
 P = ParamSpec("P")
-ExceptionHandler = (
-    Callable[Concatenate[ListenerContext, E, P], None]
-    | Callable[Concatenate[ListenerContext, E, P], Awaitable]
-)
+SyncExceptionHandler = Callable[Concatenate[ListenerContext, E, P], None]
+AsyncExcpetionHandler = Callable[
+    Concatenate[ListenerContext, E, P], Awaitable[None]
+]
+ExceptionHandler = SyncExceptionHandler[E, P] | AsyncExcpetionHandler[E, P]
 R = TypeVar("R")
 
 
 class AbstractRabbitMQService(ABC):
     def initialize(
         self, connection: AsyncioConnection, channel_pool: ChannelPool
-    ) -> Future:
+    ) -> Future[None]:
         raise NotImplementedError()
 
-
-@dataclass
-class ExceptionHandlerContainer:
-    handler: ExceptionHandler
-    dependencies: dict[str, type]
+    def close(self) -> Future[None]:
+        raise NotImplementedError()
 
 
-class RabbitMqManager(AsyncEventLoopMixin):
+class RabbitMqManager(Generic[E, P], AsyncEventLoopMixin):
     RABBITMQ_CONNECTION_STATE = PrometheusEnum(
         name="rabbitmq_connection_state",
         documentation="Babbitmq connection state",
@@ -97,7 +94,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
 
     def __init__(
         self,
-        logstash: BaseLogstashSender,
+        remote_logger: BaseRemoteLogSender,
         parameters: Parameters | str | None = None,
         reconnect_delay: float = 5.0,
         reconnect_delay_jitter: tuple[float, float] = (1.0, 5.0),
@@ -121,87 +118,39 @@ class RabbitMqManager(AsyncEventLoopMixin):
         self._connection_blocked = False
         self._services: list[AbstractRabbitMQService] = []
         self._exception_handlers: dict[
-            type[Exception], ExceptionHandlerContainer
+            type[Exception], AbstractRabbitMqExceptionHandler
         ] = {}
-
-        self.exception_handler(ServiceException)(
-            handle_rabbit_mq_service_exception
-        )
-        self.exception_handler(ValidationError)(handle_validation_error)
-        self.exception_handler(Exception)(handle_general_mq_exception)
-
         self._channel_pool = ChannelPool()
-        self._logstash = logstash
+        self._remote_logger = remote_logger
         self._logger = LoggerProvider.default().get_logger("rabbitmq")
 
     @property
     def container(self) -> Container:
         return self._container
 
-    def exception_handler(
-        self, exception: type[Exception]
-    ) -> Callable[[ExceptionHandler], ExceptionHandler]:
-        if not issubclass(exception, Exception):
-            raise TypeError(
-                f"exception should be of type `Exception`, got {exception}"
-            )
-
-        def wrapper(
-            handler: ExceptionHandler,
-        ) -> ExceptionHandler:
-            if not callable(handler):
-                raise TypeError(f"handler not a callable, got {type(handler)}")
-
-            dependencies = {}
-
-            for parameter_position, (parameter_name, parameter) in enumerate(
-                signature(handler).parameters.items()
+    def set_exception_handlers(
+        self, *exception_handlers: type[AbstractRabbitMqExceptionHandler]
+    ) -> None:
+        for index, exception_handler in enumerate(exception_handlers):
+            if not isinstance(exception_handler, type) or not issubclass(
+                exception_handler, AbstractRabbitMqExceptionHandler
             ):
-                if 0 <= parameter_position < 2:
-                    is_valid, expected_type = (
-                        self._is_valid_exception_handler_parameter(
-                            position=parameter_position,
-                            annotation=parameter.annotation,
-                        )
-                    )
-
-                    if not is_valid:
-                        raise TypeError(
-                            f"parameter `{parameter_name}` at `{parameter_position + 1}` is not annotated with type or subclass of `{expected_type}`, got {parameter.annotation}"
-                        )
-
-                    continue
-
-                dependency = validate_annotation(parameter)
-
-                if dependency is None:
-                    raise ValueError(
-                        f"handlers cannot contain parameters other than `Annotated[type, DependsOn(type)]`, got `{parameter_name}: {dependency}`"
-                    )
-
-                dependencies[parameter_name] = dependency
+                raise TypeError(
+                    f"exception handler {index} is {type(exception_handler)}, expected instance of type or subclass of `AbstractRabbitMqExceptionHandler`"
+                )
 
-            self._exception_handlers[exception] = ExceptionHandlerContainer(
-                handler=handler, dependencies=dependencies
+            self._container.register(
+                service=AbstractRabbitMqExceptionHandler,
+                factory=exception_handler,
+                scope=Scope.singleton,
             )
 
-            return handler
-
-        return wrapper
-
-    def _is_valid_exception_handler_parameter(
-        self, position: int, annotation: type
-    ) -> tuple[bool, type | None]:
-        if annotation is Parameter.empty:
-            return True, None
-
-        if position == 0 and annotation is not ListenerContext:
-            return False, ListenerContext
-
-        if position == 1 and not issubclass(annotation, Exception):
-            return False, Exception
-
-        return True, None
+    def init_default_exception_handlers(self) -> None:
+        self.set_exception_handlers(
+            RabbitMqServiceExceptionHandler,
+            ValidationErrorHandler,
+            GeneralMqExceptionHandler,
+        )
 
     def include_listener(self, listener: Listener | type[ListenerBase]) -> None:
         if isinstance(listener, Listener):
@@ -259,10 +208,11 @@ class RabbitMqManager(AsyncEventLoopMixin):
                 scope=Scope.singleton,
             )
 
-    def connect(self) -> Future:
+    def connect(self) -> Future[None]:
         if not self._connected:
             self._resolve_listener_classes()
             self._resolve_service_classes()
+            self._resolve_exception_handlers()
 
         if self._is_connection_healthy():
             raise RuntimeError("rabbitmq already connected and healthy")
@@ -289,6 +239,23 @@ class RabbitMqManager(AsyncEventLoopMixin):
             self._container.resolve_all(AbstractRabbitMQService)
         )
 
+    def _resolve_exception_handlers(self) -> None:
+        for exception_handler in self._container.resolve_all(
+            AbstractRabbitMqExceptionHandler
+        ):
+            exception_handler = cast(
+                AbstractRabbitMqExceptionHandler, exception_handler
+            )
+
+            if not callable(exception_handler):
+                raise ValueError(
+                    f"exception handler {exception_handler.__class__.__name__} is not callable"
+                )
+
+            self._exception_handlers[exception_handler.exception] = (
+                exception_handler
+            )
+
     @property
     def connection(self) -> AsyncioConnection:
         if not self._is_connection_healthy():
@@ -357,7 +324,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             and not self._connection.is_closed
         )
 
-    def disconnect(self) -> None:
+    async def disconnect(self) -> None:
         if self._disconnected:
             raise RuntimeError("already disconnected from rabbitmq")
 
@@ -366,6 +333,8 @@ class RabbitMqManager(AsyncEventLoopMixin):
         if self._connection is None:
             raise RabbitMQConnectionUnhealthyError("connection not ready yet")
 
+        await self._wait_for_listeners_and_services()
+
         if self._connection.is_closing or self._connection.is_closed:
             self._logger.info("already disconnected from rabbitmq")
         else:
@@ -374,6 +343,16 @@ class RabbitMqManager(AsyncEventLoopMixin):
 
         self.RABBITMQ_CONNECTION_STATE.state("disconnected")
 
+    async def _wait_for_listeners_and_services(self) -> None:
+        _ = await gather(
+            *(listener.cancel() for listener in self._listeners),
+            return_exceptions=True,
+        )
+        _ = await gather(
+            *(service.close() for service in self._services),
+            return_exceptions=True,
+        )
+
     def _on_connection_opened(self, connection: AsyncioConnection) -> None:
         self._connection = connection
         self._connection_blocked = False
@@ -396,7 +375,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             self._channel_pool.fill(self._connection)
         ).add_done_callback(self._channel_pool_filled)
 
-    def _channel_pool_drained(self, task: Task) -> None:
+    def _channel_pool_drained(self, task: Task[None]) -> None:
         if task.cancelled():
             if not self._connected and not self._connected_future.done():
                 _ = self._connected_future.cancel(None)
@@ -407,7 +386,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
 
         if exception is not None:
             if self._can_reconnect(exception):
-                self._logstash.error(
+                self._remote_logger.error(
                     message="couldn't drain the channel pool",
                     exception=exception,
                 )
@@ -429,7 +408,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
 
         self._connection_blocked = True
 
-        self._logstash.warning(
+        self._remote_logger.warning(
             "connection is blocked by broker, will not accept published messages"
         )
         self.RABBITMQ_PUBLISHER_BLOCKED_STATE.state("blocked")
@@ -441,13 +420,13 @@ class RabbitMqManager(AsyncEventLoopMixin):
 
         self._connection_blocked = False
 
-        self._logstash.info("broker resumed accepting published messages")
+        self._remote_logger.info("broker resumed accepting published messages")
         self.RABBITMQ_PUBLISHER_BLOCKED_STATE.state("unblocked")
 
     def _is_connection_blocked(self) -> bool:
         return self._connection_blocked
 
-    def _channel_pool_filled(self, task: Task) -> None:
+    def _channel_pool_filled(self, task: Task[None]) -> None:
         if task.cancelled():
             if not self._connected and not self._connected_future.done():
                 _ = self._connected_future.cancel(None)
@@ -460,7 +439,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             if not self._connected and not self._connected_future.done():
                 self._connected_future.set_exception(exception)
             elif self._can_reconnect(exception):
-                self._logstash.error(
+                self._remote_logger.error(
                     message="couldn't fill the channel pool",
                     exception=exception,
                 )
@@ -482,7 +461,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             *self._configure_listeners(), *self._initialize_services()
         ).add_done_callback(self._listener_and_service_config_and_init_done)
 
-    def _configure_listeners(self) -> list[Awaitable]:
+    def _configure_listeners(self) -> list[Awaitable[Any]]:
         try:
             assert self._connection is not None
 
@@ -492,7 +471,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
                     channel_pool=self._channel_pool,
                     on_exception_callback=self._invoke_exception_handler,
                     container=self._container,
-                    logstash=self._logstash,
+                    remote_logger=self._remote_logger,
                     global_retry_policy=self._listener_global_retry_policy,
                 )
                 for listener in self._listeners
@@ -504,7 +483,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
 
             return [listener_configuration_error_future]
 
-    def _initialize_services(self) -> list[Future]:
+    def _initialize_services(self) -> list[Future[Any]]:
         assert self._connection is not None
 
         try:
@@ -520,7 +499,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             return [service_initialization_error_future]
 
     def _listener_and_service_config_and_init_done(
-        self, future: Future
+        self, future: Future[list[Any]]
     ) -> None:
         if future.cancelled():
             if not self._connected and not self._connected_future.done():
@@ -534,7 +513,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             if not self._connected and not self._connected_future.done():
                 self._connected_future.set_exception(exception)
             elif self._can_reconnect(exception):
-                self._logstash.error(
+                self._remote_logger.error(
                     message="couldn't configure and initialize all listeners and services",
                     exception=exception,
                 )
@@ -579,7 +558,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             return
 
         if self._connected and not self._disconnected:
-            self._logstash.error(
+            self._remote_logger.error(
                 message="error while opening connection to rabbitmq",
                 exception=exception,
             )
@@ -599,29 +578,18 @@ class RabbitMqManager(AsyncEventLoopMixin):
         if exception_handler is None:
             return False
 
-        dependencies = {}
-
-        for (
-            parameter_name,
-            dependency,
-        ) in exception_handler.dependencies.items():
-            dependencies[parameter_name] = self._container.resolve(dependency)
+        assert callable(exception_handler)
 
-        if iscoroutinefunction(exception_handler.handler):
+        if self._is_async_exception_handler(exception_handler):
             self.loop.create_task(
-                exception_handler.handler(context, exception, **dependencies)
+                exception_handler(context, exception)
             ).add_done_callback(
                 partial(self._on_exception_handler_done, context)
             )
         else:
             self.loop.run_in_executor(
                 executor=None,
-                func=partial(
-                    exception_handler.handler,
-                    context,
-                    exception,
-                    **dependencies,
-                ),
+                func=partial(exception_handler, context, exception),
             ).add_done_callback(
                 partial(self._on_exception_handler_done, context)
             )
@@ -634,6 +602,18 @@ class RabbitMqManager(AsyncEventLoopMixin):
 
         return True
 
+    def _is_async_exception_handler(
+        self, exception_handler: AbstractRabbitMqExceptionHandler
+    ) -> bool:
+        exception_handler_callable = getattr(
+            exception_handler, "__call__", None
+        )
+
+        if exception_handler_callable is None:
+            raise RuntimeError("exception handler has not `__call__` method")
+
+        return iscoroutinefunction(exception_handler_callable)
+
     def _on_exception_handler_done(
         self, context: ListenerContext, task_or_future: Task[Any] | Future[Any]
     ) -> None:
@@ -643,7 +623,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
         exception = task_or_future.exception()
 
         if exception is not None:
-            self._logstash.error(
+            self._remote_logger.error(
                 message="error occured in listener exception handler",
                 exception=exception,
             )
@@ -661,7 +641,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             return
 
         if self._can_reconnect(exception):
-            self._logstash.error(
+            self._remote_logger.error(
                 message="connection to rabbitmq closed unexpectedly, attempting to reconnect",
                 exception=exception,
             )
@@ -683,7 +663,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
                 if not self._connected_future.done():
                     self._connected_future.set_result(None)
 
-                self._logstash.exception(
+                self._remote_logger.exception(
                     "couldn't reconnect to rabbitmq, attempting to reconnect"
                 )
                 self._reconnect()
@@ -705,7 +685,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             return
 
         if self._can_reconnect(exception):
-            self._logstash.error(
+            self._remote_logger.error(
                 message="couldn't reconnect to rabbitmq, attempting to reconnect",
                 exception=exception,
             )

qena_shared_lib/rabbitmq/_channel.py

@@ -1,6 +1,7 @@
 from asyncio import Future
 from inspect import Traceback
 from random import uniform
+from typing import cast
 from uuid import UUID, uuid4
 
 from pika.adapters.asyncio_connection import AsyncioConnection
@@ -86,7 +87,9 @@ class BaseChannel(AsyncEventLoopMixin):
         if self._channel is None:
             raise RuntimeError("underlying channel not set")
 
-        return self._channel.is_closing or self._channel.is_closed
+        return cast(bool, self._channel.is_closing) or cast(
+            bool, self._channel.is_closed
+        )
 
     def _on_cancelled(self, method: Basic.Cancel) -> None:
         del method