serializer: dict-based handler dispatch + transport hot-path log cleanup (+ tests)

[Salman778]

serializer: dict-based handler dispatch + transport hot-path log cleanup (+ tests)

Summary

Follow-up to #3, focused on the serializer side of the audio path.
Three independent commits + tests:

1. perf: dict-based frame handler dispatch in serialize().
   serialize runs on every outbound frame and previously reflected on
   the frame's class:

   handler = getattr(self, f"_frame_{type(frame).__name__.lower()}", None)
   if callable(handler):
       result = handler(frame)
       if inspect.isawaitable(result):
           return await result
       return result

   Each call paid for an f-string allocation, a str.lower(), a
   getattr, a callable check, and an inspect.isawaitable walk —
   per frame. For outbound audio that's dozens of times per second per
   call.

   Replaced with two pre-built dispatch tables (sync + async) keyed by
   frame class, populated in __init__. serialize becomes a single
   type(frame) lookup against each table. Because the sync/async
   split is known at registration time, inspect.isawaitable is gone
   from the hot path entirely.

   The old reflective form matched only the exact class name
   (type(frame).__name__, not isinstance), so an exact-type lookup
   is behavior-preserving.

2. perf: dict-based event handler dispatch in _handle_event().
   Same shape, applied to the event side. Events are rare compared to
   audio frames, so this is mostly a consistency change rather than a
   measured hot-path win — but the explicit registration makes the
   supported event set obvious at a glance, and removes the matching
   getattr(... f"_ev_{name.lower()}") reflection.

3. perf: lazy log formatting + isinstance check in
   transport.write_audio_frame / _media_start_handler. Mirrors
   the loguru lazy-formatting change made on the flow_controller hot
   path in Flow controller perf and close fix #3, applied to the per-frame error/warning logs in the
   transport. Also replaces type(payload) == bytes with
   isinstance(payload, bytes) for the conventional check.

Tests

Adds tests/test_serializer.py (15 cases) plus pytest and
pytest-asyncio in the dev dependency group. Coverage:

Frame dispatch:

• Every sync handler (EndFrame, CancelFrame, InterruptionFrame,
  AsteriskCommandFrame) is reachable via serialize() and produces
  the expected wire-format command.
• The async handler (OutputAudioRawFrame) is awaited and returns
  audio bytes through the no-resampling fast path.
• Sync handlers return a plain string, never a coroutine — regression
  guard for the sync/async split.
• Unhandled frame types (e.g. StartFrame) fall through to None.

Event dispatch:

• DTMF_END produces InputDTMFFrame; QUEUE_DRAINED produces
  InputTransportMessageFrame.
• MEDIA_XOFF / MEDIA_XON dispatch to their handlers (which log
  and return None — we check the dispatch found them).
• Missing or unknown event types return None.

Dispatch-table integrity:

• All event-handler keys are uppercase (matching chan_websocket's
  wire format).
• Sync and async frame-handler tables have no overlapping keys.

Run with uv run pytest.

Compatibility / breaking changes

None. The public API of AsteriskFrameSerializer and
AsteriskWebsocketTransport is unchanged. The dispatch refactor is
purely internal; the old reflective form was exact-match by class
name, and the new tables are exact-match by class — same behavior.

If #3 lands first, this PR rebases cleanly on top of it (the two PRs
touch different files; the only shared change is the
pytest/pytest-asyncio dev-deps and [tool.pytest.ini_options]
block in pyproject.toml, which trivially merges).

Background

Same context as #3 — auditing the audio path of a production voice
agent. After the flow_controller changes in #3, serialize was the
next thing showing up as measurable per-frame work on the outbound
side; the getattr/isawaitable reflection was small per call but
fires hundreds of times per second across a fleet of pods.

[NikolayShakin]

@Salman778, that's another great contribution, thanks!
Your research on performance based on the production data is extremely valuable.
And thanks again for the tests!
I'll merge the changes after some tests

[abalashov]

@NikolayShakin This is not a great contribution. There is zero possibility that someone has such wide and unfocused interests in low-level internals, combined with such immaculate use of Markdown formatting conventions and such inorganic formulations of natural language.

The author does not understand his PR.

This is an AI slop PR, and unfortunately, every open-source project is inundated with them right now. They should be treated like spam.

[NikolayShakin]

The idea behind _event_something methods is to make it more convenient for users.
If at some point we need to add a handler for some new event, it's enough to just add _ev_my_custom_message method.

But I agree, it's inefficient. Actually, in the first iteration I used a dict as handler registry.

However, I would create this dictionary in a loop iterating through all the methods of the class, in init method.
like this:

class test():
    def __init__(self):
        self.handlers = dict()
        for k, v in inspect.getmembers(self.__class__, predicate=inspect.isfunction):
            if k.startswith("_ev_"):
                self.handlers[k] = v
 
    def _ev_0(self): ...
    def _ev_a(self): ...
    def _ev_b(self): ...
    def _ev_c(self): ...
    def _something_a(self): ...

This would solve the perf issue and doesn't affect the mechanism of adding _ev_ prefixed handlers

[NikolayShakin]

The same idea as here

We can parse the handlers once in init to avoid overhead on every frame, save them into sync/async dicts. And splitting the handlers into sync and async is a good point; I didn't think about it

[Salman778]

Pushed: reverted the log calls back to f-strings per the convention from #3. Everything else unchanged, all tests passing.

[NikolayShakin]

Implemented in #8