omxtra 0.0.0.dev535__tar.gz → 0.0.0.dev536__tar.gz

{omxtra-0.0.0.dev535/omxtra.egg-info → omxtra-0.0.0.dev536}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omxtra
-Version: 0.0.0.dev535
+Version: 0.0.0.dev536
 Summary: omxtra
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev535
+Requires-Dist: omlish==0.0.0.dev536
 Provides-Extra: all
 Requires-Dist: h11~=0.16; extra == "all"
 Requires-Dist: h2~=4.3; extra == "all"

{omxtra-0.0.0.dev535 → omxtra-0.0.0.dev536}/omxtra/io/pipelines/_amalg.py

@@ -9,8 +9,8 @@ from .handlers.flatmap import FlatMapChannelPipelineHandler  # noqa
 from .handlers.fns import FnChannelPipelineHandler  # noqa
 from .handlers.queues import QueueChannelPipelineHandler  # noqa
 from .http.client.requests import PipelineHttpRequestEncoder  # noqa
-from .http.client.responses import PipelineHttpResponseHeadDecoder  # noqa
-from .http.server.requests import PipelineHttpRequestHeadDecoder  # noqa
+from .http.client.responses import PipelineHttpResponseDecoder  # noqa
+from .http.server.requests import PipelineHttpRequestDecoder  # noqa
 from .http.server.responses import PipelineHttpResponseEncoder  # noqa
 
 

{omxtra-0.0.0.dev535 → omxtra-0.0.0.dev536}/omxtra/io/pipelines/bytes/decoders.py

@@ -14,13 +14,13 @@ from omlish.io.streams.segmented import SegmentedByteStreamBuffer
 from omlish.io.streams.types import ByteStreamBuffer
 from omlish.io.streams.types import MutableByteStreamBuffer
 from omlish.io.streams.utils import ByteStreamBuffers
+from omlish.io.streams.utils import CanByteStreamBuffer
 from omlish.lite.abstract import Abstract
 from omlish.lite.check import check
 
 from ..core import ChannelPipelineHandler
 from ..core import ChannelPipelineHandlerContext
 from ..core import ChannelPipelineMessages
-from ..errors import DecodingChannelPipelineError
 from ..errors import IncompleteDecodingChannelPipelineError
 from ..flow.types import ChannelPipelineFlow
 from ..flow.types import ChannelPipelineFlowMessages
@@ -46,7 +46,7 @@ class UnicodeDecoderChannelPipelineHandler(ChannelPipelineHandler):
 
     def inbound(self, ctx: ChannelPipelineHandlerContext, msg: ta.Any) -> None:
         if ByteStreamBuffers.can_bytes(msg):
-            b = ByteStreamBuffers.any_to_bytes(msg)
+            b = ByteStreamBuffers.to_bytes(msg)
 
             msg = b.decode(self._encoding, errors=self._errors)
 
