singledispatchmethod should expose registry of all known overloads #87109

Activity

1. Kentzo commented on Jan 16, 2021

   

   Kentzomannequin

   on Jan 16, 2021

   MannequinAuthor

   More actions

   The wrapper created by singledispatchmethod does not (trivially) expose registry of all known overloads.
   Consider the following example:

       @singledispatchmethod
       def on_message(message):
           raise NotImplementedError
   
       @on_message.register
       def _(message: MessageA): ...
   
       @on_message.register
       def _(message: MessageB): ...

   loop = ...
   condition = ...
   messages = []
   

       def receive_message_on_thread(message):
           if ...:  # only signal to asyncio if message can be handled
               messages.append(message)
               loop.call_soon_threadsafe(condition.notify_all)
           else:
               ...
   
       async def process_messages_on_asyncio():
           while True:
               await condition.wait_for(lambda: len(messages) > 0)
   
               while len(messages):
                   m = messages.pop(0)
                   ...

   Here messages are delivered outside of asyncio in a separate thread and thus they need to be forwarded into asyncio for further processing in the app. If the flow of messages is high it is desirable to filter inside the thread handler before signaling asyncio.

   There are multiple approaches to describe which messages can be handled by the asyncio processor, but singledispatchmethod is the most elegant as it allows to keep everything in one place without if/else or code duplication.

   Having a registry (trivially) exposed would allow to write the condition as isinstance(message, tuple(on_message.registry.keys())).
2. Kentzo

   added

   3.10 (EOL)end of lifeend of life

   stdlibStandard Library Python modules in the Lib/ directoryStandard Library Python modules in the Lib/ directory

   type-featureA feature request or enhancementA feature request or enhancement

   on Jan 16, 2021
3. AlexWaygood

   added

   3.11only security fixesonly security fixes

   and removed

   3.10 (EOL)end of lifeend of life

   on Nov 4, 2021
4. ezio-melotti

   transferred this issue fromon Apr 10, 2022
5. serhiy-storchaka commented on Feb 24, 2024

   

   serhiy-storchaka

   on Feb 24, 2024

   Member

   More actions

   I do not think that isinstance(message, tuple(on_message.registry.keys())) is the most elegant way. Dispatching logic is more complex.

   You need to separate method dispatching step from method execution step. Since you process messages in asynchronous code, I think that most simple way is to make all message handlers asynchronous functions. Except the default handler.

       @singledispatchmethod
       def on_message(self, message):
           raise NotImplementedError # or return None, or whatever
   
       @on_message.register
       async def _(self, message: MessageA): ...
   
       @on_message.register
       async def _(self, message: MessageB): ...

       def receive_message_on_thread(self, message):
           try:
               handler = self.on_message(message)
           except NotImplementedError:
               ...
           else:
               messages_to_handle.append(handler)
               loop.call_soon_threadsafe(condition.notify_all)
   
       async def process_messages_on_asyncio():
           while True:
               await condition.wait_for(lambda: len(messages_to_handle) > 0)
   
               while len(messages_to_handle):
                   handler = messages_to_handle.pop(0)
                   await handler