@@ -126,30 +126,12 @@ class DelimiterFrameDecoderChannelPipelineHandler(InboundBytesBufferingChannelPi
 ##
 
 
-class BytesToMessageDecoderChannelPipelineHandler(InboundBytesBufferingChannelPipelineHandler, Abstract):
-    def __init__(
-            self,
-            *,
-            max_buffer_size: ta.Optional[int] = None,
-            buffer_chunk_size: int = 64 * 1024,
-            scanning_buffer: bool = False,
-    ) -> None:
-        super().__init__()
-
-        self._max_buffer_size = max_buffer_size
-        self._buffer_chunk_size = buffer_chunk_size
-        self._scanning_buffer = scanning_buffer
-
-    def inbound_buffered_bytes(self) -> int:
-        if (buf := self._buf) is None:
-            return 0
-        return len(buf)
-
+class BytesToMessageDecoderChannelPipelineHandler(ChannelPipelineHandler, Abstract):
     @abc.abstractmethod
     def _decode(
             self,
             ctx: ChannelPipelineHandlerContext,
-            buf: ByteStreamBuffer,
+            data: CanByteStreamBuffer,
             out: ta.List[ta.Any],
             *,
             final: bool = False,
@@ -158,40 +140,20 @@ class BytesToMessageDecoderChannelPipelineHandler(InboundBytesBufferingChannelPi
 
     #
 
-    _buf: ta.Optional[MutableByteStreamBuffer] = None
-
-    def _new_buf(self) -> MutableByteStreamBuffer:
-        buf: MutableByteStreamBuffer = SegmentedByteStreamBuffer(
-            max_size=self._max_buffer_size,
-            chunk_size=self._buffer_chunk_size,
-        )
-
-        if self._scanning_buffer:
-            buf = ScanningByteStreamBuffer(buf)
-
-        return buf
-
-    #
-
     _called_decode: bool = False  # ~ `selfFiredChannelRead`
     _produced_messages: bool = False  # ~ `firedChannelRead`
 
     def _call_decode(
             self,
             ctx: ChannelPipelineHandlerContext,
-            buf: ByteStreamBuffer,
+            data: CanByteStreamBuffer,
             *,
             final: bool = False,
     ) -> None:
         self._called_decode = True
 
         out: ta.List[ta.Any] = []
-        try:
-            self._decode(ctx, buf, out, final=final)
-        except DecodingChannelPipelineError:
-            raise
-        except Exception as e:
-            raise DecodingChannelPipelineError from e
+        self._decode(ctx, data, out, final=final)
 
         if not out:
             return
@@ -203,6 +165,11 @@ class BytesToMessageDecoderChannelPipelineHandler(InboundBytesBufferingChannelPi
 
     #
 
+    def _on_bytes_input(self, ctx: ChannelPipelineHandlerContext, data: CanByteStreamBuffer) -> None:
+        check.arg(len(data) > 0)
+
+        self._call_decode(ctx, data)
+
     def _on_flush_input(self, ctx: ChannelPipelineHandlerContext) -> None:
         if (
                 self._called_decode and
@@ -217,27 +184,10 @@ class BytesToMessageDecoderChannelPipelineHandler(InboundBytesBufferingChannelPi
         ctx.feed_in(ChannelPipelineFlowMessages.FlushInput())
 
     def _on_final_input(self, ctx: ChannelPipelineHandlerContext, msg: ChannelPipelineMessages.FinalInput) -> None:
-        dec_buf: ByteStreamBuffer
-        if self._buf is not None:
-            dec_buf = self._buf
-        else:
-            dec_buf = DirectByteStreamBuffer(b'')
-
-        self._call_decode(ctx, dec_buf, final=True)
+        self._call_decode(ctx, DirectByteStreamBuffer(b''), final=True)
 
         ctx.feed_in(msg)
 
-    def _on_bytes_input(self, ctx: ChannelPipelineHandlerContext, msg: ta.Any) -> None:
-        check.arg(len(msg) > 0)
-
-        if self._buf is None:
-            self._buf = self._new_buf()
-
-        for seg in ByteStreamBuffers.iter_segments(msg):
-            self._buf.write(seg)
-
-        self._call_decode(ctx, self._buf)
-
     #
 
     def inbound(self, ctx: ChannelPipelineHandlerContext, msg: ta.Any) -> None:
@@ -263,7 +213,7 @@ class FnBytesToMessageDecoderChannelPipelineHandler(BytesToMessageDecoderChannel
         def __call__(
                 self,
                 ctx: ChannelPipelineHandlerContext,
-                buf: ByteStreamBuffer,
+                data: CanByteStreamBuffer,
                 out: ta.List[ta.Any],
                 *,
                 final: bool = False,
@@ -273,20 +223,97 @@ class FnBytesToMessageDecoderChannelPipelineHandler(BytesToMessageDecoderChannel
     def __init__(
             self,
             decode_fn: DecodeFn,
+    ) -> None:
+        super().__init__()
+
+        self._decode_fn = decode_fn
+
+    def _decode(
+            self,
+            ctx: ChannelPipelineHandlerContext,
+            buf: CanByteStreamBuffer,
+            out: ta.List[ta.Any],
+            *,
+            final: bool = False,
+    ) -> None:
+        self._decode_fn(ctx, buf, out, final=final)
+
+
+##
+
+
+class BufferedBytesToMessageDecoderChannelPipelineHandler(
+    InboundBytesBufferingChannelPipelineHandler,
+    BytesToMessageDecoderChannelPipelineHandler,
+    Abstract,
+):
+    def __init__(
+            self,
             *,
             max_buffer_size: ta.Optional[int] = None,
             buffer_chunk_size: int = 64 * 1024,
             scanning_buffer: bool = False,
     ) -> None:
-        super().__init__(
-            max_buffer_size=max_buffer_size,
-            buffer_chunk_size=buffer_chunk_size,
-            scanning_buffer=scanning_buffer,
+        super().__init__()
+
+        self._max_buffer_size = max_buffer_size
+        self._buffer_chunk_size = buffer_chunk_size
+        self._scanning_buffer = scanning_buffer
+
+    #
+
+    def inbound_buffered_bytes(self) -> int:
+        if (buf := self._buf) is None:
+            return 0
+        return len(buf)
+
+    _buf: ta.Optional[MutableByteStreamBuffer] = None
+
+    def _new_buf(self) -> MutableByteStreamBuffer:
+        buf: MutableByteStreamBuffer = SegmentedByteStreamBuffer(
+            max_size=self._max_buffer_size,
+            chunk_size=self._buffer_chunk_size,
         )
 
-        self._decode_fn = decode_fn
+        if self._scanning_buffer:
+            buf = ScanningByteStreamBuffer(buf)
+
+        return buf
+
+    #
 
     def _decode(
+            self,
+            ctx: ChannelPipelineHandlerContext,
+            data: CanByteStreamBuffer,
+            out: ta.List[ta.Any],
+            *,
+            final: bool = False,
+    ) -> None:
+        if final:
+            check.arg(len(data) == 0)
+
+            if not isinstance(data, ByteStreamBuffer):
+                data = DirectByteStreamBuffer(b'')
+
+            self._decode_buffer(ctx, data, out, final=final)
+
+            return
+
+        check.arg(len(data) > 0)
+
+        if (buf := self._buf) is None:
+            buf = self._buf = self._new_buf()
+
+        for seg in ByteStreamBuffers.iter_segments(data):
+            buf.write(seg)
+
+        self._decode_buffer(ctx, buf, out, final=final)
+
+    #
+
+    @abc.abstractmethod
+    def _decode_buffer(
             self,
             ctx: ChannelPipelineHandlerContext,
             buf: ByteStreamBuffer,
@@ -294,4 +321,4 @@ class FnBytesToMessageDecoderChannelPipelineHandler(BytesToMessageDecoderChannel
             *,
             final: bool = False,
     ) -> None:
-        self._decode_fn(ctx, buf, out, final=final)
+        raise NotImplementedError

{omxtra-0.0.0.dev535 → omxtra-0.0.0.dev536}/omxtra/io/pipelines/core.py

@@ -11,10 +11,11 @@ from omlish.lite.check import check
 from omlish.lite.namespaces import NamespaceClass
 
 from .errors import ContextInvalidatedChannelPipelineError
-from .errors import FinalOutputChannelPipelineError
 from .errors import MessageNotPropagatedChannelPipelineError
 from .errors import MessageReachedTerminalChannelPipelineError
 from .errors import SawFinalInputChannelPipelineError
+from .errors import SawFinalOutputChannelPipelineError
+from .errors import SawInitialInputChannelPipelineError
 from .errors import UnhandleableChannelPipelineError
 
 
@@ -60,6 +61,14 @@ class ChannelPipelineMessages(NamespaceClass):
 
     #
 
+    @ta.final
+    @dc.dataclass(frozen=True, eq=False)
+    class InitialInput(NeverOutbound, MustPropagate):  # ~ Netty `ChannelInboundHandler::channelActive`
+        """Signals that the inbound stream has begun producing input (`connected`)."""
+
+        def __repr__(self) -> str:
+            return f'{type(self).__name__}@{id(self):x}()'
+
     @ta.final
     @dc.dataclass(frozen=True, eq=False)
     class FinalInput(NeverOutbound, MustPropagate):  # ~ Netty `ChannelInboundHandler::channelInactive`
@@ -1216,6 +1225,8 @@ class PipelineChannel:
 
         self._output: ta.Final[PipelineChannel._Output] = PipelineChannel._Output()
 
+        self._saw_any_input = False
+        self._saw_initial_input = False
         self._saw_final_input = False
         self._saw_final_output = False
 
@@ -1275,6 +1286,14 @@ class PipelineChannel:
 
     #
 
+    @property
+    def saw_any_input(self) -> bool:
+        return self._saw_any_input
+
+    @property
+    def saw_initial_input(self) -> bool:
+        return self._saw_initial_input
+
     @property
     def saw_final_input(self) -> bool:
         return self._saw_final_input  # Note: only 'channel-level'
@@ -1506,10 +1525,17 @@ class PipelineChannel:
         self._step_in()
         try:
             for msg in msgs:
-                if isinstance(msg, ChannelPipelineMessages.FinalInput):
+                if self._saw_final_input:
+                    raise SawFinalInputChannelPipelineError
+                elif isinstance(msg, ChannelPipelineMessages.FinalInput):
                     self._saw_final_input = True
-                elif self._saw_final_input:
-                    raise SawFinalInputChannelPipelineError  # noqa
+
+                if isinstance(msg, ChannelPipelineMessages.InitialInput):
+                    if self._saw_any_input:
+                        raise SawInitialInputChannelPipelineError
+                    check.state(not self._saw_initial_input)
+                    self._saw_initial_input = True
+                self._saw_any_input = True
 
                 ctx._inbound(msg)  # noqa
 
@@ -1525,6 +1551,9 @@ class PipelineChannel:
     def feed_in(self, *msgs: ta.Any) -> None:
         self._feed_in_to(self._pipeline._outermost, msgs)  # noqa
 
+    def feed_initial_input(self) -> None:
+        self._feed_in_to(self._pipeline._outermost, (ChannelPipelineMessages.InitialInput(),))  # noqa
+
     def feed_final_input(self) -> None:
         self._feed_in_to(self._pipeline._outermost, (ChannelPipelineMessages.FinalInput(),))  # noqa
 
@@ -1590,7 +1619,7 @@ class PipelineChannel:
         if isinstance(msg, ChannelPipelineMessages.FinalOutput):
             self._saw_final_output = True
         elif self._saw_final_output:
-            raise FinalOutputChannelPipelineError
+            raise SawFinalOutputChannelPipelineError
 
         self._output._q.append(msg)  # noqa
 

{omxtra-0.0.0.dev535 → omxtra-0.0.0.dev536}/omxtra/io/pipelines/drivers/asyncio.py

@@ -8,6 +8,7 @@ TODO:
    - dedicated read_task, flush_task, sched_task
      - read_task toggles back and forth between reading and waiting
    - main task only reads from command queue
+ - asynclite?
 """
 import abc
 import asyncio
@@ -169,6 +170,8 @@ class AsyncioStreamPipelineChannelDriver(Abstract):
     class _FeedInCommand(_Command):
         msgs: ta.Sequence[ta.Any]
 
+        fut: ta.Optional['asyncio.Future[None]'] = None
+
         def __repr__(self) -> str:
             return f'{self.__class__.__name__}([{", ".join(map(repr, self.msgs))}])'
 
@@ -176,11 +179,27 @@ class AsyncioStreamPipelineChannelDriver(Abstract):
         async def _inner() -> None:
             self._channel.feed_in(*cmd.msgs)  # noqa
 
-        await self._do_with_channel(_inner)
+        if (fut := cmd.fut) is None:
+            await self._do_with_channel(_inner)
+            return
+
+        try:
+            await self._do_with_channel(_inner)
+            fut.set_result(None)
+        except BaseException as e:  # noqa
+            fut.set_exception(e)
+            raise
 
     async def feed_in(self, *msgs: ta.Any) -> None:
         check.state(not self._shutdown_event.is_set())
 
+        fut: asyncio.Future[None] = asyncio.Future()
+        self._command_queue.put_nowait(AsyncioStreamPipelineChannelDriver._FeedInCommand(msgs, fut=fut))
+        await fut
+
+    def feed_in_nowait(self, *msgs: ta.Any) -> None:
+        check.state(not self._shutdown_event.is_set())
+
         self._command_queue.put_nowait(AsyncioStreamPipelineChannelDriver._FeedInCommand(msgs))
 
     ##
@@ -566,6 +585,11 @@ class SimpleAsyncioStreamPipelineChannelDriver(AsyncioStreamPipelineChannelDrive
         command_queue_task: ta.Optional[asyncio.Task[AsyncioStreamPipelineChannelDriver._Command]] = None
 
         try:
+            if not self._shutdown_event.is_set():
+                await self._handle_command(AsyncioStreamPipelineChannelDriver._FeedInCommand([  # noqa
+                    ChannelPipelineMessages.InitialInput(),
+                ]))
+
             while not self._shutdown_event.is_set():
                 if command_queue_task is None:
                     command_queue_task = asyncio.create_task(self._command_queue.get())

{omxtra-0.0.0.dev535 → omxtra-0.0.0.dev536}/omxtra/io/pipelines/drivers/sync.py

@@ -84,6 +84,8 @@ class SyncSocketPipelineChannelDriver:
         self._channel = PipelineChannel(self._spec)
 
         try:
+            self._channel.feed_initial_input()
+
             while True:
                 if in_msgs:
                     self._channel.feed_in(*in_msgs)

{omxtra-0.0.0.dev535 → omxtra-0.0.0.dev536}/omxtra/io/pipelines/errors.py

@@ -22,15 +22,23 @@ class UnhandleableChannelPipelineError(ChannelPipelineError):
 # state
 
 
-class ContextInvalidatedChannelPipelineError(ChannelPipelineError):
+class StateChannelPipelineError(ChannelPipelineError):
     pass
 
 
-class SawFinalInputChannelPipelineError(ChannelPipelineError):
+class ContextInvalidatedChannelPipelineError(StateChannelPipelineError):
     pass
 
 
-class FinalOutputChannelPipelineError(ChannelPipelineError):
+class SawInitialInputChannelPipelineError(StateChannelPipelineError):
+    pass
+
+
+class SawFinalInputChannelPipelineError(StateChannelPipelineError):
+    pass
+
+
+class SawFinalOutputChannelPipelineError(StateChannelPipelineError):
     pass
 
 

{omxtra-0.0.0.dev535 → omxtra-0.0.0.dev536}/omxtra/io/pipelines/flow/types.py

@@ -6,6 +6,7 @@ import typing as ta
 from omlish.lite.abstract import Abstract
 from omlish.lite.namespaces import NamespaceClass
 
+from ..core import ChannelPipelineHandlerContext
 from ..core import ChannelPipelineMessages
 from ..core import ChannelPipelineService
 
@@ -26,16 +27,6 @@ class ChannelPipelineFlowMessages(NamespaceClass):
     class FlushInput(ChannelPipelineMessages.NeverOutbound):  # ~ Netty `ChannelInboundInvoker::fireChannelReadComplete`  # noqa
         pass
 
-    @ta.final
-    @dc.dataclass(frozen=True)
-    class ReadyForOutput(ChannelPipelineMessages.NeverOutbound):  # ~ Netty `ChannelOutboundInvoker::fireChannelWritabilityChanged`  # noqa
-        pass
-
-    @ta.final
-    @dc.dataclass(frozen=True)
-    class PauseOutput(ChannelPipelineMessages.NeverOutbound):  # ~ Netty `ChannelOutboundInvoker::fireChannelWritabilityChanged`  # noqa
-        pass
-
     #
 
     @ta.final
@@ -48,6 +39,20 @@ class ChannelPipelineFlowMessages(NamespaceClass):
     class ReadyForInput(ChannelPipelineMessages.NeverInbound):  # ~ Netty `ChannelOutboundInvoker::read`
         pass
 
+    #
+
+    # # TODO:
+    # @ta.final
+    # @dc.dataclass(frozen=True)
+    # class ReadyForOutput(ChannelPipelineMessages.NeverOutbound):  # ~ Netty `ChannelOutboundInvoker::fireChannelWritabilityChanged`  # noqa
+    #     pass
+
+    # # TODO:
+    # @ta.final
+    # @dc.dataclass(frozen=True)
+    # class PauseOutput(ChannelPipelineMessages.NeverOutbound):  # ~ Netty `ChannelOutboundInvoker::fireChannelWritabilityChanged`  # noqa
+    #     pass
+
 
 ##
 
@@ -56,3 +61,7 @@ class ChannelPipelineFlow(ChannelPipelineService, Abstract):
     @abc.abstractmethod
     def is_auto_read(self) -> bool:
         raise NotImplementedError
+
+    @staticmethod
+    def is_auto_read_context(ctx: ChannelPipelineHandlerContext) -> bool:
+        return (fc := ctx.services.find(ChannelPipelineFlow)) is None or fc.is_auto_read()

{omxtra-0.0.0.dev535 → omxtra-0.0.0.dev536}/omxtra/io/pipelines/handlers/decoders.py

@@ -9,7 +9,6 @@ from ..core import ChannelPipelineHandler
 from ..core import ChannelPipelineHandlerContext
 from ..core import ChannelPipelineHandlerFn
 from ..core import ShareableChannelPipelineHandler
-from ..errors import DecodingChannelPipelineError
 from ..flow.types import ChannelPipelineFlow
 from ..flow.types import ChannelPipelineFlowMessages
 
@@ -51,13 +50,7 @@ class MessageToMessageDecoderChannelPipelineHandler(ChannelPipelineHandler, Abst
 
         self._called_decode = True
 
-        try:
-            out = list(self._decode(ctx, msg))
-
-        except DecodingChannelPipelineError:
-            raise
-        except Exception as e:
-            raise DecodingChannelPipelineError from e
+        out = list(self._decode(ctx, msg))
 
         if not out:
             return

{omxtra-0.0.0.dev535 → omxtra-0.0.0.dev536}/omxtra/io/pipelines/handlers/flatmap.py

@@ -55,6 +55,15 @@ class FlatMapChannelPipelineHandlerFns(NamespaceClass):
     ) -> FlatMapChannelPipelineHandlerFn:
         return cls.Filter(pred, fn, else_fn)
 
+    @classmethod
+    def filter_type(
+            cls,
+            ty: ta.Union[type, ta.Tuple[type, ...]],
+            fn: FlatMapChannelPipelineHandlerFn,
+            else_fn: ta.Optional[FlatMapChannelPipelineHandlerFn] = None,
+    ) -> FlatMapChannelPipelineHandlerFn:
+        return cls.filter(ChannelPipelineHandlerFns.isinstance(ty), fn, else_fn)
+
     #
 
     @dc.dataclass(frozen=True)
@@ -217,6 +226,20 @@ class FlatMapChannelPipelineHandlerFns(NamespaceClass):
     def drop(cls) -> FlatMapChannelPipelineHandlerFn:
         return cls.Drop()
 
+    #
+
+    @dc.dataclass(frozen=True)
+    class Nop:
+        def __repr__(self) -> str:
+            return f'{type(self).__name__}()'
+
+        def __call__(self, ctx: ChannelPipelineHandlerContext, msg: ta.Any) -> ta.Iterable[ta.Any]:
+            return (msg,)
+
+    @classmethod
+    def nop(cls) -> FlatMapChannelPipelineHandlerFn:
+        return cls.Nop()
+
 
 #
 
@@ -295,10 +318,7 @@ class FlatMapChannelPipelineHandlers(NamespaceClass):
             fn = FlatMapChannelPipelineHandlerFns.filter(filter, fn)
 
         if filter_type is not None:
-            fn = FlatMapChannelPipelineHandlerFns.filter(
-                ChannelPipelineHandlerFns.isinstance(filter_type),
-                fn,
-            )
+            fn = FlatMapChannelPipelineHandlerFns.filter_type(filter_type, fn)
 
         fn = FlatMapChannelPipelineHandlerFns.filter(cls._NOT_MUST_PROPAGATE, fn)
 

{omxtra-0.0.0.dev535 → omxtra-0.0.0.dev536}/omxtra/io/pipelines/handlers/queues.py

@@ -23,11 +23,13 @@ class QueueChannelPipelineHandler(ChannelPipelineHandler, Abstract):
             self,
             *,
             filter: ta.Optional[ChannelPipelineHandlerFn[ta.Any, bool]] = None,  # noqa
+            filter_type: ta.Optional[ta.Union[type, ta.Tuple[type, ...]]] = None,
             passthrough: ta.Union[bool, ta.Literal['must_propagate']] = 'must_propagate',
     ) -> None:
         super().__init__()
 
         self._filter = filter
+        self._filter_type = filter_type
         self._passthrough = passthrough
 
         self._q: collections.deque[ta.Any] = collections.deque()
@@ -39,6 +41,7 @@ class QueueChannelPipelineHandler(ChannelPipelineHandler, Abstract):
             '(',
             ', '.join([
                 *([f'filter={self._filter!r}'] if self._filter is not None else []),
+                *([f'filter_type={self._filter_type!r}'] if self._filter_type is not None else []),
                 *([f'passthrough={self._passthrough!r}'] if self._passthrough else []),
             ]),
             ')',
@@ -68,6 +71,15 @@ class QueueChannelPipelineHandler(ChannelPipelineHandler, Abstract):
 
     #
 
+    def _should_enqueue(self, ctx: ChannelPipelineHandlerContext, msg: ta.Any) -> bool:
+        if self._filter is not None and not self._filter(ctx, msg):
+            return False
+
+        if self._filter_type is not None and not isinstance(msg, self._filter_type):
+            return False
+
+        return True
+
     def _should_passthrough(self, msg: ta.Any) -> bool:
         if isinstance(pt := self._passthrough, bool):
             return pt
@@ -78,29 +90,25 @@ class QueueChannelPipelineHandler(ChannelPipelineHandler, Abstract):
         else:
             raise RuntimeError(f'Unknown passthrough mode {self._passthrough!r} for {self!r}')
 
-
-class InboundQueueChannelPipelineHandler(QueueChannelPipelineHandler):
-    def inbound(self, ctx: ChannelPipelineHandlerContext, msg: ta.Any) -> None:
-        if (self._filter is not None and not self._filter(ctx, msg)):
-            ctx.feed_in(msg)
+    def _handle(self, ctx: ChannelPipelineHandlerContext, msg: ta.Any, feed: ta.Callable[[ta.Any], None]) -> None:
+        if not self._should_enqueue(ctx, msg):
+            feed(msg)
             return
 
         self._append(msg)
 
         if self._should_passthrough(msg):
-            ctx.feed_in(msg)
+            feed(msg)
 
 
-class OutboundQueueChannelPipelineHandler(QueueChannelPipelineHandler):
-    def outbound(self, ctx: ChannelPipelineHandlerContext, msg: ta.Any) -> None:
-        if (self._filter is not None and not self._filter(ctx, msg)):
-            ctx.feed_out(msg)
-            return
+class InboundQueueChannelPipelineHandler(QueueChannelPipelineHandler):
+    def inbound(self, ctx: ChannelPipelineHandlerContext, msg: ta.Any) -> None:
+        self._handle(ctx, msg, ctx.feed_in)
 
-        self._append(msg)
 
-        if self._should_passthrough(msg):
-            ctx.feed_out(msg)
+class OutboundQueueChannelPipelineHandler(QueueChannelPipelineHandler):
+    def outbound(self, ctx: ChannelPipelineHandlerContext, msg: ta.Any) -> None:
+        self._handle(ctx, msg, ctx.feed_out)
 
 
 class DuplexQueueChannelPipelineHandler(